>{
+ async fetch(request, env, context) {
+ const response = await env.ASSETS.fetch(request.url, request);
+ return new Response(response.body, response);
+ },
+};
diff --git a/node_modules/wrangler/templates/pages-template-plugin.ts b/node_modules/wrangler/templates/pages-template-plugin.ts
new file mode 100644
index 0000000..3b99ea2
--- /dev/null
+++ b/node_modules/wrangler/templates/pages-template-plugin.ts
@@ -0,0 +1,190 @@
+import { match } from "path-to-regexp";
+
+//note: this explicitly does not include the * character, as pages requires this
+const escapeRegex = /[.+?^${}()|[\]\\]/g;
+
+type HTTPMethod =
+ | "HEAD"
+ | "OPTIONS"
+ | "GET"
+ | "POST"
+ | "PUT"
+ | "PATCH"
+ | "DELETE";
+
+/* TODO: Grab these from @cloudflare/workers-types instead */
+type Params = Record;
+
+type EventContext = {
+ request: Request;
+ functionPath: string;
+ waitUntil: (promise: Promise) => void;
+ passThroughOnException: () => void;
+ next: (input?: Request | string, init?: RequestInit) => Promise;
+ env: Env & { ASSETS: { fetch: typeof fetch } };
+ params: Params;
+ data: Data;
+};
+
+type EventPluginContext = {
+ request: Request;
+ functionPath: string;
+ waitUntil: (promise: Promise) => void;
+ passThroughOnException: () => void;
+ next: (input?: Request | string, init?: RequestInit) => Promise;
+ env: Env & { ASSETS: { fetch: typeof fetch } };
+ params: Params;
+ data: Data;
+ pluginArgs: PluginArgs;
+};
+
+declare type PagesFunction<
+ Env = unknown,
+ P extends string = string,
+ Data extends Record = Record
+> = (context: EventContext) => Response | Promise;
+
+declare type PagesPluginFunction<
+ Env = unknown,
+ P extends string = string,
+ Data extends Record = Record,
+ PluginArgs = unknown
+> = (
+ context: EventPluginContext
+) => Response | Promise;
+/* end @cloudflare/workers-types */
+
+type RouteHandler = {
+ routePath: string;
+ mountPath: string;
+ method?: HTTPMethod;
+ modules: PagesFunction[];
+ middlewares: PagesFunction[];
+};
+
+// inject `routes` via ESBuild
+declare const routes: RouteHandler[];
+
+function* executeRequest(request: Request, relativePathname: string) {
+ // First, iterate through the routes (backwards) and execute "middlewares" on partial route matches
+ for (const route of [...routes].reverse()) {
+ if (route.method && route.method !== request.method) {
+ continue;
+ }
+
+ // replaces with "\\$&", this prepends a backslash to the matched string, e.g. "[" becomes "\["
+ const routeMatcher = match(route.routePath.replace(escapeRegex, "\\$&"), {
+ end: false,
+ });
+ const mountMatcher = match(route.mountPath.replace(escapeRegex, "\\$&"), {
+ end: false,
+ });
+ const matchResult = routeMatcher(relativePathname);
+ const mountMatchResult = mountMatcher(relativePathname);
+ if (matchResult && mountMatchResult) {
+ for (const handler of route.middlewares.flat()) {
+ yield {
+ handler,
+ params: matchResult.params as Params,
+ path: mountMatchResult.path,
+ };
+ }
+ }
+ }
+
+ // Then look for the first exact route match and execute its "modules"
+ for (const route of routes) {
+ if (route.method && route.method !== request.method) {
+ continue;
+ }
+
+ const routeMatcher = match(route.routePath.replace(escapeRegex, "\\$&"), {
+ end: true,
+ });
+ const mountMatcher = match(route.mountPath.replace(escapeRegex, "\\$&"), {
+ end: false,
+ });
+ const matchResult = routeMatcher(relativePathname);
+ const mountMatchResult = mountMatcher(relativePathname);
+ if (matchResult && mountMatchResult && route.modules.length) {
+ for (const handler of route.modules.flat()) {
+ yield {
+ handler,
+ params: matchResult.params as Params,
+ path: matchResult.path,
+ };
+ }
+ break;
+ }
+ }
+}
+
+export default function (pluginArgs: unknown) {
+ const onRequest: PagesPluginFunction = async (workerContext) => {
+ let { request } = workerContext;
+ const { env, next } = workerContext;
+ let { data } = workerContext;
+
+ const url = new URL(request.url);
+ // TODO: Replace this with something actually legible.
+ const relativePathname = `/${
+ url.pathname.replace(workerContext.functionPath, "") || ""
+ }`.replace(/^\/\//, "/");
+
+ const handlerIterator = executeRequest(request, relativePathname);
+ const pluginNext = async (input?: RequestInfo, init?: RequestInit) => {
+ if (input !== undefined) {
+ let url = input;
+ if (typeof input === "string") {
+ url = new URL(input, request.url).toString();
+ }
+ request = new Request(url, init);
+ }
+
+ const result = handlerIterator.next();
+ // Note we can't use `!result.done` because this doesn't narrow to the correct type
+ if (result.done === false) {
+ const { handler, params, path } = result.value;
+ const context = {
+ request: new Request(request.clone()),
+ functionPath: workerContext.functionPath + path,
+ next: pluginNext,
+ params,
+ get data() {
+ return data;
+ },
+ set data(value) {
+ if (typeof value !== "object" || value === null) {
+ throw new Error("context.data must be an object");
+ }
+ // user has overriden context.data, so we need to merge it with the existing data
+ data = value;
+ },
+ pluginArgs,
+ env,
+ waitUntil: workerContext.waitUntil.bind(workerContext),
+ passThroughOnException:
+ workerContext.passThroughOnException.bind(workerContext),
+ };
+
+ const response = await handler(context);
+
+ return cloneResponse(response);
+ } else {
+ return next(request);
+ }
+ };
+
+ return pluginNext();
+ };
+
+ return onRequest;
+}
+
+// This makes a Response mutable
+const cloneResponse = (response: Response) =>
+ // https://fetch.spec.whatwg.org/#null-body-status
+ new Response(
+ [101, 204, 205, 304].includes(response.status) ? null : response.body,
+ response
+ );
diff --git a/node_modules/wrangler/templates/pages-template-worker.ts b/node_modules/wrangler/templates/pages-template-worker.ts
new file mode 100644
index 0000000..67e6cee
--- /dev/null
+++ b/node_modules/wrangler/templates/pages-template-worker.ts
@@ -0,0 +1,198 @@
+import { match } from "path-to-regexp";
+
+//note: this explicitly does not include the * character, as pages requires this
+const escapeRegex = /[.+?^${}()|[\]\\]/g;
+
+type HTTPMethod =
+ | "HEAD"
+ | "OPTIONS"
+ | "GET"
+ | "POST"
+ | "PUT"
+ | "PATCH"
+ | "DELETE";
+
+/* TODO: Grab these from @cloudflare/workers-types instead */
+type Params = Record;
+
+type EventContext = {
+ request: Request;
+ functionPath: string;
+ waitUntil: (promise: Promise) => void;
+ passThroughOnException: () => void;
+ next: (input?: Request | string, init?: RequestInit) => Promise;
+ env: Env & { ASSETS: { fetch: typeof fetch } };
+ params: Params;
+ data: Data;
+};
+
+declare type PagesFunction<
+ Env = unknown,
+ P extends string = string,
+ Data extends Record = Record
+> = (context: EventContext) => Response | Promise;
+/* end @cloudflare/workers-types */
+
+type RouteHandler = {
+ routePath: string;
+ mountPath: string;
+ method?: HTTPMethod;
+ modules: PagesFunction[];
+ middlewares: PagesFunction[];
+};
+
+// inject `routes` via ESBuild
+declare const routes: RouteHandler[];
+// define `__FALLBACK_SERVICE__` via ESBuild
+declare const __FALLBACK_SERVICE__: string;
+
+// expect an ASSETS fetcher binding pointing to the asset-server stage
+type FetchEnv = {
+ [name: string]: { fetch: typeof fetch };
+ ASSETS: { fetch: typeof fetch };
+};
+
+type WorkerContext = {
+ waitUntil: (promise: Promise) => void;
+ passThroughOnException: () => void;
+};
+
+function* executeRequest(request: Request) {
+ const requestPath = new URL(request.url).pathname;
+
+ // First, iterate through the routes (backwards) and execute "middlewares" on partial route matches
+ for (const route of [...routes].reverse()) {
+ if (route.method && route.method !== request.method) {
+ continue;
+ }
+
+ // replaces with "\\$&", this prepends a backslash to the matched string, e.g. "[" becomes "\["
+ const routeMatcher = match(route.routePath.replace(escapeRegex, "\\$&"), {
+ end: false,
+ });
+ const mountMatcher = match(route.mountPath.replace(escapeRegex, "\\$&"), {
+ end: false,
+ });
+ const matchResult = routeMatcher(requestPath);
+ const mountMatchResult = mountMatcher(requestPath);
+ if (matchResult && mountMatchResult) {
+ for (const handler of route.middlewares.flat()) {
+ yield {
+ handler,
+ params: matchResult.params as Params,
+ path: mountMatchResult.path,
+ };
+ }
+ }
+ }
+
+ // Then look for the first exact route match and execute its "modules"
+ for (const route of routes) {
+ if (route.method && route.method !== request.method) {
+ continue;
+ }
+ const routeMatcher = match(route.routePath.replace(escapeRegex, "\\$&"), {
+ end: true,
+ });
+ const mountMatcher = match(route.mountPath.replace(escapeRegex, "\\$&"), {
+ end: false,
+ });
+ const matchResult = routeMatcher(requestPath);
+ const mountMatchResult = mountMatcher(requestPath);
+ if (matchResult && mountMatchResult && route.modules.length) {
+ for (const handler of route.modules.flat()) {
+ yield {
+ handler,
+ params: matchResult.params as Params,
+ path: matchResult.path,
+ };
+ }
+ break;
+ }
+ }
+}
+
+export default {
+ async fetch(
+ originalRequest: Request,
+ env: FetchEnv,
+ workerContext: WorkerContext
+ ) {
+ let request = originalRequest;
+ const handlerIterator = executeRequest(request);
+ let data = {}; // arbitrary data the user can set between functions
+ let isFailOpen = false;
+
+ const next = async (input?: RequestInfo, init?: RequestInit) => {
+ if (input !== undefined) {
+ let url = input;
+ if (typeof input === "string") {
+ url = new URL(input, request.url).toString();
+ }
+ request = new Request(url, init);
+ }
+
+ const result = handlerIterator.next();
+ // Note we can't use `!result.done` because this doesn't narrow to the correct type
+ if (result.done === false) {
+ const { handler, params, path } = result.value;
+ const context = {
+ request: new Request(request.clone()),
+ functionPath: path,
+ next,
+ params,
+ get data() {
+ return data;
+ },
+ set data(value) {
+ if (typeof value !== "object" || value === null) {
+ throw new Error("context.data must be an object");
+ }
+ // user has overriden context.data, so we need to merge it with the existing data
+ data = value;
+ },
+ env,
+ waitUntil: workerContext.waitUntil.bind(workerContext),
+ passThroughOnException: () => {
+ isFailOpen = true;
+ },
+ };
+
+ const response = await handler(context);
+
+ if (!(response instanceof Response)) {
+ throw new Error("Your Pages function should return a Response");
+ }
+
+ return cloneResponse(response);
+ } else if (__FALLBACK_SERVICE__) {
+ // There are no more handlers so finish with the fallback service (`env.ASSETS.fetch` in Pages' case)
+ const response = await env[__FALLBACK_SERVICE__].fetch(request);
+ return cloneResponse(response);
+ } else {
+ // There was not fallback service so actually make the request to the origin.
+ const response = await fetch(request);
+ return cloneResponse(response);
+ }
+ };
+
+ try {
+ return await next();
+ } catch (error) {
+ if (isFailOpen) {
+ const response = await env[__FALLBACK_SERVICE__].fetch(request);
+ return cloneResponse(response);
+ }
+
+ throw error;
+ }
+ },
+};
+
+// This makes a Response mutable
+const cloneResponse = (response: Response) =>
+ // https://fetch.spec.whatwg.org/#null-body-status
+ new Response(
+ [101, 204, 205, 304].includes(response.status) ? null : response.body,
+ response
+ );
diff --git a/node_modules/wrangler/templates/tsconfig-sanity.ts b/node_modules/wrangler/templates/tsconfig-sanity.ts
new file mode 100644
index 0000000..b6de68f
--- /dev/null
+++ b/node_modules/wrangler/templates/tsconfig-sanity.ts
@@ -0,0 +1,11 @@
+// @ts-nocheck `@types/node` should NOT be included
+Buffer.from("test");
+
+// @ts-expect-error `@types/jest` should NOT be included
+test("test");
+
+// `@cloudflare/workers-types` should be included
+const _handler: ExportedHandler = {};
+new HTMLRewriter();
+
+export {};
diff --git a/node_modules/wrangler/templates/tsconfig.init.json b/node_modules/wrangler/templates/tsconfig.init.json
new file mode 100644
index 0000000..cbea026
--- /dev/null
+++ b/node_modules/wrangler/templates/tsconfig.init.json
@@ -0,0 +1,105 @@
+{
+ "compilerOptions": {
+ /* Visit https://aka.ms/tsconfig.json to read more about this file */
+
+ /* Projects */
+ // "incremental": true, /* Enable incremental compilation */
+ // "composite": true, /* Enable constraints that allow a TypeScript project to be used with project references. */
+ // "tsBuildInfoFile": "./", /* Specify the folder for .tsbuildinfo incremental compilation files. */
+ // "disableSourceOfProjectReferenceRedirect": true, /* Disable preferring source files instead of declaration files when referencing composite projects */
+ // "disableSolutionSearching": true, /* Opt a project out of multi-project reference checking when editing. */
+ // "disableReferencedProjectLoad": true, /* Reduce the number of projects loaded automatically by TypeScript. */
+
+ /* Language and Environment */
+ "target": "es2021" /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */,
+ "lib": [
+ "es2021"
+ ] /* Specify a set of bundled library declaration files that describe the target runtime environment. */,
+ "jsx": "react" /* Specify what JSX code is generated. */,
+ // "experimentalDecorators": true, /* Enable experimental support for TC39 stage 2 draft decorators. */
+ // "emitDecoratorMetadata": true, /* Emit design-type metadata for decorated declarations in source files. */
+ // "jsxFactory": "", /* Specify the JSX factory function used when targeting React JSX emit, e.g. 'React.createElement' or 'h' */
+ // "jsxFragmentFactory": "", /* Specify the JSX Fragment reference used for fragments when targeting React JSX emit e.g. 'React.Fragment' or 'Fragment'. */
+ // "jsxImportSource": "", /* Specify module specifier used to import the JSX factory functions when using `jsx: react-jsx*`.` */
+ // "reactNamespace": "", /* Specify the object invoked for `createElement`. This only applies when targeting `react` JSX emit. */
+ // "noLib": true, /* Disable including any library files, including the default lib.d.ts. */
+ // "useDefineForClassFields": true, /* Emit ECMAScript-standard-compliant class fields. */
+
+ /* Modules */
+ "module": "es2022" /* Specify what module code is generated. */,
+ // "rootDir": "./", /* Specify the root folder within your source files. */
+ "moduleResolution": "node" /* Specify how TypeScript looks up a file from a given module specifier. */,
+ // "baseUrl": "./", /* Specify the base directory to resolve non-relative module names. */
+ // "paths": {}, /* Specify a set of entries that re-map imports to additional lookup locations. */
+ // "rootDirs": [], /* Allow multiple folders to be treated as one when resolving modules. */
+ // "typeRoots": [], /* Specify multiple folders that act like `./node_modules/@types`. */
+ "types": [
+ "@cloudflare/workers-types"
+ ] /* Specify type package names to be included without being referenced in a source file. */,
+ // "allowUmdGlobalAccess": true, /* Allow accessing UMD globals from modules. */
+ "resolveJsonModule": true /* Enable importing .json files */,
+ // "noResolve": true, /* Disallow `import`s, `require`s or ``s from expanding the number of files TypeScript should add to a project. */
+
+ /* JavaScript Support */
+ "allowJs": true /* Allow JavaScript files to be a part of your program. Use the `checkJS` option to get errors from these files. */,
+ "checkJs": false /* Enable error reporting in type-checked JavaScript files. */,
+ // "maxNodeModuleJsDepth": 1, /* Specify the maximum folder depth used for checking JavaScript files from `node_modules`. Only applicable with `allowJs`. */
+
+ /* Emit */
+ // "declaration": true, /* Generate .d.ts files from TypeScript and JavaScript files in your project. */
+ // "declarationMap": true, /* Create sourcemaps for d.ts files. */
+ // "emitDeclarationOnly": true, /* Only output d.ts files and not JavaScript files. */
+ // "sourceMap": true, /* Create source map files for emitted JavaScript files. */
+ // "outFile": "./", /* Specify a file that bundles all outputs into one JavaScript file. If `declaration` is true, also designates a file that bundles all .d.ts output. */
+ // "outDir": "./", /* Specify an output folder for all emitted files. */
+ // "removeComments": true, /* Disable emitting comments. */
+ "noEmit": true /* Disable emitting files from a compilation. */,
+ // "importHelpers": true, /* Allow importing helper functions from tslib once per project, instead of including them per-file. */
+ // "importsNotUsedAsValues": "remove", /* Specify emit/checking behavior for imports that are only used for types */
+ // "downlevelIteration": true, /* Emit more compliant, but verbose and less performant JavaScript for iteration. */
+ // "sourceRoot": "", /* Specify the root path for debuggers to find the reference source code. */
+ // "mapRoot": "", /* Specify the location where debugger should locate map files instead of generated locations. */
+ // "inlineSourceMap": true, /* Include sourcemap files inside the emitted JavaScript. */
+ // "inlineSources": true, /* Include source code in the sourcemaps inside the emitted JavaScript. */
+ // "emitBOM": true, /* Emit a UTF-8 Byte Order Mark (BOM) in the beginning of output files. */
+ // "newLine": "crlf", /* Set the newline character for emitting files. */
+ // "stripInternal": true, /* Disable emitting declarations that have `@internal` in their JSDoc comments. */
+ // "noEmitHelpers": true, /* Disable generating custom helper functions like `__extends` in compiled output. */
+ // "noEmitOnError": true, /* Disable emitting files if any type checking errors are reported. */
+ // "preserveConstEnums": true, /* Disable erasing `const enum` declarations in generated code. */
+ // "declarationDir": "./", /* Specify the output directory for generated declaration files. */
+ // "preserveValueImports": true, /* Preserve unused imported values in the JavaScript output that would otherwise be removed. */
+
+ /* Interop Constraints */
+ "isolatedModules": true /* Ensure that each file can be safely transpiled without relying on other imports. */,
+ "allowSyntheticDefaultImports": true /* Allow 'import x from y' when a module doesn't have a default export. */,
+ // "esModuleInterop": true /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables `allowSyntheticDefaultImports` for type compatibility. */,
+ // "preserveSymlinks": true, /* Disable resolving symlinks to their realpath. This correlates to the same flag in node. */
+ "forceConsistentCasingInFileNames": true /* Ensure that casing is correct in imports. */,
+
+ /* Type Checking */
+ "strict": true /* Enable all strict type-checking options. */,
+ // "noImplicitAny": true, /* Enable error reporting for expressions and declarations with an implied `any` type.. */
+ // "strictNullChecks": true, /* When type checking, take into account `null` and `undefined`. */
+ // "strictFunctionTypes": true, /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */
+ // "strictBindCallApply": true, /* Check that the arguments for `bind`, `call`, and `apply` methods match the original function. */
+ // "strictPropertyInitialization": true, /* Check for class properties that are declared but not set in the constructor. */
+ // "noImplicitThis": true, /* Enable error reporting when `this` is given the type `any`. */
+ // "useUnknownInCatchVariables": true, /* Type catch clause variables as 'unknown' instead of 'any'. */
+ // "alwaysStrict": true, /* Ensure 'use strict' is always emitted. */
+ // "noUnusedLocals": true, /* Enable error reporting when a local variables aren't read. */
+ // "noUnusedParameters": true, /* Raise an error when a function parameter isn't read */
+ // "exactOptionalPropertyTypes": true, /* Interpret optional property types as written, rather than adding 'undefined'. */
+ // "noImplicitReturns": true, /* Enable error reporting for codepaths that do not explicitly return in a function. */
+ // "noFallthroughCasesInSwitch": true, /* Enable error reporting for fallthrough cases in switch statements. */
+ // "noUncheckedIndexedAccess": true, /* Include 'undefined' in index signature results */
+ // "noImplicitOverride": true, /* Ensure overriding members in derived classes are marked with an override modifier. */
+ // "noPropertyAccessFromIndexSignature": true, /* Enforces using indexed accessors for keys declared using an indexed type */
+ // "allowUnusedLabels": true, /* Disable error reporting for unused labels. */
+ // "allowUnreachableCode": true, /* Disable error reporting for unreachable code. */
+
+ /* Completeness */
+ // "skipDefaultLibCheck": true, /* Skip type checking .d.ts files that are included with TypeScript. */
+ "skipLibCheck": true /* Skip type checking all .d.ts files. */
+ }
+}
diff --git a/node_modules/wrangler/templates/tsconfig.json b/node_modules/wrangler/templates/tsconfig.json
new file mode 100644
index 0000000..358f0c3
--- /dev/null
+++ b/node_modules/wrangler/templates/tsconfig.json
@@ -0,0 +1,8 @@
+{
+ "extends": "@cloudflare/workers-tsconfig/tsconfig.json",
+ "compilerOptions": {
+ "types": ["@cloudflare/workers-types"]
+ },
+ "include": ["**/*.ts"],
+ "exclude": ["__tests__", "./init-tests/**"]
+}
diff --git a/node_modules/wrangler/wrangler-dist/cli.d.ts b/node_modules/wrangler/wrangler-dist/cli.d.ts
new file mode 100644
index 0000000..65a2f1d
--- /dev/null
+++ b/node_modules/wrangler/wrangler-dist/cli.d.ts
@@ -0,0 +1,1743 @@
+///
+
+import { Blob as Blob_2 } from 'buffer';
+import { ConnectionOptions } from 'tls';
+import { Duplex } from 'stream';
+import { EventEmitter } from 'events';
+import { IpcNetConnectOpts } from 'net';
+import type { Json } from 'miniflare';
+import { Readable } from 'stream';
+import { ReadableStream as ReadableStream_2 } from 'stream/web';
+import { Socket as Socket_2 } from 'net';
+import { TcpNetConnectOpts } from 'net';
+import { TlsOptions as TlsOptions_2 } from 'tls';
+import { TLSSocket } from 'tls';
+import { URL as URL_2 } from 'url';
+import { URLSearchParams as URLSearchParams_2 } from 'url';
+import { Writable } from 'stream';
+
+declare type AbortSignal_2 = unknown;
+
+declare interface BlobPropertyBag {
+ type?: string
+ endings?: 'native' | 'transparent'
+}
+
+declare type BodyInit_2 =
+| ArrayBuffer
+| AsyncIterable
+| Blob_2
+| FormData_2
+| Iterable
+| NodeJS.ArrayBufferView
+| URLSearchParams_2
+| null
+| string
+
+declare interface BodyMixin {
+ readonly body: ReadableStream_2 | null
+ readonly bodyUsed: boolean
+
+ readonly arrayBuffer: () => Promise
+ readonly blob: () => Promise
+ readonly formData: () => Promise
+ readonly json: () => Promise
+ readonly text: () => Promise
+}
+
+declare class BodyReadable extends Readable {
+ constructor(
+ resume?: (this: Readable, size: number) => void | null,
+ abort?: () => void | null,
+ contentType?: string
+ )
+
+ /** Consumes and returns the body as a string
+ * https://fetch.spec.whatwg.org/#dom-body-text
+ */
+ text(): Promise
+
+ /** Consumes and returns the body as a JavaScript Object
+ * https://fetch.spec.whatwg.org/#dom-body-json
+ */
+ json(): Promise
+
+ /** Consumes and returns the body as a Blob
+ * https://fetch.spec.whatwg.org/#dom-body-blob
+ */
+ blob(): Promise
+
+ /** Consumes and returns the body as an ArrayBuffer
+ * https://fetch.spec.whatwg.org/#dom-body-arraybuffer
+ */
+ arrayBuffer(): Promise
+
+ /** Not implemented
+ *
+ * https://fetch.spec.whatwg.org/#dom-body-formdata
+ */
+ formData(): Promise
+
+ /** Returns true if the body is not null and the body has been consumed
+ *
+ * Otherwise, returns false
+ *
+ * https://fetch.spec.whatwg.org/#dom-body-bodyused
+ */
+ readonly bodyUsed: boolean
+
+ /** Throws on node 16.6.0
+ *
+ * If body is null, it should return null as the body
+ *
+ * If body is not null, should return the body as a ReadableStream
+ *
+ * https://fetch.spec.whatwg.org/#dom-body-body
+ */
+ readonly body: never | undefined
+
+ /** Dumps the response body by reading `limit` number of bytes.
+ * @param opts.limit Number of bytes to read (optional) - Default: 262144
+ */
+ dump(opts?: { limit: number }): Promise
+}
+
+declare function buildConnector (options?: buildConnector.BuildOptions): buildConnector.connector
+
+declare namespace buildConnector {
+ type BuildOptions = (ConnectionOptions | TcpNetConnectOpts | IpcNetConnectOpts) & {
+ maxCachedSessions?: number | null;
+ socketPath?: string | null;
+ timeout?: number | null;
+ port?: number;
+ keepAlive?: boolean | null;
+ keepAliveInitialDelay?: number | null;
+ }
+
+ interface Options {
+ hostname: string
+ host?: string
+ protocol: string
+ port: string
+ servername?: string
+ localAddress?: string | null
+ httpSocket?: Socket_2
+ }
+
+ type Callback = (...args: CallbackArgs) => void
+ type CallbackArgs = [null, Socket_2 | TLSSocket] | [Error, null]
+
+ type connector = connectorAsync | connectorSync
+
+ interface connectorSync {
+ (options: buildConnector.Options): Socket_2 | TLSSocket
+ }
+
+ interface connectorAsync {
+ (options: buildConnector.Options, callback: buildConnector.Callback): void
+ }
+}
+
+/**
+ * An imported module.
+ */
+declare interface CfModule {
+ /**
+ * The module name.
+ *
+ * @example
+ * './src/index.js'
+ */
+ name: string;
+ /**
+ * The absolute path of the module on disk, or `undefined` if this is a
+ * virtual module. Used as the source URL for this module, so source maps are
+ * correctly resolved.
+ *
+ * @example
+ * '/path/to/src/index.js'
+ */
+ filePath: string | undefined;
+ /**
+ * The module content, usually JavaScript or WASM code.
+ *
+ * @example
+ * export default {
+ * async fetch(request) {
+ * return new Response('Ok')
+ * }
+ * }
+ */
+ content: string | Buffer;
+ /**
+ * The module type.
+ *
+ * If absent, will default to the main module's type.
+ */
+ type?: CfModuleType;
+}
+
+/**
+ * A module type.
+ */
+declare type CfModuleType = "esm" | "commonjs" | "compiled-wasm" | "text" | "buffer";
+
+/** A basic HTTP/1.1 client, mapped on top a single TCP/TLS connection. Pipelining is disabled by default. */
+declare class Client extends Dispatcher {
+ constructor(url: string | URL_2, options?: Client.Options);
+ /** Property to get and set the pipelining factor. */
+ pipelining: number;
+ /** `true` after `client.close()` has been called. */
+ closed: boolean;
+ /** `true` after `client.destroyed()` has been called or `client.close()` has been called and the client shutdown has completed. */
+ destroyed: boolean;
+}
+
+declare namespace Client {
+ interface Options {
+ /** the timeout after which a socket without active requests will time out. Monitors time between activity on a connected socket. This value may be overridden by *keep-alive* hints from the server. Default: `4e3` milliseconds (4s). */
+ keepAliveTimeout?: number | null;
+ /** the maximum allowed `idleTimeout` when overridden by *keep-alive* hints from the server. Default: `600e3` milliseconds (10min). */
+ keepAliveMaxTimeout?: number | null;
+ /** A number subtracted from server *keep-alive* hints when overriding `idleTimeout` to account for timing inaccuracies caused by e.g. transport latency. Default: `1e3` milliseconds (1s). */
+ keepAliveTimeoutThreshold?: number | null;
+ /** The amount of concurrent requests to be sent over the single TCP/TLS connection according to [RFC7230](https://tools.ietf.org/html/rfc7230#section-6.3.2). Default: `1`. */
+ pipelining?: number | null;
+ /** **/
+ connect?: buildConnector.BuildOptions | buildConnector.connector | null;
+ /** The maximum length of request headers in bytes. Default: `16384` (16KiB). */
+ maxHeaderSize?: number | null;
+ /** The timeout after which a request will time out, in milliseconds. Monitors time between receiving body data. Use `0` to disable it entirely. Default: `300e3` milliseconds (300s). */
+ bodyTimeout?: number | null;
+ /** The amount of time the parser will wait to receive the complete HTTP headers (Node 14 and above only). Default: `300e3` milliseconds (300s). */
+ headersTimeout?: number | null;
+ /** If `true`, an error is thrown when the request content-length header doesn't match the length of the request body. Default: `true`. */
+ strictContentLength?: boolean;
+ /** @deprecated use the connect option instead */
+ tls?: TlsOptions_2 | null;
+ /** */
+ maxRequestsPerClient?: number;
+ /** Max response body size in bytes, -1 is disabled */
+ maxResponseSize?: number | null;
+ /** Enables a family autodetection algorithm that loosely implements section 5 of RFC 8305. */
+ autoSelectFamily?: boolean;
+ /** The amount of time in milliseconds to wait for a connection attempt to finish before trying the next address when using the `autoSelectFamily` option. */
+ autoSelectFamilyAttemptTimeout?: number;
+
+ interceptors?: {Client: readonly Dispatcher[] | undefined}
+ }
+
+ interface SocketInfo {
+ localAddress?: string
+ localPort?: number
+ remoteAddress?: string
+ remotePort?: number
+ remoteFamily?: string
+ timeout?: number
+ bytesWritten?: number
+ bytesRead?: number
+ }
+
+
+}
+
+/**
+ * The possible types for a `Rule`.
+ */
+declare type ConfigModuleRuleType = "ESModule" | "CommonJS" | "CompiledWasm" | "Text" | "Data";
+
+declare type CustomDomainRoute = {
+ pattern: string;
+ custom_domain: boolean;
+};
+
+export declare function deleteMTlsCertificate(accountId: string, certificateId: string): Promise;
+
+/**
+ * Publish a directory to an account/project.
+ * NOTE: You will need the `CLOUDFLARE_API_KEY` environment
+ * variable set
+ */
+declare function deploy({ directory, accountId, projectName, branch, skipCaching, commitMessage, commitHash, commitDirty, functionsDirectory: customFunctionsDirectory, bundle, }: PagesDeployOptions): Promise<{
+ url: string;
+ environment: "production" | "preview";
+ id: string;
+ project_id: string;
+ project_name: string;
+ build_config: {
+ build_command: string;
+ destination_dir: string;
+ root_dir: string;
+ web_analytics_tag?: string | undefined;
+ web_analytics_token?: string | undefined;
+ fast_builds?: boolean | undefined;
+ };
+ created_on: string;
+ production_branch: string;
+ deployment_trigger: {
+ type: string;
+ metadata: {
+ branch: string;
+ commit_hash: string;
+ commit_message: string;
+ };
+ };
+ latest_stage: {
+ name: "build" | "deploy" | "queued" | "initialize" | "clone_repo";
+ status: "active" | "idle" | "canceled" | "success" | "failure" | "skipped";
+ started_on: string | null;
+ ended_on: string | null;
+ };
+ stages: {
+ name: "build" | "deploy" | "queued" | "initialize" | "clone_repo";
+ status: "active" | "idle" | "canceled" | "success" | "failure" | "skipped";
+ started_on: string | null;
+ ended_on: string | null;
+ }[];
+ aliases: string[];
+ modified_on: string;
+ short_id: string;
+ build_image_major_version: number;
+ kv_namespaces?: any;
+ source?: {
+ type: "github" | "gitlab";
+ config: {
+ owner: string;
+ repo_name: string;
+ production_branch?: string | undefined;
+ pr_comments_enabled?: boolean | undefined;
+ deployments_enabled?: boolean | undefined;
+ production_deployments_enabled?: boolean | undefined;
+ preview_deployment_setting?: "none" | "all" | "custom" | undefined;
+ preview_branch_includes?: string[] | undefined;
+ preview_branch_excludes?: string[] | undefined;
+ };
+ } | undefined;
+ env_vars?: any;
+ durable_object_namespaces?: any;
+ is_skipped?: boolean | undefined;
+ files?: {
+ [x: string]: string | undefined;
+ } | undefined;
+}>;
+
+/**
+ * Deprecated upload configuration.
+ */
+declare interface DeprecatedUpload {
+ /**
+ * The format of the Worker script.
+ *
+ * @deprecated We infer the format automatically now.
+ */
+ format?: "modules" | "service-worker";
+ /**
+ * The directory you wish to upload your worker from,
+ * relative to the wrangler.toml file.
+ *
+ * Defaults to the directory containing the wrangler.toml file.
+ *
+ * @deprecated
+ */
+ dir?: string;
+ /**
+ * The path to the Worker script, relative to `upload.dir`.
+ *
+ * @deprecated This will be replaced by a command line argument.
+ */
+ main?: string;
+ /**
+ * @deprecated This is now defined at the top level `rules` field.
+ */
+ rules?: Environment["rules"];
+}
+
+/** Dispatcher is the core API used to dispatch requests. */
+declare class Dispatcher extends EventEmitter {
+ /** Dispatches a request. This API is expected to evolve through semver-major versions and is less stable than the preceding higher level APIs. It is primarily intended for library developers who implement higher level APIs on top of this. */
+ dispatch(options: Dispatcher.DispatchOptions, handler: Dispatcher.DispatchHandlers): boolean;
+ /** Starts two-way communications with the requested resource. */
+ connect(options: Dispatcher.ConnectOptions): Promise;
+ connect(options: Dispatcher.ConnectOptions, callback: (err: Error | null, data: Dispatcher.ConnectData) => void): void;
+ /** Performs an HTTP request. */
+ request(options: Dispatcher.RequestOptions): Promise;
+ request(options: Dispatcher.RequestOptions, callback: (err: Error | null, data: Dispatcher.ResponseData) => void): void;
+ /** For easy use with `stream.pipeline`. */
+ pipeline(options: Dispatcher.PipelineOptions, handler: Dispatcher.PipelineHandler): Duplex;
+ /** A faster version of `Dispatcher.request`. */
+ stream(options: Dispatcher.RequestOptions, factory: Dispatcher.StreamFactory): Promise;
+ stream(options: Dispatcher.RequestOptions, factory: Dispatcher.StreamFactory, callback: (err: Error | null, data: Dispatcher.StreamData) => void): void;
+ /** Upgrade to a different protocol. */
+ upgrade(options: Dispatcher.UpgradeOptions): Promise;
+ upgrade(options: Dispatcher.UpgradeOptions, callback: (err: Error | null, data: Dispatcher.UpgradeData) => void): void;
+ /** Closes the client and gracefully waits for enqueued requests to complete before invoking the callback (or returning a promise if no callback is provided). */
+ close(): Promise;
+ close(callback: () => void): void;
+ /** Destroy the client abruptly with the given err. All the pending and running requests will be asynchronously aborted and error. Waits until socket is closed before invoking the callback (or returning a promise if no callback is provided). Since this operation is asynchronously dispatched there might still be some progress on dispatched requests. */
+ destroy(): Promise;
+ destroy(err: Error | null): Promise;
+ destroy(callback: () => void): void;
+ destroy(err: Error | null, callback: () => void): void;
+
+ on(eventName: 'connect', callback: (origin: URL_2, targets: readonly Dispatcher[]) => void): this;
+ on(eventName: 'disconnect', callback: (origin: URL_2, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+ on(eventName: 'connectionError', callback: (origin: URL_2, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+ on(eventName: 'drain', callback: (origin: URL_2) => void): this;
+
+
+ once(eventName: 'connect', callback: (origin: URL_2, targets: readonly Dispatcher[]) => void): this;
+ once(eventName: 'disconnect', callback: (origin: URL_2, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+ once(eventName: 'connectionError', callback: (origin: URL_2, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+ once(eventName: 'drain', callback: (origin: URL_2) => void): this;
+
+
+ off(eventName: 'connect', callback: (origin: URL_2, targets: readonly Dispatcher[]) => void): this;
+ off(eventName: 'disconnect', callback: (origin: URL_2, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+ off(eventName: 'connectionError', callback: (origin: URL_2, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+ off(eventName: 'drain', callback: (origin: URL_2) => void): this;
+
+
+ addListener(eventName: 'connect', callback: (origin: URL_2, targets: readonly Dispatcher[]) => void): this;
+ addListener(eventName: 'disconnect', callback: (origin: URL_2, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+ addListener(eventName: 'connectionError', callback: (origin: URL_2, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+ addListener(eventName: 'drain', callback: (origin: URL_2) => void): this;
+
+ removeListener(eventName: 'connect', callback: (origin: URL_2, targets: readonly Dispatcher[]) => void): this;
+ removeListener(eventName: 'disconnect', callback: (origin: URL_2, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+ removeListener(eventName: 'connectionError', callback: (origin: URL_2, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+ removeListener(eventName: 'drain', callback: (origin: URL_2) => void): this;
+
+ prependListener(eventName: 'connect', callback: (origin: URL_2, targets: readonly Dispatcher[]) => void): this;
+ prependListener(eventName: 'disconnect', callback: (origin: URL_2, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+ prependListener(eventName: 'connectionError', callback: (origin: URL_2, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+ prependListener(eventName: 'drain', callback: (origin: URL_2) => void): this;
+
+ prependOnceListener(eventName: 'connect', callback: (origin: URL_2, targets: readonly Dispatcher[]) => void): this;
+ prependOnceListener(eventName: 'disconnect', callback: (origin: URL_2, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+ prependOnceListener(eventName: 'connectionError', callback: (origin: URL_2, targets: readonly Dispatcher[], error: Errors.UndiciError) => void): this;
+ prependOnceListener(eventName: 'drain', callback: (origin: URL_2) => void): this;
+
+ listeners(eventName: 'connect'): ((origin: URL_2, targets: readonly Dispatcher[]) => void)[]
+ listeners(eventName: 'disconnect'): ((origin: URL_2, targets: readonly Dispatcher[], error: Errors.UndiciError) => void)[];
+ listeners(eventName: 'connectionError'): ((origin: URL_2, targets: readonly Dispatcher[], error: Errors.UndiciError) => void)[];
+ listeners(eventName: 'drain'): ((origin: URL_2) => void)[];
+
+ rawListeners(eventName: 'connect'): ((origin: URL_2, targets: readonly Dispatcher[]) => void)[]
+ rawListeners(eventName: 'disconnect'): ((origin: URL_2, targets: readonly Dispatcher[], error: Errors.UndiciError) => void)[];
+ rawListeners(eventName: 'connectionError'): ((origin: URL_2, targets: readonly Dispatcher[], error: Errors.UndiciError) => void)[];
+ rawListeners(eventName: 'drain'): ((origin: URL_2) => void)[];
+
+ emit(eventName: 'connect', origin: URL_2, targets: readonly Dispatcher[]): boolean;
+ emit(eventName: 'disconnect', origin: URL_2, targets: readonly Dispatcher[], error: Errors.UndiciError): boolean;
+ emit(eventName: 'connectionError', origin: URL_2, targets: readonly Dispatcher[], error: Errors.UndiciError): boolean;
+ emit(eventName: 'drain', origin: URL_2): boolean;
+}
+
+declare namespace Dispatcher {
+ interface DispatchOptions {
+ origin?: string | URL_2;
+ path: string;
+ method: HttpMethod;
+ /** Default: `null` */
+ body?: string | Buffer | Uint8Array | Readable | null | FormData_2;
+ /** Default: `null` */
+ headers?: IncomingHttpHeaders | string[] | null;
+ /** Query string params to be embedded in the request URL. Default: `null` */
+ query?: Record;
+ /** Whether the requests can be safely retried or not. If `false` the request won't be sent until all preceding requests in the pipeline have completed. Default: `true` if `method` is `HEAD` or `GET`. */
+ idempotent?: boolean;
+ /** Whether the response is expected to take a long time and would end up blocking the pipeline. When this is set to `true` further pipelining will be avoided on the same connection until headers have been received. */
+ blocking?: boolean;
+ /** Upgrade the request. Should be used to specify the kind of upgrade i.e. `'Websocket'`. Default: `method === 'CONNECT' || null`. */
+ upgrade?: boolean | string | null;
+ /** The amount of time the parser will wait to receive the complete HTTP headers. Defaults to 300 seconds. */
+ headersTimeout?: number | null;
+ /** The timeout after which a request will time out, in milliseconds. Monitors time between receiving body data. Use 0 to disable it entirely. Defaults to 300 seconds. */
+ bodyTimeout?: number | null;
+ /** Whether the request should stablish a keep-alive or not. Default `false` */
+ reset?: boolean;
+ /** Whether Undici should throw an error upon receiving a 4xx or 5xx response from the server. Defaults to false */
+ throwOnError?: boolean;
+ }
+ interface ConnectOptions {
+ path: string;
+ /** Default: `null` */
+ headers?: IncomingHttpHeaders | string[] | null;
+ /** Default: `null` */
+ signal?: AbortSignal_2 | EventEmitter | null;
+ /** This argument parameter is passed through to `ConnectData` */
+ opaque?: unknown;
+ /** Default: 0 */
+ maxRedirections?: number;
+ /** Default: `null` */
+ responseHeader?: 'raw' | null;
+ }
+ interface RequestOptions extends DispatchOptions {
+ /** Default: `null` */
+ opaque?: unknown;
+ /** Default: `null` */
+ signal?: AbortSignal_2 | EventEmitter | null;
+ /** Default: 0 */
+ maxRedirections?: number;
+ /** Default: `null` */
+ onInfo?: (info: { statusCode: number, headers: Record }) => void;
+ /** Default: `null` */
+ responseHeader?: 'raw' | null;
+ }
+ interface PipelineOptions extends RequestOptions {
+ /** `true` if the `handler` will return an object stream. Default: `false` */
+ objectMode?: boolean;
+ }
+ interface UpgradeOptions {
+ path: string;
+ /** Default: `'GET'` */
+ method?: string;
+ /** Default: `null` */
+ headers?: IncomingHttpHeaders | string[] | null;
+ /** A string of comma separated protocols, in descending preference order. Default: `'Websocket'` */
+ protocol?: string;
+ /** Default: `null` */
+ signal?: AbortSignal_2 | EventEmitter | null;
+ /** Default: 0 */
+ maxRedirections?: number;
+ /** Default: `null` */
+ responseHeader?: 'raw' | null;
+ }
+ interface ConnectData {
+ statusCode: number;
+ headers: IncomingHttpHeaders;
+ socket: Duplex;
+ opaque: unknown;
+ }
+ interface ResponseData {
+ statusCode: number;
+ headers: IncomingHttpHeaders;
+ body: BodyReadable & BodyMixin;
+ trailers: Record;
+ opaque: unknown;
+ context: object;
+ }
+ interface PipelineHandlerData {
+ statusCode: number;
+ headers: IncomingHttpHeaders;
+ opaque: unknown;
+ body: BodyReadable;
+ context: object;
+ }
+ interface StreamData {
+ opaque: unknown;
+ trailers: Record;
+ }
+ interface UpgradeData {
+ headers: IncomingHttpHeaders;
+ socket: Duplex;
+ opaque: unknown;
+ }
+ interface StreamFactoryData {
+ statusCode: number;
+ headers: IncomingHttpHeaders;
+ opaque: unknown;
+ context: object;
+ }
+ type StreamFactory = (data: StreamFactoryData) => Writable;
+ interface DispatchHandlers {
+ /** Invoked before request is dispatched on socket. May be invoked multiple times when a request is retried when the request at the head of the pipeline fails. */
+ onConnect?(abort: () => void): void;
+ /** Invoked when an error has occurred. */
+ onError?(err: Error): void;
+ /** Invoked when request is upgraded either due to a `Upgrade` header or `CONNECT` method. */
+ onUpgrade?(statusCode: number, headers: Buffer[] | string[] | null, socket: Duplex): void;
+ /** Invoked when statusCode and headers have been received. May be invoked multiple times due to 1xx informational headers. */
+ onHeaders?(statusCode: number, headers: Buffer[] | string[] | null, resume: () => void): boolean;
+ /** Invoked when response payload data is received. */
+ onData?(chunk: Buffer): boolean;
+ /** Invoked when response payload and trailers have been received and the request has completed. */
+ onComplete?(trailers: string[] | null): void;
+ /** Invoked when a body chunk is sent to the server. May be invoked multiple times for chunked requests */
+ onBodySent?(chunkSize: number, totalBytesSent: number): void;
+ }
+ type PipelineHandler = (data: PipelineHandlerData) => Readable;
+ type HttpMethod = 'GET' | 'HEAD' | 'POST' | 'PUT' | 'DELETE' | 'CONNECT' | 'OPTIONS' | 'TRACE' | 'PATCH';
+
+ /**
+ * @link https://fetch.spec.whatwg.org/#body-mixin
+ */
+ interface BodyMixin {
+ readonly body?: never; // throws on node v16.6.0
+ readonly bodyUsed: boolean;
+ arrayBuffer(): Promise;
+ blob(): Promise;
+ formData(): Promise;
+ json(): Promise;
+ text(): Promise;
+ }
+
+ interface DispatchInterceptor {
+ (dispatch: Dispatcher['dispatch']): Dispatcher['dispatch']
+ }
+}
+
+declare interface DispatchNamespaceOutbound {
+ /** Name of the service handling the outbound requests */
+ service: string;
+ /** (Optional) Name of the environment handling the outbound requests. */
+ environment?: string;
+ /** (Optional) List of parameter names, for sending context from your dispatch worker to the outbound handler */
+ parameters?: string[];
+}
+
+declare type DurableObjectBindings = {
+ /** The name of the binding used to refer to the Durable Object */
+ name: string;
+ /** The exported class name of the Durable Object */
+ class_name: string;
+ /** The script where the Durable Object is defined (if it's external to this worker) */
+ script_name?: string;
+ /** The service environment of the script_name to bind to */
+ environment?: string;
+}[];
+
+declare interface EnablePagesAssetsServiceBindingOptions {
+ proxyPort?: number;
+ directory?: string;
+}
+
+/**
+ * The `Environment` interface declares all the configuration fields that
+ * can be specified for an environment.
+ *
+ * This could be the top-level default environment, or a specific named environment.
+ */
+declare interface Environment extends EnvironmentInheritable, EnvironmentNonInheritable {
+}
+
+/**
+ * The `EnvironmentInheritable` interface declares all the configuration fields for an environment
+ * that can be inherited (and overridden) from the top-level environment.
+ */
+declare interface EnvironmentInheritable {
+ /**
+ * The name of your worker. Alphanumeric + dashes only.
+ *
+ * @inheritable
+ */
+ name: string | undefined;
+ /**
+ * This is the ID of the account associated with your zone.
+ * You might have more than one account, so make sure to use
+ * the ID of the account associated with the zone/route you
+ * provide, if you provide one. It can also be specified through
+ * the CLOUDFLARE_ACCOUNT_ID environment variable.
+ *
+ * @inheritable
+ */
+ account_id: string | undefined;
+ /**
+ * A date in the form yyyy-mm-dd, which will be used to determine
+ * which version of the Workers runtime is used.
+ *
+ * More details at https://developers.cloudflare.com/workers/platform/compatibility-dates
+ *
+ * @inheritable
+ */
+ compatibility_date: string | undefined;
+ /**
+ * A list of flags that enable features from upcoming features of
+ * the Workers runtime, usually used together with compatibility_flags.
+ *
+ * More details at https://developers.cloudflare.com/workers/platform/compatibility-dates
+ *
+ * @inheritable
+ */
+ compatibility_flags: string[];
+ /**
+ * The entrypoint/path to the JavaScript file that will be executed.
+ */
+ main: string | undefined;
+ /**
+ * The directory in which module rules should be evaluated in a `--no-bundle` worker
+ * This defaults to dirname(main) when left undefined
+ */
+ base_dir: string | undefined;
+ /**
+ * Whether we use ..workers.dev to
+ * test and deploy your worker.
+ *
+ * @default `true` (This is a breaking change from Wrangler v1)
+ * @breaking
+ * @inheritable
+ */
+ workers_dev: boolean | undefined;
+ /**
+ * A list of routes that your worker should be published to.
+ * Only one of `routes` or `route` is required.
+ *
+ * Only required when workers_dev is false, and there's no scheduled worker (see `triggers`)
+ *
+ * @inheritable
+ */
+ routes: Route[] | undefined;
+ /**
+ * A route that your worker should be published to. Literally
+ * the same as routes, but only one.
+ * Only one of `routes` or `route` is required.
+ *
+ * Only required when workers_dev is false, and there's no scheduled worker
+ *
+ * @inheritable
+ */
+ route: Route | undefined;
+ /**
+ * Path to a custom tsconfig
+ */
+ tsconfig: string | undefined;
+ /**
+ * The function to use to replace jsx syntax.
+ *
+ * @default `"React.createElement"`
+ * @inheritable
+ */
+ jsx_factory: string;
+ /**
+ * The function to use to replace jsx fragment syntax.
+ *
+ * @default `"React.Fragment"`
+ * @inheritable
+ */
+ jsx_fragment: string;
+ /**
+ * "Cron" definitions to trigger a worker's "scheduled" function.
+ *
+ * Lets you call workers periodically, much like a cron job.
+ *
+ * More details here https://developers.cloudflare.com/workers/platform/cron-triggers
+ *
+ * @default `{crons:[]}`
+ * @inheritable
+ */
+ triggers: {
+ crons: string[];
+ };
+ /**
+ * Specifies the Usage Model for your Worker. There are two options -
+ * [bundled](https://developers.cloudflare.com/workers/platform/limits#bundled-usage-model) and
+ * [unbound](https://developers.cloudflare.com/workers/platform/limits#unbound-usage-model).
+ * For newly created Workers, if the Usage Model is omitted
+ * it will be set to the [default Usage Model set on the account](https://dash.cloudflare.com/?account=workers/default-usage-model).
+ * For existing Workers, if the Usage Model is omitted, it will be
+ * set to the Usage Model configured in the dashboard for that Worker.
+ *
+ * @inheritable
+ */
+ usage_model: "bundled" | "unbound" | undefined;
+ /**
+ * An ordered list of rules that define which modules to import,
+ * and what type to import them as. You will need to specify rules
+ * to use Text, Data, and CompiledWasm modules, or when you wish to
+ * have a .js file be treated as an ESModule instead of CommonJS.
+ *
+ * @inheritable
+ */
+ rules: Rule[];
+ /**
+ * Configures a custom build step to be run by Wrangler when building your Worker.
+ *
+ * Refer to the [custom builds documentation](https://developers.cloudflare.com/workers/cli-wrangler/configuration#build)
+ * for more details.
+ *
+ * @default {}
+ */
+ build: {
+ /** The command used to build your Worker. On Linux and macOS, the command is executed in the `sh` shell and the `cmd` shell for Windows. The `&&` and `||` shell operators may be used. */
+ command?: string;
+ /** The directory in which the command is executed. */
+ cwd?: string;
+ /** The directory to watch for changes while using wrangler dev, defaults to the current working directory */
+ watch_dir?: string | string[];
+ /**
+ * Deprecated field previously used to configure the build and upload of the script.
+ * @deprecated
+ */
+ upload?: DeprecatedUpload;
+ };
+ /**
+ * Skip internal build steps and directly deploy script
+ * @inheritable
+ */
+ no_bundle: boolean | undefined;
+ /**
+ * Minify the script before uploading.
+ * @inheritable
+ */
+ minify: boolean | undefined;
+ /**
+ * Add polyfills for node builtin modules and globals
+ * @inheritable
+ */
+ node_compat: boolean | undefined;
+ /**
+ * Specifies namespace bindings that are bound to this Worker environment.
+ *
+ * NOTE: This field is not automatically inherited from the top level environment,
+ * and so must be specified in every named environment.
+ *
+ * @default `[]`
+ * @nonInheritable
+ */
+ dispatch_namespaces: {
+ /** The binding name used to refer to the bound service. */
+ binding: string;
+ /** The namespace to bind to. */
+ namespace: string;
+ /** Details about the outbound worker which will handle outbound requests from your namespace */
+ outbound?: DispatchNamespaceOutbound;
+ }[];
+ /**
+ * Designates this worker as an internal-only "first-party" worker.
+ */
+ first_party_worker: boolean | undefined;
+ /**
+ * TODO: remove this as it has been deprecated.
+ *
+ * This is just here for now because the `route` commands use it.
+ * So we need to include it in this type so it is available.
+ */
+ zone_id?: string;
+ /**
+ * List of bindings that you will send to logfwdr
+ *
+ * @default `{bindings:[]}`
+ * @inheritable
+ */
+ logfwdr: {
+ bindings: {
+ /** The binding name used to refer to logfwdr */
+ name: string;
+ /** The destination for this logged message */
+ destination: string;
+ }[];
+ };
+ /**
+ * Send Trace Events from this worker to Workers Logpush.
+ *
+ * This will not configure a corresponding Logpush job automatically.
+ *
+ * For more information about Workers Logpush, see:
+ * https://blog.cloudflare.com/logpush-for-workers/
+ *
+ * @inheritable
+ */
+ logpush: boolean | undefined;
+ /**
+ * Specify how the worker should be located to minimize round-trip time.
+ *
+ * More details: https://developers.cloudflare.com/workers/platform/smart-placement/
+ */
+ placement: {
+ mode: "off" | "smart";
+ } | undefined;
+}
+
+/**
+ * The `EnvironmentNonInheritable` interface declares all the configuration fields for an environment
+ * that cannot be inherited from the top-level environment, and must be defined specifically.
+ *
+ * If any of these fields are defined at the top-level then they should also be specifically defined
+ * for each named environment.
+ */
+declare interface EnvironmentNonInheritable {
+ /**
+ * A map of values to substitute when deploying your worker.
+ *
+ * NOTE: This field is not automatically inherited from the top level environment,
+ * and so must be specified in every named environment.
+ *
+ * @default `{}`
+ * @nonInheritable
+ */
+ define: Record;
+ /**
+ * A map of environment variables to set when deploying your worker.
+ *
+ * NOTE: This field is not automatically inherited from the top level environment,
+ * and so must be specified in every named environment.
+ *
+ * @default `{}`
+ * @nonInheritable
+ */
+ vars: Record;
+ /**
+ * A list of durable objects that your worker should be bound to.
+ *
+ * For more information about Durable Objects, see the documentation at
+ * https://developers.cloudflare.com/workers/learning/using-durable-objects
+ *
+ * NOTE: This field is not automatically inherited from the top level environment,
+ * and so must be specified in every named environment.
+ *
+ * @default `{bindings:[]}`
+ * @nonInheritable
+ */
+ durable_objects: {
+ bindings: DurableObjectBindings;
+ };
+ /**
+ * These specify any Workers KV Namespaces you want to
+ * access from inside your Worker.
+ *
+ * To learn more about KV Namespaces,
+ * see the documentation at https://developers.cloudflare.com/workers/learning/how-kv-works
+ *
+ * NOTE: This field is not automatically inherited from the top level environment,
+ * and so must be specified in every named environment.
+ *
+ * @default `[]`
+ * @nonInheritable
+ */
+ kv_namespaces: {
+ /** The binding name used to refer to the KV Namespace */
+ binding: string;
+ /** The ID of the KV namespace */
+ id: string;
+ /** The ID of the KV namespace used during `wrangler dev` */
+ preview_id?: string;
+ }[];
+ /**
+ * These specify bindings to send email from inside your Worker.
+ *
+ * NOTE: This field is not automatically inherited from the top level environment,
+ * and so must be specified in every named environment.
+ *
+ * @default `[]`
+ * @nonInheritable
+ */
+ send_email: {
+ /** The binding name used to refer to the this binding */
+ name: string;
+ /** If this binding should be restricted to a specific verified address */
+ destination_address?: string;
+ /** If this binding should be restricted to a set of verified addresses */
+ allowed_destination_addresses?: string[];
+ }[];
+ /**
+ * Specifies Queues that are bound to this Worker environment.
+ *
+ * NOTE: This field is not automatically inherited from the top level environment,
+ * and so must be specified in every named environment.
+ *
+ * @default `{}`
+ * @nonInheritable
+ */
+ queues: {
+ /** Producer bindings */
+ producers?: {
+ /** The binding name used to refer to the Queue in the worker. */
+ binding: string;
+ /** The name of this Queue. */
+ queue: string;
+ }[];
+ /** Consumer configuration */
+ consumers?: {
+ /** The name of the queue from which this script should consume. */
+ queue: string;
+ /** The maximum number of messages per batch */
+ max_batch_size?: number;
+ /** The maximum number of seconds to wait to fill a batch with messages. */
+ max_batch_timeout?: number;
+ /** The maximum number of retries for each message. */
+ max_retries?: number;
+ /** The queue to send messages that failed to be consumed. */
+ dead_letter_queue?: string;
+ /** The maximum number of concurrent consumer Worker invocations. Leaving this unset will allow your consumer to scale to the maximum concurrency needed to keep up with the message backlog. */
+ max_concurrency?: number | null;
+ }[];
+ };
+ /**
+ * Specifies R2 buckets that are bound to this Worker environment.
+ *
+ * NOTE: This field is not automatically inherited from the top level environment,
+ * and so must be specified in every named environment.
+ *
+ * @default `[]`
+ * @nonInheritable
+ */
+ r2_buckets: {
+ /** The binding name used to refer to the R2 bucket in the worker. */
+ binding: string;
+ /** The name of this R2 bucket at the edge. */
+ bucket_name: string;
+ /** The preview name of this R2 bucket at the edge. */
+ preview_bucket_name?: string;
+ /** The jurisdiction that the bucket exists in. Default if not present. */
+ jurisdiction?: string;
+ }[];
+ /**
+ * Specifies D1 databases that are bound to this Worker environment.
+ *
+ * NOTE: This field is not automatically inherited from the top level environment,
+ * and so must be specified in every named environment.
+ *
+ * @default `[]`
+ * @nonInheritable
+ */
+ d1_databases: {
+ /** The binding name used to refer to the D1 database in the worker. */
+ binding: string;
+ /** The name of this D1 database. */
+ database_name: string;
+ /** The UUID of this D1 database (not required). */
+ database_id: string;
+ /** The UUID of this D1 database for Wrangler Dev (if specified). */
+ preview_database_id?: string;
+ /** The name of the migrations table for this D1 database (defaults to 'd1_migrations'). */
+ migrations_table?: string;
+ /** The path to the directory of migrations for this D1 database (defaults to './migrations'). */
+ migrations_dir?: string;
+ /** Internal use only. */
+ database_internal_env?: string;
+ }[];
+ /**
+ * Specifies Constellation projects that are bound to this Worker environment.
+ *
+ * NOTE: This field is not automatically inherited from the top level environment,
+ * and so must be specified in every named environment.
+ *
+ * @default `[]`
+ * @nonInheritable
+ */
+ constellation: {
+ /** The binding name used to refer to the project in the worker. */
+ binding: string;
+ /** The id of the project. */
+ project_id: string;
+ }[];
+ /**
+ * Specifies service bindings (worker-to-worker) that are bound to this Worker environment.
+ *
+ * NOTE: This field is not automatically inherited from the top level environment,
+ * and so must be specified in every named environment.
+ *
+ * @default `[]`
+ * @nonInheritable
+ */
+ services: {
+ /** The binding name used to refer to the bound service. */
+ binding: string;
+ /** The name of the service. */
+ service: string;
+ /** The environment of the service (e.g. production, staging, etc). */
+ environment?: string;
+ }[] | undefined;
+ /**
+ * Specifies analytics engine datasets that are bound to this Worker environment.
+ *
+ * NOTE: This field is not automatically inherited from the top level environment,
+ * and so must be specified in every named environment.
+ *
+ * @default `[]`
+ * @nonInheritable
+ */
+ analytics_engine_datasets: {
+ /** The binding name used to refer to the dataset in the worker. */
+ binding: string;
+ /** The name of this dataset to write to. */
+ dataset?: string;
+ }[];
+ /**
+ * A browser that will be usable from the worker.
+ */
+ browser: {
+ binding: string;
+ } | undefined;
+ /**
+ * "Unsafe" tables for features that aren't directly supported by wrangler.
+ *
+ * NOTE: This field is not automatically inherited from the top level environment,
+ * and so must be specified in every named environment.
+ *
+ * @nonInheritable
+ */
+ unsafe: {
+ /**
+ * A set of bindings that should be put into a Worker's upload metadata without changes. These
+ * can be used to implement bindings for features that haven't released and aren't supported
+ * directly by wrangler or miniflare.
+ */
+ bindings?: {
+ name: string;
+ type: string;
+ [key: string]: unknown;
+ }[];
+ /**
+ * Arbitrary key/value pairs that will be included in the uploaded metadata. Values specified
+ * here will always be applied to metadata last, so can add new or override existing fields.
+ */
+ metadata?: {
+ [key: string]: string;
+ };
+ /**
+ * Used for internal capnp uploads for the Workers runtime
+ */
+ capnp?: {
+ base_path: string;
+ source_schemas: string[];
+ compiled_schema?: never;
+ } | {
+ base_path?: never;
+ source_schemas?: never;
+ compiled_schema: string;
+ };
+ };
+ mtls_certificates: {
+ /** The binding name used to refer to the certificate in the worker */
+ binding: string;
+ /** The uuid of the uploaded mTLS certificate */
+ certificate_id: string;
+ }[];
+ tail_consumers?: TailConsumer[];
+}
+
+declare namespace Errors {
+ class UndiciError extends Error { }
+
+ /** Connect timeout error. */
+ class ConnectTimeoutError extends UndiciError {
+ name: 'ConnectTimeoutError';
+ code: 'UND_ERR_CONNECT_TIMEOUT';
+ }
+
+ /** A header exceeds the `headersTimeout` option. */
+ class HeadersTimeoutError extends UndiciError {
+ name: 'HeadersTimeoutError';
+ code: 'UND_ERR_HEADERS_TIMEOUT';
+ }
+
+ /** Headers overflow error. */
+ class HeadersOverflowError extends UndiciError {
+ name: 'HeadersOverflowError'
+ code: 'UND_ERR_HEADERS_OVERFLOW'
+ }
+
+ /** A body exceeds the `bodyTimeout` option. */
+ class BodyTimeoutError extends UndiciError {
+ name: 'BodyTimeoutError';
+ code: 'UND_ERR_BODY_TIMEOUT';
+ }
+
+ class ResponseStatusCodeError extends UndiciError {
+ name: 'ResponseStatusCodeError';
+ code: 'UND_ERR_RESPONSE_STATUS_CODE';
+ body: null | Record | string
+ status: number
+ statusCode: number
+ headers: IncomingHttpHeaders | string[] | null;
+ }
+
+ /** Passed an invalid argument. */
+ class InvalidArgumentError extends UndiciError {
+ name: 'InvalidArgumentError';
+ code: 'UND_ERR_INVALID_ARG';
+ }
+
+ /** Returned an invalid value. */
+ class InvalidReturnValueError extends UndiciError {
+ name: 'InvalidReturnValueError';
+ code: 'UND_ERR_INVALID_RETURN_VALUE';
+ }
+
+ /** The request has been aborted by the user. */
+ class RequestAbortedError extends UndiciError {
+ name: 'AbortError';
+ code: 'UND_ERR_ABORTED';
+ }
+
+ /** Expected error with reason. */
+ class InformationalError extends UndiciError {
+ name: 'InformationalError';
+ code: 'UND_ERR_INFO';
+ }
+
+ /** Request body length does not match content-length header. */
+ class RequestContentLengthMismatchError extends UndiciError {
+ name: 'RequestContentLengthMismatchError';
+ code: 'UND_ERR_REQ_CONTENT_LENGTH_MISMATCH';
+ }
+
+ /** Response body length does not match content-length header. */
+ class ResponseContentLengthMismatchError extends UndiciError {
+ name: 'ResponseContentLengthMismatchError';
+ code: 'UND_ERR_RES_CONTENT_LENGTH_MISMATCH';
+ }
+
+ /** Trying to use a destroyed client. */
+ class ClientDestroyedError extends UndiciError {
+ name: 'ClientDestroyedError';
+ code: 'UND_ERR_DESTROYED';
+ }
+
+ /** Trying to use a closed client. */
+ class ClientClosedError extends UndiciError {
+ name: 'ClientClosedError';
+ code: 'UND_ERR_CLOSED';
+ }
+
+ /** There is an error with the socket. */
+ class SocketError extends UndiciError {
+ name: 'SocketError';
+ code: 'UND_ERR_SOCKET';
+ socket: Client.SocketInfo | null
+ }
+
+ /** Encountered unsupported functionality. */
+ class NotSupportedError extends UndiciError {
+ name: 'NotSupportedError';
+ code: 'UND_ERR_NOT_SUPPORTED';
+ }
+
+ /** No upstream has been added to the BalancedPool. */
+ class BalancedPoolMissingUpstreamError extends UndiciError {
+ name: 'MissingUpstreamError';
+ code: 'UND_ERR_BPL_MISSING_UPSTREAM';
+ }
+
+ class HTTPParserError extends UndiciError {
+ name: 'HTTPParserError';
+ code: string;
+ }
+
+ /** The response exceed the length allowed. */
+ class ResponseExceededMaxSizeError extends UndiciError {
+ name: 'ResponseExceededMaxSizeError';
+ code: 'UND_ERR_RES_EXCEEDED_MAX_SIZE';
+ }
+}
+
+declare class File_2 extends Blob_2 {
+ /**
+ * Creates a new File instance.
+ *
+ * @param fileBits An `Array` strings, or [`ArrayBuffer`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer), [`ArrayBufferView`](https://developer.mozilla.org/en-US/docs/Web/API/ArrayBufferView), [`Blob`](https://developer.mozilla.org/en-US/docs/Web/API/Blob) objects, or a mix of any of such objects, that will be put inside the [`File`](https://developer.mozilla.org/en-US/docs/Web/API/File).
+ * @param fileName The name of the file.
+ * @param options An options object containing optional attributes for the file.
+ */
+ constructor(fileBits: ReadonlyArray, fileName: string, options?: FilePropertyBag)
+
+ /**
+ * Name of the file referenced by the File object.
+ */
+ readonly name: string
+
+ /**
+ * The last modified date of the file as the number of milliseconds since the Unix epoch (January 1, 1970 at midnight). Files without a known last modified date return the current date.
+ */
+ readonly lastModified: number
+
+ readonly [Symbol.toStringTag]: string
+}
+
+declare interface FilePropertyBag extends BlobPropertyBag {
+ /**
+ * The last modified date of the file as the number of milliseconds since the Unix epoch (January 1, 1970 at midnight). Files without a known last modified date return the current date.
+ */
+ lastModified?: number
+}
+
+/**
+ * Provides a way to easily construct a set of key/value pairs representing form fields and their values, which can then be easily sent using fetch().
+ */
+declare class FormData_2 {
+ /**
+ * Appends a new value onto an existing key inside a FormData object,
+ * or adds the key if it does not already exist.
+ *
+ * The difference between `set()` and `append()` is that if the specified key already exists, `set()` will overwrite all existing values with the new one, whereas `append()` will append the new value onto the end of the existing set of values.
+ *
+ * @param name The name of the field whose data is contained in `value`.
+ * @param value The field's value. This can be [`Blob`](https://developer.mozilla.org/en-US/docs/Web/API/Blob)
+ or [`File`](https://developer.mozilla.org/en-US/docs/Web/API/File). If none of these are specified the value is converted to a string.
+ * @param fileName The filename reported to the server, when a Blob or File is passed as the second parameter. The default filename for Blob objects is "blob". The default filename for File objects is the file's filename.
+ */
+ append(name: string, value: unknown, fileName?: string): void
+
+ /**
+ * Set a new value for an existing key inside FormData,
+ * or add the new field if it does not already exist.
+ *
+ * @param name The name of the field whose data is contained in `value`.
+ * @param value The field's value. This can be [`Blob`](https://developer.mozilla.org/en-US/docs/Web/API/Blob)
+ or [`File`](https://developer.mozilla.org/en-US/docs/Web/API/File). If none of these are specified the value is converted to a string.
+ * @param fileName The filename reported to the server, when a Blob or File is passed as the second parameter. The default filename for Blob objects is "blob". The default filename for File objects is the file's filename.
+ *
+ */
+ set(name: string, value: unknown, fileName?: string): void
+
+ /**
+ * Returns the first value associated with a given key from within a `FormData` object.
+ * If you expect multiple values and want all of them, use the `getAll()` method instead.
+ *
+ * @param {string} name A name of the value you want to retrieve.
+ *
+ * @returns A `FormDataEntryValue` containing the value. If the key doesn't exist, the method returns null.
+ */
+ get(name: string): FormDataEntryValue | null
+
+ /**
+ * Returns all the values associated with a given key from within a `FormData` object.
+ *
+ * @param {string} name A name of the value you want to retrieve.
+ *
+ * @returns An array of `FormDataEntryValue` whose key matches the value passed in the `name` parameter. If the key doesn't exist, the method returns an empty list.
+ */
+ getAll(name: string): FormDataEntryValue[]
+
+ /**
+ * Returns a boolean stating whether a `FormData` object contains a certain key.
+ *
+ * @param name A string representing the name of the key you want to test for.
+ *
+ * @return A boolean value.
+ */
+ has(name: string): boolean
+
+ /**
+ * Deletes a key and its value(s) from a `FormData` object.
+ *
+ * @param name The name of the key you want to delete.
+ */
+ delete(name: string): void
+
+ /**
+ * Executes given callback function for each field of the FormData instance
+ */
+ forEach: (
+ callbackfn: (value: FormDataEntryValue, key: string, iterable: FormData_2) => void,
+ thisArg?: unknown
+ ) => void
+
+ /**
+ * Returns an [`iterator`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols) allowing to go through all keys contained in this `FormData` object.
+ * Each key is a `string`.
+ */
+ keys: () => SpecIterableIterator
+
+ /**
+ * Returns an [`iterator`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols) allowing to go through all values contained in this object `FormData` object.
+ * Each value is a [`FormDataValue`](https://developer.mozilla.org/en-US/docs/Web/API/FormDataEntryValue).
+ */
+ values: () => SpecIterableIterator
+
+ /**
+ * Returns an [`iterator`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols) allowing to go through the `FormData` key/value pairs.
+ * The key of each pair is a string; the value is a [`FormDataValue`](https://developer.mozilla.org/en-US/docs/Web/API/FormDataEntryValue).
+ */
+ entries: () => SpecIterableIterator<[string, FormDataEntryValue]>
+
+ /**
+ * An alias for FormData#entries()
+ */
+ [Symbol.iterator]: () => SpecIterableIterator<[string, FormDataEntryValue]>
+
+ readonly [Symbol.toStringTag]: string
+}
+
+/**
+ * A `string` or `File` that represents a single value from a set of `FormData` key-value pairs.
+ */
+declare type FormDataEntryValue = string | File_2
+
+/**
+ * fetches an mTLS certificate from the account mTLS certificate store by ID
+ */
+export declare function getMTlsCertificate(accountId: string, id: string): Promise;
+
+/**
+ * fetches an mTLS certificate from the account mTLS certificate store by name. will throw an error if no certificates are found, or multiple are found with that name
+ */
+export declare function getMTlsCertificateByName(accountId: string, name: string): Promise;
+
+declare class Headers_2 implements SpecIterable<[string, string]> {
+ constructor (init?: HeadersInit_2)
+ readonly append: (name: string, value: string) => void
+ readonly delete: (name: string) => void
+ readonly get: (name: string) => string | null
+ readonly has: (name: string) => boolean
+ readonly set: (name: string, value: string) => void
+ readonly getSetCookie: () => string[]
+ readonly forEach: (
+ callbackfn: (value: string, key: string, iterable: Headers_2) => void,
+ thisArg?: unknown
+ ) => void
+
+ readonly keys: () => SpecIterableIterator
+ readonly values: () => SpecIterableIterator
+ readonly entries: () => SpecIterableIterator<[string, string]>
+ readonly [Symbol.iterator]: () => SpecIterator<[string, string]>
+}
+
+declare type HeadersInit_2 = string[][] | Record> | Headers_2
+
+/**
+ * The header type declaration of `undici`.
+ */
+declare type IncomingHttpHeaders = Record;
+
+/**
+ * lists mTLS certificates for an account. filtering by name is supported
+ */
+export declare function listMTlsCertificates(accountId: string, filter: MTlsCertificateListFilter): Promise;
+
+/**
+ * details for uploading an mTLS certificate via the ssl api
+ */
+declare interface MTlsCertificateBody {
+ certificateChain: string;
+ privateKey: string;
+ name?: string;
+}
+
+/**
+ * supported filters for listing mTLS certificates via the ssl api
+ */
+declare interface MTlsCertificateListFilter {
+ name?: string;
+}
+
+/**
+ * the representation of an mTLS certificate in the account certificate store
+ */
+declare interface MTlsCertificateResponse {
+ id: string;
+ name?: string;
+ ca: boolean;
+ certificates: string;
+ expires_on: string;
+ issuer: string;
+ serial_number: string;
+ signature: string;
+ uploaded_on: string;
+}
+
+/**
+ * details for uploading an mTLS certificate from disk
+ */
+declare interface MTlsCertificateUploadDetails {
+ certificateChainFilename: string;
+ privateKeyFilename: string;
+ name?: string;
+}
+
+declare interface PagesDeployOptions {
+ /**
+ * Path to static assets to deploy to Pages
+ */
+ directory: string;
+ /**
+ * The Cloudflare Account ID that owns the project that's
+ * being published
+ */
+ accountId: string;
+ /**
+ * The name of the project to be published
+ */
+ projectName: string;
+ /**
+ * Branch name to use. Defaults to production branch
+ */
+ branch?: string;
+ /**
+ * Whether or not to skip local file upload result caching
+ */
+ skipCaching?: boolean;
+ /**
+ * Commit message associated to deployment
+ */
+ commitMessage?: string;
+ /**
+ * Commit hash associated to deployment
+ */
+ commitHash?: string;
+ /**
+ * Whether or not the deployment should be considered to be
+ * in a dirty commit state
+ */
+ commitDirty?: boolean;
+ /**
+ * Path to the project's functions directory. Default uses
+ * the current working directory + /functions since this is
+ * typically called in a CLI
+ */
+ functionsDirectory?: string;
+ /**
+ * Whether to run bundling on `_worker.js` before deploying.
+ * Default: true
+ */
+ bundle?: boolean;
+}
+
+declare type ReferrerPolicy =
+| ''
+| 'no-referrer'
+| 'no-referrer-when-downgrade'
+| 'origin'
+| 'origin-when-cross-origin'
+| 'same-origin'
+| 'strict-origin'
+| 'strict-origin-when-cross-origin'
+| 'unsafe-url';
+
+declare class Request_2 implements BodyMixin {
+ constructor (input: RequestInfo_2, init?: RequestInit_2)
+
+ readonly cache: RequestCache
+ readonly credentials: RequestCredentials
+ readonly destination: RequestDestination
+ readonly headers: Headers_2
+ readonly integrity: string
+ readonly method: string
+ readonly mode: RequestMode
+ readonly redirect: RequestRedirect
+ readonly referrerPolicy: string
+ readonly url: string
+
+ readonly keepalive: boolean
+ readonly signal: AbortSignal
+ readonly duplex: RequestDuplex
+
+ readonly body: ReadableStream_2 | null
+ readonly bodyUsed: boolean
+
+ readonly arrayBuffer: () => Promise
+ readonly blob: () => Promise
+ readonly formData: () => Promise
+ readonly json: () => Promise
+ readonly text: () => Promise
+
+ readonly clone: () => Request_2
+}
+
+declare type RequestCache =
+| 'default'
+| 'force-cache'
+| 'no-cache'
+| 'no-store'
+| 'only-if-cached'
+| 'reload'
+
+declare type RequestCredentials = 'omit' | 'include' | 'same-origin'
+
+declare type RequestDestination =
+| ''
+| 'audio'
+| 'audioworklet'
+| 'document'
+| 'embed'
+| 'font'
+| 'image'
+| 'manifest'
+| 'object'
+| 'paintworklet'
+| 'report'
+| 'script'
+| 'sharedworker'
+| 'style'
+| 'track'
+| 'video'
+| 'worker'
+| 'xslt'
+
+declare type RequestDuplex = 'half'
+
+declare type RequestInfo_2 = string | URL_2 | Request_2
+
+declare interface RequestInit_2 {
+ method?: string
+ keepalive?: boolean
+ headers?: HeadersInit_2
+ body?: BodyInit_2
+ redirect?: RequestRedirect
+ integrity?: string
+ signal?: AbortSignal
+ credentials?: RequestCredentials
+ mode?: RequestMode
+ referrer?: string
+ referrerPolicy?: ReferrerPolicy
+ window?: null
+ dispatcher?: Dispatcher
+ duplex?: RequestDuplex
+}
+
+declare type RequestMode = 'cors' | 'navigate' | 'no-cors' | 'same-origin'
+
+declare type RequestRedirect = 'error' | 'follow' | 'manual'
+
+declare class Response_2 implements BodyMixin {
+ constructor (body?: BodyInit_2, init?: ResponseInit_2)
+
+ readonly headers: Headers_2
+ readonly ok: boolean
+ readonly status: number
+ readonly statusText: string
+ readonly type: ResponseType
+ readonly url: string
+ readonly redirected: boolean
+
+ readonly body: ReadableStream_2 | null
+ readonly bodyUsed: boolean
+
+ readonly arrayBuffer: () => Promise
+ readonly blob: () => Promise
+ readonly formData: () => Promise
+ readonly json: () => Promise
+ readonly text: () => Promise
+
+ readonly clone: () => Response_2
+
+ static error (): Response_2
+ static json(data: any, init?: ResponseInit_2): Response_2
+ static redirect (url: string | URL_2, status: ResponseRedirectStatus): Response_2
+}
+
+declare interface ResponseInit_2 {
+ readonly status?: number
+ readonly statusText?: string
+ readonly headers?: HeadersInit_2
+}
+
+declare type ResponseRedirectStatus = 301 | 302 | 303 | 307 | 308
+
+declare type ResponseType =
+| 'basic'
+| 'cors'
+| 'default'
+| 'error'
+| 'opaque'
+| 'opaqueredirect'
+
+declare type Route = SimpleRoute | ZoneIdRoute | ZoneNameRoute | CustomDomainRoute;
+
+/**
+ * A bundling resolver rule, defining the modules type for paths that match the specified globs.
+ */
+declare type Rule = {
+ type: ConfigModuleRuleType;
+ globs: string[];
+ fallthrough?: boolean;
+};
+
+declare type SimpleRoute = string;
+
+declare interface SpecIterable {
+ [Symbol.iterator](): SpecIterator;
+}
+
+declare interface SpecIterableIterator extends SpecIterator {
+ [Symbol.iterator](): SpecIterableIterator;
+}
+
+declare interface SpecIterator {
+ next(...args: [] | [TNext]): IteratorResult;
+}
+
+declare type TailConsumer = {
+ /** The name of the service tail events will be forwarded to. */
+ service: string;
+ /** (Optional) The environt of the service. */
+ environment?: string;
+};
+
+/**
+ * unstable_dev starts a wrangler dev server, and returns a promise that resolves with utility functions to interact with it.
+ */
+export declare function unstable_dev(script: string, options?: UnstableDevOptions, apiOptions?: unknown): Promise;
+
+export declare const unstable_pages: {
+ deploy: typeof deploy;
+};
+
+export declare interface UnstableDevOptions {
+ config?: string;
+ env?: string;
+ ip?: string;
+ port?: number;
+ bundle?: boolean;
+ inspectorPort?: number;
+ localProtocol?: "http" | "https";
+ assets?: string;
+ site?: string;
+ siteInclude?: string[];
+ siteExclude?: string[];
+ nodeCompat?: boolean;
+ compatibilityDate?: string;
+ compatibilityFlags?: string[];
+ persist?: boolean;
+ persistTo?: string;
+ vars?: Record;
+ kv?: {
+ binding: string;
+ id: string;
+ preview_id?: string;
+ }[];
+ durableObjects?: {
+ name: string;
+ class_name: string;
+ script_name?: string | undefined;
+ environment?: string | undefined;
+ }[];
+ r2?: {
+ binding: string;
+ bucket_name: string;
+ preview_bucket_name?: string;
+ }[];
+ moduleRoot?: string;
+ rules?: Rule[];
+ logLevel?: "none" | "info" | "error" | "log" | "warn" | "debug";
+ inspect?: boolean;
+ local?: boolean;
+ accountId?: string;
+ experimental?: {
+ processEntrypoint?: boolean;
+ additionalModules?: CfModule[];
+ d1Databases?: Environment["d1_databases"];
+ disableExperimentalWarning?: boolean;
+ disableDevRegistry?: boolean;
+ enablePagesAssetsServiceBinding?: EnablePagesAssetsServiceBindingOptions;
+ forceLocal?: boolean;
+ liveReload?: boolean;
+ showInteractiveDevSession?: boolean;
+ testMode?: boolean;
+ testScheduled?: boolean;
+ watch?: boolean;
+ };
+}
+
+export declare interface UnstableDevWorker {
+ port: number;
+ address: string;
+ stop: () => Promise;
+ fetch: (input?: RequestInfo_2, init?: RequestInit_2) => Promise;
+ waitUntilExit: () => Promise;
+}
+
+/**
+ * uploads an mTLS certificate and private key pair to the account mTLS certificate store
+ */
+export declare function uploadMTlsCertificate(accountId: string, body: MTlsCertificateBody): Promise;
+
+/**
+ * reads an mTLS certificate and private key pair from disk and uploads it to the account mTLS certificate store
+ */
+export declare function uploadMTlsCertificateFromFs(accountId: string, details: MTlsCertificateUploadDetails): Promise;
+
+declare type ZoneIdRoute = {
+ pattern: string;
+ zone_id: string;
+ custom_domain?: boolean;
+};
+
+declare type ZoneNameRoute = {
+ pattern: string;
+ zone_name: string;
+ custom_domain?: boolean;
+};
+
+export { }
diff --git a/node_modules/wrangler/wrangler-dist/cli.js b/node_modules/wrangler/wrangler-dist/cli.js
new file mode 100644
index 0000000..03f5c35
--- /dev/null
+++ b/node_modules/wrangler/wrangler-dist/cli.js
@@ -0,0 +1,152035 @@
+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 __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __esm = (fn2, res) => function __init() {
+ return fn2 && (res = (0, fn2[__getOwnPropNames(fn2)[0]])(fn2 = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require() {
+ return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all2) => {
+ for (var name in all2)
+ __defProp(target, name, { get: all2[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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+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);
+
+// import_meta_url.js
+var import_meta_url;
+var init_import_meta_url = __esm({
+ "import_meta_url.js"() {
+ import_meta_url = require("url").pathToFileURL(__filename);
+ }
+});
+
+// ../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/core/symbols.js
+var require_symbols = __commonJS({
+ "../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/core/symbols.js"(exports2, module2) {
+ init_import_meta_url();
+ module2.exports = {
+ kClose: Symbol("close"),
+ kDestroy: Symbol("destroy"),
+ kDispatch: Symbol("dispatch"),
+ kUrl: Symbol("url"),
+ kWriting: Symbol("writing"),
+ kResuming: Symbol("resuming"),
+ kQueue: Symbol("queue"),
+ kConnect: Symbol("connect"),
+ kConnecting: Symbol("connecting"),
+ kHeadersList: Symbol("headers list"),
+ kKeepAliveDefaultTimeout: Symbol("default keep alive timeout"),
+ kKeepAliveMaxTimeout: Symbol("max keep alive timeout"),
+ kKeepAliveTimeoutThreshold: Symbol("keep alive timeout threshold"),
+ kKeepAliveTimeoutValue: Symbol("keep alive timeout"),
+ kKeepAlive: Symbol("keep alive"),
+ kHeadersTimeout: Symbol("headers timeout"),
+ kBodyTimeout: Symbol("body timeout"),
+ kServerName: Symbol("server name"),
+ kLocalAddress: Symbol("local address"),
+ kHost: Symbol("host"),
+ kNoRef: Symbol("no ref"),
+ kBodyUsed: Symbol("used"),
+ kRunning: Symbol("running"),
+ kBlocking: Symbol("blocking"),
+ kPending: Symbol("pending"),
+ kSize: Symbol("size"),
+ kBusy: Symbol("busy"),
+ kQueued: Symbol("queued"),
+ kFree: Symbol("free"),
+ kConnected: Symbol("connected"),
+ kClosed: Symbol("closed"),
+ kNeedDrain: Symbol("need drain"),
+ kReset: Symbol("reset"),
+ kDestroyed: Symbol.for("nodejs.stream.destroyed"),
+ kMaxHeadersSize: Symbol("max headers size"),
+ kRunningIdx: Symbol("running index"),
+ kPendingIdx: Symbol("pending index"),
+ kError: Symbol("error"),
+ kClients: Symbol("clients"),
+ kClient: Symbol("client"),
+ kParser: Symbol("parser"),
+ kOnDestroyed: Symbol("destroy callbacks"),
+ kPipelining: Symbol("pipelinig"),
+ kSocket: Symbol("socket"),
+ kHostHeader: Symbol("host header"),
+ kConnector: Symbol("connector"),
+ kStrictContentLength: Symbol("strict content length"),
+ kMaxRedirections: Symbol("maxRedirections"),
+ kMaxRequests: Symbol("maxRequestsPerClient"),
+ kProxy: Symbol("proxy agent options"),
+ kCounter: Symbol("socket request counter"),
+ kInterceptors: Symbol("dispatch interceptors"),
+ kMaxResponseSize: Symbol("max response size")
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/core/errors.js
+var require_errors = __commonJS({
+ "../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/core/errors.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var UndiciError = class extends Error {
+ constructor(message) {
+ super(message);
+ this.name = "UndiciError";
+ this.code = "UND_ERR";
+ }
+ };
+ __name(UndiciError, "UndiciError");
+ var ConnectTimeoutError = class extends UndiciError {
+ constructor(message) {
+ super(message);
+ Error.captureStackTrace(this, ConnectTimeoutError);
+ this.name = "ConnectTimeoutError";
+ this.message = message || "Connect Timeout Error";
+ this.code = "UND_ERR_CONNECT_TIMEOUT";
+ }
+ };
+ __name(ConnectTimeoutError, "ConnectTimeoutError");
+ var HeadersTimeoutError = class extends UndiciError {
+ constructor(message) {
+ super(message);
+ Error.captureStackTrace(this, HeadersTimeoutError);
+ this.name = "HeadersTimeoutError";
+ this.message = message || "Headers Timeout Error";
+ this.code = "UND_ERR_HEADERS_TIMEOUT";
+ }
+ };
+ __name(HeadersTimeoutError, "HeadersTimeoutError");
+ var HeadersOverflowError = class extends UndiciError {
+ constructor(message) {
+ super(message);
+ Error.captureStackTrace(this, HeadersOverflowError);
+ this.name = "HeadersOverflowError";
+ this.message = message || "Headers Overflow Error";
+ this.code = "UND_ERR_HEADERS_OVERFLOW";
+ }
+ };
+ __name(HeadersOverflowError, "HeadersOverflowError");
+ var BodyTimeoutError = class extends UndiciError {
+ constructor(message) {
+ super(message);
+ Error.captureStackTrace(this, BodyTimeoutError);
+ this.name = "BodyTimeoutError";
+ this.message = message || "Body Timeout Error";
+ this.code = "UND_ERR_BODY_TIMEOUT";
+ }
+ };
+ __name(BodyTimeoutError, "BodyTimeoutError");
+ var ResponseStatusCodeError = class extends UndiciError {
+ constructor(message, statusCode, headers, body) {
+ super(message);
+ Error.captureStackTrace(this, ResponseStatusCodeError);
+ this.name = "ResponseStatusCodeError";
+ this.message = message || "Response Status Code Error";
+ this.code = "UND_ERR_RESPONSE_STATUS_CODE";
+ this.body = body;
+ this.status = statusCode;
+ this.statusCode = statusCode;
+ this.headers = headers;
+ }
+ };
+ __name(ResponseStatusCodeError, "ResponseStatusCodeError");
+ var InvalidArgumentError = class extends UndiciError {
+ constructor(message) {
+ super(message);
+ Error.captureStackTrace(this, InvalidArgumentError);
+ this.name = "InvalidArgumentError";
+ this.message = message || "Invalid Argument Error";
+ this.code = "UND_ERR_INVALID_ARG";
+ }
+ };
+ __name(InvalidArgumentError, "InvalidArgumentError");
+ var InvalidReturnValueError = class extends UndiciError {
+ constructor(message) {
+ super(message);
+ Error.captureStackTrace(this, InvalidReturnValueError);
+ this.name = "InvalidReturnValueError";
+ this.message = message || "Invalid Return Value Error";
+ this.code = "UND_ERR_INVALID_RETURN_VALUE";
+ }
+ };
+ __name(InvalidReturnValueError, "InvalidReturnValueError");
+ var RequestAbortedError = class extends UndiciError {
+ constructor(message) {
+ super(message);
+ Error.captureStackTrace(this, RequestAbortedError);
+ this.name = "AbortError";
+ this.message = message || "Request aborted";
+ this.code = "UND_ERR_ABORTED";
+ }
+ };
+ __name(RequestAbortedError, "RequestAbortedError");
+ var InformationalError = class extends UndiciError {
+ constructor(message) {
+ super(message);
+ Error.captureStackTrace(this, InformationalError);
+ this.name = "InformationalError";
+ this.message = message || "Request information";
+ this.code = "UND_ERR_INFO";
+ }
+ };
+ __name(InformationalError, "InformationalError");
+ var RequestContentLengthMismatchError = class extends UndiciError {
+ constructor(message) {
+ super(message);
+ Error.captureStackTrace(this, RequestContentLengthMismatchError);
+ this.name = "RequestContentLengthMismatchError";
+ this.message = message || "Request body length does not match content-length header";
+ this.code = "UND_ERR_REQ_CONTENT_LENGTH_MISMATCH";
+ }
+ };
+ __name(RequestContentLengthMismatchError, "RequestContentLengthMismatchError");
+ var ResponseContentLengthMismatchError = class extends UndiciError {
+ constructor(message) {
+ super(message);
+ Error.captureStackTrace(this, ResponseContentLengthMismatchError);
+ this.name = "ResponseContentLengthMismatchError";
+ this.message = message || "Response body length does not match content-length header";
+ this.code = "UND_ERR_RES_CONTENT_LENGTH_MISMATCH";
+ }
+ };
+ __name(ResponseContentLengthMismatchError, "ResponseContentLengthMismatchError");
+ var ClientDestroyedError = class extends UndiciError {
+ constructor(message) {
+ super(message);
+ Error.captureStackTrace(this, ClientDestroyedError);
+ this.name = "ClientDestroyedError";
+ this.message = message || "The client is destroyed";
+ this.code = "UND_ERR_DESTROYED";
+ }
+ };
+ __name(ClientDestroyedError, "ClientDestroyedError");
+ var ClientClosedError = class extends UndiciError {
+ constructor(message) {
+ super(message);
+ Error.captureStackTrace(this, ClientClosedError);
+ this.name = "ClientClosedError";
+ this.message = message || "The client is closed";
+ this.code = "UND_ERR_CLOSED";
+ }
+ };
+ __name(ClientClosedError, "ClientClosedError");
+ var SocketError = class extends UndiciError {
+ constructor(message, socket) {
+ super(message);
+ Error.captureStackTrace(this, SocketError);
+ this.name = "SocketError";
+ this.message = message || "Socket error";
+ this.code = "UND_ERR_SOCKET";
+ this.socket = socket;
+ }
+ };
+ __name(SocketError, "SocketError");
+ var NotSupportedError = class extends UndiciError {
+ constructor(message) {
+ super(message);
+ Error.captureStackTrace(this, NotSupportedError);
+ this.name = "NotSupportedError";
+ this.message = message || "Not supported error";
+ this.code = "UND_ERR_NOT_SUPPORTED";
+ }
+ };
+ __name(NotSupportedError, "NotSupportedError");
+ var BalancedPoolMissingUpstreamError = class extends UndiciError {
+ constructor(message) {
+ super(message);
+ Error.captureStackTrace(this, NotSupportedError);
+ this.name = "MissingUpstreamError";
+ this.message = message || "No upstream has been added to the BalancedPool";
+ this.code = "UND_ERR_BPL_MISSING_UPSTREAM";
+ }
+ };
+ __name(BalancedPoolMissingUpstreamError, "BalancedPoolMissingUpstreamError");
+ var HTTPParserError = class extends Error {
+ constructor(message, code, data) {
+ super(message);
+ Error.captureStackTrace(this, HTTPParserError);
+ this.name = "HTTPParserError";
+ this.code = code ? `HPE_${code}` : void 0;
+ this.data = data ? data.toString() : void 0;
+ }
+ };
+ __name(HTTPParserError, "HTTPParserError");
+ var ResponseExceededMaxSizeError = class extends UndiciError {
+ constructor(message) {
+ super(message);
+ Error.captureStackTrace(this, ResponseExceededMaxSizeError);
+ this.name = "ResponseExceededMaxSizeError";
+ this.message = message || "Response content exceeded max size";
+ this.code = "UND_ERR_RES_EXCEEDED_MAX_SIZE";
+ }
+ };
+ __name(ResponseExceededMaxSizeError, "ResponseExceededMaxSizeError");
+ module2.exports = {
+ HTTPParserError,
+ UndiciError,
+ HeadersTimeoutError,
+ HeadersOverflowError,
+ BodyTimeoutError,
+ RequestContentLengthMismatchError,
+ ConnectTimeoutError,
+ ResponseStatusCodeError,
+ InvalidArgumentError,
+ InvalidReturnValueError,
+ RequestAbortedError,
+ ClientDestroyedError,
+ ClientClosedError,
+ InformationalError,
+ SocketError,
+ NotSupportedError,
+ ResponseContentLengthMismatchError,
+ BalancedPoolMissingUpstreamError,
+ ResponseExceededMaxSizeError
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/core/util.js
+var require_util = __commonJS({
+ "../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/core/util.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var assert18 = require("assert");
+ var { kDestroyed, kBodyUsed } = require_symbols();
+ var { IncomingMessage } = require("http");
+ var stream2 = require("stream");
+ var net3 = require("net");
+ var { InvalidArgumentError } = require_errors();
+ var { Blob: Blob5 } = require("buffer");
+ var nodeUtil = require("util");
+ var { stringify } = require("querystring");
+ var [nodeMajor, nodeMinor] = process.versions.node.split(".").map((v) => Number(v));
+ function nop() {
+ }
+ __name(nop, "nop");
+ function isStream2(obj) {
+ return obj && typeof obj.pipe === "function";
+ }
+ __name(isStream2, "isStream");
+ function isBlobLike(object) {
+ return Blob5 && object instanceof Blob5 || object && typeof object === "object" && (typeof object.stream === "function" || typeof object.arrayBuffer === "function") && /^(Blob|File)$/.test(object[Symbol.toStringTag]);
+ }
+ __name(isBlobLike, "isBlobLike");
+ function buildURL(url3, queryParams) {
+ if (url3.includes("?") || url3.includes("#")) {
+ throw new Error('Query params cannot be passed when url already contains "?" or "#".');
+ }
+ const stringified = stringify(queryParams);
+ if (stringified) {
+ url3 += "?" + stringified;
+ }
+ return url3;
+ }
+ __name(buildURL, "buildURL");
+ function parseURL(url3) {
+ if (typeof url3 === "string") {
+ url3 = new URL(url3);
+ }
+ if (!url3 || typeof url3 !== "object") {
+ throw new InvalidArgumentError("invalid url");
+ }
+ if (url3.port != null && url3.port !== "" && !Number.isFinite(parseInt(url3.port))) {
+ throw new InvalidArgumentError("invalid port");
+ }
+ if (url3.path != null && typeof url3.path !== "string") {
+ throw new InvalidArgumentError("invalid path");
+ }
+ if (url3.pathname != null && typeof url3.pathname !== "string") {
+ throw new InvalidArgumentError("invalid pathname");
+ }
+ if (url3.hostname != null && typeof url3.hostname !== "string") {
+ throw new InvalidArgumentError("invalid hostname");
+ }
+ if (url3.origin != null && typeof url3.origin !== "string") {
+ throw new InvalidArgumentError("invalid origin");
+ }
+ if (!/^https?:/.test(url3.origin || url3.protocol)) {
+ throw new InvalidArgumentError("invalid protocol");
+ }
+ if (!(url3 instanceof URL)) {
+ const port2 = url3.port != null ? url3.port : url3.protocol === "https:" ? 443 : 80;
+ let origin = url3.origin != null ? url3.origin : `${url3.protocol}//${url3.hostname}:${port2}`;
+ let path45 = url3.path != null ? url3.path : `${url3.pathname || ""}${url3.search || ""}`;
+ if (origin.endsWith("/")) {
+ origin = origin.substring(0, origin.length - 1);
+ }
+ if (path45 && !path45.startsWith("/")) {
+ path45 = `/${path45}`;
+ }
+ url3 = new URL(origin + path45);
+ }
+ return url3;
+ }
+ __name(parseURL, "parseURL");
+ function parseOrigin(url3) {
+ url3 = parseURL(url3);
+ if (url3.pathname !== "/" || url3.search || url3.hash) {
+ throw new InvalidArgumentError("invalid url");
+ }
+ return url3;
+ }
+ __name(parseOrigin, "parseOrigin");
+ function getHostname(host) {
+ if (host[0] === "[") {
+ const idx2 = host.indexOf("]");
+ assert18(idx2 !== -1);
+ return host.substr(1, idx2 - 1);
+ }
+ const idx = host.indexOf(":");
+ if (idx === -1)
+ return host;
+ return host.substr(0, idx);
+ }
+ __name(getHostname, "getHostname");
+ function getServerName(host) {
+ if (!host) {
+ return null;
+ }
+ assert18.strictEqual(typeof host, "string");
+ const servername = getHostname(host);
+ if (net3.isIP(servername)) {
+ return "";
+ }
+ return servername;
+ }
+ __name(getServerName, "getServerName");
+ function deepClone(obj) {
+ return JSON.parse(JSON.stringify(obj));
+ }
+ __name(deepClone, "deepClone");
+ function isAsyncIterable(obj) {
+ return !!(obj != null && typeof obj[Symbol.asyncIterator] === "function");
+ }
+ __name(isAsyncIterable, "isAsyncIterable");
+ function isIterable(obj) {
+ return !!(obj != null && (typeof obj[Symbol.iterator] === "function" || typeof obj[Symbol.asyncIterator] === "function"));
+ }
+ __name(isIterable, "isIterable");
+ function bodyLength(body) {
+ if (body == null) {
+ return 0;
+ } else if (isStream2(body)) {
+ const state = body._readableState;
+ return state && state.ended === true && Number.isFinite(state.length) ? state.length : null;
+ } else if (isBlobLike(body)) {
+ return body.size != null ? body.size : null;
+ } else if (isBuffer(body)) {
+ return body.byteLength;
+ }
+ return null;
+ }
+ __name(bodyLength, "bodyLength");
+ function isDestroyed(stream3) {
+ return !stream3 || !!(stream3.destroyed || stream3[kDestroyed]);
+ }
+ __name(isDestroyed, "isDestroyed");
+ function isReadableAborted(stream3) {
+ const state = stream3 && stream3._readableState;
+ return isDestroyed(stream3) && state && !state.endEmitted;
+ }
+ __name(isReadableAborted, "isReadableAborted");
+ function destroy(stream3, err) {
+ if (!isStream2(stream3) || isDestroyed(stream3)) {
+ return;
+ }
+ if (typeof stream3.destroy === "function") {
+ if (Object.getPrototypeOf(stream3).constructor === IncomingMessage) {
+ stream3.socket = null;
+ }
+ stream3.destroy(err);
+ } else if (err) {
+ process.nextTick((stream4, err2) => {
+ stream4.emit("error", err2);
+ }, stream3, err);
+ }
+ if (stream3.destroyed !== true) {
+ stream3[kDestroyed] = true;
+ }
+ }
+ __name(destroy, "destroy");
+ var KEEPALIVE_TIMEOUT_EXPR = /timeout=(\d+)/;
+ function parseKeepAliveTimeout(val) {
+ const m = val.toString().match(KEEPALIVE_TIMEOUT_EXPR);
+ return m ? parseInt(m[1], 10) * 1e3 : null;
+ }
+ __name(parseKeepAliveTimeout, "parseKeepAliveTimeout");
+ function parseHeaders2(headers, obj = {}) {
+ for (let i = 0; i < headers.length; i += 2) {
+ const key = headers[i].toString().toLowerCase();
+ let val = obj[key];
+ const encoding = key.length === 19 && key === "content-disposition" ? "latin1" : "utf8";
+ if (!val) {
+ if (Array.isArray(headers[i + 1])) {
+ obj[key] = headers[i + 1];
+ } else {
+ obj[key] = headers[i + 1].toString(encoding);
+ }
+ } else {
+ if (!Array.isArray(val)) {
+ val = [val];
+ obj[key] = val;
+ }
+ val.push(headers[i + 1].toString(encoding));
+ }
+ }
+ return obj;
+ }
+ __name(parseHeaders2, "parseHeaders");
+ function parseRawHeaders(headers) {
+ const ret = [];
+ for (let n = 0; n < headers.length; n += 2) {
+ const key = headers[n + 0].toString();
+ const encoding = key.length === 19 && key.toLowerCase() === "content-disposition" ? "latin1" : "utf8";
+ const val = headers[n + 1].toString(encoding);
+ ret.push(key, val);
+ }
+ return ret;
+ }
+ __name(parseRawHeaders, "parseRawHeaders");
+ function isBuffer(buffer) {
+ return buffer instanceof Uint8Array || Buffer.isBuffer(buffer);
+ }
+ __name(isBuffer, "isBuffer");
+ function validateHandler(handler15, method, upgrade) {
+ if (!handler15 || typeof handler15 !== "object") {
+ throw new InvalidArgumentError("handler must be an object");
+ }
+ if (typeof handler15.onConnect !== "function") {
+ throw new InvalidArgumentError("invalid onConnect method");
+ }
+ if (typeof handler15.onError !== "function") {
+ throw new InvalidArgumentError("invalid onError method");
+ }
+ if (typeof handler15.onBodySent !== "function" && handler15.onBodySent !== void 0) {
+ throw new InvalidArgumentError("invalid onBodySent method");
+ }
+ if (upgrade || method === "CONNECT") {
+ if (typeof handler15.onUpgrade !== "function") {
+ throw new InvalidArgumentError("invalid onUpgrade method");
+ }
+ } else {
+ if (typeof handler15.onHeaders !== "function") {
+ throw new InvalidArgumentError("invalid onHeaders method");
+ }
+ if (typeof handler15.onData !== "function") {
+ throw new InvalidArgumentError("invalid onData method");
+ }
+ if (typeof handler15.onComplete !== "function") {
+ throw new InvalidArgumentError("invalid onComplete method");
+ }
+ }
+ }
+ __name(validateHandler, "validateHandler");
+ function isDisturbed(body) {
+ return !!(body && (stream2.isDisturbed ? stream2.isDisturbed(body) || body[kBodyUsed] : body[kBodyUsed] || body.readableDidRead || body._readableState && body._readableState.dataEmitted || isReadableAborted(body)));
+ }
+ __name(isDisturbed, "isDisturbed");
+ function isErrored(body) {
+ return !!(body && (stream2.isErrored ? stream2.isErrored(body) : /state: 'errored'/.test(
+ nodeUtil.inspect(body)
+ )));
+ }
+ __name(isErrored, "isErrored");
+ function isReadable(body) {
+ return !!(body && (stream2.isReadable ? stream2.isReadable(body) : /state: 'readable'/.test(
+ nodeUtil.inspect(body)
+ )));
+ }
+ __name(isReadable, "isReadable");
+ function getSocketInfo(socket) {
+ return {
+ localAddress: socket.localAddress,
+ localPort: socket.localPort,
+ remoteAddress: socket.remoteAddress,
+ remotePort: socket.remotePort,
+ remoteFamily: socket.remoteFamily,
+ timeout: socket.timeout,
+ bytesWritten: socket.bytesWritten,
+ bytesRead: socket.bytesRead
+ };
+ }
+ __name(getSocketInfo, "getSocketInfo");
+ var ReadableStream2;
+ function ReadableStreamFrom(iterable) {
+ if (!ReadableStream2) {
+ ReadableStream2 = require("stream/web").ReadableStream;
+ }
+ if (ReadableStream2.from) {
+ return ReadableStream2.from(iterable);
+ }
+ let iterator;
+ return new ReadableStream2(
+ {
+ async start() {
+ iterator = iterable[Symbol.asyncIterator]();
+ },
+ async pull(controller) {
+ const { done, value } = await iterator.next();
+ if (done) {
+ queueMicrotask(() => {
+ controller.close();
+ });
+ } else {
+ const buf = Buffer.isBuffer(value) ? value : Buffer.from(value);
+ controller.enqueue(new Uint8Array(buf));
+ }
+ return controller.desiredSize > 0;
+ },
+ async cancel(reason) {
+ await iterator.return();
+ }
+ },
+ 0
+ );
+ }
+ __name(ReadableStreamFrom, "ReadableStreamFrom");
+ function isFormDataLike(chunk) {
+ return chunk && chunk.constructor && chunk.constructor.name === "FormData" && typeof chunk === "object" && (typeof chunk.append === "function" && typeof chunk.delete === "function" && typeof chunk.get === "function" && typeof chunk.getAll === "function" && typeof chunk.has === "function" && typeof chunk.set === "function" && typeof chunk.entries === "function" && typeof chunk.keys === "function" && typeof chunk.values === "function" && typeof chunk.forEach === "function");
+ }
+ __name(isFormDataLike, "isFormDataLike");
+ var kEnumerableProperty = /* @__PURE__ */ Object.create(null);
+ kEnumerableProperty.enumerable = true;
+ module2.exports = {
+ kEnumerableProperty,
+ nop,
+ isDisturbed,
+ isErrored,
+ isReadable,
+ toUSVString: nodeUtil.toUSVString || ((val) => `${val}`),
+ isReadableAborted,
+ isBlobLike,
+ parseOrigin,
+ parseURL,
+ getServerName,
+ isStream: isStream2,
+ isIterable,
+ isAsyncIterable,
+ isDestroyed,
+ parseRawHeaders,
+ parseHeaders: parseHeaders2,
+ parseKeepAliveTimeout,
+ destroy,
+ bodyLength,
+ deepClone,
+ ReadableStreamFrom,
+ isBuffer,
+ validateHandler,
+ getSocketInfo,
+ isFormDataLike,
+ buildURL,
+ nodeMajor,
+ nodeMinor,
+ nodeHasAutoSelectFamily: nodeMajor > 18 || nodeMajor === 18 && nodeMinor >= 13
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/timers.js
+var require_timers = __commonJS({
+ "../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/timers.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var fastNow = Date.now();
+ var fastNowTimeout;
+ var fastTimers = [];
+ function onTimeout() {
+ fastNow = Date.now();
+ let len = fastTimers.length;
+ let idx = 0;
+ while (idx < len) {
+ const timer = fastTimers[idx];
+ if (timer.expires && fastNow >= timer.expires) {
+ timer.expires = 0;
+ timer.callback(timer.opaque);
+ }
+ if (timer.expires === 0) {
+ timer.active = false;
+ if (idx !== len - 1) {
+ fastTimers[idx] = fastTimers.pop();
+ } else {
+ fastTimers.pop();
+ }
+ len -= 1;
+ } else {
+ idx += 1;
+ }
+ }
+ if (fastTimers.length > 0) {
+ refreshTimeout();
+ }
+ }
+ __name(onTimeout, "onTimeout");
+ function refreshTimeout() {
+ if (fastNowTimeout && fastNowTimeout.refresh) {
+ fastNowTimeout.refresh();
+ } else {
+ clearTimeout(fastNowTimeout);
+ fastNowTimeout = setTimeout(onTimeout, 1e3);
+ if (fastNowTimeout.unref) {
+ fastNowTimeout.unref();
+ }
+ }
+ }
+ __name(refreshTimeout, "refreshTimeout");
+ var Timeout = class {
+ constructor(callback, delay, opaque) {
+ this.callback = callback;
+ this.delay = delay;
+ this.opaque = opaque;
+ this.expires = 0;
+ this.active = false;
+ this.refresh();
+ }
+ refresh() {
+ if (!this.active) {
+ this.active = true;
+ fastTimers.push(this);
+ if (!fastNowTimeout || fastTimers.length === 1) {
+ refreshTimeout();
+ fastNow = Date.now();
+ }
+ }
+ this.expires = fastNow + this.delay;
+ }
+ clear() {
+ this.expires = 0;
+ }
+ };
+ __name(Timeout, "Timeout");
+ module2.exports = {
+ setTimeout(callback, delay, opaque) {
+ return new Timeout(callback, delay, opaque);
+ },
+ clearTimeout(timeout) {
+ if (timeout && timeout.clear) {
+ timeout.clear();
+ }
+ }
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/busboy@1.6.0/node_modules/busboy/lib/utils.js
+var require_utils = __commonJS({
+ "../../node_modules/.pnpm/busboy@1.6.0/node_modules/busboy/lib/utils.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ function parseContentType(str) {
+ if (str.length === 0)
+ return;
+ const params = /* @__PURE__ */ Object.create(null);
+ let i = 0;
+ for (; i < str.length; ++i) {
+ const code = str.charCodeAt(i);
+ if (TOKEN[code] !== 1) {
+ if (code !== 47 || i === 0)
+ return;
+ break;
+ }
+ }
+ if (i === str.length)
+ return;
+ const type = str.slice(0, i).toLowerCase();
+ const subtypeStart = ++i;
+ for (; i < str.length; ++i) {
+ const code = str.charCodeAt(i);
+ if (TOKEN[code] !== 1) {
+ if (i === subtypeStart)
+ return;
+ if (parseContentTypeParams(str, i, params) === void 0)
+ return;
+ break;
+ }
+ }
+ if (i === subtypeStart)
+ return;
+ const subtype = str.slice(subtypeStart, i).toLowerCase();
+ return { type, subtype, params };
+ }
+ __name(parseContentType, "parseContentType");
+ function parseContentTypeParams(str, i, params) {
+ while (i < str.length) {
+ for (; i < str.length; ++i) {
+ const code = str.charCodeAt(i);
+ if (code !== 32 && code !== 9)
+ break;
+ }
+ if (i === str.length)
+ break;
+ if (str.charCodeAt(i++) !== 59)
+ return;
+ for (; i < str.length; ++i) {
+ const code = str.charCodeAt(i);
+ if (code !== 32 && code !== 9)
+ break;
+ }
+ if (i === str.length)
+ return;
+ let name;
+ const nameStart = i;
+ for (; i < str.length; ++i) {
+ const code = str.charCodeAt(i);
+ if (TOKEN[code] !== 1) {
+ if (code !== 61)
+ return;
+ break;
+ }
+ }
+ if (i === str.length)
+ return;
+ name = str.slice(nameStart, i);
+ ++i;
+ if (i === str.length)
+ return;
+ let value = "";
+ let valueStart;
+ if (str.charCodeAt(i) === 34) {
+ valueStart = ++i;
+ let escaping = false;
+ for (; i < str.length; ++i) {
+ const code = str.charCodeAt(i);
+ if (code === 92) {
+ if (escaping) {
+ valueStart = i;
+ escaping = false;
+ } else {
+ value += str.slice(valueStart, i);
+ escaping = true;
+ }
+ continue;
+ }
+ if (code === 34) {
+ if (escaping) {
+ valueStart = i;
+ escaping = false;
+ continue;
+ }
+ value += str.slice(valueStart, i);
+ break;
+ }
+ if (escaping) {
+ valueStart = i - 1;
+ escaping = false;
+ }
+ if (QDTEXT[code] !== 1)
+ return;
+ }
+ if (i === str.length)
+ return;
+ ++i;
+ } else {
+ valueStart = i;
+ for (; i < str.length; ++i) {
+ const code = str.charCodeAt(i);
+ if (TOKEN[code] !== 1) {
+ if (i === valueStart)
+ return;
+ break;
+ }
+ }
+ value = str.slice(valueStart, i);
+ }
+ name = name.toLowerCase();
+ if (params[name] === void 0)
+ params[name] = value;
+ }
+ return params;
+ }
+ __name(parseContentTypeParams, "parseContentTypeParams");
+ function parseDisposition(str, defDecoder) {
+ if (str.length === 0)
+ return;
+ const params = /* @__PURE__ */ Object.create(null);
+ let i = 0;
+ for (; i < str.length; ++i) {
+ const code = str.charCodeAt(i);
+ if (TOKEN[code] !== 1) {
+ if (parseDispositionParams(str, i, params, defDecoder) === void 0)
+ return;
+ break;
+ }
+ }
+ const type = str.slice(0, i).toLowerCase();
+ return { type, params };
+ }
+ __name(parseDisposition, "parseDisposition");
+ function parseDispositionParams(str, i, params, defDecoder) {
+ while (i < str.length) {
+ for (; i < str.length; ++i) {
+ const code = str.charCodeAt(i);
+ if (code !== 32 && code !== 9)
+ break;
+ }
+ if (i === str.length)
+ break;
+ if (str.charCodeAt(i++) !== 59)
+ return;
+ for (; i < str.length; ++i) {
+ const code = str.charCodeAt(i);
+ if (code !== 32 && code !== 9)
+ break;
+ }
+ if (i === str.length)
+ return;
+ let name;
+ const nameStart = i;
+ for (; i < str.length; ++i) {
+ const code = str.charCodeAt(i);
+ if (TOKEN[code] !== 1) {
+ if (code === 61)
+ break;
+ return;
+ }
+ }
+ if (i === str.length)
+ return;
+ let value = "";
+ let valueStart;
+ let charset;
+ name = str.slice(nameStart, i);
+ if (name.charCodeAt(name.length - 1) === 42) {
+ const charsetStart = ++i;
+ for (; i < str.length; ++i) {
+ const code = str.charCodeAt(i);
+ if (CHARSET[code] !== 1) {
+ if (code !== 39)
+ return;
+ break;
+ }
+ }
+ if (i === str.length)
+ return;
+ charset = str.slice(charsetStart, i);
+ ++i;
+ for (; i < str.length; ++i) {
+ const code = str.charCodeAt(i);
+ if (code === 39)
+ break;
+ }
+ if (i === str.length)
+ return;
+ ++i;
+ if (i === str.length)
+ return;
+ valueStart = i;
+ let encode = 0;
+ for (; i < str.length; ++i) {
+ const code = str.charCodeAt(i);
+ if (EXTENDED_VALUE[code] !== 1) {
+ if (code === 37) {
+ let hexUpper;
+ let hexLower;
+ if (i + 2 < str.length && (hexUpper = HEX_VALUES[str.charCodeAt(i + 1)]) !== -1 && (hexLower = HEX_VALUES[str.charCodeAt(i + 2)]) !== -1) {
+ const byteVal = (hexUpper << 4) + hexLower;
+ value += str.slice(valueStart, i);
+ value += String.fromCharCode(byteVal);
+ i += 2;
+ valueStart = i + 1;
+ if (byteVal >= 128)
+ encode = 2;
+ else if (encode === 0)
+ encode = 1;
+ continue;
+ }
+ return;
+ }
+ break;
+ }
+ }
+ value += str.slice(valueStart, i);
+ value = convertToUTF8(value, charset, encode);
+ if (value === void 0)
+ return;
+ } else {
+ ++i;
+ if (i === str.length)
+ return;
+ if (str.charCodeAt(i) === 34) {
+ valueStart = ++i;
+ let escaping = false;
+ for (; i < str.length; ++i) {
+ const code = str.charCodeAt(i);
+ if (code === 92) {
+ if (escaping) {
+ valueStart = i;
+ escaping = false;
+ } else {
+ value += str.slice(valueStart, i);
+ escaping = true;
+ }
+ continue;
+ }
+ if (code === 34) {
+ if (escaping) {
+ valueStart = i;
+ escaping = false;
+ continue;
+ }
+ value += str.slice(valueStart, i);
+ break;
+ }
+ if (escaping) {
+ valueStart = i - 1;
+ escaping = false;
+ }
+ if (QDTEXT[code] !== 1)
+ return;
+ }
+ if (i === str.length)
+ return;
+ ++i;
+ } else {
+ valueStart = i;
+ for (; i < str.length; ++i) {
+ const code = str.charCodeAt(i);
+ if (TOKEN[code] !== 1) {
+ if (i === valueStart)
+ return;
+ break;
+ }
+ }
+ value = str.slice(valueStart, i);
+ }
+ value = defDecoder(value, 2);
+ if (value === void 0)
+ return;
+ }
+ name = name.toLowerCase();
+ if (params[name] === void 0)
+ params[name] = value;
+ }
+ return params;
+ }
+ __name(parseDispositionParams, "parseDispositionParams");
+ function getDecoder(charset) {
+ let lc;
+ while (true) {
+ switch (charset) {
+ case "utf-8":
+ case "utf8":
+ return decoders.utf8;
+ case "latin1":
+ case "ascii":
+ case "us-ascii":
+ case "iso-8859-1":
+ case "iso8859-1":
+ case "iso88591":
+ case "iso_8859-1":
+ case "windows-1252":
+ case "iso_8859-1:1987":
+ case "cp1252":
+ case "x-cp1252":
+ return decoders.latin1;
+ case "utf16le":
+ case "utf-16le":
+ case "ucs2":
+ case "ucs-2":
+ return decoders.utf16le;
+ case "base64":
+ return decoders.base64;
+ default:
+ if (lc === void 0) {
+ lc = true;
+ charset = charset.toLowerCase();
+ continue;
+ }
+ return decoders.other.bind(charset);
+ }
+ }
+ }
+ __name(getDecoder, "getDecoder");
+ var decoders = {
+ utf8: (data, hint) => {
+ if (data.length === 0)
+ return "";
+ if (typeof data === "string") {
+ if (hint < 2)
+ return data;
+ data = Buffer.from(data, "latin1");
+ }
+ return data.utf8Slice(0, data.length);
+ },
+ latin1: (data, hint) => {
+ if (data.length === 0)
+ return "";
+ if (typeof data === "string")
+ return data;
+ return data.latin1Slice(0, data.length);
+ },
+ utf16le: (data, hint) => {
+ if (data.length === 0)
+ return "";
+ if (typeof data === "string")
+ data = Buffer.from(data, "latin1");
+ return data.ucs2Slice(0, data.length);
+ },
+ base64: (data, hint) => {
+ if (data.length === 0)
+ return "";
+ if (typeof data === "string")
+ data = Buffer.from(data, "latin1");
+ return data.base64Slice(0, data.length);
+ },
+ other: (data, hint) => {
+ if (data.length === 0)
+ return "";
+ if (typeof data === "string")
+ data = Buffer.from(data, "latin1");
+ try {
+ const decoder = new TextDecoder(exports2);
+ return decoder.decode(data);
+ } catch {
+ }
+ }
+ };
+ function convertToUTF8(data, charset, hint) {
+ const decode = getDecoder(charset);
+ if (decode)
+ return decode(data, hint);
+ }
+ __name(convertToUTF8, "convertToUTF8");
+ function basename6(path45) {
+ if (typeof path45 !== "string")
+ return "";
+ for (let i = path45.length - 1; i >= 0; --i) {
+ switch (path45.charCodeAt(i)) {
+ case 47:
+ case 92:
+ path45 = path45.slice(i + 1);
+ return path45 === ".." || path45 === "." ? "" : path45;
+ }
+ }
+ return path45 === ".." || path45 === "." ? "" : path45;
+ }
+ __name(basename6, "basename");
+ var TOKEN = [
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 1,
+ 0,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 0,
+ 0,
+ 1,
+ 1,
+ 0,
+ 1,
+ 1,
+ 0,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 0,
+ 0,
+ 0,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 0,
+ 1,
+ 0,
+ 1,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0
+ ];
+ var QDTEXT = [
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 1,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 1,
+ 1,
+ 0,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 0,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 0,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1
+ ];
+ var CHARSET = [
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 1,
+ 0,
+ 1,
+ 1,
+ 1,
+ 1,
+ 0,
+ 0,
+ 0,
+ 0,
+ 1,
+ 0,
+ 1,
+ 0,
+ 0,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 0,
+ 0,
+ 0,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 0,
+ 1,
+ 1,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0
+ ];
+ var EXTENDED_VALUE = [
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 1,
+ 0,
+ 1,
+ 1,
+ 0,
+ 1,
+ 0,
+ 0,
+ 0,
+ 0,
+ 1,
+ 0,
+ 1,
+ 1,
+ 0,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 0,
+ 0,
+ 0,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 0,
+ 1,
+ 0,
+ 1,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0
+ ];
+ var HEX_VALUES = [
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ 0,
+ 1,
+ 2,
+ 3,
+ 4,
+ 5,
+ 6,
+ 7,
+ 8,
+ 9,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ 10,
+ 11,
+ 12,
+ 13,
+ 14,
+ 15,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ 10,
+ 11,
+ 12,
+ 13,
+ 14,
+ 15,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1
+ ];
+ module2.exports = {
+ basename: basename6,
+ convertToUTF8,
+ getDecoder,
+ parseContentType,
+ parseDisposition
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/streamsearch@1.1.0/node_modules/streamsearch/lib/sbmh.js
+var require_sbmh = __commonJS({
+ "../../node_modules/.pnpm/streamsearch@1.1.0/node_modules/streamsearch/lib/sbmh.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ function memcmp(buf1, pos1, buf2, pos2, num) {
+ for (let i = 0; i < num; ++i) {
+ if (buf1[pos1 + i] !== buf2[pos2 + i])
+ return false;
+ }
+ return true;
+ }
+ __name(memcmp, "memcmp");
+ var SBMH = class {
+ constructor(needle, cb) {
+ if (typeof cb !== "function")
+ throw new Error("Missing match callback");
+ if (typeof needle === "string")
+ needle = Buffer.from(needle);
+ else if (!Buffer.isBuffer(needle))
+ throw new Error(`Expected Buffer for needle, got ${typeof needle}`);
+ const needleLen = needle.length;
+ this.maxMatches = Infinity;
+ this.matches = 0;
+ this._cb = cb;
+ this._lookbehindSize = 0;
+ this._needle = needle;
+ this._bufPos = 0;
+ this._lookbehind = Buffer.allocUnsafe(needleLen);
+ this._occ = [
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen,
+ needleLen
+ ];
+ if (needleLen > 1) {
+ for (let i = 0; i < needleLen - 1; ++i)
+ this._occ[needle[i]] = needleLen - 1 - i;
+ }
+ }
+ reset() {
+ this.matches = 0;
+ this._lookbehindSize = 0;
+ this._bufPos = 0;
+ }
+ push(chunk, pos) {
+ let result;
+ if (!Buffer.isBuffer(chunk))
+ chunk = Buffer.from(chunk, "latin1");
+ const chunkLen = chunk.length;
+ this._bufPos = pos || 0;
+ while (result !== chunkLen && this.matches < this.maxMatches)
+ result = feed(this, chunk);
+ return result;
+ }
+ destroy() {
+ const lbSize = this._lookbehindSize;
+ if (lbSize)
+ this._cb(false, this._lookbehind, 0, lbSize, false);
+ this.reset();
+ }
+ };
+ __name(SBMH, "SBMH");
+ function feed(self2, data) {
+ const len = data.length;
+ const needle = self2._needle;
+ const needleLen = needle.length;
+ let pos = -self2._lookbehindSize;
+ const lastNeedleCharPos = needleLen - 1;
+ const lastNeedleChar = needle[lastNeedleCharPos];
+ const end = len - needleLen;
+ const occ = self2._occ;
+ const lookbehind = self2._lookbehind;
+ if (pos < 0) {
+ while (pos < 0 && pos <= end) {
+ const nextPos = pos + lastNeedleCharPos;
+ const ch = nextPos < 0 ? lookbehind[self2._lookbehindSize + nextPos] : data[nextPos];
+ if (ch === lastNeedleChar && matchNeedle(self2, data, pos, lastNeedleCharPos)) {
+ self2._lookbehindSize = 0;
+ ++self2.matches;
+ if (pos > -self2._lookbehindSize)
+ self2._cb(true, lookbehind, 0, self2._lookbehindSize + pos, false);
+ else
+ self2._cb(true, void 0, 0, 0, true);
+ return self2._bufPos = pos + needleLen;
+ }
+ pos += occ[ch];
+ }
+ while (pos < 0 && !matchNeedle(self2, data, pos, len - pos))
+ ++pos;
+ if (pos < 0) {
+ const bytesToCutOff = self2._lookbehindSize + pos;
+ if (bytesToCutOff > 0) {
+ self2._cb(false, lookbehind, 0, bytesToCutOff, false);
+ }
+ self2._lookbehindSize -= bytesToCutOff;
+ lookbehind.copy(lookbehind, 0, bytesToCutOff, self2._lookbehindSize);
+ lookbehind.set(data, self2._lookbehindSize);
+ self2._lookbehindSize += len;
+ self2._bufPos = len;
+ return len;
+ }
+ self2._cb(false, lookbehind, 0, self2._lookbehindSize, false);
+ self2._lookbehindSize = 0;
+ }
+ pos += self2._bufPos;
+ const firstNeedleChar = needle[0];
+ while (pos <= end) {
+ const ch = data[pos + lastNeedleCharPos];
+ if (ch === lastNeedleChar && data[pos] === firstNeedleChar && memcmp(needle, 0, data, pos, lastNeedleCharPos)) {
+ ++self2.matches;
+ if (pos > 0)
+ self2._cb(true, data, self2._bufPos, pos, true);
+ else
+ self2._cb(true, void 0, 0, 0, true);
+ return self2._bufPos = pos + needleLen;
+ }
+ pos += occ[ch];
+ }
+ while (pos < len) {
+ if (data[pos] !== firstNeedleChar || !memcmp(data, pos, needle, 0, len - pos)) {
+ ++pos;
+ continue;
+ }
+ data.copy(lookbehind, 0, pos, len);
+ self2._lookbehindSize = len - pos;
+ break;
+ }
+ if (pos > 0)
+ self2._cb(false, data, self2._bufPos, pos < len ? pos : len, true);
+ self2._bufPos = len;
+ return len;
+ }
+ __name(feed, "feed");
+ function matchNeedle(self2, data, pos, len) {
+ const lb = self2._lookbehind;
+ const lbSize = self2._lookbehindSize;
+ const needle = self2._needle;
+ for (let i = 0; i < len; ++i, ++pos) {
+ const ch = pos < 0 ? lb[lbSize + pos] : data[pos];
+ if (ch !== needle[i])
+ return false;
+ }
+ return true;
+ }
+ __name(matchNeedle, "matchNeedle");
+ module2.exports = SBMH;
+ }
+});
+
+// ../../node_modules/.pnpm/busboy@1.6.0/node_modules/busboy/lib/types/multipart.js
+var require_multipart = __commonJS({
+ "../../node_modules/.pnpm/busboy@1.6.0/node_modules/busboy/lib/types/multipart.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var { Readable, Writable } = require("stream");
+ var StreamSearch = require_sbmh();
+ var {
+ basename: basename6,
+ convertToUTF8,
+ getDecoder,
+ parseContentType,
+ parseDisposition
+ } = require_utils();
+ var BUF_CRLF = Buffer.from("\r\n");
+ var BUF_CR = Buffer.from("\r");
+ var BUF_DASH = Buffer.from("-");
+ function noop() {
+ }
+ __name(noop, "noop");
+ var MAX_HEADER_PAIRS = 2e3;
+ var MAX_HEADER_SIZE = 16 * 1024;
+ var HPARSER_NAME = 0;
+ var HPARSER_PRE_OWS = 1;
+ var HPARSER_VALUE = 2;
+ var HeaderParser = class {
+ constructor(cb) {
+ this.header = /* @__PURE__ */ Object.create(null);
+ this.pairCount = 0;
+ this.byteCount = 0;
+ this.state = HPARSER_NAME;
+ this.name = "";
+ this.value = "";
+ this.crlf = 0;
+ this.cb = cb;
+ }
+ reset() {
+ this.header = /* @__PURE__ */ Object.create(null);
+ this.pairCount = 0;
+ this.byteCount = 0;
+ this.state = HPARSER_NAME;
+ this.name = "";
+ this.value = "";
+ this.crlf = 0;
+ }
+ push(chunk, pos, end) {
+ let start = pos;
+ while (pos < end) {
+ switch (this.state) {
+ case HPARSER_NAME: {
+ let done = false;
+ for (; pos < end; ++pos) {
+ if (this.byteCount === MAX_HEADER_SIZE)
+ return -1;
+ ++this.byteCount;
+ const code = chunk[pos];
+ if (TOKEN[code] !== 1) {
+ if (code !== 58)
+ return -1;
+ this.name += chunk.latin1Slice(start, pos);
+ if (this.name.length === 0)
+ return -1;
+ ++pos;
+ done = true;
+ this.state = HPARSER_PRE_OWS;
+ break;
+ }
+ }
+ if (!done) {
+ this.name += chunk.latin1Slice(start, pos);
+ break;
+ }
+ }
+ case HPARSER_PRE_OWS: {
+ let done = false;
+ for (; pos < end; ++pos) {
+ if (this.byteCount === MAX_HEADER_SIZE)
+ return -1;
+ ++this.byteCount;
+ const code = chunk[pos];
+ if (code !== 32 && code !== 9) {
+ start = pos;
+ done = true;
+ this.state = HPARSER_VALUE;
+ break;
+ }
+ }
+ if (!done)
+ break;
+ }
+ case HPARSER_VALUE:
+ switch (this.crlf) {
+ case 0:
+ for (; pos < end; ++pos) {
+ if (this.byteCount === MAX_HEADER_SIZE)
+ return -1;
+ ++this.byteCount;
+ const code = chunk[pos];
+ if (FIELD_VCHAR[code] !== 1) {
+ if (code !== 13)
+ return -1;
+ ++this.crlf;
+ break;
+ }
+ }
+ this.value += chunk.latin1Slice(start, pos++);
+ break;
+ case 1:
+ if (this.byteCount === MAX_HEADER_SIZE)
+ return -1;
+ ++this.byteCount;
+ if (chunk[pos++] !== 10)
+ return -1;
+ ++this.crlf;
+ break;
+ case 2: {
+ if (this.byteCount === MAX_HEADER_SIZE)
+ return -1;
+ ++this.byteCount;
+ const code = chunk[pos];
+ if (code === 32 || code === 9) {
+ start = pos;
+ this.crlf = 0;
+ } else {
+ if (++this.pairCount < MAX_HEADER_PAIRS) {
+ this.name = this.name.toLowerCase();
+ if (this.header[this.name] === void 0)
+ this.header[this.name] = [this.value];
+ else
+ this.header[this.name].push(this.value);
+ }
+ if (code === 13) {
+ ++this.crlf;
+ ++pos;
+ } else {
+ start = pos;
+ this.crlf = 0;
+ this.state = HPARSER_NAME;
+ this.name = "";
+ this.value = "";
+ }
+ }
+ break;
+ }
+ case 3: {
+ if (this.byteCount === MAX_HEADER_SIZE)
+ return -1;
+ ++this.byteCount;
+ if (chunk[pos++] !== 10)
+ return -1;
+ const header = this.header;
+ this.reset();
+ this.cb(header);
+ return pos;
+ }
+ }
+ break;
+ }
+ }
+ return pos;
+ }
+ };
+ __name(HeaderParser, "HeaderParser");
+ var FileStream = class extends Readable {
+ constructor(opts, owner) {
+ super(opts);
+ this.truncated = false;
+ this._readcb = null;
+ this.once("end", () => {
+ this._read();
+ if (--owner._fileEndsLeft === 0 && owner._finalcb) {
+ const cb = owner._finalcb;
+ owner._finalcb = null;
+ process.nextTick(cb);
+ }
+ });
+ }
+ _read(n) {
+ const cb = this._readcb;
+ if (cb) {
+ this._readcb = null;
+ cb();
+ }
+ }
+ };
+ __name(FileStream, "FileStream");
+ var ignoreData = {
+ push: (chunk, pos) => {
+ },
+ destroy: () => {
+ }
+ };
+ function callAndUnsetCb(self2, err) {
+ const cb = self2._writecb;
+ self2._writecb = null;
+ if (err)
+ self2.destroy(err);
+ else if (cb)
+ cb();
+ }
+ __name(callAndUnsetCb, "callAndUnsetCb");
+ function nullDecoder(val, hint) {
+ return val;
+ }
+ __name(nullDecoder, "nullDecoder");
+ var Multipart = class extends Writable {
+ constructor(cfg) {
+ const streamOpts = {
+ autoDestroy: true,
+ emitClose: true,
+ highWaterMark: typeof cfg.highWaterMark === "number" ? cfg.highWaterMark : void 0
+ };
+ super(streamOpts);
+ if (!cfg.conType.params || typeof cfg.conType.params.boundary !== "string")
+ throw new Error("Multipart: Boundary not found");
+ const boundary = cfg.conType.params.boundary;
+ const paramDecoder = typeof cfg.defParamCharset === "string" && cfg.defParamCharset ? getDecoder(cfg.defParamCharset) : nullDecoder;
+ const defCharset = cfg.defCharset || "utf8";
+ const preservePath = cfg.preservePath;
+ const fileOpts = {
+ autoDestroy: true,
+ emitClose: true,
+ highWaterMark: typeof cfg.fileHwm === "number" ? cfg.fileHwm : void 0
+ };
+ const limits = cfg.limits;
+ const fieldSizeLimit = limits && typeof limits.fieldSize === "number" ? limits.fieldSize : 1 * 1024 * 1024;
+ const fileSizeLimit = limits && typeof limits.fileSize === "number" ? limits.fileSize : Infinity;
+ const filesLimit = limits && typeof limits.files === "number" ? limits.files : Infinity;
+ const fieldsLimit = limits && typeof limits.fields === "number" ? limits.fields : Infinity;
+ const partsLimit = limits && typeof limits.parts === "number" ? limits.parts : Infinity;
+ let parts = -1;
+ let fields = 0;
+ let files = 0;
+ let skipPart = false;
+ this._fileEndsLeft = 0;
+ this._fileStream = void 0;
+ this._complete = false;
+ let fileSize = 0;
+ let field;
+ let fieldSize = 0;
+ let partCharset;
+ let partEncoding;
+ let partType;
+ let partName;
+ let partTruncated = false;
+ let hitFilesLimit = false;
+ let hitFieldsLimit = false;
+ this._hparser = null;
+ const hparser = new HeaderParser((header) => {
+ this._hparser = null;
+ skipPart = false;
+ partType = "text/plain";
+ partCharset = defCharset;
+ partEncoding = "7bit";
+ partName = void 0;
+ partTruncated = false;
+ let filename;
+ if (!header["content-disposition"]) {
+ skipPart = true;
+ return;
+ }
+ const disp = parseDisposition(
+ header["content-disposition"][0],
+ paramDecoder
+ );
+ if (!disp || disp.type !== "form-data") {
+ skipPart = true;
+ return;
+ }
+ if (disp.params) {
+ if (disp.params.name)
+ partName = disp.params.name;
+ if (disp.params["filename*"])
+ filename = disp.params["filename*"];
+ else if (disp.params.filename)
+ filename = disp.params.filename;
+ if (filename !== void 0 && !preservePath)
+ filename = basename6(filename);
+ }
+ if (header["content-type"]) {
+ const conType = parseContentType(header["content-type"][0]);
+ if (conType) {
+ partType = `${conType.type}/${conType.subtype}`;
+ if (conType.params && typeof conType.params.charset === "string")
+ partCharset = conType.params.charset.toLowerCase();
+ }
+ }
+ if (header["content-transfer-encoding"])
+ partEncoding = header["content-transfer-encoding"][0].toLowerCase();
+ if (partType === "application/octet-stream" || filename !== void 0) {
+ if (files === filesLimit) {
+ if (!hitFilesLimit) {
+ hitFilesLimit = true;
+ this.emit("filesLimit");
+ }
+ skipPart = true;
+ return;
+ }
+ ++files;
+ if (this.listenerCount("file") === 0) {
+ skipPart = true;
+ return;
+ }
+ fileSize = 0;
+ this._fileStream = new FileStream(fileOpts, this);
+ ++this._fileEndsLeft;
+ this.emit(
+ "file",
+ partName,
+ this._fileStream,
+ {
+ filename,
+ encoding: partEncoding,
+ mimeType: partType
+ }
+ );
+ } else {
+ if (fields === fieldsLimit) {
+ if (!hitFieldsLimit) {
+ hitFieldsLimit = true;
+ this.emit("fieldsLimit");
+ }
+ skipPart = true;
+ return;
+ }
+ ++fields;
+ if (this.listenerCount("field") === 0) {
+ skipPart = true;
+ return;
+ }
+ field = [];
+ fieldSize = 0;
+ }
+ });
+ let matchPostBoundary = 0;
+ const ssCb = /* @__PURE__ */ __name((isMatch, data, start, end, isDataSafe) => {
+ retrydata:
+ while (data) {
+ if (this._hparser !== null) {
+ const ret = this._hparser.push(data, start, end);
+ if (ret === -1) {
+ this._hparser = null;
+ hparser.reset();
+ this.emit("error", new Error("Malformed part header"));
+ break;
+ }
+ start = ret;
+ }
+ if (start === end)
+ break;
+ if (matchPostBoundary !== 0) {
+ if (matchPostBoundary === 1) {
+ switch (data[start]) {
+ case 45:
+ matchPostBoundary = 2;
+ ++start;
+ break;
+ case 13:
+ matchPostBoundary = 3;
+ ++start;
+ break;
+ default:
+ matchPostBoundary = 0;
+ }
+ if (start === end)
+ return;
+ }
+ if (matchPostBoundary === 2) {
+ matchPostBoundary = 0;
+ if (data[start] === 45) {
+ this._complete = true;
+ this._bparser = ignoreData;
+ return;
+ }
+ const writecb = this._writecb;
+ this._writecb = noop;
+ ssCb(false, BUF_DASH, 0, 1, false);
+ this._writecb = writecb;
+ } else if (matchPostBoundary === 3) {
+ matchPostBoundary = 0;
+ if (data[start] === 10) {
+ ++start;
+ if (parts >= partsLimit)
+ break;
+ this._hparser = hparser;
+ if (start === end)
+ break;
+ continue retrydata;
+ } else {
+ const writecb = this._writecb;
+ this._writecb = noop;
+ ssCb(false, BUF_CR, 0, 1, false);
+ this._writecb = writecb;
+ }
+ }
+ }
+ if (!skipPart) {
+ if (this._fileStream) {
+ let chunk;
+ const actualLen = Math.min(end - start, fileSizeLimit - fileSize);
+ if (!isDataSafe) {
+ chunk = Buffer.allocUnsafe(actualLen);
+ data.copy(chunk, 0, start, start + actualLen);
+ } else {
+ chunk = data.slice(start, start + actualLen);
+ }
+ fileSize += chunk.length;
+ if (fileSize === fileSizeLimit) {
+ if (chunk.length > 0)
+ this._fileStream.push(chunk);
+ this._fileStream.emit("limit");
+ this._fileStream.truncated = true;
+ skipPart = true;
+ } else if (!this._fileStream.push(chunk)) {
+ if (this._writecb)
+ this._fileStream._readcb = this._writecb;
+ this._writecb = null;
+ }
+ } else if (field !== void 0) {
+ let chunk;
+ const actualLen = Math.min(
+ end - start,
+ fieldSizeLimit - fieldSize
+ );
+ if (!isDataSafe) {
+ chunk = Buffer.allocUnsafe(actualLen);
+ data.copy(chunk, 0, start, start + actualLen);
+ } else {
+ chunk = data.slice(start, start + actualLen);
+ }
+ fieldSize += actualLen;
+ field.push(chunk);
+ if (fieldSize === fieldSizeLimit) {
+ skipPart = true;
+ partTruncated = true;
+ }
+ }
+ }
+ break;
+ }
+ if (isMatch) {
+ matchPostBoundary = 1;
+ if (this._fileStream) {
+ this._fileStream.push(null);
+ this._fileStream = null;
+ } else if (field !== void 0) {
+ let data2;
+ switch (field.length) {
+ case 0:
+ data2 = "";
+ break;
+ case 1:
+ data2 = convertToUTF8(field[0], partCharset, 0);
+ break;
+ default:
+ data2 = convertToUTF8(
+ Buffer.concat(field, fieldSize),
+ partCharset,
+ 0
+ );
+ }
+ field = void 0;
+ fieldSize = 0;
+ this.emit(
+ "field",
+ partName,
+ data2,
+ {
+ nameTruncated: false,
+ valueTruncated: partTruncated,
+ encoding: partEncoding,
+ mimeType: partType
+ }
+ );
+ }
+ if (++parts === partsLimit)
+ this.emit("partsLimit");
+ }
+ }, "ssCb");
+ this._bparser = new StreamSearch(`\r
+--${boundary}`, ssCb);
+ this._writecb = null;
+ this._finalcb = null;
+ this.write(BUF_CRLF);
+ }
+ static detect(conType) {
+ return conType.type === "multipart" && conType.subtype === "form-data";
+ }
+ _write(chunk, enc, cb) {
+ this._writecb = cb;
+ this._bparser.push(chunk, 0);
+ if (this._writecb)
+ callAndUnsetCb(this);
+ }
+ _destroy(err, cb) {
+ this._hparser = null;
+ this._bparser = ignoreData;
+ if (!err)
+ err = checkEndState(this);
+ const fileStream = this._fileStream;
+ if (fileStream) {
+ this._fileStream = null;
+ fileStream.destroy(err);
+ }
+ cb(err);
+ }
+ _final(cb) {
+ this._bparser.destroy();
+ if (!this._complete)
+ return cb(new Error("Unexpected end of form"));
+ if (this._fileEndsLeft)
+ this._finalcb = finalcb.bind(null, this, cb);
+ else
+ finalcb(this, cb);
+ }
+ };
+ __name(Multipart, "Multipart");
+ function finalcb(self2, cb, err) {
+ if (err)
+ return cb(err);
+ err = checkEndState(self2);
+ cb(err);
+ }
+ __name(finalcb, "finalcb");
+ function checkEndState(self2) {
+ if (self2._hparser)
+ return new Error("Malformed part header");
+ const fileStream = self2._fileStream;
+ if (fileStream) {
+ self2._fileStream = null;
+ fileStream.destroy(new Error("Unexpected end of file"));
+ }
+ if (!self2._complete)
+ return new Error("Unexpected end of form");
+ }
+ __name(checkEndState, "checkEndState");
+ var TOKEN = [
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 1,
+ 0,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 0,
+ 0,
+ 1,
+ 1,
+ 0,
+ 1,
+ 1,
+ 0,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 0,
+ 0,
+ 0,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 0,
+ 1,
+ 0,
+ 1,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0
+ ];
+ var FIELD_VCHAR = [
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 1,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 0,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1
+ ];
+ module2.exports = Multipart;
+ }
+});
+
+// ../../node_modules/.pnpm/busboy@1.6.0/node_modules/busboy/lib/types/urlencoded.js
+var require_urlencoded = __commonJS({
+ "../../node_modules/.pnpm/busboy@1.6.0/node_modules/busboy/lib/types/urlencoded.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var { Writable } = require("stream");
+ var { getDecoder } = require_utils();
+ var URLEncoded = class extends Writable {
+ constructor(cfg) {
+ const streamOpts = {
+ autoDestroy: true,
+ emitClose: true,
+ highWaterMark: typeof cfg.highWaterMark === "number" ? cfg.highWaterMark : void 0
+ };
+ super(streamOpts);
+ let charset = cfg.defCharset || "utf8";
+ if (cfg.conType.params && typeof cfg.conType.params.charset === "string")
+ charset = cfg.conType.params.charset;
+ this.charset = charset;
+ const limits = cfg.limits;
+ this.fieldSizeLimit = limits && typeof limits.fieldSize === "number" ? limits.fieldSize : 1 * 1024 * 1024;
+ this.fieldsLimit = limits && typeof limits.fields === "number" ? limits.fields : Infinity;
+ this.fieldNameSizeLimit = limits && typeof limits.fieldNameSize === "number" ? limits.fieldNameSize : 100;
+ this._inKey = true;
+ this._keyTrunc = false;
+ this._valTrunc = false;
+ this._bytesKey = 0;
+ this._bytesVal = 0;
+ this._fields = 0;
+ this._key = "";
+ this._val = "";
+ this._byte = -2;
+ this._lastPos = 0;
+ this._encode = 0;
+ this._decoder = getDecoder(charset);
+ }
+ static detect(conType) {
+ return conType.type === "application" && conType.subtype === "x-www-form-urlencoded";
+ }
+ _write(chunk, enc, cb) {
+ if (this._fields >= this.fieldsLimit)
+ return cb();
+ let i = 0;
+ const len = chunk.length;
+ this._lastPos = 0;
+ if (this._byte !== -2) {
+ i = readPctEnc(this, chunk, i, len);
+ if (i === -1)
+ return cb(new Error("Malformed urlencoded form"));
+ if (i >= len)
+ return cb();
+ if (this._inKey)
+ ++this._bytesKey;
+ else
+ ++this._bytesVal;
+ }
+ main:
+ while (i < len) {
+ if (this._inKey) {
+ i = skipKeyBytes(this, chunk, i, len);
+ while (i < len) {
+ switch (chunk[i]) {
+ case 61:
+ if (this._lastPos < i)
+ this._key += chunk.latin1Slice(this._lastPos, i);
+ this._lastPos = ++i;
+ this._key = this._decoder(this._key, this._encode);
+ this._encode = 0;
+ this._inKey = false;
+ continue main;
+ case 38:
+ if (this._lastPos < i)
+ this._key += chunk.latin1Slice(this._lastPos, i);
+ this._lastPos = ++i;
+ this._key = this._decoder(this._key, this._encode);
+ this._encode = 0;
+ if (this._bytesKey > 0) {
+ this.emit(
+ "field",
+ this._key,
+ "",
+ {
+ nameTruncated: this._keyTrunc,
+ valueTruncated: false,
+ encoding: this.charset,
+ mimeType: "text/plain"
+ }
+ );
+ }
+ this._key = "";
+ this._val = "";
+ this._keyTrunc = false;
+ this._valTrunc = false;
+ this._bytesKey = 0;
+ this._bytesVal = 0;
+ if (++this._fields >= this.fieldsLimit) {
+ this.emit("fieldsLimit");
+ return cb();
+ }
+ continue;
+ case 43:
+ if (this._lastPos < i)
+ this._key += chunk.latin1Slice(this._lastPos, i);
+ this._key += " ";
+ this._lastPos = i + 1;
+ break;
+ case 37:
+ if (this._encode === 0)
+ this._encode = 1;
+ if (this._lastPos < i)
+ this._key += chunk.latin1Slice(this._lastPos, i);
+ this._lastPos = i + 1;
+ this._byte = -1;
+ i = readPctEnc(this, chunk, i + 1, len);
+ if (i === -1)
+ return cb(new Error("Malformed urlencoded form"));
+ if (i >= len)
+ return cb();
+ ++this._bytesKey;
+ i = skipKeyBytes(this, chunk, i, len);
+ continue;
+ }
+ ++i;
+ ++this._bytesKey;
+ i = skipKeyBytes(this, chunk, i, len);
+ }
+ if (this._lastPos < i)
+ this._key += chunk.latin1Slice(this._lastPos, i);
+ } else {
+ i = skipValBytes(this, chunk, i, len);
+ while (i < len) {
+ switch (chunk[i]) {
+ case 38:
+ if (this._lastPos < i)
+ this._val += chunk.latin1Slice(this._lastPos, i);
+ this._lastPos = ++i;
+ this._inKey = true;
+ this._val = this._decoder(this._val, this._encode);
+ this._encode = 0;
+ if (this._bytesKey > 0 || this._bytesVal > 0) {
+ this.emit(
+ "field",
+ this._key,
+ this._val,
+ {
+ nameTruncated: this._keyTrunc,
+ valueTruncated: this._valTrunc,
+ encoding: this.charset,
+ mimeType: "text/plain"
+ }
+ );
+ }
+ this._key = "";
+ this._val = "";
+ this._keyTrunc = false;
+ this._valTrunc = false;
+ this._bytesKey = 0;
+ this._bytesVal = 0;
+ if (++this._fields >= this.fieldsLimit) {
+ this.emit("fieldsLimit");
+ return cb();
+ }
+ continue main;
+ case 43:
+ if (this._lastPos < i)
+ this._val += chunk.latin1Slice(this._lastPos, i);
+ this._val += " ";
+ this._lastPos = i + 1;
+ break;
+ case 37:
+ if (this._encode === 0)
+ this._encode = 1;
+ if (this._lastPos < i)
+ this._val += chunk.latin1Slice(this._lastPos, i);
+ this._lastPos = i + 1;
+ this._byte = -1;
+ i = readPctEnc(this, chunk, i + 1, len);
+ if (i === -1)
+ return cb(new Error("Malformed urlencoded form"));
+ if (i >= len)
+ return cb();
+ ++this._bytesVal;
+ i = skipValBytes(this, chunk, i, len);
+ continue;
+ }
+ ++i;
+ ++this._bytesVal;
+ i = skipValBytes(this, chunk, i, len);
+ }
+ if (this._lastPos < i)
+ this._val += chunk.latin1Slice(this._lastPos, i);
+ }
+ }
+ cb();
+ }
+ _final(cb) {
+ if (this._byte !== -2)
+ return cb(new Error("Malformed urlencoded form"));
+ if (!this._inKey || this._bytesKey > 0 || this._bytesVal > 0) {
+ if (this._inKey)
+ this._key = this._decoder(this._key, this._encode);
+ else
+ this._val = this._decoder(this._val, this._encode);
+ this.emit(
+ "field",
+ this._key,
+ this._val,
+ {
+ nameTruncated: this._keyTrunc,
+ valueTruncated: this._valTrunc,
+ encoding: this.charset,
+ mimeType: "text/plain"
+ }
+ );
+ }
+ cb();
+ }
+ };
+ __name(URLEncoded, "URLEncoded");
+ function readPctEnc(self2, chunk, pos, len) {
+ if (pos >= len)
+ return len;
+ if (self2._byte === -1) {
+ const hexUpper = HEX_VALUES[chunk[pos++]];
+ if (hexUpper === -1)
+ return -1;
+ if (hexUpper >= 8)
+ self2._encode = 2;
+ if (pos < len) {
+ const hexLower = HEX_VALUES[chunk[pos++]];
+ if (hexLower === -1)
+ return -1;
+ if (self2._inKey)
+ self2._key += String.fromCharCode((hexUpper << 4) + hexLower);
+ else
+ self2._val += String.fromCharCode((hexUpper << 4) + hexLower);
+ self2._byte = -2;
+ self2._lastPos = pos;
+ } else {
+ self2._byte = hexUpper;
+ }
+ } else {
+ const hexLower = HEX_VALUES[chunk[pos++]];
+ if (hexLower === -1)
+ return -1;
+ if (self2._inKey)
+ self2._key += String.fromCharCode((self2._byte << 4) + hexLower);
+ else
+ self2._val += String.fromCharCode((self2._byte << 4) + hexLower);
+ self2._byte = -2;
+ self2._lastPos = pos;
+ }
+ return pos;
+ }
+ __name(readPctEnc, "readPctEnc");
+ function skipKeyBytes(self2, chunk, pos, len) {
+ if (self2._bytesKey > self2.fieldNameSizeLimit) {
+ if (!self2._keyTrunc) {
+ if (self2._lastPos < pos)
+ self2._key += chunk.latin1Slice(self2._lastPos, pos - 1);
+ }
+ self2._keyTrunc = true;
+ for (; pos < len; ++pos) {
+ const code = chunk[pos];
+ if (code === 61 || code === 38)
+ break;
+ ++self2._bytesKey;
+ }
+ self2._lastPos = pos;
+ }
+ return pos;
+ }
+ __name(skipKeyBytes, "skipKeyBytes");
+ function skipValBytes(self2, chunk, pos, len) {
+ if (self2._bytesVal > self2.fieldSizeLimit) {
+ if (!self2._valTrunc) {
+ if (self2._lastPos < pos)
+ self2._val += chunk.latin1Slice(self2._lastPos, pos - 1);
+ }
+ self2._valTrunc = true;
+ for (; pos < len; ++pos) {
+ if (chunk[pos] === 38)
+ break;
+ ++self2._bytesVal;
+ }
+ self2._lastPos = pos;
+ }
+ return pos;
+ }
+ __name(skipValBytes, "skipValBytes");
+ var HEX_VALUES = [
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ 0,
+ 1,
+ 2,
+ 3,
+ 4,
+ 5,
+ 6,
+ 7,
+ 8,
+ 9,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ 10,
+ 11,
+ 12,
+ 13,
+ 14,
+ 15,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ 10,
+ 11,
+ 12,
+ 13,
+ 14,
+ 15,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1
+ ];
+ module2.exports = URLEncoded;
+ }
+});
+
+// ../../node_modules/.pnpm/busboy@1.6.0/node_modules/busboy/lib/index.js
+var require_lib = __commonJS({
+ "../../node_modules/.pnpm/busboy@1.6.0/node_modules/busboy/lib/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var { parseContentType } = require_utils();
+ function getInstance(cfg) {
+ const headers = cfg.headers;
+ const conType = parseContentType(headers["content-type"]);
+ if (!conType)
+ throw new Error("Malformed content type");
+ for (const type of TYPES) {
+ const matched = type.detect(conType);
+ if (!matched)
+ continue;
+ const instanceCfg = {
+ limits: cfg.limits,
+ headers,
+ conType,
+ highWaterMark: void 0,
+ fileHwm: void 0,
+ defCharset: void 0,
+ defParamCharset: void 0,
+ preservePath: false
+ };
+ if (cfg.highWaterMark)
+ instanceCfg.highWaterMark = cfg.highWaterMark;
+ if (cfg.fileHwm)
+ instanceCfg.fileHwm = cfg.fileHwm;
+ instanceCfg.defCharset = cfg.defCharset;
+ instanceCfg.defParamCharset = cfg.defParamCharset;
+ instanceCfg.preservePath = cfg.preservePath;
+ return new type(instanceCfg);
+ }
+ throw new Error(`Unsupported content type: ${headers["content-type"]}`);
+ }
+ __name(getInstance, "getInstance");
+ var TYPES = [
+ require_multipart(),
+ require_urlencoded()
+ ].filter(function(typemod) {
+ return typeof typemod.detect === "function";
+ });
+ module2.exports = (cfg) => {
+ if (typeof cfg !== "object" || cfg === null)
+ cfg = {};
+ if (typeof cfg.headers !== "object" || cfg.headers === null || typeof cfg.headers["content-type"] !== "string") {
+ throw new Error("Missing Content-Type");
+ }
+ return getInstance(cfg);
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/fetch/constants.js
+var require_constants = __commonJS({
+ "../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/fetch/constants.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var { MessageChannel: MessageChannel2, receiveMessageOnPort } = require("worker_threads");
+ var corsSafeListedMethods = ["GET", "HEAD", "POST"];
+ var nullBodyStatus = [101, 204, 205, 304];
+ var redirectStatus = [301, 302, 303, 307, 308];
+ var badPorts = [
+ "1",
+ "7",
+ "9",
+ "11",
+ "13",
+ "15",
+ "17",
+ "19",
+ "20",
+ "21",
+ "22",
+ "23",
+ "25",
+ "37",
+ "42",
+ "43",
+ "53",
+ "69",
+ "77",
+ "79",
+ "87",
+ "95",
+ "101",
+ "102",
+ "103",
+ "104",
+ "109",
+ "110",
+ "111",
+ "113",
+ "115",
+ "117",
+ "119",
+ "123",
+ "135",
+ "137",
+ "139",
+ "143",
+ "161",
+ "179",
+ "389",
+ "427",
+ "465",
+ "512",
+ "513",
+ "514",
+ "515",
+ "526",
+ "530",
+ "531",
+ "532",
+ "540",
+ "548",
+ "554",
+ "556",
+ "563",
+ "587",
+ "601",
+ "636",
+ "989",
+ "990",
+ "993",
+ "995",
+ "1719",
+ "1720",
+ "1723",
+ "2049",
+ "3659",
+ "4045",
+ "5060",
+ "5061",
+ "6000",
+ "6566",
+ "6665",
+ "6666",
+ "6667",
+ "6668",
+ "6669",
+ "6697",
+ "10080"
+ ];
+ var referrerPolicy = [
+ "",
+ "no-referrer",
+ "no-referrer-when-downgrade",
+ "same-origin",
+ "origin",
+ "strict-origin",
+ "origin-when-cross-origin",
+ "strict-origin-when-cross-origin",
+ "unsafe-url"
+ ];
+ var requestRedirect = ["follow", "manual", "error"];
+ var safeMethods = ["GET", "HEAD", "OPTIONS", "TRACE"];
+ var requestMode = ["navigate", "same-origin", "no-cors", "cors"];
+ var requestCredentials = ["omit", "same-origin", "include"];
+ var requestCache = [
+ "default",
+ "no-store",
+ "reload",
+ "no-cache",
+ "force-cache",
+ "only-if-cached"
+ ];
+ var requestBodyHeader = [
+ "content-encoding",
+ "content-language",
+ "content-location",
+ "content-type"
+ ];
+ var requestDuplex = [
+ "half"
+ ];
+ var forbiddenMethods = ["CONNECT", "TRACE", "TRACK"];
+ var subresource = [
+ "audio",
+ "audioworklet",
+ "font",
+ "image",
+ "manifest",
+ "paintworklet",
+ "script",
+ "style",
+ "track",
+ "video",
+ "xslt",
+ ""
+ ];
+ var DOMException = globalThis.DOMException ?? (() => {
+ try {
+ atob("~");
+ } catch (err) {
+ return Object.getPrototypeOf(err).constructor;
+ }
+ })();
+ var channel;
+ var structuredClone = globalThis.structuredClone ?? // https://github.com/nodejs/node/blob/b27ae24dcc4251bad726d9d84baf678d1f707fed/lib/internal/structured_clone.js
+ // structuredClone was added in v17.0.0, but fetch supports v16.8
+ /* @__PURE__ */ __name(function structuredClone2(value, options14 = void 0) {
+ if (arguments.length === 0) {
+ throw new TypeError("missing argument");
+ }
+ if (!channel) {
+ channel = new MessageChannel2();
+ }
+ channel.port1.unref();
+ channel.port2.unref();
+ channel.port1.postMessage(value, options14?.transfer);
+ return receiveMessageOnPort(channel.port2).message;
+ }, "structuredClone");
+ module2.exports = {
+ DOMException,
+ structuredClone,
+ subresource,
+ forbiddenMethods,
+ requestBodyHeader,
+ referrerPolicy,
+ requestRedirect,
+ requestMode,
+ requestCredentials,
+ requestCache,
+ redirectStatus,
+ corsSafeListedMethods,
+ nullBodyStatus,
+ safeMethods,
+ badPorts,
+ requestDuplex
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/fetch/util.js
+var require_util2 = __commonJS({
+ "../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/fetch/util.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var { redirectStatus, badPorts, referrerPolicy: referrerPolicyTokens } = require_constants();
+ var { performance: performance2 } = require("perf_hooks");
+ var { isBlobLike, toUSVString, ReadableStreamFrom } = require_util();
+ var assert18 = require("assert");
+ var { isUint8Array } = require("util/types");
+ var crypto6;
+ try {
+ crypto6 = require("crypto");
+ } catch {
+ }
+ function responseURL(response) {
+ const urlList = response.urlList;
+ const length = urlList.length;
+ return length === 0 ? null : urlList[length - 1].toString();
+ }
+ __name(responseURL, "responseURL");
+ function responseLocationURL(response, requestFragment) {
+ if (!redirectStatus.includes(response.status)) {
+ return null;
+ }
+ let location = response.headersList.get("location");
+ location = location ? new URL(location, responseURL(response)) : null;
+ if (location && !location.hash) {
+ location.hash = requestFragment;
+ }
+ return location;
+ }
+ __name(responseLocationURL, "responseLocationURL");
+ function requestCurrentURL(request) {
+ return request.urlList[request.urlList.length - 1];
+ }
+ __name(requestCurrentURL, "requestCurrentURL");
+ function requestBadPort(request) {
+ const url3 = requestCurrentURL(request);
+ if (/^https?:/.test(url3.protocol) && badPorts.includes(url3.port)) {
+ return "blocked";
+ }
+ return "allowed";
+ }
+ __name(requestBadPort, "requestBadPort");
+ function isErrorLike(object) {
+ return object instanceof Error || (object?.constructor?.name === "Error" || object?.constructor?.name === "DOMException");
+ }
+ __name(isErrorLike, "isErrorLike");
+ function isValidReasonPhrase(statusText) {
+ for (let i = 0; i < statusText.length; ++i) {
+ const c = statusText.charCodeAt(i);
+ if (!(c === 9 || // HTAB
+ c >= 32 && c <= 126 || // SP / VCHAR
+ c >= 128 && c <= 255)) {
+ return false;
+ }
+ }
+ return true;
+ }
+ __name(isValidReasonPhrase, "isValidReasonPhrase");
+ function isTokenChar(c) {
+ return !(c >= 127 || c <= 32 || c === "(" || c === ")" || c === "<" || c === ">" || c === "@" || c === "," || c === ";" || c === ":" || c === "\\" || c === '"' || c === "/" || c === "[" || c === "]" || c === "?" || c === "=" || c === "{" || c === "}");
+ }
+ __name(isTokenChar, "isTokenChar");
+ function isValidHTTPToken(characters) {
+ if (!characters || typeof characters !== "string") {
+ return false;
+ }
+ for (let i = 0; i < characters.length; ++i) {
+ const c = characters.charCodeAt(i);
+ if (c > 127 || !isTokenChar(c)) {
+ return false;
+ }
+ }
+ return true;
+ }
+ __name(isValidHTTPToken, "isValidHTTPToken");
+ function isValidHeaderName(potentialValue) {
+ if (potentialValue.length === 0) {
+ return false;
+ }
+ return isValidHTTPToken(potentialValue);
+ }
+ __name(isValidHeaderName, "isValidHeaderName");
+ function isValidHeaderValue(potentialValue) {
+ if (potentialValue.startsWith(" ") || potentialValue.startsWith(" ") || potentialValue.endsWith(" ") || potentialValue.endsWith(" ")) {
+ return false;
+ }
+ if (potentialValue.includes("\0") || potentialValue.includes("\r") || potentialValue.includes("\n")) {
+ return false;
+ }
+ return true;
+ }
+ __name(isValidHeaderValue, "isValidHeaderValue");
+ function setRequestReferrerPolicyOnRedirect(request, actualResponse) {
+ const { headersList } = actualResponse;
+ const policyHeader = (headersList.get("referrer-policy") ?? "").split(",");
+ let policy = "";
+ if (policyHeader.length > 0) {
+ for (let i = policyHeader.length; i !== 0; i--) {
+ const token = policyHeader[i - 1].trim();
+ if (referrerPolicyTokens.includes(token)) {
+ policy = token;
+ break;
+ }
+ }
+ }
+ if (policy !== "") {
+ request.referrerPolicy = policy;
+ }
+ }
+ __name(setRequestReferrerPolicyOnRedirect, "setRequestReferrerPolicyOnRedirect");
+ function crossOriginResourcePolicyCheck() {
+ return "allowed";
+ }
+ __name(crossOriginResourcePolicyCheck, "crossOriginResourcePolicyCheck");
+ function corsCheck() {
+ return "success";
+ }
+ __name(corsCheck, "corsCheck");
+ function TAOCheck() {
+ return "success";
+ }
+ __name(TAOCheck, "TAOCheck");
+ function appendFetchMetadata(httpRequest) {
+ let header = null;
+ header = httpRequest.mode;
+ httpRequest.headersList.set("sec-fetch-mode", header);
+ }
+ __name(appendFetchMetadata, "appendFetchMetadata");
+ function appendRequestOriginHeader(request) {
+ let serializedOrigin = request.origin;
+ if (request.responseTainting === "cors" || request.mode === "websocket") {
+ if (serializedOrigin) {
+ request.headersList.append("Origin", serializedOrigin);
+ }
+ } else if (request.method !== "GET" && request.method !== "HEAD") {
+ switch (request.referrerPolicy) {
+ case "no-referrer":
+ serializedOrigin = null;
+ break;
+ case "no-referrer-when-downgrade":
+ case "strict-origin":
+ case "strict-origin-when-cross-origin":
+ if (/^https:/.test(request.origin) && !/^https:/.test(requestCurrentURL(request))) {
+ serializedOrigin = null;
+ }
+ break;
+ case "same-origin":
+ if (!sameOrigin(request, requestCurrentURL(request))) {
+ serializedOrigin = null;
+ }
+ break;
+ default:
+ }
+ if (serializedOrigin) {
+ request.headersList.append("Origin", serializedOrigin);
+ }
+ }
+ }
+ __name(appendRequestOriginHeader, "appendRequestOriginHeader");
+ function coarsenedSharedCurrentTime(crossOriginIsolatedCapability) {
+ return performance2.now();
+ }
+ __name(coarsenedSharedCurrentTime, "coarsenedSharedCurrentTime");
+ function createOpaqueTimingInfo(timingInfo) {
+ return {
+ startTime: timingInfo.startTime ?? 0,
+ redirectStartTime: 0,
+ redirectEndTime: 0,
+ postRedirectStartTime: timingInfo.startTime ?? 0,
+ finalServiceWorkerStartTime: 0,
+ finalNetworkResponseStartTime: 0,
+ finalNetworkRequestStartTime: 0,
+ endTime: 0,
+ encodedBodySize: 0,
+ decodedBodySize: 0,
+ finalConnectionTimingInfo: null
+ };
+ }
+ __name(createOpaqueTimingInfo, "createOpaqueTimingInfo");
+ function makePolicyContainer() {
+ return {};
+ }
+ __name(makePolicyContainer, "makePolicyContainer");
+ function clonePolicyContainer() {
+ return {};
+ }
+ __name(clonePolicyContainer, "clonePolicyContainer");
+ function determineRequestsReferrer(request) {
+ const policy = request.referrerPolicy;
+ if (policy == null || policy === "" || policy === "no-referrer") {
+ return "no-referrer";
+ }
+ const environment = request.client;
+ let referrerSource = null;
+ if (request.referrer === "client") {
+ if (request.client?.globalObject?.constructor?.name === "Window") {
+ const origin = environment.globalObject.self?.origin ?? environment.globalObject.location?.origin;
+ if (origin == null || origin === "null")
+ return "no-referrer";
+ referrerSource = new URL(environment.globalObject.location.href);
+ } else {
+ if (environment?.globalObject?.location == null) {
+ return "no-referrer";
+ }
+ referrerSource = new URL(environment.globalObject.location.href);
+ }
+ } else if (request.referrer instanceof URL) {
+ referrerSource = request.referrer;
+ } else {
+ return "no-referrer";
+ }
+ const urlProtocol = referrerSource.protocol;
+ if (urlProtocol === "about:" || urlProtocol === "data:" || urlProtocol === "blob:") {
+ return "no-referrer";
+ }
+ let temp;
+ let referrerOrigin;
+ const referrerUrl = (temp = stripURLForReferrer(referrerSource)).length > 4096 ? referrerOrigin = stripURLForReferrer(referrerSource, true) : temp;
+ const areSameOrigin = sameOrigin(request, referrerUrl);
+ const isNonPotentiallyTrustWorthy = isURLPotentiallyTrustworthy(referrerUrl) && !isURLPotentiallyTrustworthy(request.url);
+ switch (policy) {
+ case "origin":
+ return referrerOrigin != null ? referrerOrigin : stripURLForReferrer(referrerSource, true);
+ case "unsafe-url":
+ return referrerUrl;
+ case "same-origin":
+ return areSameOrigin ? referrerOrigin : "no-referrer";
+ case "origin-when-cross-origin":
+ return areSameOrigin ? referrerUrl : referrerOrigin;
+ case "strict-origin-when-cross-origin":
+ if (areSameOrigin)
+ return referrerOrigin;
+ case "strict-origin":
+ case "no-referrer-when-downgrade":
+ default:
+ return isNonPotentiallyTrustWorthy ? "no-referrer" : referrerOrigin;
+ }
+ function stripURLForReferrer(url3, originOnly = false) {
+ const urlObject = new URL(url3.href);
+ urlObject.username = "";
+ urlObject.password = "";
+ urlObject.hash = "";
+ return originOnly ? urlObject.origin : urlObject.href;
+ }
+ __name(stripURLForReferrer, "stripURLForReferrer");
+ }
+ __name(determineRequestsReferrer, "determineRequestsReferrer");
+ function isURLPotentiallyTrustworthy(url3) {
+ if (!(url3 instanceof URL)) {
+ return false;
+ }
+ if (url3.href === "about:blank" || url3.href === "about:srcdoc") {
+ return true;
+ }
+ if (url3.protocol === "data:")
+ return true;
+ if (url3.protocol === "file:")
+ return true;
+ return isOriginPotentiallyTrustworthy(url3.origin);
+ function isOriginPotentiallyTrustworthy(origin) {
+ if (origin == null || origin === "null")
+ return false;
+ const originAsURL = new URL(origin);
+ if (originAsURL.protocol === "https:" || originAsURL.protocol === "wss:") {
+ return true;
+ }
+ if (/^127(?:\.[0-9]+){0,2}\.[0-9]+$|^\[(?:0*:)*?:?0*1\]$/.test(originAsURL.hostname) || (originAsURL.hostname === "localhost" || originAsURL.hostname.includes("localhost.")) || originAsURL.hostname.endsWith(".localhost")) {
+ return true;
+ }
+ return false;
+ }
+ __name(isOriginPotentiallyTrustworthy, "isOriginPotentiallyTrustworthy");
+ }
+ __name(isURLPotentiallyTrustworthy, "isURLPotentiallyTrustworthy");
+ function bytesMatch(bytes, metadataList) {
+ if (crypto6 === void 0) {
+ return true;
+ }
+ const parsedMetadata = parseMetadata(metadataList);
+ if (parsedMetadata === "no metadata") {
+ return true;
+ }
+ if (parsedMetadata.length === 0) {
+ return true;
+ }
+ const list = parsedMetadata.sort((c, d) => d.algo.localeCompare(c.algo));
+ const strongest = list[0].algo;
+ const metadata = list.filter((item) => item.algo === strongest);
+ for (const item of metadata) {
+ const algorithm = item.algo;
+ const expectedValue = item.hash;
+ const actualValue = crypto6.createHash(algorithm).update(bytes).digest("base64");
+ if (actualValue === expectedValue) {
+ return true;
+ }
+ }
+ return false;
+ }
+ __name(bytesMatch, "bytesMatch");
+ var parseHashWithOptions = /((?sha256|sha384|sha512)-(?[A-z0-9+/]{1}.*={0,2}))( +[\x21-\x7e]?)?/i;
+ function parseMetadata(metadata) {
+ const result = [];
+ let empty2 = true;
+ const supportedHashes = crypto6.getHashes();
+ for (const token of metadata.split(" ")) {
+ empty2 = false;
+ const parsedToken = parseHashWithOptions.exec(token);
+ if (parsedToken === null || parsedToken.groups === void 0) {
+ continue;
+ }
+ const algorithm = parsedToken.groups.algo;
+ if (supportedHashes.includes(algorithm.toLowerCase())) {
+ result.push(parsedToken.groups);
+ }
+ }
+ if (empty2 === true) {
+ return "no metadata";
+ }
+ return result;
+ }
+ __name(parseMetadata, "parseMetadata");
+ function tryUpgradeRequestToAPotentiallyTrustworthyURL(request) {
+ }
+ __name(tryUpgradeRequestToAPotentiallyTrustworthyURL, "tryUpgradeRequestToAPotentiallyTrustworthyURL");
+ function sameOrigin(A, B) {
+ if (A.protocol === B.protocol && A.hostname === B.hostname && A.port === B.port) {
+ return true;
+ }
+ return false;
+ }
+ __name(sameOrigin, "sameOrigin");
+ function createDeferredPromise() {
+ let res;
+ let rej;
+ const promise = new Promise((resolve18, reject) => {
+ res = resolve18;
+ rej = reject;
+ });
+ return { promise, resolve: res, reject: rej };
+ }
+ __name(createDeferredPromise, "createDeferredPromise");
+ function isAborted(fetchParams) {
+ return fetchParams.controller.state === "aborted";
+ }
+ __name(isAborted, "isAborted");
+ function isCancelled(fetchParams) {
+ return fetchParams.controller.state === "aborted" || fetchParams.controller.state === "terminated";
+ }
+ __name(isCancelled, "isCancelled");
+ function normalizeMethod(method) {
+ return /^(DELETE|GET|HEAD|OPTIONS|POST|PUT)$/i.test(method) ? method.toUpperCase() : method;
+ }
+ __name(normalizeMethod, "normalizeMethod");
+ function serializeJavascriptValueToJSONString(value) {
+ const result = JSON.stringify(value);
+ if (result === void 0) {
+ throw new TypeError("Value is not JSON serializable");
+ }
+ assert18(typeof result === "string");
+ return result;
+ }
+ __name(serializeJavascriptValueToJSONString, "serializeJavascriptValueToJSONString");
+ var esIteratorPrototype = Object.getPrototypeOf(Object.getPrototypeOf([][Symbol.iterator]()));
+ function makeIterator(iterator, name, kind) {
+ const object = {
+ index: 0,
+ kind,
+ target: iterator
+ };
+ const i = {
+ next() {
+ if (Object.getPrototypeOf(this) !== i) {
+ throw new TypeError(
+ `'next' called on an object that does not implement interface ${name} Iterator.`
+ );
+ }
+ const { index, kind: kind2, target } = object;
+ const values = target();
+ const len = values.length;
+ if (index >= len) {
+ return { value: void 0, done: true };
+ }
+ const pair = values[index];
+ object.index = index + 1;
+ return iteratorResult(pair, kind2);
+ },
+ // The class string of an iterator prototype object for a given interface is the
+ // result of concatenating the identifier of the interface and the string " Iterator".
+ [Symbol.toStringTag]: `${name} Iterator`
+ };
+ Object.setPrototypeOf(i, esIteratorPrototype);
+ return Object.setPrototypeOf({}, i);
+ }
+ __name(makeIterator, "makeIterator");
+ function iteratorResult(pair, kind) {
+ let result;
+ switch (kind) {
+ case "key": {
+ result = pair[0];
+ break;
+ }
+ case "value": {
+ result = pair[1];
+ break;
+ }
+ case "key+value": {
+ result = pair;
+ break;
+ }
+ }
+ return { value: result, done: false };
+ }
+ __name(iteratorResult, "iteratorResult");
+ function fullyReadBody(body, processBody, processBodyError) {
+ const successSteps = /* @__PURE__ */ __name((bytes) => queueMicrotask(() => processBody(bytes)), "successSteps");
+ const errorSteps = /* @__PURE__ */ __name((error) => queueMicrotask(() => processBodyError(error)), "errorSteps");
+ let reader;
+ try {
+ reader = body.stream.getReader();
+ } catch (e2) {
+ errorSteps(e2);
+ return;
+ }
+ readAllBytes(reader, successSteps, errorSteps);
+ }
+ __name(fullyReadBody, "fullyReadBody");
+ var ReadableStream2 = globalThis.ReadableStream;
+ function isReadableStreamLike(stream2) {
+ if (!ReadableStream2) {
+ ReadableStream2 = require("stream/web").ReadableStream;
+ }
+ return stream2 instanceof ReadableStream2 || stream2[Symbol.toStringTag] === "ReadableStream" && typeof stream2.tee === "function";
+ }
+ __name(isReadableStreamLike, "isReadableStreamLike");
+ var MAXIMUM_ARGUMENT_LENGTH = 65535;
+ function isomorphicDecode(input) {
+ if (input.length < MAXIMUM_ARGUMENT_LENGTH) {
+ return String.fromCharCode(...input);
+ }
+ return input.reduce((previous, current) => previous + String.fromCharCode(current), "");
+ }
+ __name(isomorphicDecode, "isomorphicDecode");
+ function readableStreamClose(controller) {
+ try {
+ controller.close();
+ } catch (err) {
+ if (!err.message.includes("Controller is already closed")) {
+ throw err;
+ }
+ }
+ }
+ __name(readableStreamClose, "readableStreamClose");
+ function isomorphicEncode(input) {
+ for (let i = 0; i < input.length; i++) {
+ assert18(input.charCodeAt(i) <= 255);
+ }
+ return input;
+ }
+ __name(isomorphicEncode, "isomorphicEncode");
+ async function readAllBytes(reader, successSteps, failureSteps) {
+ const bytes = [];
+ let byteLength = 0;
+ while (true) {
+ let done;
+ let chunk;
+ try {
+ ({ done, value: chunk } = await reader.read());
+ } catch (e2) {
+ failureSteps(e2);
+ return;
+ }
+ if (done) {
+ successSteps(Buffer.concat(bytes, byteLength));
+ return;
+ }
+ if (!isUint8Array(chunk)) {
+ failureSteps(new TypeError("Received non-Uint8Array chunk"));
+ return;
+ }
+ bytes.push(chunk);
+ byteLength += chunk.length;
+ }
+ }
+ __name(readAllBytes, "readAllBytes");
+ var hasOwn = Object.hasOwn || ((dict, key) => Object.prototype.hasOwnProperty.call(dict, key));
+ module2.exports = {
+ isAborted,
+ isCancelled,
+ createDeferredPromise,
+ ReadableStreamFrom,
+ toUSVString,
+ tryUpgradeRequestToAPotentiallyTrustworthyURL,
+ coarsenedSharedCurrentTime,
+ determineRequestsReferrer,
+ makePolicyContainer,
+ clonePolicyContainer,
+ appendFetchMetadata,
+ appendRequestOriginHeader,
+ TAOCheck,
+ corsCheck,
+ crossOriginResourcePolicyCheck,
+ createOpaqueTimingInfo,
+ setRequestReferrerPolicyOnRedirect,
+ isValidHTTPToken,
+ requestBadPort,
+ requestCurrentURL,
+ responseURL,
+ responseLocationURL,
+ isBlobLike,
+ isURLPotentiallyTrustworthy,
+ isValidReasonPhrase,
+ sameOrigin,
+ normalizeMethod,
+ serializeJavascriptValueToJSONString,
+ makeIterator,
+ isValidHeaderName,
+ isValidHeaderValue,
+ hasOwn,
+ isErrorLike,
+ fullyReadBody,
+ bytesMatch,
+ isReadableStreamLike,
+ readableStreamClose,
+ isomorphicEncode,
+ isomorphicDecode
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/fetch/symbols.js
+var require_symbols2 = __commonJS({
+ "../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/fetch/symbols.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ module2.exports = {
+ kUrl: Symbol("url"),
+ kHeaders: Symbol("headers"),
+ kSignal: Symbol("signal"),
+ kState: Symbol("state"),
+ kGuard: Symbol("guard"),
+ kRealm: Symbol("realm"),
+ kHeadersCaseInsensitive: Symbol("headers case insensitive")
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/fetch/webidl.js
+var require_webidl = __commonJS({
+ "../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/fetch/webidl.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var { types } = require("util");
+ var { hasOwn, toUSVString } = require_util2();
+ var webidl = {};
+ webidl.converters = {};
+ webidl.util = {};
+ webidl.errors = {};
+ webidl.errors.exception = function(message) {
+ return new TypeError(`${message.header}: ${message.message}`);
+ };
+ webidl.errors.conversionFailed = function(context2) {
+ const plural = context2.types.length === 1 ? "" : " one of";
+ const message = `${context2.argument} could not be converted to${plural}: ${context2.types.join(", ")}.`;
+ return webidl.errors.exception({
+ header: context2.prefix,
+ message
+ });
+ };
+ webidl.errors.invalidArgument = function(context2) {
+ return webidl.errors.exception({
+ header: context2.prefix,
+ message: `"${context2.value}" is an invalid ${context2.type}.`
+ });
+ };
+ webidl.brandCheck = function(V, I, opts = void 0) {
+ if (opts?.strict !== false && !(V instanceof I)) {
+ throw new TypeError("Illegal invocation");
+ } else {
+ return V?.[Symbol.toStringTag] === I.prototype[Symbol.toStringTag];
+ }
+ };
+ webidl.argumentLengthCheck = function({ length }, min, ctx) {
+ if (length < min) {
+ throw webidl.errors.exception({
+ message: `${min} argument${min !== 1 ? "s" : ""} required, but${length ? " only" : ""} ${length} found.`,
+ ...ctx
+ });
+ }
+ };
+ webidl.util.Type = function(V) {
+ switch (typeof V) {
+ case "undefined":
+ return "Undefined";
+ case "boolean":
+ return "Boolean";
+ case "string":
+ return "String";
+ case "symbol":
+ return "Symbol";
+ case "number":
+ return "Number";
+ case "bigint":
+ return "BigInt";
+ case "function":
+ case "object": {
+ if (V === null) {
+ return "Null";
+ }
+ return "Object";
+ }
+ }
+ };
+ webidl.util.ConvertToInt = function(V, bitLength, signedness, opts = {}) {
+ let upperBound;
+ let lowerBound2;
+ if (bitLength === 64) {
+ upperBound = Math.pow(2, 53) - 1;
+ if (signedness === "unsigned") {
+ lowerBound2 = 0;
+ } else {
+ lowerBound2 = Math.pow(-2, 53) + 1;
+ }
+ } else if (signedness === "unsigned") {
+ lowerBound2 = 0;
+ upperBound = Math.pow(2, bitLength) - 1;
+ } else {
+ lowerBound2 = Math.pow(-2, bitLength) - 1;
+ upperBound = Math.pow(2, bitLength - 1) - 1;
+ }
+ let x = Number(V);
+ if (x === 0) {
+ x = 0;
+ }
+ if (opts.enforceRange === true) {
+ if (Number.isNaN(x) || x === Number.POSITIVE_INFINITY || x === Number.NEGATIVE_INFINITY) {
+ throw webidl.errors.exception({
+ header: "Integer conversion",
+ message: `Could not convert ${V} to an integer.`
+ });
+ }
+ x = webidl.util.IntegerPart(x);
+ if (x < lowerBound2 || x > upperBound) {
+ throw webidl.errors.exception({
+ header: "Integer conversion",
+ message: `Value must be between ${lowerBound2}-${upperBound}, got ${x}.`
+ });
+ }
+ return x;
+ }
+ if (!Number.isNaN(x) && opts.clamp === true) {
+ x = Math.min(Math.max(x, lowerBound2), upperBound);
+ if (Math.floor(x) % 2 === 0) {
+ x = Math.floor(x);
+ } else {
+ x = Math.ceil(x);
+ }
+ return x;
+ }
+ if (Number.isNaN(x) || x === 0 && Object.is(0, x) || x === Number.POSITIVE_INFINITY || x === Number.NEGATIVE_INFINITY) {
+ return 0;
+ }
+ x = webidl.util.IntegerPart(x);
+ x = x % Math.pow(2, bitLength);
+ if (signedness === "signed" && x >= Math.pow(2, bitLength) - 1) {
+ return x - Math.pow(2, bitLength);
+ }
+ return x;
+ };
+ webidl.util.IntegerPart = function(n) {
+ const r = Math.floor(Math.abs(n));
+ if (n < 0) {
+ return -1 * r;
+ }
+ return r;
+ };
+ webidl.sequenceConverter = function(converter) {
+ return (V) => {
+ if (webidl.util.Type(V) !== "Object") {
+ throw webidl.errors.exception({
+ header: "Sequence",
+ message: `Value of type ${webidl.util.Type(V)} is not an Object.`
+ });
+ }
+ const method = V?.[Symbol.iterator]?.();
+ const seq = [];
+ if (method === void 0 || typeof method.next !== "function") {
+ throw webidl.errors.exception({
+ header: "Sequence",
+ message: "Object is not an iterator."
+ });
+ }
+ while (true) {
+ const { done, value } = method.next();
+ if (done) {
+ break;
+ }
+ seq.push(converter(value));
+ }
+ return seq;
+ };
+ };
+ webidl.recordConverter = function(keyConverter, valueConverter) {
+ return (O) => {
+ if (webidl.util.Type(O) !== "Object") {
+ throw webidl.errors.exception({
+ header: "Record",
+ message: `Value of type ${webidl.util.Type(O)} is not an Object.`
+ });
+ }
+ const result = {};
+ if (!types.isProxy(O)) {
+ const keys2 = Object.keys(O);
+ for (const key of keys2) {
+ const typedKey = keyConverter(key);
+ const typedValue = valueConverter(O[key]);
+ result[typedKey] = typedValue;
+ }
+ return result;
+ }
+ const keys = Reflect.ownKeys(O);
+ for (const key of keys) {
+ const desc = Reflect.getOwnPropertyDescriptor(O, key);
+ if (desc?.enumerable) {
+ const typedKey = keyConverter(key);
+ const typedValue = valueConverter(O[key]);
+ result[typedKey] = typedValue;
+ }
+ }
+ return result;
+ };
+ };
+ webidl.interfaceConverter = function(i) {
+ return (V, opts = {}) => {
+ if (opts.strict !== false && !(V instanceof i)) {
+ throw webidl.errors.exception({
+ header: i.name,
+ message: `Expected ${V} to be an instance of ${i.name}.`
+ });
+ }
+ return V;
+ };
+ };
+ webidl.dictionaryConverter = function(converters) {
+ return (dictionary) => {
+ const type = webidl.util.Type(dictionary);
+ const dict = {};
+ if (type === "Null" || type === "Undefined") {
+ return dict;
+ } else if (type !== "Object") {
+ throw webidl.errors.exception({
+ header: "Dictionary",
+ message: `Expected ${dictionary} to be one of: Null, Undefined, Object.`
+ });
+ }
+ for (const options14 of converters) {
+ const { key, defaultValue, required, converter } = options14;
+ if (required === true) {
+ if (!hasOwn(dictionary, key)) {
+ throw webidl.errors.exception({
+ header: "Dictionary",
+ message: `Missing required key "${key}".`
+ });
+ }
+ }
+ let value = dictionary[key];
+ const hasDefault = hasOwn(options14, "defaultValue");
+ if (hasDefault && value !== null) {
+ value = value ?? defaultValue;
+ }
+ if (required || hasDefault || value !== void 0) {
+ value = converter(value);
+ if (options14.allowedValues && !options14.allowedValues.includes(value)) {
+ throw webidl.errors.exception({
+ header: "Dictionary",
+ message: `${value} is not an accepted type. Expected one of ${options14.allowedValues.join(", ")}.`
+ });
+ }
+ dict[key] = value;
+ }
+ }
+ return dict;
+ };
+ };
+ webidl.nullableConverter = function(converter) {
+ return (V) => {
+ if (V === null) {
+ return V;
+ }
+ return converter(V);
+ };
+ };
+ webidl.converters.DOMString = function(V, opts = {}) {
+ if (V === null && opts.legacyNullToEmptyString) {
+ return "";
+ }
+ if (typeof V === "symbol") {
+ throw new TypeError("Could not convert argument of type symbol to string.");
+ }
+ return String(V);
+ };
+ webidl.converters.ByteString = function(V) {
+ const x = webidl.converters.DOMString(V);
+ for (let index = 0; index < x.length; index++) {
+ const charCode = x.charCodeAt(index);
+ if (charCode > 255) {
+ throw new TypeError(
+ `Cannot convert argument to a ByteString because the character at index ${index} has a value of ${charCode} which is greater than 255.`
+ );
+ }
+ }
+ return x;
+ };
+ webidl.converters.USVString = toUSVString;
+ webidl.converters.boolean = function(V) {
+ const x = Boolean(V);
+ return x;
+ };
+ webidl.converters.any = function(V) {
+ return V;
+ };
+ webidl.converters["long long"] = function(V) {
+ const x = webidl.util.ConvertToInt(V, 64, "signed");
+ return x;
+ };
+ webidl.converters["unsigned long long"] = function(V) {
+ const x = webidl.util.ConvertToInt(V, 64, "unsigned");
+ return x;
+ };
+ webidl.converters["unsigned long"] = function(V) {
+ const x = webidl.util.ConvertToInt(V, 32, "unsigned");
+ return x;
+ };
+ webidl.converters["unsigned short"] = function(V, opts) {
+ const x = webidl.util.ConvertToInt(V, 16, "unsigned", opts);
+ return x;
+ };
+ webidl.converters.ArrayBuffer = function(V, opts = {}) {
+ if (webidl.util.Type(V) !== "Object" || !types.isAnyArrayBuffer(V)) {
+ throw webidl.errors.conversionFailed({
+ prefix: `${V}`,
+ argument: `${V}`,
+ types: ["ArrayBuffer"]
+ });
+ }
+ if (opts.allowShared === false && types.isSharedArrayBuffer(V)) {
+ throw webidl.errors.exception({
+ header: "ArrayBuffer",
+ message: "SharedArrayBuffer is not allowed."
+ });
+ }
+ return V;
+ };
+ webidl.converters.TypedArray = function(V, T, opts = {}) {
+ if (webidl.util.Type(V) !== "Object" || !types.isTypedArray(V) || V.constructor.name !== T.name) {
+ throw webidl.errors.conversionFailed({
+ prefix: `${T.name}`,
+ argument: `${V}`,
+ types: [T.name]
+ });
+ }
+ if (opts.allowShared === false && types.isSharedArrayBuffer(V.buffer)) {
+ throw webidl.errors.exception({
+ header: "ArrayBuffer",
+ message: "SharedArrayBuffer is not allowed."
+ });
+ }
+ return V;
+ };
+ webidl.converters.DataView = function(V, opts = {}) {
+ if (webidl.util.Type(V) !== "Object" || !types.isDataView(V)) {
+ throw webidl.errors.exception({
+ header: "DataView",
+ message: "Object is not a DataView."
+ });
+ }
+ if (opts.allowShared === false && types.isSharedArrayBuffer(V.buffer)) {
+ throw webidl.errors.exception({
+ header: "ArrayBuffer",
+ message: "SharedArrayBuffer is not allowed."
+ });
+ }
+ return V;
+ };
+ webidl.converters.BufferSource = function(V, opts = {}) {
+ if (types.isAnyArrayBuffer(V)) {
+ return webidl.converters.ArrayBuffer(V, opts);
+ }
+ if (types.isTypedArray(V)) {
+ return webidl.converters.TypedArray(V, V.constructor);
+ }
+ if (types.isDataView(V)) {
+ return webidl.converters.DataView(V, opts);
+ }
+ throw new TypeError(`Could not convert ${V} to a BufferSource.`);
+ };
+ webidl.converters["sequence"] = webidl.sequenceConverter(
+ webidl.converters.ByteString
+ );
+ webidl.converters["sequence>"] = webidl.sequenceConverter(
+ webidl.converters["sequence"]
+ );
+ webidl.converters["record"] = webidl.recordConverter(
+ webidl.converters.ByteString,
+ webidl.converters.ByteString
+ );
+ module2.exports = {
+ webidl
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/fetch/dataURL.js
+var require_dataURL = __commonJS({
+ "../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/fetch/dataURL.js"(exports2, module2) {
+ init_import_meta_url();
+ var assert18 = require("assert");
+ var { atob: atob2 } = require("buffer");
+ var { format: format8 } = require("url");
+ var { isValidHTTPToken, isomorphicDecode } = require_util2();
+ var encoder = new TextEncoder();
+ var HTTP_TOKEN_CODEPOINTS = /^[!#$%&'*+-.^_|~A-z0-9]+$/;
+ var HTTP_WHITESPACE_REGEX = /(\u000A|\u000D|\u0009|\u0020)/;
+ var HTTP_QUOTED_STRING_TOKENS = /^(\u0009|\x{0020}-\x{007E}|\x{0080}-\x{00FF})+$/;
+ function dataURLProcessor(dataURL) {
+ assert18(dataURL.protocol === "data:");
+ let input = URLSerializer(dataURL, true);
+ input = input.slice(5);
+ const position = { position: 0 };
+ let mimeType = collectASequenceOfCodePointsFast(
+ ",",
+ input,
+ position
+ );
+ const mimeTypeLength = mimeType.length;
+ mimeType = mimeType.replace(/^(\u0020)+|(\u0020)+$/g, "");
+ if (position.position >= input.length) {
+ return "failure";
+ }
+ position.position++;
+ const encodedBody = input.slice(mimeTypeLength + 1);
+ let body = stringPercentDecode(encodedBody);
+ if (/;(\u0020){0,}base64$/i.test(mimeType)) {
+ const stringBody = isomorphicDecode(body);
+ body = forgivingBase64(stringBody);
+ if (body === "failure") {
+ return "failure";
+ }
+ mimeType = mimeType.slice(0, -6);
+ mimeType = mimeType.replace(/(\u0020)+$/, "");
+ mimeType = mimeType.slice(0, -1);
+ }
+ if (mimeType.startsWith(";")) {
+ mimeType = "text/plain" + mimeType;
+ }
+ let mimeTypeRecord = parseMIMEType(mimeType);
+ if (mimeTypeRecord === "failure") {
+ mimeTypeRecord = parseMIMEType("text/plain;charset=US-ASCII");
+ }
+ return { mimeType: mimeTypeRecord, body };
+ }
+ __name(dataURLProcessor, "dataURLProcessor");
+ function URLSerializer(url3, excludeFragment = false) {
+ return format8(url3, { fragment: !excludeFragment });
+ }
+ __name(URLSerializer, "URLSerializer");
+ function collectASequenceOfCodePoints(condition, input, position) {
+ let result = "";
+ while (position.position < input.length && condition(input[position.position])) {
+ result += input[position.position];
+ position.position++;
+ }
+ return result;
+ }
+ __name(collectASequenceOfCodePoints, "collectASequenceOfCodePoints");
+ function collectASequenceOfCodePointsFast(char, input, position) {
+ const idx = input.indexOf(char, position.position);
+ const start = position.position;
+ if (idx === -1) {
+ position.position = input.length;
+ return input.slice(start);
+ }
+ position.position = idx;
+ return input.slice(start, position.position);
+ }
+ __name(collectASequenceOfCodePointsFast, "collectASequenceOfCodePointsFast");
+ function stringPercentDecode(input) {
+ const bytes = encoder.encode(input);
+ return percentDecode(bytes);
+ }
+ __name(stringPercentDecode, "stringPercentDecode");
+ function percentDecode(input) {
+ const output = [];
+ for (let i = 0; i < input.length; i++) {
+ const byte = input[i];
+ if (byte !== 37) {
+ output.push(byte);
+ } else if (byte === 37 && !/^[0-9A-Fa-f]{2}$/i.test(String.fromCharCode(input[i + 1], input[i + 2]))) {
+ output.push(37);
+ } else {
+ const nextTwoBytes = String.fromCharCode(input[i + 1], input[i + 2]);
+ const bytePoint = Number.parseInt(nextTwoBytes, 16);
+ output.push(bytePoint);
+ i += 2;
+ }
+ }
+ return Uint8Array.from(output);
+ }
+ __name(percentDecode, "percentDecode");
+ function parseMIMEType(input) {
+ input = input.trim();
+ const position = { position: 0 };
+ const type = collectASequenceOfCodePointsFast(
+ "/",
+ input,
+ position
+ );
+ if (type.length === 0 || !HTTP_TOKEN_CODEPOINTS.test(type)) {
+ return "failure";
+ }
+ if (position.position > input.length) {
+ return "failure";
+ }
+ position.position++;
+ let subtype = collectASequenceOfCodePointsFast(
+ ";",
+ input,
+ position
+ );
+ subtype = subtype.trimEnd();
+ if (subtype.length === 0 || !HTTP_TOKEN_CODEPOINTS.test(subtype)) {
+ return "failure";
+ }
+ const mimeType = {
+ type: type.toLowerCase(),
+ subtype: subtype.toLowerCase(),
+ /** @type {Map} */
+ parameters: /* @__PURE__ */ new Map(),
+ // https://mimesniff.spec.whatwg.org/#mime-type-essence
+ essence: `${type}/${subtype}`
+ };
+ while (position.position < input.length) {
+ position.position++;
+ collectASequenceOfCodePoints(
+ // https://fetch.spec.whatwg.org/#http-whitespace
+ (char) => HTTP_WHITESPACE_REGEX.test(char),
+ input,
+ position
+ );
+ let parameterName = collectASequenceOfCodePoints(
+ (char) => char !== ";" && char !== "=",
+ input,
+ position
+ );
+ parameterName = parameterName.toLowerCase();
+ if (position.position < input.length) {
+ if (input[position.position] === ";") {
+ continue;
+ }
+ position.position++;
+ }
+ if (position.position > input.length) {
+ break;
+ }
+ let parameterValue = null;
+ if (input[position.position] === '"') {
+ parameterValue = collectAnHTTPQuotedString(input, position, true);
+ collectASequenceOfCodePointsFast(
+ ";",
+ input,
+ position
+ );
+ } else {
+ parameterValue = collectASequenceOfCodePointsFast(
+ ";",
+ input,
+ position
+ );
+ parameterValue = parameterValue.trimEnd();
+ if (parameterValue.length === 0) {
+ continue;
+ }
+ }
+ if (parameterName.length !== 0 && HTTP_TOKEN_CODEPOINTS.test(parameterName) && !HTTP_QUOTED_STRING_TOKENS.test(parameterValue) && !mimeType.parameters.has(parameterName)) {
+ mimeType.parameters.set(parameterName, parameterValue);
+ }
+ }
+ return mimeType;
+ }
+ __name(parseMIMEType, "parseMIMEType");
+ function forgivingBase64(data) {
+ data = data.replace(/[\u0009\u000A\u000C\u000D\u0020]/g, "");
+ if (data.length % 4 === 0) {
+ data = data.replace(/=?=$/, "");
+ }
+ if (data.length % 4 === 1) {
+ return "failure";
+ }
+ if (/[^+/0-9A-Za-z]/.test(data)) {
+ return "failure";
+ }
+ const binary = atob2(data);
+ const bytes = new Uint8Array(binary.length);
+ for (let byte = 0; byte < binary.length; byte++) {
+ bytes[byte] = binary.charCodeAt(byte);
+ }
+ return bytes;
+ }
+ __name(forgivingBase64, "forgivingBase64");
+ function collectAnHTTPQuotedString(input, position, extractValue) {
+ const positionStart = position.position;
+ let value = "";
+ assert18(input[position.position] === '"');
+ position.position++;
+ while (true) {
+ value += collectASequenceOfCodePoints(
+ (char) => char !== '"' && char !== "\\",
+ input,
+ position
+ );
+ if (position.position >= input.length) {
+ break;
+ }
+ const quoteOrBackslash = input[position.position];
+ position.position++;
+ if (quoteOrBackslash === "\\") {
+ if (position.position >= input.length) {
+ value += "\\";
+ break;
+ }
+ value += input[position.position];
+ position.position++;
+ } else {
+ assert18(quoteOrBackslash === '"');
+ break;
+ }
+ }
+ if (extractValue) {
+ return value;
+ }
+ return input.slice(positionStart, position.position);
+ }
+ __name(collectAnHTTPQuotedString, "collectAnHTTPQuotedString");
+ function serializeAMimeType(mimeType) {
+ assert18(mimeType !== "failure");
+ const { type, subtype, parameters } = mimeType;
+ let serialization = `${type}/${subtype}`;
+ for (let [name, value] of parameters.entries()) {
+ serialization += ";";
+ serialization += name;
+ serialization += "=";
+ if (!isValidHTTPToken(value)) {
+ value = value.replace(/(\\|")/g, "\\$1");
+ value = '"' + value;
+ value += '"';
+ }
+ serialization += value;
+ }
+ return serialization;
+ }
+ __name(serializeAMimeType, "serializeAMimeType");
+ module2.exports = {
+ dataURLProcessor,
+ URLSerializer,
+ collectASequenceOfCodePoints,
+ collectASequenceOfCodePointsFast,
+ stringPercentDecode,
+ parseMIMEType,
+ collectAnHTTPQuotedString,
+ serializeAMimeType
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/fetch/file.js
+var require_file = __commonJS({
+ "../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/fetch/file.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var { Blob: Blob5, File: NativeFile } = require("buffer");
+ var { types } = require("util");
+ var { kState } = require_symbols2();
+ var { isBlobLike } = require_util2();
+ var { webidl } = require_webidl();
+ var { parseMIMEType, serializeAMimeType } = require_dataURL();
+ var { kEnumerableProperty } = require_util();
+ var File5 = class extends Blob5 {
+ constructor(fileBits, fileName, options14 = {}) {
+ webidl.argumentLengthCheck(arguments, 2, { header: "File constructor" });
+ fileBits = webidl.converters["sequence"](fileBits);
+ fileName = webidl.converters.USVString(fileName);
+ options14 = webidl.converters.FilePropertyBag(options14);
+ const n = fileName;
+ let t2 = options14.type;
+ let d;
+ substep: {
+ if (t2) {
+ t2 = parseMIMEType(t2);
+ if (t2 === "failure") {
+ t2 = "";
+ break substep;
+ }
+ t2 = serializeAMimeType(t2).toLowerCase();
+ }
+ d = options14.lastModified;
+ }
+ super(processBlobParts(fileBits, options14), { type: t2 });
+ this[kState] = {
+ name: n,
+ lastModified: d,
+ type: t2
+ };
+ }
+ get name() {
+ webidl.brandCheck(this, File5);
+ return this[kState].name;
+ }
+ get lastModified() {
+ webidl.brandCheck(this, File5);
+ return this[kState].lastModified;
+ }
+ get type() {
+ webidl.brandCheck(this, File5);
+ return this[kState].type;
+ }
+ };
+ __name(File5, "File");
+ var FileLike = class {
+ constructor(blobLike, fileName, options14 = {}) {
+ const n = fileName;
+ const t2 = options14.type;
+ const d = options14.lastModified ?? Date.now();
+ this[kState] = {
+ blobLike,
+ name: n,
+ type: t2,
+ lastModified: d
+ };
+ }
+ stream(...args) {
+ webidl.brandCheck(this, FileLike);
+ return this[kState].blobLike.stream(...args);
+ }
+ arrayBuffer(...args) {
+ webidl.brandCheck(this, FileLike);
+ return this[kState].blobLike.arrayBuffer(...args);
+ }
+ slice(...args) {
+ webidl.brandCheck(this, FileLike);
+ return this[kState].blobLike.slice(...args);
+ }
+ text(...args) {
+ webidl.brandCheck(this, FileLike);
+ return this[kState].blobLike.text(...args);
+ }
+ get size() {
+ webidl.brandCheck(this, FileLike);
+ return this[kState].blobLike.size;
+ }
+ get type() {
+ webidl.brandCheck(this, FileLike);
+ return this[kState].blobLike.type;
+ }
+ get name() {
+ webidl.brandCheck(this, FileLike);
+ return this[kState].name;
+ }
+ get lastModified() {
+ webidl.brandCheck(this, FileLike);
+ return this[kState].lastModified;
+ }
+ get [Symbol.toStringTag]() {
+ return "File";
+ }
+ };
+ __name(FileLike, "FileLike");
+ Object.defineProperties(File5.prototype, {
+ [Symbol.toStringTag]: {
+ value: "File",
+ configurable: true
+ },
+ name: kEnumerableProperty,
+ lastModified: kEnumerableProperty
+ });
+ webidl.converters.Blob = webidl.interfaceConverter(Blob5);
+ webidl.converters.BlobPart = function(V, opts) {
+ if (webidl.util.Type(V) === "Object") {
+ if (isBlobLike(V)) {
+ return webidl.converters.Blob(V, { strict: false });
+ }
+ if (ArrayBuffer.isView(V) || types.isAnyArrayBuffer(V)) {
+ return webidl.converters.BufferSource(V, opts);
+ }
+ }
+ return webidl.converters.USVString(V, opts);
+ };
+ webidl.converters["sequence"] = webidl.sequenceConverter(
+ webidl.converters.BlobPart
+ );
+ webidl.converters.FilePropertyBag = webidl.dictionaryConverter([
+ {
+ key: "lastModified",
+ converter: webidl.converters["long long"],
+ get defaultValue() {
+ return Date.now();
+ }
+ },
+ {
+ key: "type",
+ converter: webidl.converters.DOMString,
+ defaultValue: ""
+ },
+ {
+ key: "endings",
+ converter: (value) => {
+ value = webidl.converters.DOMString(value);
+ value = value.toLowerCase();
+ if (value !== "native") {
+ value = "transparent";
+ }
+ return value;
+ },
+ defaultValue: "transparent"
+ }
+ ]);
+ function processBlobParts(parts, options14) {
+ const bytes = [];
+ for (const element of parts) {
+ if (typeof element === "string") {
+ let s = element;
+ if (options14.endings === "native") {
+ s = convertLineEndingsNative(s);
+ }
+ bytes.push(new TextEncoder().encode(s));
+ } else if (types.isAnyArrayBuffer(element) || types.isTypedArray(element)) {
+ if (!element.buffer) {
+ bytes.push(new Uint8Array(element));
+ } else {
+ bytes.push(
+ new Uint8Array(element.buffer, element.byteOffset, element.byteLength)
+ );
+ }
+ } else if (isBlobLike(element)) {
+ bytes.push(element);
+ }
+ }
+ return bytes;
+ }
+ __name(processBlobParts, "processBlobParts");
+ function convertLineEndingsNative(s) {
+ let nativeLineEnding = "\n";
+ if (process.platform === "win32") {
+ nativeLineEnding = "\r\n";
+ }
+ return s.replace(/\r?\n/g, nativeLineEnding);
+ }
+ __name(convertLineEndingsNative, "convertLineEndingsNative");
+ function isFileLike(object) {
+ return NativeFile && object instanceof NativeFile || object instanceof File5 || object && (typeof object.stream === "function" || typeof object.arrayBuffer === "function") && object[Symbol.toStringTag] === "File";
+ }
+ __name(isFileLike, "isFileLike");
+ module2.exports = { File: File5, FileLike, isFileLike };
+ }
+});
+
+// ../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/fetch/formdata.js
+var require_formdata = __commonJS({
+ "../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/fetch/formdata.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var { isBlobLike, toUSVString, makeIterator } = require_util2();
+ var { kState } = require_symbols2();
+ var { File: UndiciFile, FileLike, isFileLike } = require_file();
+ var { webidl } = require_webidl();
+ var { Blob: Blob5, File: NativeFile } = require("buffer");
+ var File5 = NativeFile ?? UndiciFile;
+ var FormData6 = class {
+ constructor(form) {
+ if (form !== void 0) {
+ throw webidl.errors.conversionFailed({
+ prefix: "FormData constructor",
+ argument: "Argument 1",
+ types: ["undefined"]
+ });
+ }
+ this[kState] = [];
+ }
+ append(name, value, filename = void 0) {
+ webidl.brandCheck(this, FormData6);
+ webidl.argumentLengthCheck(arguments, 2, { header: "FormData.append" });
+ if (arguments.length === 3 && !isBlobLike(value)) {
+ throw new TypeError(
+ "Failed to execute 'append' on 'FormData': parameter 2 is not of type 'Blob'"
+ );
+ }
+ name = webidl.converters.USVString(name);
+ value = isBlobLike(value) ? webidl.converters.Blob(value, { strict: false }) : webidl.converters.USVString(value);
+ filename = arguments.length === 3 ? webidl.converters.USVString(filename) : void 0;
+ const entry = makeEntry(name, value, filename);
+ this[kState].push(entry);
+ }
+ delete(name) {
+ webidl.brandCheck(this, FormData6);
+ webidl.argumentLengthCheck(arguments, 1, { header: "FormData.delete" });
+ name = webidl.converters.USVString(name);
+ const next = [];
+ for (const entry of this[kState]) {
+ if (entry.name !== name) {
+ next.push(entry);
+ }
+ }
+ this[kState] = next;
+ }
+ get(name) {
+ webidl.brandCheck(this, FormData6);
+ webidl.argumentLengthCheck(arguments, 1, { header: "FormData.get" });
+ name = webidl.converters.USVString(name);
+ const idx = this[kState].findIndex((entry) => entry.name === name);
+ if (idx === -1) {
+ return null;
+ }
+ return this[kState][idx].value;
+ }
+ getAll(name) {
+ webidl.brandCheck(this, FormData6);
+ webidl.argumentLengthCheck(arguments, 1, { header: "FormData.getAll" });
+ name = webidl.converters.USVString(name);
+ return this[kState].filter((entry) => entry.name === name).map((entry) => entry.value);
+ }
+ has(name) {
+ webidl.brandCheck(this, FormData6);
+ webidl.argumentLengthCheck(arguments, 1, { header: "FormData.has" });
+ name = webidl.converters.USVString(name);
+ return this[kState].findIndex((entry) => entry.name === name) !== -1;
+ }
+ set(name, value, filename = void 0) {
+ webidl.brandCheck(this, FormData6);
+ webidl.argumentLengthCheck(arguments, 2, { header: "FormData.set" });
+ if (arguments.length === 3 && !isBlobLike(value)) {
+ throw new TypeError(
+ "Failed to execute 'set' on 'FormData': parameter 2 is not of type 'Blob'"
+ );
+ }
+ name = webidl.converters.USVString(name);
+ value = isBlobLike(value) ? webidl.converters.Blob(value, { strict: false }) : webidl.converters.USVString(value);
+ filename = arguments.length === 3 ? toUSVString(filename) : void 0;
+ const entry = makeEntry(name, value, filename);
+ const idx = this[kState].findIndex((entry2) => entry2.name === name);
+ if (idx !== -1) {
+ this[kState] = [
+ ...this[kState].slice(0, idx),
+ entry,
+ ...this[kState].slice(idx + 1).filter((entry2) => entry2.name !== name)
+ ];
+ } else {
+ this[kState].push(entry);
+ }
+ }
+ entries() {
+ webidl.brandCheck(this, FormData6);
+ return makeIterator(
+ () => this[kState].map((pair) => [pair.name, pair.value]),
+ "FormData",
+ "key+value"
+ );
+ }
+ keys() {
+ webidl.brandCheck(this, FormData6);
+ return makeIterator(
+ () => this[kState].map((pair) => [pair.name, pair.value]),
+ "FormData",
+ "key"
+ );
+ }
+ values() {
+ webidl.brandCheck(this, FormData6);
+ return makeIterator(
+ () => this[kState].map((pair) => [pair.name, pair.value]),
+ "FormData",
+ "value"
+ );
+ }
+ /**
+ * @param {(value: string, key: string, self: FormData) => void} callbackFn
+ * @param {unknown} thisArg
+ */
+ forEach(callbackFn, thisArg = globalThis) {
+ webidl.brandCheck(this, FormData6);
+ webidl.argumentLengthCheck(arguments, 1, { header: "FormData.forEach" });
+ if (typeof callbackFn !== "function") {
+ throw new TypeError(
+ "Failed to execute 'forEach' on 'FormData': parameter 1 is not of type 'Function'."
+ );
+ }
+ for (const [key, value] of this) {
+ callbackFn.apply(thisArg, [value, key, this]);
+ }
+ }
+ };
+ __name(FormData6, "FormData");
+ FormData6.prototype[Symbol.iterator] = FormData6.prototype.entries;
+ Object.defineProperties(FormData6.prototype, {
+ [Symbol.toStringTag]: {
+ value: "FormData",
+ configurable: true
+ }
+ });
+ function makeEntry(name, value, filename) {
+ name = Buffer.from(name).toString("utf8");
+ if (typeof value === "string") {
+ value = Buffer.from(value).toString("utf8");
+ } else {
+ if (!isFileLike(value)) {
+ value = value instanceof Blob5 ? new File5([value], "blob", { type: value.type }) : new FileLike(value, "blob", { type: value.type });
+ }
+ if (filename !== void 0) {
+ const options14 = {
+ type: value.type,
+ lastModified: value.lastModified
+ };
+ value = NativeFile && value instanceof NativeFile || value instanceof UndiciFile ? new File5([value], filename, options14) : new FileLike(value, filename, options14);
+ }
+ }
+ return { name, value };
+ }
+ __name(makeEntry, "makeEntry");
+ module2.exports = { FormData: FormData6 };
+ }
+});
+
+// ../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/fetch/body.js
+var require_body = __commonJS({
+ "../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/fetch/body.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var Busboy = require_lib();
+ var util3 = require_util();
+ var {
+ ReadableStreamFrom,
+ isBlobLike,
+ isReadableStreamLike,
+ readableStreamClose,
+ createDeferredPromise,
+ fullyReadBody
+ } = require_util2();
+ var { FormData: FormData6 } = require_formdata();
+ var { kState } = require_symbols2();
+ var { webidl } = require_webidl();
+ var { DOMException, structuredClone } = require_constants();
+ var { Blob: Blob5, File: NativeFile } = require("buffer");
+ var { kBodyUsed } = require_symbols();
+ var assert18 = require("assert");
+ var { isErrored } = require_util();
+ var { isUint8Array, isArrayBuffer } = require("util/types");
+ var { File: UndiciFile } = require_file();
+ var { parseMIMEType, serializeAMimeType } = require_dataURL();
+ var ReadableStream2 = globalThis.ReadableStream;
+ var File5 = NativeFile ?? UndiciFile;
+ function extractBody(object, keepalive = false) {
+ if (!ReadableStream2) {
+ ReadableStream2 = require("stream/web").ReadableStream;
+ }
+ let stream2 = null;
+ if (object instanceof ReadableStream2) {
+ stream2 = object;
+ } else if (isBlobLike(object)) {
+ stream2 = object.stream();
+ } else {
+ stream2 = new ReadableStream2({
+ async pull(controller) {
+ controller.enqueue(
+ typeof source === "string" ? new TextEncoder().encode(source) : source
+ );
+ queueMicrotask(() => readableStreamClose(controller));
+ },
+ start() {
+ },
+ type: void 0
+ });
+ }
+ assert18(isReadableStreamLike(stream2));
+ let action = null;
+ let source = null;
+ let length = null;
+ let type = null;
+ if (typeof object === "string") {
+ source = object;
+ type = "text/plain;charset=UTF-8";
+ } else if (object instanceof URLSearchParams) {
+ source = object.toString();
+ type = "application/x-www-form-urlencoded;charset=UTF-8";
+ } else if (isArrayBuffer(object)) {
+ source = new Uint8Array(object.slice());
+ } else if (ArrayBuffer.isView(object)) {
+ source = new Uint8Array(object.buffer.slice(object.byteOffset, object.byteOffset + object.byteLength));
+ } else if (util3.isFormDataLike(object)) {
+ const boundary = `----formdata-undici-${Math.random()}`.replace(".", "").slice(0, 32);
+ const prefix = `--${boundary}\r
+Content-Disposition: form-data`;
+ const escape2 = /* @__PURE__ */ __name((str) => str.replace(/\n/g, "%0A").replace(/\r/g, "%0D").replace(/"/g, "%22"), "escape");
+ const normalizeLinefeeds = /* @__PURE__ */ __name((value) => value.replace(/\r?\n|\r/g, "\r\n"), "normalizeLinefeeds");
+ const enc = new TextEncoder();
+ const blobParts = [];
+ const rn = new Uint8Array([13, 10]);
+ length = 0;
+ for (const [name, value] of object) {
+ if (typeof value === "string") {
+ const chunk2 = enc.encode(prefix + `; name="${escape2(normalizeLinefeeds(name))}"\r
+\r
+${normalizeLinefeeds(value)}\r
+`);
+ blobParts.push(chunk2);
+ length += chunk2.byteLength;
+ } else {
+ const chunk2 = enc.encode(`${prefix}; name="${escape2(normalizeLinefeeds(name))}"` + (value.name ? `; filename="${escape2(value.name)}"` : "") + `\r
+Content-Type: ${value.type || "application/octet-stream"}\r
+\r
+`);
+ blobParts.push(chunk2, value, rn);
+ length += chunk2.byteLength + value.size + rn.byteLength;
+ }
+ }
+ const chunk = enc.encode(`--${boundary}--`);
+ blobParts.push(chunk);
+ length += chunk.byteLength;
+ source = object;
+ action = /* @__PURE__ */ __name(async function* () {
+ for (const part of blobParts) {
+ if (part.stream) {
+ yield* part.stream();
+ } else {
+ yield part;
+ }
+ }
+ }, "action");
+ type = "multipart/form-data; boundary=" + boundary;
+ } else if (isBlobLike(object)) {
+ source = object;
+ length = object.size;
+ if (object.type) {
+ type = object.type;
+ }
+ } else if (typeof object[Symbol.asyncIterator] === "function") {
+ if (keepalive) {
+ throw new TypeError("keepalive");
+ }
+ if (util3.isDisturbed(object) || object.locked) {
+ throw new TypeError(
+ "Response body object should not be disturbed or locked"
+ );
+ }
+ stream2 = object instanceof ReadableStream2 ? object : ReadableStreamFrom(object);
+ }
+ if (typeof source === "string" || util3.isBuffer(source)) {
+ length = Buffer.byteLength(source);
+ }
+ if (action != null) {
+ let iterator;
+ stream2 = new ReadableStream2({
+ async start() {
+ iterator = action(object)[Symbol.asyncIterator]();
+ },
+ async pull(controller) {
+ const { value, done } = await iterator.next();
+ if (done) {
+ queueMicrotask(() => {
+ controller.close();
+ });
+ } else {
+ if (!isErrored(stream2)) {
+ controller.enqueue(new Uint8Array(value));
+ }
+ }
+ return controller.desiredSize > 0;
+ },
+ async cancel(reason) {
+ await iterator.return();
+ },
+ type: void 0
+ });
+ }
+ const body = { stream: stream2, source, length };
+ return [body, type];
+ }
+ __name(extractBody, "extractBody");
+ function safelyExtractBody(object, keepalive = false) {
+ if (!ReadableStream2) {
+ ReadableStream2 = require("stream/web").ReadableStream;
+ }
+ if (object instanceof ReadableStream2) {
+ assert18(!util3.isDisturbed(object), "The body has already been consumed.");
+ assert18(!object.locked, "The stream is locked.");
+ }
+ return extractBody(object, keepalive);
+ }
+ __name(safelyExtractBody, "safelyExtractBody");
+ function cloneBody(body) {
+ const [out1, out2] = body.stream.tee();
+ const out2Clone = structuredClone(out2, { transfer: [out2] });
+ const [, finalClone] = out2Clone.tee();
+ body.stream = out1;
+ return {
+ stream: finalClone,
+ length: body.length,
+ source: body.source
+ };
+ }
+ __name(cloneBody, "cloneBody");
+ async function* consumeBody(body) {
+ if (body) {
+ if (isUint8Array(body)) {
+ yield body;
+ } else {
+ const stream2 = body.stream;
+ if (util3.isDisturbed(stream2)) {
+ throw new TypeError("The body has already been consumed.");
+ }
+ if (stream2.locked) {
+ throw new TypeError("The stream is locked.");
+ }
+ stream2[kBodyUsed] = true;
+ yield* stream2;
+ }
+ }
+ }
+ __name(consumeBody, "consumeBody");
+ function throwIfAborted(state) {
+ if (state.aborted) {
+ throw new DOMException("The operation was aborted.", "AbortError");
+ }
+ }
+ __name(throwIfAborted, "throwIfAborted");
+ function bodyMixinMethods(instance) {
+ const methods = {
+ blob() {
+ return specConsumeBody(this, (bytes) => {
+ let mimeType = bodyMimeType(this);
+ if (mimeType === "failure") {
+ mimeType = "";
+ } else if (mimeType) {
+ mimeType = serializeAMimeType(mimeType);
+ }
+ return new Blob5([bytes], { type: mimeType });
+ }, instance);
+ },
+ arrayBuffer() {
+ return specConsumeBody(this, (bytes) => {
+ return new Uint8Array(bytes).buffer;
+ }, instance);
+ },
+ text() {
+ return specConsumeBody(this, utf8DecodeBytes, instance);
+ },
+ json() {
+ return specConsumeBody(this, parseJSONFromBytes, instance);
+ },
+ async formData() {
+ webidl.brandCheck(this, instance);
+ throwIfAborted(this[kState]);
+ const contentType = this.headers.get("Content-Type");
+ if (/multipart\/form-data/.test(contentType)) {
+ const headers = {};
+ for (const [key, value] of this.headers)
+ headers[key.toLowerCase()] = value;
+ const responseFormData = new FormData6();
+ let busboy;
+ try {
+ busboy = Busboy({
+ headers,
+ defParamCharset: "utf8"
+ });
+ } catch (err) {
+ throw new DOMException(`${err}`, "AbortError");
+ }
+ busboy.on("field", (name, value) => {
+ responseFormData.append(name, value);
+ });
+ busboy.on("file", (name, value, info) => {
+ const { filename, encoding, mimeType } = info;
+ const chunks = [];
+ if (encoding === "base64" || encoding.toLowerCase() === "base64") {
+ let base64chunk = "";
+ value.on("data", (chunk) => {
+ base64chunk += chunk.toString().replace(/[\r\n]/gm, "");
+ const end = base64chunk.length - base64chunk.length % 4;
+ chunks.push(Buffer.from(base64chunk.slice(0, end), "base64"));
+ base64chunk = base64chunk.slice(end);
+ });
+ value.on("end", () => {
+ chunks.push(Buffer.from(base64chunk, "base64"));
+ responseFormData.append(name, new File5(chunks, filename, { type: mimeType }));
+ });
+ } else {
+ value.on("data", (chunk) => {
+ chunks.push(chunk);
+ });
+ value.on("end", () => {
+ responseFormData.append(name, new File5(chunks, filename, { type: mimeType }));
+ });
+ }
+ });
+ const busboyResolve = new Promise((resolve18, reject) => {
+ busboy.on("finish", resolve18);
+ busboy.on("error", (err) => reject(new TypeError(err)));
+ });
+ if (this.body !== null)
+ for await (const chunk of consumeBody(this[kState].body))
+ busboy.write(chunk);
+ busboy.end();
+ await busboyResolve;
+ return responseFormData;
+ } else if (/application\/x-www-form-urlencoded/.test(contentType)) {
+ let entries;
+ try {
+ let text = "";
+ const textDecoder = new TextDecoder("utf-8", { ignoreBOM: true });
+ for await (const chunk of consumeBody(this[kState].body)) {
+ if (!isUint8Array(chunk)) {
+ throw new TypeError("Expected Uint8Array chunk");
+ }
+ text += textDecoder.decode(chunk, { stream: true });
+ }
+ text += textDecoder.decode();
+ entries = new URLSearchParams(text);
+ } catch (err) {
+ throw Object.assign(new TypeError(), { cause: err });
+ }
+ const formData = new FormData6();
+ for (const [name, value] of entries) {
+ formData.append(name, value);
+ }
+ return formData;
+ } else {
+ await Promise.resolve();
+ throwIfAborted(this[kState]);
+ throw webidl.errors.exception({
+ header: `${instance.name}.formData`,
+ message: "Could not parse content as FormData."
+ });
+ }
+ }
+ };
+ return methods;
+ }
+ __name(bodyMixinMethods, "bodyMixinMethods");
+ function mixinBody(prototype) {
+ Object.assign(prototype.prototype, bodyMixinMethods(prototype));
+ }
+ __name(mixinBody, "mixinBody");
+ async function specConsumeBody(object, convertBytesToJSValue, instance) {
+ webidl.brandCheck(object, instance);
+ throwIfAborted(object[kState]);
+ if (bodyUnusable(object[kState].body)) {
+ throw new TypeError("Body is unusable");
+ }
+ const promise = createDeferredPromise();
+ const errorSteps = /* @__PURE__ */ __name((error) => promise.reject(error), "errorSteps");
+ const successSteps = /* @__PURE__ */ __name((data) => {
+ try {
+ promise.resolve(convertBytesToJSValue(data));
+ } catch (e2) {
+ errorSteps(e2);
+ }
+ }, "successSteps");
+ if (object[kState].body == null) {
+ successSteps(new Uint8Array());
+ return promise.promise;
+ }
+ fullyReadBody(object[kState].body, successSteps, errorSteps);
+ return promise.promise;
+ }
+ __name(specConsumeBody, "specConsumeBody");
+ function bodyUnusable(body) {
+ return body != null && (body.stream.locked || util3.isDisturbed(body.stream));
+ }
+ __name(bodyUnusable, "bodyUnusable");
+ function utf8DecodeBytes(buffer) {
+ if (buffer.length === 0) {
+ return "";
+ }
+ if (buffer[0] === 239 && buffer[1] === 187 && buffer[2] === 191) {
+ buffer = buffer.subarray(3);
+ }
+ const output = new TextDecoder().decode(buffer);
+ return output;
+ }
+ __name(utf8DecodeBytes, "utf8DecodeBytes");
+ function parseJSONFromBytes(bytes) {
+ return JSON.parse(utf8DecodeBytes(bytes));
+ }
+ __name(parseJSONFromBytes, "parseJSONFromBytes");
+ function bodyMimeType(object) {
+ const { headersList } = object[kState];
+ const contentType = headersList.get("content-type");
+ if (contentType === null) {
+ return "failure";
+ }
+ return parseMIMEType(contentType);
+ }
+ __name(bodyMimeType, "bodyMimeType");
+ module2.exports = {
+ extractBody,
+ safelyExtractBody,
+ cloneBody,
+ mixinBody
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/core/request.js
+var require_request = __commonJS({
+ "../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/core/request.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var {
+ InvalidArgumentError,
+ NotSupportedError
+ } = require_errors();
+ var assert18 = require("assert");
+ var util3 = require_util();
+ var tokenRegExp = /^[\^_`a-zA-Z\-0-9!#$%&'*+.|~]+$/;
+ var headerCharRegex = /[^\t\x20-\x7e\x80-\xff]/;
+ var invalidPathRegex = /[^\u0021-\u00ff]/;
+ var kHandler = Symbol("handler");
+ var channels = {};
+ var extractBody;
+ try {
+ const diagnosticsChannel = require("diagnostics_channel");
+ channels.create = diagnosticsChannel.channel("undici:request:create");
+ channels.bodySent = diagnosticsChannel.channel("undici:request:bodySent");
+ channels.headers = diagnosticsChannel.channel("undici:request:headers");
+ channels.trailers = diagnosticsChannel.channel("undici:request:trailers");
+ channels.error = diagnosticsChannel.channel("undici:request:error");
+ } catch {
+ channels.create = { hasSubscribers: false };
+ channels.bodySent = { hasSubscribers: false };
+ channels.headers = { hasSubscribers: false };
+ channels.trailers = { hasSubscribers: false };
+ channels.error = { hasSubscribers: false };
+ }
+ var Request3 = class {
+ constructor(origin, {
+ path: path45,
+ method,
+ body,
+ headers,
+ query,
+ idempotent,
+ blocking,
+ upgrade,
+ headersTimeout,
+ bodyTimeout,
+ reset,
+ throwOnError
+ }, handler15) {
+ if (typeof path45 !== "string") {
+ throw new InvalidArgumentError("path must be a string");
+ } else if (path45[0] !== "/" && !(path45.startsWith("http://") || path45.startsWith("https://")) && method !== "CONNECT") {
+ throw new InvalidArgumentError("path must be an absolute URL or start with a slash");
+ } else if (invalidPathRegex.exec(path45) !== null) {
+ throw new InvalidArgumentError("invalid request path");
+ }
+ if (typeof method !== "string") {
+ throw new InvalidArgumentError("method must be a string");
+ } else if (tokenRegExp.exec(method) === null) {
+ throw new InvalidArgumentError("invalid request method");
+ }
+ if (upgrade && typeof upgrade !== "string") {
+ throw new InvalidArgumentError("upgrade must be a string");
+ }
+ if (headersTimeout != null && (!Number.isFinite(headersTimeout) || headersTimeout < 0)) {
+ throw new InvalidArgumentError("invalid headersTimeout");
+ }
+ if (bodyTimeout != null && (!Number.isFinite(bodyTimeout) || bodyTimeout < 0)) {
+ throw new InvalidArgumentError("invalid bodyTimeout");
+ }
+ if (reset != null && typeof reset !== "boolean") {
+ throw new InvalidArgumentError("invalid reset");
+ }
+ this.headersTimeout = headersTimeout;
+ this.bodyTimeout = bodyTimeout;
+ this.throwOnError = throwOnError === true;
+ this.method = method;
+ if (body == null) {
+ this.body = null;
+ } else if (util3.isStream(body)) {
+ this.body = body;
+ } else if (util3.isBuffer(body)) {
+ this.body = body.byteLength ? body : null;
+ } else if (ArrayBuffer.isView(body)) {
+ this.body = body.buffer.byteLength ? Buffer.from(body.buffer, body.byteOffset, body.byteLength) : null;
+ } else if (body instanceof ArrayBuffer) {
+ this.body = body.byteLength ? Buffer.from(body) : null;
+ } else if (typeof body === "string") {
+ this.body = body.length ? Buffer.from(body) : null;
+ } else if (util3.isFormDataLike(body) || util3.isIterable(body) || util3.isBlobLike(body)) {
+ this.body = body;
+ } else {
+ throw new InvalidArgumentError("body must be a string, a Buffer, a Readable stream, an iterable, or an async iterable");
+ }
+ this.completed = false;
+ this.aborted = false;
+ this.upgrade = upgrade || null;
+ this.path = query ? util3.buildURL(path45, query) : path45;
+ this.origin = origin;
+ this.idempotent = idempotent == null ? method === "HEAD" || method === "GET" : idempotent;
+ this.blocking = blocking == null ? false : blocking;
+ this.reset = reset == null ? null : reset;
+ this.host = null;
+ this.contentLength = null;
+ this.contentType = null;
+ this.headers = "";
+ if (Array.isArray(headers)) {
+ if (headers.length % 2 !== 0) {
+ throw new InvalidArgumentError("headers array must be even");
+ }
+ for (let i = 0; i < headers.length; i += 2) {
+ processHeader(this, headers[i], headers[i + 1]);
+ }
+ } else if (headers && typeof headers === "object") {
+ const keys = Object.keys(headers);
+ for (let i = 0; i < keys.length; i++) {
+ const key = keys[i];
+ processHeader(this, key, headers[key]);
+ }
+ } else if (headers != null) {
+ throw new InvalidArgumentError("headers must be an object or an array");
+ }
+ if (util3.isFormDataLike(this.body)) {
+ if (util3.nodeMajor < 16 || util3.nodeMajor === 16 && util3.nodeMinor < 8) {
+ throw new InvalidArgumentError("Form-Data bodies are only supported in node v16.8 and newer.");
+ }
+ if (!extractBody) {
+ extractBody = require_body().extractBody;
+ }
+ const [bodyStream, contentType] = extractBody(body);
+ if (this.contentType == null) {
+ this.contentType = contentType;
+ this.headers += `content-type: ${contentType}\r
+`;
+ }
+ this.body = bodyStream.stream;
+ } else if (util3.isBlobLike(body) && this.contentType == null && body.type) {
+ this.contentType = body.type;
+ this.headers += `content-type: ${body.type}\r
+`;
+ }
+ util3.validateHandler(handler15, method, upgrade);
+ this.servername = util3.getServerName(this.host);
+ this[kHandler] = handler15;
+ if (channels.create.hasSubscribers) {
+ channels.create.publish({ request: this });
+ }
+ }
+ onBodySent(chunk) {
+ if (this[kHandler].onBodySent) {
+ try {
+ this[kHandler].onBodySent(chunk);
+ } catch (err) {
+ this.onError(err);
+ }
+ }
+ }
+ onRequestSent() {
+ if (channels.bodySent.hasSubscribers) {
+ channels.bodySent.publish({ request: this });
+ }
+ }
+ onConnect(abort) {
+ assert18(!this.aborted);
+ assert18(!this.completed);
+ return this[kHandler].onConnect(abort);
+ }
+ onHeaders(statusCode, headers, resume, statusText) {
+ assert18(!this.aborted);
+ assert18(!this.completed);
+ if (channels.headers.hasSubscribers) {
+ channels.headers.publish({ request: this, response: { statusCode, headers, statusText } });
+ }
+ return this[kHandler].onHeaders(statusCode, headers, resume, statusText);
+ }
+ onData(chunk) {
+ assert18(!this.aborted);
+ assert18(!this.completed);
+ return this[kHandler].onData(chunk);
+ }
+ onUpgrade(statusCode, headers, socket) {
+ assert18(!this.aborted);
+ assert18(!this.completed);
+ return this[kHandler].onUpgrade(statusCode, headers, socket);
+ }
+ onComplete(trailers) {
+ assert18(!this.aborted);
+ this.completed = true;
+ if (channels.trailers.hasSubscribers) {
+ channels.trailers.publish({ request: this, trailers });
+ }
+ return this[kHandler].onComplete(trailers);
+ }
+ onError(error) {
+ if (channels.error.hasSubscribers) {
+ channels.error.publish({ request: this, error });
+ }
+ if (this.aborted) {
+ return;
+ }
+ this.aborted = true;
+ return this[kHandler].onError(error);
+ }
+ addHeader(key, value) {
+ processHeader(this, key, value);
+ return this;
+ }
+ };
+ __name(Request3, "Request");
+ function processHeaderValue(key, val) {
+ if (val && typeof val === "object") {
+ throw new InvalidArgumentError(`invalid ${key} header`);
+ }
+ val = val != null ? `${val}` : "";
+ if (headerCharRegex.exec(val) !== null) {
+ throw new InvalidArgumentError(`invalid ${key} header`);
+ }
+ return `${key}: ${val}\r
+`;
+ }
+ __name(processHeaderValue, "processHeaderValue");
+ function processHeader(request, key, val) {
+ if (val && (typeof val === "object" && !Array.isArray(val))) {
+ throw new InvalidArgumentError(`invalid ${key} header`);
+ } else if (val === void 0) {
+ return;
+ }
+ if (request.host === null && key.length === 4 && key.toLowerCase() === "host") {
+ if (headerCharRegex.exec(val) !== null) {
+ throw new InvalidArgumentError(`invalid ${key} header`);
+ }
+ request.host = val;
+ } else if (request.contentLength === null && key.length === 14 && key.toLowerCase() === "content-length") {
+ request.contentLength = parseInt(val, 10);
+ if (!Number.isFinite(request.contentLength)) {
+ throw new InvalidArgumentError("invalid content-length header");
+ }
+ } else if (request.contentType === null && key.length === 12 && key.toLowerCase() === "content-type") {
+ request.contentType = val;
+ request.headers += processHeaderValue(key, val);
+ } else if (key.length === 17 && key.toLowerCase() === "transfer-encoding") {
+ throw new InvalidArgumentError("invalid transfer-encoding header");
+ } else if (key.length === 10 && key.toLowerCase() === "connection") {
+ const value = typeof val === "string" ? val.toLowerCase() : null;
+ if (value !== "close" && value !== "keep-alive") {
+ throw new InvalidArgumentError("invalid connection header");
+ } else if (value === "close") {
+ request.reset = true;
+ }
+ } else if (key.length === 10 && key.toLowerCase() === "keep-alive") {
+ throw new InvalidArgumentError("invalid keep-alive header");
+ } else if (key.length === 7 && key.toLowerCase() === "upgrade") {
+ throw new InvalidArgumentError("invalid upgrade header");
+ } else if (key.length === 6 && key.toLowerCase() === "expect") {
+ throw new NotSupportedError("expect header not supported");
+ } else if (tokenRegExp.exec(key) === null) {
+ throw new InvalidArgumentError("invalid header key");
+ } else {
+ if (Array.isArray(val)) {
+ for (let i = 0; i < val.length; i++) {
+ request.headers += processHeaderValue(key, val[i]);
+ }
+ } else {
+ request.headers += processHeaderValue(key, val);
+ }
+ }
+ }
+ __name(processHeader, "processHeader");
+ module2.exports = Request3;
+ }
+});
+
+// ../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/dispatcher.js
+var require_dispatcher = __commonJS({
+ "../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/dispatcher.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var EventEmitter3 = require("events");
+ var Dispatcher = class extends EventEmitter3 {
+ dispatch() {
+ throw new Error("not implemented");
+ }
+ close() {
+ throw new Error("not implemented");
+ }
+ destroy() {
+ throw new Error("not implemented");
+ }
+ };
+ __name(Dispatcher, "Dispatcher");
+ module2.exports = Dispatcher;
+ }
+});
+
+// ../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/dispatcher-base.js
+var require_dispatcher_base = __commonJS({
+ "../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/dispatcher-base.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var Dispatcher = require_dispatcher();
+ var {
+ ClientDestroyedError,
+ ClientClosedError,
+ InvalidArgumentError
+ } = require_errors();
+ var { kDestroy, kClose, kDispatch, kInterceptors } = require_symbols();
+ var kDestroyed = Symbol("destroyed");
+ var kClosed = Symbol("closed");
+ var kOnDestroyed = Symbol("onDestroyed");
+ var kOnClosed = Symbol("onClosed");
+ var kInterceptedDispatch = Symbol("Intercepted Dispatch");
+ var DispatcherBase = class extends Dispatcher {
+ constructor() {
+ super();
+ this[kDestroyed] = false;
+ this[kOnDestroyed] = [];
+ this[kClosed] = false;
+ this[kOnClosed] = [];
+ }
+ get destroyed() {
+ return this[kDestroyed];
+ }
+ get closed() {
+ return this[kClosed];
+ }
+ get interceptors() {
+ return this[kInterceptors];
+ }
+ set interceptors(newInterceptors) {
+ if (newInterceptors) {
+ for (let i = newInterceptors.length - 1; i >= 0; i--) {
+ const interceptor = this[kInterceptors][i];
+ if (typeof interceptor !== "function") {
+ throw new InvalidArgumentError("interceptor must be an function");
+ }
+ }
+ }
+ this[kInterceptors] = newInterceptors;
+ }
+ close(callback) {
+ if (callback === void 0) {
+ return new Promise((resolve18, reject) => {
+ this.close((err, data) => {
+ return err ? reject(err) : resolve18(data);
+ });
+ });
+ }
+ if (typeof callback !== "function") {
+ throw new InvalidArgumentError("invalid callback");
+ }
+ if (this[kDestroyed]) {
+ queueMicrotask(() => callback(new ClientDestroyedError(), null));
+ return;
+ }
+ if (this[kClosed]) {
+ if (this[kOnClosed]) {
+ this[kOnClosed].push(callback);
+ } else {
+ queueMicrotask(() => callback(null, null));
+ }
+ return;
+ }
+ this[kClosed] = true;
+ this[kOnClosed].push(callback);
+ const onClosed = /* @__PURE__ */ __name(() => {
+ const callbacks = this[kOnClosed];
+ this[kOnClosed] = null;
+ for (let i = 0; i < callbacks.length; i++) {
+ callbacks[i](null, null);
+ }
+ }, "onClosed");
+ this[kClose]().then(() => this.destroy()).then(() => {
+ queueMicrotask(onClosed);
+ });
+ }
+ destroy(err, callback) {
+ if (typeof err === "function") {
+ callback = err;
+ err = null;
+ }
+ if (callback === void 0) {
+ return new Promise((resolve18, reject) => {
+ this.destroy(err, (err2, data) => {
+ return err2 ? (
+ /* istanbul ignore next: should never error */
+ reject(err2)
+ ) : resolve18(data);
+ });
+ });
+ }
+ if (typeof callback !== "function") {
+ throw new InvalidArgumentError("invalid callback");
+ }
+ if (this[kDestroyed]) {
+ if (this[kOnDestroyed]) {
+ this[kOnDestroyed].push(callback);
+ } else {
+ queueMicrotask(() => callback(null, null));
+ }
+ return;
+ }
+ if (!err) {
+ err = new ClientDestroyedError();
+ }
+ this[kDestroyed] = true;
+ this[kOnDestroyed].push(callback);
+ const onDestroyed = /* @__PURE__ */ __name(() => {
+ const callbacks = this[kOnDestroyed];
+ this[kOnDestroyed] = null;
+ for (let i = 0; i < callbacks.length; i++) {
+ callbacks[i](null, null);
+ }
+ }, "onDestroyed");
+ this[kDestroy](err).then(() => {
+ queueMicrotask(onDestroyed);
+ });
+ }
+ [kInterceptedDispatch](opts, handler15) {
+ if (!this[kInterceptors] || this[kInterceptors].length === 0) {
+ this[kInterceptedDispatch] = this[kDispatch];
+ return this[kDispatch](opts, handler15);
+ }
+ let dispatch = this[kDispatch].bind(this);
+ for (let i = this[kInterceptors].length - 1; i >= 0; i--) {
+ dispatch = this[kInterceptors][i](dispatch);
+ }
+ this[kInterceptedDispatch] = dispatch;
+ return dispatch(opts, handler15);
+ }
+ dispatch(opts, handler15) {
+ if (!handler15 || typeof handler15 !== "object") {
+ throw new InvalidArgumentError("handler must be an object");
+ }
+ try {
+ if (!opts || typeof opts !== "object") {
+ throw new InvalidArgumentError("opts must be an object.");
+ }
+ if (this[kDestroyed]) {
+ throw new ClientDestroyedError();
+ }
+ if (this[kClosed]) {
+ throw new ClientClosedError();
+ }
+ return this[kInterceptedDispatch](opts, handler15);
+ } catch (err) {
+ if (typeof handler15.onError !== "function") {
+ throw new InvalidArgumentError("invalid onError method");
+ }
+ handler15.onError(err);
+ return false;
+ }
+ }
+ };
+ __name(DispatcherBase, "DispatcherBase");
+ module2.exports = DispatcherBase;
+ }
+});
+
+// ../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/core/connect.js
+var require_connect = __commonJS({
+ "../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/core/connect.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var net3 = require("net");
+ var assert18 = require("assert");
+ var util3 = require_util();
+ var { InvalidArgumentError, ConnectTimeoutError } = require_errors();
+ var tls;
+ var SessionCache;
+ if (global.FinalizationRegistry) {
+ SessionCache = /* @__PURE__ */ __name(class WeakSessionCache {
+ constructor(maxCachedSessions) {
+ this._maxCachedSessions = maxCachedSessions;
+ this._sessionCache = /* @__PURE__ */ new Map();
+ this._sessionRegistry = new global.FinalizationRegistry((key) => {
+ if (this._sessionCache.size < this._maxCachedSessions) {
+ return;
+ }
+ const ref = this._sessionCache.get(key);
+ if (ref !== void 0 && ref.deref() === void 0) {
+ this._sessionCache.delete(key);
+ }
+ });
+ }
+ get(sessionKey) {
+ const ref = this._sessionCache.get(sessionKey);
+ return ref ? ref.deref() : null;
+ }
+ set(sessionKey, session) {
+ if (this._maxCachedSessions === 0) {
+ return;
+ }
+ this._sessionCache.set(sessionKey, new WeakRef(session));
+ this._sessionRegistry.register(session, sessionKey);
+ }
+ }, "WeakSessionCache");
+ } else {
+ SessionCache = /* @__PURE__ */ __name(class SimpleSessionCache {
+ constructor(maxCachedSessions) {
+ this._maxCachedSessions = maxCachedSessions;
+ this._sessionCache = /* @__PURE__ */ new Map();
+ }
+ get(sessionKey) {
+ return this._sessionCache.get(sessionKey);
+ }
+ set(sessionKey, session) {
+ if (this._maxCachedSessions === 0) {
+ return;
+ }
+ if (this._sessionCache.size >= this._maxCachedSessions) {
+ const { value: oldestKey } = this._sessionCache.keys().next();
+ this._sessionCache.delete(oldestKey);
+ }
+ this._sessionCache.set(sessionKey, session);
+ }
+ }, "SimpleSessionCache");
+ }
+ function buildConnector({ maxCachedSessions, socketPath, timeout, ...opts }) {
+ if (maxCachedSessions != null && (!Number.isInteger(maxCachedSessions) || maxCachedSessions < 0)) {
+ throw new InvalidArgumentError("maxCachedSessions must be a positive integer or zero");
+ }
+ const options14 = { path: socketPath, ...opts };
+ const sessionCache = new SessionCache(maxCachedSessions == null ? 100 : maxCachedSessions);
+ timeout = timeout == null ? 1e4 : timeout;
+ return /* @__PURE__ */ __name(function connect2({ hostname, host, protocol, port: port2, servername, localAddress, httpSocket }, callback) {
+ let socket;
+ if (protocol === "https:") {
+ if (!tls) {
+ tls = require("tls");
+ }
+ servername = servername || options14.servername || util3.getServerName(host) || null;
+ const sessionKey = servername || hostname;
+ const session = sessionCache.get(sessionKey) || null;
+ assert18(sessionKey);
+ socket = tls.connect({
+ highWaterMark: 16384,
+ // TLS in node can't have bigger HWM anyway...
+ ...options14,
+ servername,
+ session,
+ localAddress,
+ socket: httpSocket,
+ // upgrade socket connection
+ port: port2 || 443,
+ host: hostname
+ });
+ socket.on("session", function(session2) {
+ sessionCache.set(sessionKey, session2);
+ });
+ } else {
+ assert18(!httpSocket, "httpSocket can only be sent on TLS update");
+ socket = net3.connect({
+ highWaterMark: 64 * 1024,
+ // Same as nodejs fs streams.
+ ...options14,
+ localAddress,
+ port: port2 || 80,
+ host: hostname
+ });
+ }
+ if (options14.keepAlive == null || options14.keepAlive) {
+ const keepAliveInitialDelay = options14.keepAliveInitialDelay === void 0 ? 6e4 : options14.keepAliveInitialDelay;
+ socket.setKeepAlive(true, keepAliveInitialDelay);
+ }
+ const cancelTimeout = setupTimeout2(() => onConnectTimeout(socket), timeout);
+ socket.setNoDelay(true).once(protocol === "https:" ? "secureConnect" : "connect", function() {
+ cancelTimeout();
+ if (callback) {
+ const cb = callback;
+ callback = null;
+ cb(null, this);
+ }
+ }).on("error", function(err) {
+ cancelTimeout();
+ if (callback) {
+ const cb = callback;
+ callback = null;
+ cb(err);
+ }
+ });
+ return socket;
+ }, "connect");
+ }
+ __name(buildConnector, "buildConnector");
+ function setupTimeout2(onConnectTimeout2, timeout) {
+ if (!timeout) {
+ return () => {
+ };
+ }
+ let s1 = null;
+ let s2 = null;
+ const timeoutId = setTimeout(() => {
+ s1 = setImmediate(() => {
+ if (process.platform === "win32") {
+ s2 = setImmediate(() => onConnectTimeout2());
+ } else {
+ onConnectTimeout2();
+ }
+ });
+ }, timeout);
+ return () => {
+ clearTimeout(timeoutId);
+ clearImmediate(s1);
+ clearImmediate(s2);
+ };
+ }
+ __name(setupTimeout2, "setupTimeout");
+ function onConnectTimeout(socket) {
+ util3.destroy(socket, new ConnectTimeoutError());
+ }
+ __name(onConnectTimeout, "onConnectTimeout");
+ module2.exports = buildConnector;
+ }
+});
+
+// ../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/llhttp/utils.js
+var require_utils2 = __commonJS({
+ "../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/llhttp/utils.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ Object.defineProperty(exports2, "__esModule", { value: true });
+ exports2.enumToMap = void 0;
+ function enumToMap(obj) {
+ const res = {};
+ Object.keys(obj).forEach((key) => {
+ const value = obj[key];
+ if (typeof value === "number") {
+ res[key] = value;
+ }
+ });
+ return res;
+ }
+ __name(enumToMap, "enumToMap");
+ exports2.enumToMap = enumToMap;
+ }
+});
+
+// ../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/llhttp/constants.js
+var require_constants2 = __commonJS({
+ "../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/llhttp/constants.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ Object.defineProperty(exports2, "__esModule", { value: true });
+ exports2.SPECIAL_HEADERS = exports2.HEADER_STATE = exports2.MINOR = exports2.MAJOR = exports2.CONNECTION_TOKEN_CHARS = exports2.HEADER_CHARS = exports2.TOKEN = exports2.STRICT_TOKEN = exports2.HEX = exports2.URL_CHAR = exports2.STRICT_URL_CHAR = exports2.USERINFO_CHARS = exports2.MARK = exports2.ALPHANUM = exports2.NUM = exports2.HEX_MAP = exports2.NUM_MAP = exports2.ALPHA = exports2.FINISH = exports2.H_METHOD_MAP = exports2.METHOD_MAP = exports2.METHODS_RTSP = exports2.METHODS_ICE = exports2.METHODS_HTTP = exports2.METHODS = exports2.LENIENT_FLAGS = exports2.FLAGS = exports2.TYPE = exports2.ERROR = void 0;
+ var utils_1 = require_utils2();
+ var ERROR;
+ (function(ERROR2) {
+ ERROR2[ERROR2["OK"] = 0] = "OK";
+ ERROR2[ERROR2["INTERNAL"] = 1] = "INTERNAL";
+ ERROR2[ERROR2["STRICT"] = 2] = "STRICT";
+ ERROR2[ERROR2["LF_EXPECTED"] = 3] = "LF_EXPECTED";
+ ERROR2[ERROR2["UNEXPECTED_CONTENT_LENGTH"] = 4] = "UNEXPECTED_CONTENT_LENGTH";
+ ERROR2[ERROR2["CLOSED_CONNECTION"] = 5] = "CLOSED_CONNECTION";
+ ERROR2[ERROR2["INVALID_METHOD"] = 6] = "INVALID_METHOD";
+ ERROR2[ERROR2["INVALID_URL"] = 7] = "INVALID_URL";
+ ERROR2[ERROR2["INVALID_CONSTANT"] = 8] = "INVALID_CONSTANT";
+ ERROR2[ERROR2["INVALID_VERSION"] = 9] = "INVALID_VERSION";
+ ERROR2[ERROR2["INVALID_HEADER_TOKEN"] = 10] = "INVALID_HEADER_TOKEN";
+ ERROR2[ERROR2["INVALID_CONTENT_LENGTH"] = 11] = "INVALID_CONTENT_LENGTH";
+ ERROR2[ERROR2["INVALID_CHUNK_SIZE"] = 12] = "INVALID_CHUNK_SIZE";
+ ERROR2[ERROR2["INVALID_STATUS"] = 13] = "INVALID_STATUS";
+ ERROR2[ERROR2["INVALID_EOF_STATE"] = 14] = "INVALID_EOF_STATE";
+ ERROR2[ERROR2["INVALID_TRANSFER_ENCODING"] = 15] = "INVALID_TRANSFER_ENCODING";
+ ERROR2[ERROR2["CB_MESSAGE_BEGIN"] = 16] = "CB_MESSAGE_BEGIN";
+ ERROR2[ERROR2["CB_HEADERS_COMPLETE"] = 17] = "CB_HEADERS_COMPLETE";
+ ERROR2[ERROR2["CB_MESSAGE_COMPLETE"] = 18] = "CB_MESSAGE_COMPLETE";
+ ERROR2[ERROR2["CB_CHUNK_HEADER"] = 19] = "CB_CHUNK_HEADER";
+ ERROR2[ERROR2["CB_CHUNK_COMPLETE"] = 20] = "CB_CHUNK_COMPLETE";
+ ERROR2[ERROR2["PAUSED"] = 21] = "PAUSED";
+ ERROR2[ERROR2["PAUSED_UPGRADE"] = 22] = "PAUSED_UPGRADE";
+ ERROR2[ERROR2["PAUSED_H2_UPGRADE"] = 23] = "PAUSED_H2_UPGRADE";
+ ERROR2[ERROR2["USER"] = 24] = "USER";
+ })(ERROR = exports2.ERROR || (exports2.ERROR = {}));
+ var TYPE;
+ (function(TYPE2) {
+ TYPE2[TYPE2["BOTH"] = 0] = "BOTH";
+ TYPE2[TYPE2["REQUEST"] = 1] = "REQUEST";
+ TYPE2[TYPE2["RESPONSE"] = 2] = "RESPONSE";
+ })(TYPE = exports2.TYPE || (exports2.TYPE = {}));
+ var FLAGS;
+ (function(FLAGS2) {
+ FLAGS2[FLAGS2["CONNECTION_KEEP_ALIVE"] = 1] = "CONNECTION_KEEP_ALIVE";
+ FLAGS2[FLAGS2["CONNECTION_CLOSE"] = 2] = "CONNECTION_CLOSE";
+ FLAGS2[FLAGS2["CONNECTION_UPGRADE"] = 4] = "CONNECTION_UPGRADE";
+ FLAGS2[FLAGS2["CHUNKED"] = 8] = "CHUNKED";
+ FLAGS2[FLAGS2["UPGRADE"] = 16] = "UPGRADE";
+ FLAGS2[FLAGS2["CONTENT_LENGTH"] = 32] = "CONTENT_LENGTH";
+ FLAGS2[FLAGS2["SKIPBODY"] = 64] = "SKIPBODY";
+ FLAGS2[FLAGS2["TRAILING"] = 128] = "TRAILING";
+ FLAGS2[FLAGS2["TRANSFER_ENCODING"] = 512] = "TRANSFER_ENCODING";
+ })(FLAGS = exports2.FLAGS || (exports2.FLAGS = {}));
+ var LENIENT_FLAGS;
+ (function(LENIENT_FLAGS2) {
+ LENIENT_FLAGS2[LENIENT_FLAGS2["HEADERS"] = 1] = "HEADERS";
+ LENIENT_FLAGS2[LENIENT_FLAGS2["CHUNKED_LENGTH"] = 2] = "CHUNKED_LENGTH";
+ LENIENT_FLAGS2[LENIENT_FLAGS2["KEEP_ALIVE"] = 4] = "KEEP_ALIVE";
+ })(LENIENT_FLAGS = exports2.LENIENT_FLAGS || (exports2.LENIENT_FLAGS = {}));
+ var METHODS;
+ (function(METHODS2) {
+ METHODS2[METHODS2["DELETE"] = 0] = "DELETE";
+ METHODS2[METHODS2["GET"] = 1] = "GET";
+ METHODS2[METHODS2["HEAD"] = 2] = "HEAD";
+ METHODS2[METHODS2["POST"] = 3] = "POST";
+ METHODS2[METHODS2["PUT"] = 4] = "PUT";
+ METHODS2[METHODS2["CONNECT"] = 5] = "CONNECT";
+ METHODS2[METHODS2["OPTIONS"] = 6] = "OPTIONS";
+ METHODS2[METHODS2["TRACE"] = 7] = "TRACE";
+ METHODS2[METHODS2["COPY"] = 8] = "COPY";
+ METHODS2[METHODS2["LOCK"] = 9] = "LOCK";
+ METHODS2[METHODS2["MKCOL"] = 10] = "MKCOL";
+ METHODS2[METHODS2["MOVE"] = 11] = "MOVE";
+ METHODS2[METHODS2["PROPFIND"] = 12] = "PROPFIND";
+ METHODS2[METHODS2["PROPPATCH"] = 13] = "PROPPATCH";
+ METHODS2[METHODS2["SEARCH"] = 14] = "SEARCH";
+ METHODS2[METHODS2["UNLOCK"] = 15] = "UNLOCK";
+ METHODS2[METHODS2["BIND"] = 16] = "BIND";
+ METHODS2[METHODS2["REBIND"] = 17] = "REBIND";
+ METHODS2[METHODS2["UNBIND"] = 18] = "UNBIND";
+ METHODS2[METHODS2["ACL"] = 19] = "ACL";
+ METHODS2[METHODS2["REPORT"] = 20] = "REPORT";
+ METHODS2[METHODS2["MKACTIVITY"] = 21] = "MKACTIVITY";
+ METHODS2[METHODS2["CHECKOUT"] = 22] = "CHECKOUT";
+ METHODS2[METHODS2["MERGE"] = 23] = "MERGE";
+ METHODS2[METHODS2["M-SEARCH"] = 24] = "M-SEARCH";
+ METHODS2[METHODS2["NOTIFY"] = 25] = "NOTIFY";
+ METHODS2[METHODS2["SUBSCRIBE"] = 26] = "SUBSCRIBE";
+ METHODS2[METHODS2["UNSUBSCRIBE"] = 27] = "UNSUBSCRIBE";
+ METHODS2[METHODS2["PATCH"] = 28] = "PATCH";
+ METHODS2[METHODS2["PURGE"] = 29] = "PURGE";
+ METHODS2[METHODS2["MKCALENDAR"] = 30] = "MKCALENDAR";
+ METHODS2[METHODS2["LINK"] = 31] = "LINK";
+ METHODS2[METHODS2["UNLINK"] = 32] = "UNLINK";
+ METHODS2[METHODS2["SOURCE"] = 33] = "SOURCE";
+ METHODS2[METHODS2["PRI"] = 34] = "PRI";
+ METHODS2[METHODS2["DESCRIBE"] = 35] = "DESCRIBE";
+ METHODS2[METHODS2["ANNOUNCE"] = 36] = "ANNOUNCE";
+ METHODS2[METHODS2["SETUP"] = 37] = "SETUP";
+ METHODS2[METHODS2["PLAY"] = 38] = "PLAY";
+ METHODS2[METHODS2["PAUSE"] = 39] = "PAUSE";
+ METHODS2[METHODS2["TEARDOWN"] = 40] = "TEARDOWN";
+ METHODS2[METHODS2["GET_PARAMETER"] = 41] = "GET_PARAMETER";
+ METHODS2[METHODS2["SET_PARAMETER"] = 42] = "SET_PARAMETER";
+ METHODS2[METHODS2["REDIRECT"] = 43] = "REDIRECT";
+ METHODS2[METHODS2["RECORD"] = 44] = "RECORD";
+ METHODS2[METHODS2["FLUSH"] = 45] = "FLUSH";
+ })(METHODS = exports2.METHODS || (exports2.METHODS = {}));
+ exports2.METHODS_HTTP = [
+ METHODS.DELETE,
+ METHODS.GET,
+ METHODS.HEAD,
+ METHODS.POST,
+ METHODS.PUT,
+ METHODS.CONNECT,
+ METHODS.OPTIONS,
+ METHODS.TRACE,
+ METHODS.COPY,
+ METHODS.LOCK,
+ METHODS.MKCOL,
+ METHODS.MOVE,
+ METHODS.PROPFIND,
+ METHODS.PROPPATCH,
+ METHODS.SEARCH,
+ METHODS.UNLOCK,
+ METHODS.BIND,
+ METHODS.REBIND,
+ METHODS.UNBIND,
+ METHODS.ACL,
+ METHODS.REPORT,
+ METHODS.MKACTIVITY,
+ METHODS.CHECKOUT,
+ METHODS.MERGE,
+ METHODS["M-SEARCH"],
+ METHODS.NOTIFY,
+ METHODS.SUBSCRIBE,
+ METHODS.UNSUBSCRIBE,
+ METHODS.PATCH,
+ METHODS.PURGE,
+ METHODS.MKCALENDAR,
+ METHODS.LINK,
+ METHODS.UNLINK,
+ METHODS.PRI,
+ // TODO(indutny): should we allow it with HTTP?
+ METHODS.SOURCE
+ ];
+ exports2.METHODS_ICE = [
+ METHODS.SOURCE
+ ];
+ exports2.METHODS_RTSP = [
+ METHODS.OPTIONS,
+ METHODS.DESCRIBE,
+ METHODS.ANNOUNCE,
+ METHODS.SETUP,
+ METHODS.PLAY,
+ METHODS.PAUSE,
+ METHODS.TEARDOWN,
+ METHODS.GET_PARAMETER,
+ METHODS.SET_PARAMETER,
+ METHODS.REDIRECT,
+ METHODS.RECORD,
+ METHODS.FLUSH,
+ // For AirPlay
+ METHODS.GET,
+ METHODS.POST
+ ];
+ exports2.METHOD_MAP = utils_1.enumToMap(METHODS);
+ exports2.H_METHOD_MAP = {};
+ Object.keys(exports2.METHOD_MAP).forEach((key) => {
+ if (/^H/.test(key)) {
+ exports2.H_METHOD_MAP[key] = exports2.METHOD_MAP[key];
+ }
+ });
+ var FINISH;
+ (function(FINISH2) {
+ FINISH2[FINISH2["SAFE"] = 0] = "SAFE";
+ FINISH2[FINISH2["SAFE_WITH_CB"] = 1] = "SAFE_WITH_CB";
+ FINISH2[FINISH2["UNSAFE"] = 2] = "UNSAFE";
+ })(FINISH = exports2.FINISH || (exports2.FINISH = {}));
+ exports2.ALPHA = [];
+ for (let i = "A".charCodeAt(0); i <= "Z".charCodeAt(0); i++) {
+ exports2.ALPHA.push(String.fromCharCode(i));
+ exports2.ALPHA.push(String.fromCharCode(i + 32));
+ }
+ exports2.NUM_MAP = {
+ 0: 0,
+ 1: 1,
+ 2: 2,
+ 3: 3,
+ 4: 4,
+ 5: 5,
+ 6: 6,
+ 7: 7,
+ 8: 8,
+ 9: 9
+ };
+ exports2.HEX_MAP = {
+ 0: 0,
+ 1: 1,
+ 2: 2,
+ 3: 3,
+ 4: 4,
+ 5: 5,
+ 6: 6,
+ 7: 7,
+ 8: 8,
+ 9: 9,
+ A: 10,
+ B: 11,
+ C: 12,
+ D: 13,
+ E: 14,
+ F: 15,
+ a: 10,
+ b: 11,
+ c: 12,
+ d: 13,
+ e: 14,
+ f: 15
+ };
+ exports2.NUM = [
+ "0",
+ "1",
+ "2",
+ "3",
+ "4",
+ "5",
+ "6",
+ "7",
+ "8",
+ "9"
+ ];
+ exports2.ALPHANUM = exports2.ALPHA.concat(exports2.NUM);
+ exports2.MARK = ["-", "_", ".", "!", "~", "*", "'", "(", ")"];
+ exports2.USERINFO_CHARS = exports2.ALPHANUM.concat(exports2.MARK).concat(["%", ";", ":", "&", "=", "+", "$", ","]);
+ exports2.STRICT_URL_CHAR = [
+ "!",
+ '"',
+ "$",
+ "%",
+ "&",
+ "'",
+ "(",
+ ")",
+ "*",
+ "+",
+ ",",
+ "-",
+ ".",
+ "/",
+ ":",
+ ";",
+ "<",
+ "=",
+ ">",
+ "@",
+ "[",
+ "\\",
+ "]",
+ "^",
+ "_",
+ "`",
+ "{",
+ "|",
+ "}",
+ "~"
+ ].concat(exports2.ALPHANUM);
+ exports2.URL_CHAR = exports2.STRICT_URL_CHAR.concat([" ", "\f"]);
+ for (let i = 128; i <= 255; i++) {
+ exports2.URL_CHAR.push(i);
+ }
+ exports2.HEX = exports2.NUM.concat(["a", "b", "c", "d", "e", "f", "A", "B", "C", "D", "E", "F"]);
+ exports2.STRICT_TOKEN = [
+ "!",
+ "#",
+ "$",
+ "%",
+ "&",
+ "'",
+ "*",
+ "+",
+ "-",
+ ".",
+ "^",
+ "_",
+ "`",
+ "|",
+ "~"
+ ].concat(exports2.ALPHANUM);
+ exports2.TOKEN = exports2.STRICT_TOKEN.concat([" "]);
+ exports2.HEADER_CHARS = [" "];
+ for (let i = 32; i <= 255; i++) {
+ if (i !== 127) {
+ exports2.HEADER_CHARS.push(i);
+ }
+ }
+ exports2.CONNECTION_TOKEN_CHARS = exports2.HEADER_CHARS.filter((c) => c !== 44);
+ exports2.MAJOR = exports2.NUM_MAP;
+ exports2.MINOR = exports2.MAJOR;
+ var HEADER_STATE;
+ (function(HEADER_STATE2) {
+ HEADER_STATE2[HEADER_STATE2["GENERAL"] = 0] = "GENERAL";
+ HEADER_STATE2[HEADER_STATE2["CONNECTION"] = 1] = "CONNECTION";
+ HEADER_STATE2[HEADER_STATE2["CONTENT_LENGTH"] = 2] = "CONTENT_LENGTH";
+ HEADER_STATE2[HEADER_STATE2["TRANSFER_ENCODING"] = 3] = "TRANSFER_ENCODING";
+ HEADER_STATE2[HEADER_STATE2["UPGRADE"] = 4] = "UPGRADE";
+ HEADER_STATE2[HEADER_STATE2["CONNECTION_KEEP_ALIVE"] = 5] = "CONNECTION_KEEP_ALIVE";
+ HEADER_STATE2[HEADER_STATE2["CONNECTION_CLOSE"] = 6] = "CONNECTION_CLOSE";
+ HEADER_STATE2[HEADER_STATE2["CONNECTION_UPGRADE"] = 7] = "CONNECTION_UPGRADE";
+ HEADER_STATE2[HEADER_STATE2["TRANSFER_ENCODING_CHUNKED"] = 8] = "TRANSFER_ENCODING_CHUNKED";
+ })(HEADER_STATE = exports2.HEADER_STATE || (exports2.HEADER_STATE = {}));
+ exports2.SPECIAL_HEADERS = {
+ "connection": HEADER_STATE.CONNECTION,
+ "content-length": HEADER_STATE.CONTENT_LENGTH,
+ "proxy-connection": HEADER_STATE.CONNECTION,
+ "transfer-encoding": HEADER_STATE.TRANSFER_ENCODING,
+ "upgrade": HEADER_STATE.UPGRADE
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/handler/RedirectHandler.js
+var require_RedirectHandler = __commonJS({
+ "../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/handler/RedirectHandler.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var util3 = require_util();
+ var { kBodyUsed } = require_symbols();
+ var assert18 = require("assert");
+ var { InvalidArgumentError } = require_errors();
+ var EE = require("events");
+ var redirectableStatusCodes = [300, 301, 302, 303, 307, 308];
+ var kBody = Symbol("body");
+ var BodyAsyncIterable = class {
+ constructor(body) {
+ this[kBody] = body;
+ this[kBodyUsed] = false;
+ }
+ async *[Symbol.asyncIterator]() {
+ assert18(!this[kBodyUsed], "disturbed");
+ this[kBodyUsed] = true;
+ yield* this[kBody];
+ }
+ };
+ __name(BodyAsyncIterable, "BodyAsyncIterable");
+ var RedirectHandler = class {
+ constructor(dispatch, maxRedirections, opts, handler15) {
+ if (maxRedirections != null && (!Number.isInteger(maxRedirections) || maxRedirections < 0)) {
+ throw new InvalidArgumentError("maxRedirections must be a positive number");
+ }
+ util3.validateHandler(handler15, opts.method, opts.upgrade);
+ this.dispatch = dispatch;
+ this.location = null;
+ this.abort = null;
+ this.opts = { ...opts, maxRedirections: 0 };
+ this.maxRedirections = maxRedirections;
+ this.handler = handler15;
+ this.history = [];
+ if (util3.isStream(this.opts.body)) {
+ if (util3.bodyLength(this.opts.body) === 0) {
+ this.opts.body.on("data", function() {
+ assert18(false);
+ });
+ }
+ if (typeof this.opts.body.readableDidRead !== "boolean") {
+ this.opts.body[kBodyUsed] = false;
+ EE.prototype.on.call(this.opts.body, "data", function() {
+ this[kBodyUsed] = true;
+ });
+ }
+ } else if (this.opts.body && typeof this.opts.body.pipeTo === "function") {
+ this.opts.body = new BodyAsyncIterable(this.opts.body);
+ } else if (this.opts.body && typeof this.opts.body !== "string" && !ArrayBuffer.isView(this.opts.body) && util3.isIterable(this.opts.body)) {
+ this.opts.body = new BodyAsyncIterable(this.opts.body);
+ }
+ }
+ onConnect(abort) {
+ this.abort = abort;
+ this.handler.onConnect(abort, { history: this.history });
+ }
+ onUpgrade(statusCode, headers, socket) {
+ this.handler.onUpgrade(statusCode, headers, socket);
+ }
+ onError(error) {
+ this.handler.onError(error);
+ }
+ onHeaders(statusCode, headers, resume, statusText) {
+ this.location = this.history.length >= this.maxRedirections || util3.isDisturbed(this.opts.body) ? null : parseLocation(statusCode, headers);
+ if (this.opts.origin) {
+ this.history.push(new URL(this.opts.path, this.opts.origin));
+ }
+ if (!this.location) {
+ return this.handler.onHeaders(statusCode, headers, resume, statusText);
+ }
+ const { origin, pathname, search } = util3.parseURL(new URL(this.location, this.opts.origin && new URL(this.opts.path, this.opts.origin)));
+ const path45 = search ? `${pathname}${search}` : pathname;
+ this.opts.headers = cleanRequestHeaders(this.opts.headers, statusCode === 303, this.opts.origin !== origin);
+ this.opts.path = path45;
+ this.opts.origin = origin;
+ this.opts.maxRedirections = 0;
+ this.opts.query = null;
+ if (statusCode === 303 && this.opts.method !== "HEAD") {
+ this.opts.method = "GET";
+ this.opts.body = null;
+ }
+ }
+ onData(chunk) {
+ if (this.location) {
+ } else {
+ return this.handler.onData(chunk);
+ }
+ }
+ onComplete(trailers) {
+ if (this.location) {
+ this.location = null;
+ this.abort = null;
+ this.dispatch(this.opts, this);
+ } else {
+ this.handler.onComplete(trailers);
+ }
+ }
+ onBodySent(chunk) {
+ if (this.handler.onBodySent) {
+ this.handler.onBodySent(chunk);
+ }
+ }
+ };
+ __name(RedirectHandler, "RedirectHandler");
+ function parseLocation(statusCode, headers) {
+ if (redirectableStatusCodes.indexOf(statusCode) === -1) {
+ return null;
+ }
+ for (let i = 0; i < headers.length; i += 2) {
+ if (headers[i].toString().toLowerCase() === "location") {
+ return headers[i + 1];
+ }
+ }
+ }
+ __name(parseLocation, "parseLocation");
+ function shouldRemoveHeader(header, removeContent, unknownOrigin) {
+ return header.length === 4 && header.toString().toLowerCase() === "host" || removeContent && header.toString().toLowerCase().indexOf("content-") === 0 || unknownOrigin && header.length === 13 && header.toString().toLowerCase() === "authorization" || unknownOrigin && header.length === 6 && header.toString().toLowerCase() === "cookie";
+ }
+ __name(shouldRemoveHeader, "shouldRemoveHeader");
+ function cleanRequestHeaders(headers, removeContent, unknownOrigin) {
+ const ret = [];
+ if (Array.isArray(headers)) {
+ for (let i = 0; i < headers.length; i += 2) {
+ if (!shouldRemoveHeader(headers[i], removeContent, unknownOrigin)) {
+ ret.push(headers[i], headers[i + 1]);
+ }
+ }
+ } else if (headers && typeof headers === "object") {
+ for (const key of Object.keys(headers)) {
+ if (!shouldRemoveHeader(key, removeContent, unknownOrigin)) {
+ ret.push(key, headers[key]);
+ }
+ }
+ } else {
+ assert18(headers == null, "headers must be an object or an array");
+ }
+ return ret;
+ }
+ __name(cleanRequestHeaders, "cleanRequestHeaders");
+ module2.exports = RedirectHandler;
+ }
+});
+
+// ../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/interceptor/redirectInterceptor.js
+var require_redirectInterceptor = __commonJS({
+ "../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/interceptor/redirectInterceptor.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var RedirectHandler = require_RedirectHandler();
+ function createRedirectInterceptor({ maxRedirections: defaultMaxRedirections }) {
+ return (dispatch) => {
+ return /* @__PURE__ */ __name(function Intercept(opts, handler15) {
+ const { maxRedirections = defaultMaxRedirections } = opts;
+ if (!maxRedirections) {
+ return dispatch(opts, handler15);
+ }
+ const redirectHandler = new RedirectHandler(dispatch, maxRedirections, opts, handler15);
+ opts = { ...opts, maxRedirections: 0 };
+ return dispatch(opts, redirectHandler);
+ }, "Intercept");
+ };
+ }
+ __name(createRedirectInterceptor, "createRedirectInterceptor");
+ module2.exports = createRedirectInterceptor;
+ }
+});
+
+// ../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/llhttp/llhttp.wasm.js
+var require_llhttp_wasm = __commonJS({
+ "../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/llhttp/llhttp.wasm.js"(exports2, module2) {
+ init_import_meta_url();
+ module2.exports = "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";
+ }
+});
+
+// ../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/llhttp/llhttp_simd.wasm.js
+var require_llhttp_simd_wasm = __commonJS({
+ "../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/llhttp/llhttp_simd.wasm.js"(exports2, module2) {
+ init_import_meta_url();
+ module2.exports = "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";
+ }
+});
+
+// ../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/client.js
+var require_client = __commonJS({
+ "../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/client.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var assert18 = require("assert");
+ var net3 = require("net");
+ var util3 = require_util();
+ var timers = require_timers();
+ var Request3 = require_request();
+ var DispatcherBase = require_dispatcher_base();
+ var {
+ RequestContentLengthMismatchError,
+ ResponseContentLengthMismatchError,
+ InvalidArgumentError,
+ RequestAbortedError,
+ HeadersTimeoutError,
+ HeadersOverflowError,
+ SocketError,
+ InformationalError,
+ BodyTimeoutError,
+ HTTPParserError,
+ ResponseExceededMaxSizeError
+ } = require_errors();
+ var buildConnector = require_connect();
+ var {
+ kUrl,
+ kReset: kReset2,
+ kServerName,
+ kClient,
+ kBusy,
+ kParser,
+ kConnect,
+ kBlocking,
+ kResuming,
+ kRunning,
+ kPending,
+ kSize,
+ kWriting,
+ kQueue,
+ kConnected,
+ kConnecting,
+ kNeedDrain,
+ kNoRef,
+ kKeepAliveDefaultTimeout,
+ kHostHeader,
+ kPendingIdx,
+ kRunningIdx,
+ kError,
+ kPipelining,
+ kSocket,
+ kKeepAliveTimeoutValue,
+ kMaxHeadersSize,
+ kKeepAliveMaxTimeout,
+ kKeepAliveTimeoutThreshold,
+ kHeadersTimeout,
+ kBodyTimeout,
+ kStrictContentLength,
+ kConnector,
+ kMaxRedirections,
+ kMaxRequests,
+ kCounter,
+ kClose,
+ kDestroy,
+ kDispatch,
+ kInterceptors,
+ kLocalAddress,
+ kMaxResponseSize
+ } = require_symbols();
+ var FastBuffer = Buffer[Symbol.species];
+ var kClosedResolve = Symbol("kClosedResolve");
+ var channels = {};
+ try {
+ const diagnosticsChannel = require("diagnostics_channel");
+ channels.sendHeaders = diagnosticsChannel.channel("undici:client:sendHeaders");
+ channels.beforeConnect = diagnosticsChannel.channel("undici:client:beforeConnect");
+ channels.connectError = diagnosticsChannel.channel("undici:client:connectError");
+ channels.connected = diagnosticsChannel.channel("undici:client:connected");
+ } catch {
+ channels.sendHeaders = { hasSubscribers: false };
+ channels.beforeConnect = { hasSubscribers: false };
+ channels.connectError = { hasSubscribers: false };
+ channels.connected = { hasSubscribers: false };
+ }
+ var Client = class extends DispatcherBase {
+ constructor(url3, {
+ interceptors,
+ maxHeaderSize,
+ headersTimeout,
+ socketTimeout,
+ requestTimeout,
+ connectTimeout,
+ bodyTimeout,
+ idleTimeout,
+ keepAlive,
+ keepAliveTimeout,
+ maxKeepAliveTimeout,
+ keepAliveMaxTimeout,
+ keepAliveTimeoutThreshold,
+ socketPath,
+ pipelining,
+ tls,
+ strictContentLength,
+ maxCachedSessions,
+ maxRedirections,
+ connect: connect3,
+ maxRequestsPerClient,
+ localAddress,
+ maxResponseSize,
+ autoSelectFamily,
+ autoSelectFamilyAttemptTimeout
+ } = {}) {
+ super();
+ if (keepAlive !== void 0) {
+ throw new InvalidArgumentError("unsupported keepAlive, use pipelining=0 instead");
+ }
+ if (socketTimeout !== void 0) {
+ throw new InvalidArgumentError("unsupported socketTimeout, use headersTimeout & bodyTimeout instead");
+ }
+ if (requestTimeout !== void 0) {
+ throw new InvalidArgumentError("unsupported requestTimeout, use headersTimeout & bodyTimeout instead");
+ }
+ if (idleTimeout !== void 0) {
+ throw new InvalidArgumentError("unsupported idleTimeout, use keepAliveTimeout instead");
+ }
+ if (maxKeepAliveTimeout !== void 0) {
+ throw new InvalidArgumentError("unsupported maxKeepAliveTimeout, use keepAliveMaxTimeout instead");
+ }
+ if (maxHeaderSize != null && !Number.isFinite(maxHeaderSize)) {
+ throw new InvalidArgumentError("invalid maxHeaderSize");
+ }
+ if (socketPath != null && typeof socketPath !== "string") {
+ throw new InvalidArgumentError("invalid socketPath");
+ }
+ if (connectTimeout != null && (!Number.isFinite(connectTimeout) || connectTimeout < 0)) {
+ throw new InvalidArgumentError("invalid connectTimeout");
+ }
+ if (keepAliveTimeout != null && (!Number.isFinite(keepAliveTimeout) || keepAliveTimeout <= 0)) {
+ throw new InvalidArgumentError("invalid keepAliveTimeout");
+ }
+ if (keepAliveMaxTimeout != null && (!Number.isFinite(keepAliveMaxTimeout) || keepAliveMaxTimeout <= 0)) {
+ throw new InvalidArgumentError("invalid keepAliveMaxTimeout");
+ }
+ if (keepAliveTimeoutThreshold != null && !Number.isFinite(keepAliveTimeoutThreshold)) {
+ throw new InvalidArgumentError("invalid keepAliveTimeoutThreshold");
+ }
+ if (headersTimeout != null && (!Number.isInteger(headersTimeout) || headersTimeout < 0)) {
+ throw new InvalidArgumentError("headersTimeout must be a positive integer or zero");
+ }
+ if (bodyTimeout != null && (!Number.isInteger(bodyTimeout) || bodyTimeout < 0)) {
+ throw new InvalidArgumentError("bodyTimeout must be a positive integer or zero");
+ }
+ if (connect3 != null && typeof connect3 !== "function" && typeof connect3 !== "object") {
+ throw new InvalidArgumentError("connect must be a function or an object");
+ }
+ if (maxRedirections != null && (!Number.isInteger(maxRedirections) || maxRedirections < 0)) {
+ throw new InvalidArgumentError("maxRedirections must be a positive number");
+ }
+ if (maxRequestsPerClient != null && (!Number.isInteger(maxRequestsPerClient) || maxRequestsPerClient < 0)) {
+ throw new InvalidArgumentError("maxRequestsPerClient must be a positive number");
+ }
+ if (localAddress != null && (typeof localAddress !== "string" || net3.isIP(localAddress) === 0)) {
+ throw new InvalidArgumentError("localAddress must be valid string IP address");
+ }
+ if (maxResponseSize != null && (!Number.isInteger(maxResponseSize) || maxResponseSize < -1)) {
+ throw new InvalidArgumentError("maxResponseSize must be a positive number");
+ }
+ if (autoSelectFamilyAttemptTimeout != null && (!Number.isInteger(autoSelectFamilyAttemptTimeout) || autoSelectFamilyAttemptTimeout < -1)) {
+ throw new InvalidArgumentError("autoSelectFamilyAttemptTimeout must be a positive number");
+ }
+ if (typeof connect3 !== "function") {
+ connect3 = buildConnector({
+ ...tls,
+ maxCachedSessions,
+ socketPath,
+ timeout: connectTimeout,
+ ...util3.nodeHasAutoSelectFamily && autoSelectFamily ? { autoSelectFamily, autoSelectFamilyAttemptTimeout } : void 0,
+ ...connect3
+ });
+ }
+ this[kInterceptors] = interceptors && interceptors.Client && Array.isArray(interceptors.Client) ? interceptors.Client : [createRedirectInterceptor({ maxRedirections })];
+ this[kUrl] = util3.parseOrigin(url3);
+ this[kConnector] = connect3;
+ this[kSocket] = null;
+ this[kPipelining] = pipelining != null ? pipelining : 1;
+ this[kMaxHeadersSize] = maxHeaderSize || 16384;
+ this[kKeepAliveDefaultTimeout] = keepAliveTimeout == null ? 4e3 : keepAliveTimeout;
+ this[kKeepAliveMaxTimeout] = keepAliveMaxTimeout == null ? 6e5 : keepAliveMaxTimeout;
+ this[kKeepAliveTimeoutThreshold] = keepAliveTimeoutThreshold == null ? 1e3 : keepAliveTimeoutThreshold;
+ this[kKeepAliveTimeoutValue] = this[kKeepAliveDefaultTimeout];
+ this[kServerName] = null;
+ this[kLocalAddress] = localAddress != null ? localAddress : null;
+ this[kResuming] = 0;
+ this[kNeedDrain] = 0;
+ this[kHostHeader] = `host: ${this[kUrl].hostname}${this[kUrl].port ? `:${this[kUrl].port}` : ""}\r
+`;
+ this[kBodyTimeout] = bodyTimeout != null ? bodyTimeout : 3e5;
+ this[kHeadersTimeout] = headersTimeout != null ? headersTimeout : 3e5;
+ this[kStrictContentLength] = strictContentLength == null ? true : strictContentLength;
+ this[kMaxRedirections] = maxRedirections;
+ this[kMaxRequests] = maxRequestsPerClient;
+ this[kClosedResolve] = null;
+ this[kMaxResponseSize] = maxResponseSize > -1 ? maxResponseSize : -1;
+ this[kQueue] = [];
+ this[kRunningIdx] = 0;
+ this[kPendingIdx] = 0;
+ }
+ get pipelining() {
+ return this[kPipelining];
+ }
+ set pipelining(value) {
+ this[kPipelining] = value;
+ resume(this, true);
+ }
+ get [kPending]() {
+ return this[kQueue].length - this[kPendingIdx];
+ }
+ get [kRunning]() {
+ return this[kPendingIdx] - this[kRunningIdx];
+ }
+ get [kSize]() {
+ return this[kQueue].length - this[kRunningIdx];
+ }
+ get [kConnected]() {
+ return !!this[kSocket] && !this[kConnecting] && !this[kSocket].destroyed;
+ }
+ get [kBusy]() {
+ const socket = this[kSocket];
+ return socket && (socket[kReset2] || socket[kWriting] || socket[kBlocking]) || this[kSize] >= (this[kPipelining] || 1) || this[kPending] > 0;
+ }
+ /* istanbul ignore: only used for test */
+ [kConnect](cb) {
+ connect2(this);
+ this.once("connect", cb);
+ }
+ [kDispatch](opts, handler15) {
+ const origin = opts.origin || this[kUrl].origin;
+ const request = new Request3(origin, opts, handler15);
+ this[kQueue].push(request);
+ if (this[kResuming]) {
+ } else if (util3.bodyLength(request.body) == null && util3.isIterable(request.body)) {
+ this[kResuming] = 1;
+ process.nextTick(resume, this);
+ } else {
+ resume(this, true);
+ }
+ if (this[kResuming] && this[kNeedDrain] !== 2 && this[kBusy]) {
+ this[kNeedDrain] = 2;
+ }
+ return this[kNeedDrain] < 2;
+ }
+ async [kClose]() {
+ return new Promise((resolve18) => {
+ if (!this[kSize]) {
+ this.destroy(resolve18);
+ } else {
+ this[kClosedResolve] = resolve18;
+ }
+ });
+ }
+ async [kDestroy](err) {
+ return new Promise((resolve18) => {
+ const requests = this[kQueue].splice(this[kPendingIdx]);
+ for (let i = 0; i < requests.length; i++) {
+ const request = requests[i];
+ errorRequest(this, request, err);
+ }
+ const callback = /* @__PURE__ */ __name(() => {
+ if (this[kClosedResolve]) {
+ this[kClosedResolve]();
+ this[kClosedResolve] = null;
+ }
+ resolve18();
+ }, "callback");
+ if (!this[kSocket]) {
+ queueMicrotask(callback);
+ } else {
+ util3.destroy(this[kSocket].on("close", callback), err);
+ }
+ resume(this);
+ });
+ }
+ };
+ __name(Client, "Client");
+ var constants3 = require_constants2();
+ var createRedirectInterceptor = require_redirectInterceptor();
+ var EMPTY_BUF = Buffer.alloc(0);
+ async function lazyllhttp() {
+ const llhttpWasmData = process.env.JEST_WORKER_ID ? require_llhttp_wasm() : void 0;
+ let mod;
+ try {
+ mod = await WebAssembly.compile(Buffer.from(require_llhttp_simd_wasm(), "base64"));
+ } catch (e2) {
+ mod = await WebAssembly.compile(Buffer.from(llhttpWasmData || require_llhttp_wasm(), "base64"));
+ }
+ return await WebAssembly.instantiate(mod, {
+ env: {
+ /* eslint-disable camelcase */
+ wasm_on_url: (p, at, len) => {
+ return 0;
+ },
+ wasm_on_status: (p, at, len) => {
+ assert18.strictEqual(currentParser.ptr, p);
+ const start = at - currentBufferPtr + currentBufferRef.byteOffset;
+ return currentParser.onStatus(new FastBuffer(currentBufferRef.buffer, start, len)) || 0;
+ },
+ wasm_on_message_begin: (p) => {
+ assert18.strictEqual(currentParser.ptr, p);
+ return currentParser.onMessageBegin() || 0;
+ },
+ wasm_on_header_field: (p, at, len) => {
+ assert18.strictEqual(currentParser.ptr, p);
+ const start = at - currentBufferPtr + currentBufferRef.byteOffset;
+ return currentParser.onHeaderField(new FastBuffer(currentBufferRef.buffer, start, len)) || 0;
+ },
+ wasm_on_header_value: (p, at, len) => {
+ assert18.strictEqual(currentParser.ptr, p);
+ const start = at - currentBufferPtr + currentBufferRef.byteOffset;
+ return currentParser.onHeaderValue(new FastBuffer(currentBufferRef.buffer, start, len)) || 0;
+ },
+ wasm_on_headers_complete: (p, statusCode, upgrade, shouldKeepAlive) => {
+ assert18.strictEqual(currentParser.ptr, p);
+ return currentParser.onHeadersComplete(statusCode, Boolean(upgrade), Boolean(shouldKeepAlive)) || 0;
+ },
+ wasm_on_body: (p, at, len) => {
+ assert18.strictEqual(currentParser.ptr, p);
+ const start = at - currentBufferPtr + currentBufferRef.byteOffset;
+ return currentParser.onBody(new FastBuffer(currentBufferRef.buffer, start, len)) || 0;
+ },
+ wasm_on_message_complete: (p) => {
+ assert18.strictEqual(currentParser.ptr, p);
+ return currentParser.onMessageComplete() || 0;
+ }
+ /* eslint-enable camelcase */
+ }
+ });
+ }
+ __name(lazyllhttp, "lazyllhttp");
+ var llhttpInstance = null;
+ var llhttpPromise = lazyllhttp();
+ llhttpPromise.catch();
+ var currentParser = null;
+ var currentBufferRef = null;
+ var currentBufferSize = 0;
+ var currentBufferPtr = null;
+ var TIMEOUT_HEADERS = 1;
+ var TIMEOUT_BODY = 2;
+ var TIMEOUT_IDLE = 3;
+ var Parser2 = class {
+ constructor(client, socket, { exports: exports3 }) {
+ assert18(Number.isFinite(client[kMaxHeadersSize]) && client[kMaxHeadersSize] > 0);
+ this.llhttp = exports3;
+ this.ptr = this.llhttp.llhttp_alloc(constants3.TYPE.RESPONSE);
+ this.client = client;
+ this.socket = socket;
+ this.timeout = null;
+ this.timeoutValue = null;
+ this.timeoutType = null;
+ this.statusCode = null;
+ this.statusText = "";
+ this.upgrade = false;
+ this.headers = [];
+ this.headersSize = 0;
+ this.headersMaxSize = client[kMaxHeadersSize];
+ this.shouldKeepAlive = false;
+ this.paused = false;
+ this.resume = this.resume.bind(this);
+ this.bytesRead = 0;
+ this.keepAlive = "";
+ this.contentLength = "";
+ this.connection = "";
+ this.maxResponseSize = client[kMaxResponseSize];
+ }
+ setTimeout(value, type) {
+ this.timeoutType = type;
+ if (value !== this.timeoutValue) {
+ timers.clearTimeout(this.timeout);
+ if (value) {
+ this.timeout = timers.setTimeout(onParserTimeout, value, this);
+ if (this.timeout.unref) {
+ this.timeout.unref();
+ }
+ } else {
+ this.timeout = null;
+ }
+ this.timeoutValue = value;
+ } else if (this.timeout) {
+ if (this.timeout.refresh) {
+ this.timeout.refresh();
+ }
+ }
+ }
+ resume() {
+ if (this.socket.destroyed || !this.paused) {
+ return;
+ }
+ assert18(this.ptr != null);
+ assert18(currentParser == null);
+ this.llhttp.llhttp_resume(this.ptr);
+ assert18(this.timeoutType === TIMEOUT_BODY);
+ if (this.timeout) {
+ if (this.timeout.refresh) {
+ this.timeout.refresh();
+ }
+ }
+ this.paused = false;
+ this.execute(this.socket.read() || EMPTY_BUF);
+ this.readMore();
+ }
+ readMore() {
+ while (!this.paused && this.ptr) {
+ const chunk = this.socket.read();
+ if (chunk === null) {
+ break;
+ }
+ this.execute(chunk);
+ }
+ }
+ execute(data) {
+ assert18(this.ptr != null);
+ assert18(currentParser == null);
+ assert18(!this.paused);
+ const { socket, llhttp } = this;
+ if (data.length > currentBufferSize) {
+ if (currentBufferPtr) {
+ llhttp.free(currentBufferPtr);
+ }
+ currentBufferSize = Math.ceil(data.length / 4096) * 4096;
+ currentBufferPtr = llhttp.malloc(currentBufferSize);
+ }
+ new Uint8Array(llhttp.memory.buffer, currentBufferPtr, currentBufferSize).set(data);
+ try {
+ let ret;
+ try {
+ currentBufferRef = data;
+ currentParser = this;
+ ret = llhttp.llhttp_execute(this.ptr, currentBufferPtr, data.length);
+ } catch (err) {
+ throw err;
+ } finally {
+ currentParser = null;
+ currentBufferRef = null;
+ }
+ const offset = llhttp.llhttp_get_error_pos(this.ptr) - currentBufferPtr;
+ if (ret === constants3.ERROR.PAUSED_UPGRADE) {
+ this.onUpgrade(data.slice(offset));
+ } else if (ret === constants3.ERROR.PAUSED) {
+ this.paused = true;
+ socket.unshift(data.slice(offset));
+ } else if (ret !== constants3.ERROR.OK) {
+ const ptr = llhttp.llhttp_get_error_reason(this.ptr);
+ let message = "";
+ if (ptr) {
+ const len = new Uint8Array(llhttp.memory.buffer, ptr).indexOf(0);
+ message = Buffer.from(llhttp.memory.buffer, ptr, len).toString();
+ }
+ throw new HTTPParserError(message, constants3.ERROR[ret], data.slice(offset));
+ }
+ } catch (err) {
+ util3.destroy(socket, err);
+ }
+ }
+ destroy() {
+ assert18(this.ptr != null);
+ assert18(currentParser == null);
+ this.llhttp.llhttp_free(this.ptr);
+ this.ptr = null;
+ timers.clearTimeout(this.timeout);
+ this.timeout = null;
+ this.timeoutValue = null;
+ this.timeoutType = null;
+ this.paused = false;
+ }
+ onStatus(buf) {
+ this.statusText = buf.toString();
+ }
+ onMessageBegin() {
+ const { socket, client } = this;
+ if (socket.destroyed) {
+ return -1;
+ }
+ const request = client[kQueue][client[kRunningIdx]];
+ if (!request) {
+ return -1;
+ }
+ }
+ onHeaderField(buf) {
+ const len = this.headers.length;
+ if ((len & 1) === 0) {
+ this.headers.push(buf);
+ } else {
+ this.headers[len - 1] = Buffer.concat([this.headers[len - 1], buf]);
+ }
+ this.trackHeader(buf.length);
+ }
+ onHeaderValue(buf) {
+ let len = this.headers.length;
+ if ((len & 1) === 1) {
+ this.headers.push(buf);
+ len += 1;
+ } else {
+ this.headers[len - 1] = Buffer.concat([this.headers[len - 1], buf]);
+ }
+ const key = this.headers[len - 2];
+ if (key.length === 10 && key.toString().toLowerCase() === "keep-alive") {
+ this.keepAlive += buf.toString();
+ } else if (key.length === 10 && key.toString().toLowerCase() === "connection") {
+ this.connection += buf.toString();
+ } else if (key.length === 14 && key.toString().toLowerCase() === "content-length") {
+ this.contentLength += buf.toString();
+ }
+ this.trackHeader(buf.length);
+ }
+ trackHeader(len) {
+ this.headersSize += len;
+ if (this.headersSize >= this.headersMaxSize) {
+ util3.destroy(this.socket, new HeadersOverflowError());
+ }
+ }
+ onUpgrade(head) {
+ const { upgrade, client, socket, headers, statusCode } = this;
+ assert18(upgrade);
+ const request = client[kQueue][client[kRunningIdx]];
+ assert18(request);
+ assert18(!socket.destroyed);
+ assert18(socket === client[kSocket]);
+ assert18(!this.paused);
+ assert18(request.upgrade || request.method === "CONNECT");
+ this.statusCode = null;
+ this.statusText = "";
+ this.shouldKeepAlive = null;
+ assert18(this.headers.length % 2 === 0);
+ this.headers = [];
+ this.headersSize = 0;
+ socket.unshift(head);
+ socket[kParser].destroy();
+ socket[kParser] = null;
+ socket[kClient] = null;
+ socket[kError] = null;
+ socket.removeListener("error", onSocketError).removeListener("readable", onSocketReadable).removeListener("end", onSocketEnd).removeListener("close", onSocketClose);
+ client[kSocket] = null;
+ client[kQueue][client[kRunningIdx]++] = null;
+ client.emit("disconnect", client[kUrl], [client], new InformationalError("upgrade"));
+ try {
+ request.onUpgrade(statusCode, headers, socket);
+ } catch (err) {
+ util3.destroy(socket, err);
+ }
+ resume(client);
+ }
+ onHeadersComplete(statusCode, upgrade, shouldKeepAlive) {
+ const { client, socket, headers, statusText } = this;
+ if (socket.destroyed) {
+ return -1;
+ }
+ const request = client[kQueue][client[kRunningIdx]];
+ if (!request) {
+ return -1;
+ }
+ assert18(!this.upgrade);
+ assert18(this.statusCode < 200);
+ if (statusCode === 100) {
+ util3.destroy(socket, new SocketError("bad response", util3.getSocketInfo(socket)));
+ return -1;
+ }
+ if (upgrade && !request.upgrade) {
+ util3.destroy(socket, new SocketError("bad upgrade", util3.getSocketInfo(socket)));
+ return -1;
+ }
+ assert18.strictEqual(this.timeoutType, TIMEOUT_HEADERS);
+ this.statusCode = statusCode;
+ this.shouldKeepAlive = shouldKeepAlive || // Override llhttp value which does not allow keepAlive for HEAD.
+ request.method === "HEAD" && !socket[kReset2] && this.connection.toLowerCase() === "keep-alive";
+ if (this.statusCode >= 200) {
+ const bodyTimeout = request.bodyTimeout != null ? request.bodyTimeout : client[kBodyTimeout];
+ this.setTimeout(bodyTimeout, TIMEOUT_BODY);
+ } else if (this.timeout) {
+ if (this.timeout.refresh) {
+ this.timeout.refresh();
+ }
+ }
+ if (request.method === "CONNECT") {
+ assert18(client[kRunning] === 1);
+ this.upgrade = true;
+ return 2;
+ }
+ if (upgrade) {
+ assert18(client[kRunning] === 1);
+ this.upgrade = true;
+ return 2;
+ }
+ assert18(this.headers.length % 2 === 0);
+ this.headers = [];
+ this.headersSize = 0;
+ if (this.shouldKeepAlive && client[kPipelining]) {
+ const keepAliveTimeout = this.keepAlive ? util3.parseKeepAliveTimeout(this.keepAlive) : null;
+ if (keepAliveTimeout != null) {
+ const timeout = Math.min(
+ keepAliveTimeout - client[kKeepAliveTimeoutThreshold],
+ client[kKeepAliveMaxTimeout]
+ );
+ if (timeout <= 0) {
+ socket[kReset2] = true;
+ } else {
+ client[kKeepAliveTimeoutValue] = timeout;
+ }
+ } else {
+ client[kKeepAliveTimeoutValue] = client[kKeepAliveDefaultTimeout];
+ }
+ } else {
+ socket[kReset2] = true;
+ }
+ let pause;
+ try {
+ pause = request.onHeaders(statusCode, headers, this.resume, statusText) === false;
+ } catch (err) {
+ util3.destroy(socket, err);
+ return -1;
+ }
+ if (request.method === "HEAD") {
+ return 1;
+ }
+ if (statusCode < 200) {
+ return 1;
+ }
+ if (socket[kBlocking]) {
+ socket[kBlocking] = false;
+ resume(client);
+ }
+ return pause ? constants3.ERROR.PAUSED : 0;
+ }
+ onBody(buf) {
+ const { client, socket, statusCode, maxResponseSize } = this;
+ if (socket.destroyed) {
+ return -1;
+ }
+ const request = client[kQueue][client[kRunningIdx]];
+ assert18(request);
+ assert18.strictEqual(this.timeoutType, TIMEOUT_BODY);
+ if (this.timeout) {
+ if (this.timeout.refresh) {
+ this.timeout.refresh();
+ }
+ }
+ assert18(statusCode >= 200);
+ if (maxResponseSize > -1 && this.bytesRead + buf.length > maxResponseSize) {
+ util3.destroy(socket, new ResponseExceededMaxSizeError());
+ return -1;
+ }
+ this.bytesRead += buf.length;
+ try {
+ if (request.onData(buf) === false) {
+ return constants3.ERROR.PAUSED;
+ }
+ } catch (err) {
+ util3.destroy(socket, err);
+ return -1;
+ }
+ }
+ onMessageComplete() {
+ const { client, socket, statusCode, upgrade, headers, contentLength, bytesRead, shouldKeepAlive } = this;
+ if (socket.destroyed && (!statusCode || shouldKeepAlive)) {
+ return -1;
+ }
+ if (upgrade) {
+ return;
+ }
+ const request = client[kQueue][client[kRunningIdx]];
+ assert18(request);
+ assert18(statusCode >= 100);
+ this.statusCode = null;
+ this.statusText = "";
+ this.bytesRead = 0;
+ this.contentLength = "";
+ this.keepAlive = "";
+ this.connection = "";
+ assert18(this.headers.length % 2 === 0);
+ this.headers = [];
+ this.headersSize = 0;
+ if (statusCode < 200) {
+ return;
+ }
+ if (request.method !== "HEAD" && contentLength && bytesRead !== parseInt(contentLength, 10)) {
+ util3.destroy(socket, new ResponseContentLengthMismatchError());
+ return -1;
+ }
+ try {
+ request.onComplete(headers);
+ } catch (err) {
+ errorRequest(client, request, err);
+ }
+ client[kQueue][client[kRunningIdx]++] = null;
+ if (socket[kWriting]) {
+ assert18.strictEqual(client[kRunning], 0);
+ util3.destroy(socket, new InformationalError("reset"));
+ return constants3.ERROR.PAUSED;
+ } else if (!shouldKeepAlive) {
+ util3.destroy(socket, new InformationalError("reset"));
+ return constants3.ERROR.PAUSED;
+ } else if (socket[kReset2] && client[kRunning] === 0) {
+ util3.destroy(socket, new InformationalError("reset"));
+ return constants3.ERROR.PAUSED;
+ } else if (client[kPipelining] === 1) {
+ setImmediate(resume, client);
+ } else {
+ resume(client);
+ }
+ }
+ };
+ __name(Parser2, "Parser");
+ function onParserTimeout(parser2) {
+ const { socket, timeoutType, client } = parser2;
+ if (timeoutType === TIMEOUT_HEADERS) {
+ if (!socket[kWriting] || socket.writableNeedDrain || client[kRunning] > 1) {
+ assert18(!parser2.paused, "cannot be paused while waiting for headers");
+ util3.destroy(socket, new HeadersTimeoutError());
+ }
+ } else if (timeoutType === TIMEOUT_BODY) {
+ if (!parser2.paused) {
+ util3.destroy(socket, new BodyTimeoutError());
+ }
+ } else if (timeoutType === TIMEOUT_IDLE) {
+ assert18(client[kRunning] === 0 && client[kKeepAliveTimeoutValue]);
+ util3.destroy(socket, new InformationalError("socket idle timeout"));
+ }
+ }
+ __name(onParserTimeout, "onParserTimeout");
+ function onSocketReadable() {
+ const { [kParser]: parser2 } = this;
+ parser2.readMore();
+ }
+ __name(onSocketReadable, "onSocketReadable");
+ function onSocketError(err) {
+ const { [kParser]: parser2 } = this;
+ assert18(err.code !== "ERR_TLS_CERT_ALTNAME_INVALID");
+ if (err.code === "ECONNRESET" && parser2.statusCode && !parser2.shouldKeepAlive) {
+ parser2.onMessageComplete();
+ return;
+ }
+ this[kError] = err;
+ onError(this[kClient], err);
+ }
+ __name(onSocketError, "onSocketError");
+ function onError(client, err) {
+ if (client[kRunning] === 0 && err.code !== "UND_ERR_INFO" && err.code !== "UND_ERR_SOCKET") {
+ assert18(client[kPendingIdx] === client[kRunningIdx]);
+ const requests = client[kQueue].splice(client[kRunningIdx]);
+ for (let i = 0; i < requests.length; i++) {
+ const request = requests[i];
+ errorRequest(client, request, err);
+ }
+ assert18(client[kSize] === 0);
+ }
+ }
+ __name(onError, "onError");
+ function onSocketEnd() {
+ const { [kParser]: parser2 } = this;
+ if (parser2.statusCode && !parser2.shouldKeepAlive) {
+ parser2.onMessageComplete();
+ return;
+ }
+ util3.destroy(this, new SocketError("other side closed", util3.getSocketInfo(this)));
+ }
+ __name(onSocketEnd, "onSocketEnd");
+ function onSocketClose() {
+ const { [kClient]: client } = this;
+ if (!this[kError] && this[kParser].statusCode && !this[kParser].shouldKeepAlive) {
+ this[kParser].onMessageComplete();
+ }
+ this[kParser].destroy();
+ this[kParser] = null;
+ const err = this[kError] || new SocketError("closed", util3.getSocketInfo(this));
+ client[kSocket] = null;
+ if (client.destroyed) {
+ assert18(client[kPending] === 0);
+ const requests = client[kQueue].splice(client[kRunningIdx]);
+ for (let i = 0; i < requests.length; i++) {
+ const request = requests[i];
+ errorRequest(client, request, err);
+ }
+ } else if (client[kRunning] > 0 && err.code !== "UND_ERR_INFO") {
+ const request = client[kQueue][client[kRunningIdx]];
+ client[kQueue][client[kRunningIdx]++] = null;
+ errorRequest(client, request, err);
+ }
+ client[kPendingIdx] = client[kRunningIdx];
+ assert18(client[kRunning] === 0);
+ client.emit("disconnect", client[kUrl], [client], err);
+ resume(client);
+ }
+ __name(onSocketClose, "onSocketClose");
+ async function connect2(client) {
+ assert18(!client[kConnecting]);
+ assert18(!client[kSocket]);
+ let { host, hostname, protocol, port: port2 } = client[kUrl];
+ if (hostname[0] === "[") {
+ const idx = hostname.indexOf("]");
+ assert18(idx !== -1);
+ const ip2 = hostname.substr(1, idx - 1);
+ assert18(net3.isIP(ip2));
+ hostname = ip2;
+ }
+ client[kConnecting] = true;
+ if (channels.beforeConnect.hasSubscribers) {
+ channels.beforeConnect.publish({
+ connectParams: {
+ host,
+ hostname,
+ protocol,
+ port: port2,
+ servername: client[kServerName],
+ localAddress: client[kLocalAddress]
+ },
+ connector: client[kConnector]
+ });
+ }
+ try {
+ const socket = await new Promise((resolve18, reject) => {
+ client[kConnector]({
+ host,
+ hostname,
+ protocol,
+ port: port2,
+ servername: client[kServerName],
+ localAddress: client[kLocalAddress]
+ }, (err, socket2) => {
+ if (err) {
+ reject(err);
+ } else {
+ resolve18(socket2);
+ }
+ });
+ });
+ if (!llhttpInstance) {
+ llhttpInstance = await llhttpPromise;
+ llhttpPromise = null;
+ }
+ client[kConnecting] = false;
+ assert18(socket);
+ socket[kNoRef] = false;
+ socket[kWriting] = false;
+ socket[kReset2] = false;
+ socket[kBlocking] = false;
+ socket[kError] = null;
+ socket[kParser] = new Parser2(client, socket, llhttpInstance);
+ socket[kClient] = client;
+ socket[kCounter] = 0;
+ socket[kMaxRequests] = client[kMaxRequests];
+ socket.on("error", onSocketError).on("readable", onSocketReadable).on("end", onSocketEnd).on("close", onSocketClose);
+ client[kSocket] = socket;
+ if (channels.connected.hasSubscribers) {
+ channels.connected.publish({
+ connectParams: {
+ host,
+ hostname,
+ protocol,
+ port: port2,
+ servername: client[kServerName],
+ localAddress: client[kLocalAddress]
+ },
+ connector: client[kConnector],
+ socket
+ });
+ }
+ client.emit("connect", client[kUrl], [client]);
+ } catch (err) {
+ client[kConnecting] = false;
+ if (channels.connectError.hasSubscribers) {
+ channels.connectError.publish({
+ connectParams: {
+ host,
+ hostname,
+ protocol,
+ port: port2,
+ servername: client[kServerName],
+ localAddress: client[kLocalAddress]
+ },
+ connector: client[kConnector],
+ error: err
+ });
+ }
+ if (err.code === "ERR_TLS_CERT_ALTNAME_INVALID") {
+ assert18(client[kRunning] === 0);
+ while (client[kPending] > 0 && client[kQueue][client[kPendingIdx]].servername === client[kServerName]) {
+ const request = client[kQueue][client[kPendingIdx]++];
+ errorRequest(client, request, err);
+ }
+ } else {
+ onError(client, err);
+ }
+ client.emit("connectionError", client[kUrl], [client], err);
+ }
+ resume(client);
+ }
+ __name(connect2, "connect");
+ function emitDrain(client) {
+ client[kNeedDrain] = 0;
+ client.emit("drain", client[kUrl], [client]);
+ }
+ __name(emitDrain, "emitDrain");
+ function resume(client, sync) {
+ if (client[kResuming] === 2) {
+ return;
+ }
+ client[kResuming] = 2;
+ _resume(client, sync);
+ client[kResuming] = 0;
+ if (client[kRunningIdx] > 256) {
+ client[kQueue].splice(0, client[kRunningIdx]);
+ client[kPendingIdx] -= client[kRunningIdx];
+ client[kRunningIdx] = 0;
+ }
+ }
+ __name(resume, "resume");
+ function _resume(client, sync) {
+ while (true) {
+ if (client.destroyed) {
+ assert18(client[kPending] === 0);
+ return;
+ }
+ if (client.closed && !client[kSize]) {
+ client.destroy();
+ return;
+ }
+ const socket = client[kSocket];
+ if (socket && !socket.destroyed) {
+ if (client[kSize] === 0) {
+ if (!socket[kNoRef] && socket.unref) {
+ socket.unref();
+ socket[kNoRef] = true;
+ }
+ } else if (socket[kNoRef] && socket.ref) {
+ socket.ref();
+ socket[kNoRef] = false;
+ }
+ if (client[kSize] === 0) {
+ if (socket[kParser].timeoutType !== TIMEOUT_IDLE) {
+ socket[kParser].setTimeout(client[kKeepAliveTimeoutValue], TIMEOUT_IDLE);
+ }
+ } else if (client[kRunning] > 0 && socket[kParser].statusCode < 200) {
+ if (socket[kParser].timeoutType !== TIMEOUT_HEADERS) {
+ const request2 = client[kQueue][client[kRunningIdx]];
+ const headersTimeout = request2.headersTimeout != null ? request2.headersTimeout : client[kHeadersTimeout];
+ socket[kParser].setTimeout(headersTimeout, TIMEOUT_HEADERS);
+ }
+ }
+ }
+ if (client[kBusy]) {
+ client[kNeedDrain] = 2;
+ } else if (client[kNeedDrain] === 2) {
+ if (sync) {
+ client[kNeedDrain] = 1;
+ process.nextTick(emitDrain, client);
+ } else {
+ emitDrain(client);
+ }
+ continue;
+ }
+ if (client[kPending] === 0) {
+ return;
+ }
+ if (client[kRunning] >= (client[kPipelining] || 1)) {
+ return;
+ }
+ const request = client[kQueue][client[kPendingIdx]];
+ if (client[kUrl].protocol === "https:" && client[kServerName] !== request.servername) {
+ if (client[kRunning] > 0) {
+ return;
+ }
+ client[kServerName] = request.servername;
+ if (socket && socket.servername !== request.servername) {
+ util3.destroy(socket, new InformationalError("servername changed"));
+ return;
+ }
+ }
+ if (client[kConnecting]) {
+ return;
+ }
+ if (!socket) {
+ connect2(client);
+ return;
+ }
+ if (socket.destroyed || socket[kWriting] || socket[kReset2] || socket[kBlocking]) {
+ return;
+ }
+ if (client[kRunning] > 0 && !request.idempotent) {
+ return;
+ }
+ if (client[kRunning] > 0 && (request.upgrade || request.method === "CONNECT")) {
+ return;
+ }
+ if (util3.isStream(request.body) && util3.bodyLength(request.body) === 0) {
+ request.body.on(
+ "data",
+ /* istanbul ignore next */
+ function() {
+ assert18(false);
+ }
+ ).on("error", function(err) {
+ errorRequest(client, request, err);
+ }).on("end", function() {
+ util3.destroy(this);
+ });
+ request.body = null;
+ }
+ if (client[kRunning] > 0 && (util3.isStream(request.body) || util3.isAsyncIterable(request.body))) {
+ return;
+ }
+ if (!request.aborted && write(client, request)) {
+ client[kPendingIdx]++;
+ } else {
+ client[kQueue].splice(client[kPendingIdx], 1);
+ }
+ }
+ }
+ __name(_resume, "_resume");
+ function write(client, request) {
+ const { body, method, path: path45, host, upgrade, headers, blocking, reset } = request;
+ const expectsPayload = method === "PUT" || method === "POST" || method === "PATCH";
+ if (body && typeof body.read === "function") {
+ body.read(0);
+ }
+ let contentLength = util3.bodyLength(body);
+ if (contentLength === null) {
+ contentLength = request.contentLength;
+ }
+ if (contentLength === 0 && !expectsPayload) {
+ contentLength = null;
+ }
+ if (request.contentLength !== null && request.contentLength !== contentLength) {
+ if (client[kStrictContentLength]) {
+ errorRequest(client, request, new RequestContentLengthMismatchError());
+ return false;
+ }
+ process.emitWarning(new RequestContentLengthMismatchError());
+ }
+ const socket = client[kSocket];
+ try {
+ request.onConnect((err) => {
+ if (request.aborted || request.completed) {
+ return;
+ }
+ errorRequest(client, request, err || new RequestAbortedError());
+ util3.destroy(socket, new InformationalError("aborted"));
+ });
+ } catch (err) {
+ errorRequest(client, request, err);
+ }
+ if (request.aborted) {
+ return false;
+ }
+ if (method === "HEAD") {
+ socket[kReset2] = true;
+ }
+ if (upgrade || method === "CONNECT") {
+ socket[kReset2] = true;
+ }
+ if (reset != null) {
+ socket[kReset2] = reset;
+ }
+ if (client[kMaxRequests] && socket[kCounter]++ >= client[kMaxRequests]) {
+ socket[kReset2] = true;
+ }
+ if (blocking) {
+ socket[kBlocking] = true;
+ }
+ let header = `${method} ${path45} HTTP/1.1\r
+`;
+ if (typeof host === "string") {
+ header += `host: ${host}\r
+`;
+ } else {
+ header += client[kHostHeader];
+ }
+ if (upgrade) {
+ header += `connection: upgrade\r
+upgrade: ${upgrade}\r
+`;
+ } else if (client[kPipelining] && !socket[kReset2]) {
+ header += "connection: keep-alive\r\n";
+ } else {
+ header += "connection: close\r\n";
+ }
+ if (headers) {
+ header += headers;
+ }
+ if (channels.sendHeaders.hasSubscribers) {
+ channels.sendHeaders.publish({ request, headers: header, socket });
+ }
+ if (!body) {
+ if (contentLength === 0) {
+ socket.write(`${header}content-length: 0\r
+\r
+`, "ascii");
+ } else {
+ assert18(contentLength === null, "no body must not have content length");
+ socket.write(`${header}\r
+`, "ascii");
+ }
+ request.onRequestSent();
+ } else if (util3.isBuffer(body)) {
+ assert18(contentLength === body.byteLength, "buffer body must have content length");
+ socket.cork();
+ socket.write(`${header}content-length: ${contentLength}\r
+\r
+`, "ascii");
+ socket.write(body);
+ socket.uncork();
+ request.onBodySent(body);
+ request.onRequestSent();
+ if (!expectsPayload) {
+ socket[kReset2] = true;
+ }
+ } else if (util3.isBlobLike(body)) {
+ if (typeof body.stream === "function") {
+ writeIterable({ body: body.stream(), client, request, socket, contentLength, header, expectsPayload });
+ } else {
+ writeBlob({ body, client, request, socket, contentLength, header, expectsPayload });
+ }
+ } else if (util3.isStream(body)) {
+ writeStream({ body, client, request, socket, contentLength, header, expectsPayload });
+ } else if (util3.isIterable(body)) {
+ writeIterable({ body, client, request, socket, contentLength, header, expectsPayload });
+ } else {
+ assert18(false);
+ }
+ return true;
+ }
+ __name(write, "write");
+ function writeStream({ body, client, request, socket, contentLength, header, expectsPayload }) {
+ assert18(contentLength !== 0 || client[kRunning] === 0, "stream body cannot be pipelined");
+ let finished = false;
+ const writer = new AsyncWriter({ socket, request, contentLength, client, expectsPayload, header });
+ const onData = /* @__PURE__ */ __name(function(chunk) {
+ try {
+ assert18(!finished);
+ if (!writer.write(chunk) && this.pause) {
+ this.pause();
+ }
+ } catch (err) {
+ util3.destroy(this, err);
+ }
+ }, "onData");
+ const onDrain = /* @__PURE__ */ __name(function() {
+ assert18(!finished);
+ if (body.resume) {
+ body.resume();
+ }
+ }, "onDrain");
+ const onAbort = /* @__PURE__ */ __name(function() {
+ onFinished(new RequestAbortedError());
+ }, "onAbort");
+ const onFinished = /* @__PURE__ */ __name(function(err) {
+ if (finished) {
+ return;
+ }
+ finished = true;
+ assert18(socket.destroyed || socket[kWriting] && client[kRunning] <= 1);
+ socket.off("drain", onDrain).off("error", onFinished);
+ body.removeListener("data", onData).removeListener("end", onFinished).removeListener("error", onFinished).removeListener("close", onAbort);
+ if (!err) {
+ try {
+ writer.end();
+ } catch (er) {
+ err = er;
+ }
+ }
+ writer.destroy(err);
+ if (err && (err.code !== "UND_ERR_INFO" || err.message !== "reset")) {
+ util3.destroy(body, err);
+ } else {
+ util3.destroy(body);
+ }
+ }, "onFinished");
+ body.on("data", onData).on("end", onFinished).on("error", onFinished).on("close", onAbort);
+ if (body.resume) {
+ body.resume();
+ }
+ socket.on("drain", onDrain).on("error", onFinished);
+ }
+ __name(writeStream, "writeStream");
+ async function writeBlob({ body, client, request, socket, contentLength, header, expectsPayload }) {
+ assert18(contentLength === body.size, "blob body must have content length");
+ try {
+ if (contentLength != null && contentLength !== body.size) {
+ throw new RequestContentLengthMismatchError();
+ }
+ const buffer = Buffer.from(await body.arrayBuffer());
+ socket.cork();
+ socket.write(`${header}content-length: ${contentLength}\r
+\r
+`, "ascii");
+ socket.write(buffer);
+ socket.uncork();
+ request.onBodySent(buffer);
+ request.onRequestSent();
+ if (!expectsPayload) {
+ socket[kReset2] = true;
+ }
+ resume(client);
+ } catch (err) {
+ util3.destroy(socket, err);
+ }
+ }
+ __name(writeBlob, "writeBlob");
+ async function writeIterable({ body, client, request, socket, contentLength, header, expectsPayload }) {
+ assert18(contentLength !== 0 || client[kRunning] === 0, "iterator body cannot be pipelined");
+ let callback = null;
+ function onDrain() {
+ if (callback) {
+ const cb = callback;
+ callback = null;
+ cb();
+ }
+ }
+ __name(onDrain, "onDrain");
+ const waitForDrain = /* @__PURE__ */ __name(() => new Promise((resolve18, reject) => {
+ assert18(callback === null);
+ if (socket[kError]) {
+ reject(socket[kError]);
+ } else {
+ callback = resolve18;
+ }
+ }), "waitForDrain");
+ socket.on("close", onDrain).on("drain", onDrain);
+ const writer = new AsyncWriter({ socket, request, contentLength, client, expectsPayload, header });
+ try {
+ for await (const chunk of body) {
+ if (socket[kError]) {
+ throw socket[kError];
+ }
+ if (!writer.write(chunk)) {
+ await waitForDrain();
+ }
+ }
+ writer.end();
+ } catch (err) {
+ writer.destroy(err);
+ } finally {
+ socket.off("close", onDrain).off("drain", onDrain);
+ }
+ }
+ __name(writeIterable, "writeIterable");
+ var AsyncWriter = class {
+ constructor({ socket, request, contentLength, client, expectsPayload, header }) {
+ this.socket = socket;
+ this.request = request;
+ this.contentLength = contentLength;
+ this.client = client;
+ this.bytesWritten = 0;
+ this.expectsPayload = expectsPayload;
+ this.header = header;
+ socket[kWriting] = true;
+ }
+ write(chunk) {
+ const { socket, request, contentLength, client, bytesWritten, expectsPayload, header } = this;
+ if (socket[kError]) {
+ throw socket[kError];
+ }
+ if (socket.destroyed) {
+ return false;
+ }
+ const len = Buffer.byteLength(chunk);
+ if (!len) {
+ return true;
+ }
+ if (contentLength !== null && bytesWritten + len > contentLength) {
+ if (client[kStrictContentLength]) {
+ throw new RequestContentLengthMismatchError();
+ }
+ process.emitWarning(new RequestContentLengthMismatchError());
+ }
+ if (bytesWritten === 0) {
+ if (!expectsPayload) {
+ socket[kReset2] = true;
+ }
+ if (contentLength === null) {
+ socket.write(`${header}transfer-encoding: chunked\r
+`, "ascii");
+ } else {
+ socket.write(`${header}content-length: ${contentLength}\r
+\r
+`, "ascii");
+ }
+ }
+ if (contentLength === null) {
+ socket.write(`\r
+${len.toString(16)}\r
+`, "ascii");
+ }
+ this.bytesWritten += len;
+ const ret = socket.write(chunk);
+ request.onBodySent(chunk);
+ if (!ret) {
+ if (socket[kParser].timeout && socket[kParser].timeoutType === TIMEOUT_HEADERS) {
+ if (socket[kParser].timeout.refresh) {
+ socket[kParser].timeout.refresh();
+ }
+ }
+ }
+ return ret;
+ }
+ end() {
+ const { socket, contentLength, client, bytesWritten, expectsPayload, header, request } = this;
+ request.onRequestSent();
+ socket[kWriting] = false;
+ if (socket[kError]) {
+ throw socket[kError];
+ }
+ if (socket.destroyed) {
+ return;
+ }
+ if (bytesWritten === 0) {
+ if (expectsPayload) {
+ socket.write(`${header}content-length: 0\r
+\r
+`, "ascii");
+ } else {
+ socket.write(`${header}\r
+`, "ascii");
+ }
+ } else if (contentLength === null) {
+ socket.write("\r\n0\r\n\r\n", "ascii");
+ }
+ if (contentLength !== null && bytesWritten !== contentLength) {
+ if (client[kStrictContentLength]) {
+ throw new RequestContentLengthMismatchError();
+ } else {
+ process.emitWarning(new RequestContentLengthMismatchError());
+ }
+ }
+ if (socket[kParser].timeout && socket[kParser].timeoutType === TIMEOUT_HEADERS) {
+ if (socket[kParser].timeout.refresh) {
+ socket[kParser].timeout.refresh();
+ }
+ }
+ resume(client);
+ }
+ destroy(err) {
+ const { socket, client } = this;
+ socket[kWriting] = false;
+ if (err) {
+ assert18(client[kRunning] <= 1, "pipeline should only contain this request");
+ util3.destroy(socket, err);
+ }
+ }
+ };
+ __name(AsyncWriter, "AsyncWriter");
+ function errorRequest(client, request, err) {
+ try {
+ request.onError(err);
+ assert18(request.aborted);
+ } catch (err2) {
+ client.emit("error", err2);
+ }
+ }
+ __name(errorRequest, "errorRequest");
+ module2.exports = Client;
+ }
+});
+
+// ../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/node/fixed-queue.js
+var require_fixed_queue = __commonJS({
+ "../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/node/fixed-queue.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var kSize = 2048;
+ var kMask = kSize - 1;
+ var FixedCircularBuffer = class {
+ constructor() {
+ this.bottom = 0;
+ this.top = 0;
+ this.list = new Array(kSize);
+ this.next = null;
+ }
+ isEmpty() {
+ return this.top === this.bottom;
+ }
+ isFull() {
+ return (this.top + 1 & kMask) === this.bottom;
+ }
+ push(data) {
+ this.list[this.top] = data;
+ this.top = this.top + 1 & kMask;
+ }
+ shift() {
+ const nextItem = this.list[this.bottom];
+ if (nextItem === void 0)
+ return null;
+ this.list[this.bottom] = void 0;
+ this.bottom = this.bottom + 1 & kMask;
+ return nextItem;
+ }
+ };
+ __name(FixedCircularBuffer, "FixedCircularBuffer");
+ module2.exports = /* @__PURE__ */ __name(class FixedQueue {
+ constructor() {
+ this.head = this.tail = new FixedCircularBuffer();
+ }
+ isEmpty() {
+ return this.head.isEmpty();
+ }
+ push(data) {
+ if (this.head.isFull()) {
+ this.head = this.head.next = new FixedCircularBuffer();
+ }
+ this.head.push(data);
+ }
+ shift() {
+ const tail = this.tail;
+ const next = tail.shift();
+ if (tail.isEmpty() && tail.next !== null) {
+ this.tail = tail.next;
+ }
+ return next;
+ }
+ }, "FixedQueue");
+ }
+});
+
+// ../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/pool-stats.js
+var require_pool_stats = __commonJS({
+ "../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/pool-stats.js"(exports2, module2) {
+ init_import_meta_url();
+ var { kFree, kConnected, kPending, kQueued, kRunning, kSize } = require_symbols();
+ var kPool = Symbol("pool");
+ var PoolStats = class {
+ constructor(pool2) {
+ this[kPool] = pool2;
+ }
+ get connected() {
+ return this[kPool][kConnected];
+ }
+ get free() {
+ return this[kPool][kFree];
+ }
+ get pending() {
+ return this[kPool][kPending];
+ }
+ get queued() {
+ return this[kPool][kQueued];
+ }
+ get running() {
+ return this[kPool][kRunning];
+ }
+ get size() {
+ return this[kPool][kSize];
+ }
+ };
+ __name(PoolStats, "PoolStats");
+ module2.exports = PoolStats;
+ }
+});
+
+// ../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/pool-base.js
+var require_pool_base = __commonJS({
+ "../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/pool-base.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var DispatcherBase = require_dispatcher_base();
+ var FixedQueue = require_fixed_queue();
+ var { kConnected, kSize, kRunning, kPending, kQueued, kBusy, kFree, kUrl, kClose, kDestroy, kDispatch } = require_symbols();
+ var PoolStats = require_pool_stats();
+ var kClients = Symbol("clients");
+ var kNeedDrain = Symbol("needDrain");
+ var kQueue = Symbol("queue");
+ var kClosedResolve = Symbol("closed resolve");
+ var kOnDrain = Symbol("onDrain");
+ var kOnConnect = Symbol("onConnect");
+ var kOnDisconnect = Symbol("onDisconnect");
+ var kOnConnectionError = Symbol("onConnectionError");
+ var kGetDispatcher = Symbol("get dispatcher");
+ var kAddClient = Symbol("add client");
+ var kRemoveClient = Symbol("remove client");
+ var kStats = Symbol("stats");
+ var PoolBase = class extends DispatcherBase {
+ constructor() {
+ super();
+ this[kQueue] = new FixedQueue();
+ this[kClients] = [];
+ this[kQueued] = 0;
+ const pool2 = this;
+ this[kOnDrain] = /* @__PURE__ */ __name(function onDrain(origin, targets) {
+ const queue = pool2[kQueue];
+ let needDrain = false;
+ while (!needDrain) {
+ const item = queue.shift();
+ if (!item) {
+ break;
+ }
+ pool2[kQueued]--;
+ needDrain = !this.dispatch(item.opts, item.handler);
+ }
+ this[kNeedDrain] = needDrain;
+ if (!this[kNeedDrain] && pool2[kNeedDrain]) {
+ pool2[kNeedDrain] = false;
+ pool2.emit("drain", origin, [pool2, ...targets]);
+ }
+ if (pool2[kClosedResolve] && queue.isEmpty()) {
+ Promise.all(pool2[kClients].map((c) => c.close())).then(pool2[kClosedResolve]);
+ }
+ }, "onDrain");
+ this[kOnConnect] = (origin, targets) => {
+ pool2.emit("connect", origin, [pool2, ...targets]);
+ };
+ this[kOnDisconnect] = (origin, targets, err) => {
+ pool2.emit("disconnect", origin, [pool2, ...targets], err);
+ };
+ this[kOnConnectionError] = (origin, targets, err) => {
+ pool2.emit("connectionError", origin, [pool2, ...targets], err);
+ };
+ this[kStats] = new PoolStats(this);
+ }
+ get [kBusy]() {
+ return this[kNeedDrain];
+ }
+ get [kConnected]() {
+ return this[kClients].filter((client) => client[kConnected]).length;
+ }
+ get [kFree]() {
+ return this[kClients].filter((client) => client[kConnected] && !client[kNeedDrain]).length;
+ }
+ get [kPending]() {
+ let ret = this[kQueued];
+ for (const { [kPending]: pending } of this[kClients]) {
+ ret += pending;
+ }
+ return ret;
+ }
+ get [kRunning]() {
+ let ret = 0;
+ for (const { [kRunning]: running } of this[kClients]) {
+ ret += running;
+ }
+ return ret;
+ }
+ get [kSize]() {
+ let ret = this[kQueued];
+ for (const { [kSize]: size } of this[kClients]) {
+ ret += size;
+ }
+ return ret;
+ }
+ get stats() {
+ return this[kStats];
+ }
+ async [kClose]() {
+ if (this[kQueue].isEmpty()) {
+ return Promise.all(this[kClients].map((c) => c.close()));
+ } else {
+ return new Promise((resolve18) => {
+ this[kClosedResolve] = resolve18;
+ });
+ }
+ }
+ async [kDestroy](err) {
+ while (true) {
+ const item = this[kQueue].shift();
+ if (!item) {
+ break;
+ }
+ item.handler.onError(err);
+ }
+ return Promise.all(this[kClients].map((c) => c.destroy(err)));
+ }
+ [kDispatch](opts, handler15) {
+ const dispatcher = this[kGetDispatcher]();
+ if (!dispatcher) {
+ this[kNeedDrain] = true;
+ this[kQueue].push({ opts, handler: handler15 });
+ this[kQueued]++;
+ } else if (!dispatcher.dispatch(opts, handler15)) {
+ dispatcher[kNeedDrain] = true;
+ this[kNeedDrain] = !this[kGetDispatcher]();
+ }
+ return !this[kNeedDrain];
+ }
+ [kAddClient](client) {
+ client.on("drain", this[kOnDrain]).on("connect", this[kOnConnect]).on("disconnect", this[kOnDisconnect]).on("connectionError", this[kOnConnectionError]);
+ this[kClients].push(client);
+ if (this[kNeedDrain]) {
+ process.nextTick(() => {
+ if (this[kNeedDrain]) {
+ this[kOnDrain](client[kUrl], [this, client]);
+ }
+ });
+ }
+ return this;
+ }
+ [kRemoveClient](client) {
+ client.close(() => {
+ const idx = this[kClients].indexOf(client);
+ if (idx !== -1) {
+ this[kClients].splice(idx, 1);
+ }
+ });
+ this[kNeedDrain] = this[kClients].some((dispatcher) => !dispatcher[kNeedDrain] && dispatcher.closed !== true && dispatcher.destroyed !== true);
+ }
+ };
+ __name(PoolBase, "PoolBase");
+ module2.exports = {
+ PoolBase,
+ kClients,
+ kNeedDrain,
+ kAddClient,
+ kRemoveClient,
+ kGetDispatcher
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/pool.js
+var require_pool = __commonJS({
+ "../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/pool.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var {
+ PoolBase,
+ kClients,
+ kNeedDrain,
+ kAddClient,
+ kGetDispatcher
+ } = require_pool_base();
+ var Client = require_client();
+ var {
+ InvalidArgumentError
+ } = require_errors();
+ var util3 = require_util();
+ var { kUrl, kInterceptors } = require_symbols();
+ var buildConnector = require_connect();
+ var kOptions = Symbol("options");
+ var kConnections = Symbol("connections");
+ var kFactory = Symbol("factory");
+ function defaultFactory(origin, opts) {
+ return new Client(origin, opts);
+ }
+ __name(defaultFactory, "defaultFactory");
+ var Pool = class extends PoolBase {
+ constructor(origin, {
+ connections,
+ factory = defaultFactory,
+ connect: connect2,
+ connectTimeout,
+ tls,
+ maxCachedSessions,
+ socketPath,
+ autoSelectFamily,
+ autoSelectFamilyAttemptTimeout,
+ ...options14
+ } = {}) {
+ super();
+ if (connections != null && (!Number.isFinite(connections) || connections < 0)) {
+ throw new InvalidArgumentError("invalid connections");
+ }
+ if (typeof factory !== "function") {
+ throw new InvalidArgumentError("factory must be a function.");
+ }
+ if (connect2 != null && typeof connect2 !== "function" && typeof connect2 !== "object") {
+ throw new InvalidArgumentError("connect must be a function or an object");
+ }
+ if (typeof connect2 !== "function") {
+ connect2 = buildConnector({
+ ...tls,
+ maxCachedSessions,
+ socketPath,
+ timeout: connectTimeout == null ? 1e4 : connectTimeout,
+ ...util3.nodeHasAutoSelectFamily && autoSelectFamily ? { autoSelectFamily, autoSelectFamilyAttemptTimeout } : void 0,
+ ...connect2
+ });
+ }
+ this[kInterceptors] = options14.interceptors && options14.interceptors.Pool && Array.isArray(options14.interceptors.Pool) ? options14.interceptors.Pool : [];
+ this[kConnections] = connections || null;
+ this[kUrl] = util3.parseOrigin(origin);
+ this[kOptions] = { ...util3.deepClone(options14), connect: connect2 };
+ this[kOptions].interceptors = options14.interceptors ? { ...options14.interceptors } : void 0;
+ this[kFactory] = factory;
+ }
+ [kGetDispatcher]() {
+ let dispatcher = this[kClients].find((dispatcher2) => !dispatcher2[kNeedDrain]);
+ if (dispatcher) {
+ return dispatcher;
+ }
+ if (!this[kConnections] || this[kClients].length < this[kConnections]) {
+ dispatcher = this[kFactory](this[kUrl], this[kOptions]);
+ this[kAddClient](dispatcher);
+ }
+ return dispatcher;
+ }
+ };
+ __name(Pool, "Pool");
+ module2.exports = Pool;
+ }
+});
+
+// ../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/balanced-pool.js
+var require_balanced_pool = __commonJS({
+ "../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/balanced-pool.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var {
+ BalancedPoolMissingUpstreamError,
+ InvalidArgumentError
+ } = require_errors();
+ var {
+ PoolBase,
+ kClients,
+ kNeedDrain,
+ kAddClient,
+ kRemoveClient,
+ kGetDispatcher
+ } = require_pool_base();
+ var Pool = require_pool();
+ var { kUrl, kInterceptors } = require_symbols();
+ var { parseOrigin } = require_util();
+ var kFactory = Symbol("factory");
+ var kOptions = Symbol("options");
+ var kGreatestCommonDivisor = Symbol("kGreatestCommonDivisor");
+ var kCurrentWeight = Symbol("kCurrentWeight");
+ var kIndex = Symbol("kIndex");
+ var kWeight = Symbol("kWeight");
+ var kMaxWeightPerServer = Symbol("kMaxWeightPerServer");
+ var kErrorPenalty = Symbol("kErrorPenalty");
+ function getGreatestCommonDivisor(a, b) {
+ if (b === 0)
+ return a;
+ return getGreatestCommonDivisor(b, a % b);
+ }
+ __name(getGreatestCommonDivisor, "getGreatestCommonDivisor");
+ function defaultFactory(origin, opts) {
+ return new Pool(origin, opts);
+ }
+ __name(defaultFactory, "defaultFactory");
+ var BalancedPool = class extends PoolBase {
+ constructor(upstreams = [], { factory = defaultFactory, ...opts } = {}) {
+ super();
+ this[kOptions] = opts;
+ this[kIndex] = -1;
+ this[kCurrentWeight] = 0;
+ this[kMaxWeightPerServer] = this[kOptions].maxWeightPerServer || 100;
+ this[kErrorPenalty] = this[kOptions].errorPenalty || 15;
+ if (!Array.isArray(upstreams)) {
+ upstreams = [upstreams];
+ }
+ if (typeof factory !== "function") {
+ throw new InvalidArgumentError("factory must be a function.");
+ }
+ this[kInterceptors] = opts.interceptors && opts.interceptors.BalancedPool && Array.isArray(opts.interceptors.BalancedPool) ? opts.interceptors.BalancedPool : [];
+ this[kFactory] = factory;
+ for (const upstream of upstreams) {
+ this.addUpstream(upstream);
+ }
+ this._updateBalancedPoolStats();
+ }
+ addUpstream(upstream) {
+ const upstreamOrigin = parseOrigin(upstream).origin;
+ if (this[kClients].find((pool3) => pool3[kUrl].origin === upstreamOrigin && pool3.closed !== true && pool3.destroyed !== true)) {
+ return this;
+ }
+ const pool2 = this[kFactory](upstreamOrigin, Object.assign({}, this[kOptions]));
+ this[kAddClient](pool2);
+ pool2.on("connect", () => {
+ pool2[kWeight] = Math.min(this[kMaxWeightPerServer], pool2[kWeight] + this[kErrorPenalty]);
+ });
+ pool2.on("connectionError", () => {
+ pool2[kWeight] = Math.max(1, pool2[kWeight] - this[kErrorPenalty]);
+ this._updateBalancedPoolStats();
+ });
+ pool2.on("disconnect", (...args) => {
+ const err = args[2];
+ if (err && err.code === "UND_ERR_SOCKET") {
+ pool2[kWeight] = Math.max(1, pool2[kWeight] - this[kErrorPenalty]);
+ this._updateBalancedPoolStats();
+ }
+ });
+ for (const client of this[kClients]) {
+ client[kWeight] = this[kMaxWeightPerServer];
+ }
+ this._updateBalancedPoolStats();
+ return this;
+ }
+ _updateBalancedPoolStats() {
+ this[kGreatestCommonDivisor] = this[kClients].map((p) => p[kWeight]).reduce(getGreatestCommonDivisor, 0);
+ }
+ removeUpstream(upstream) {
+ const upstreamOrigin = parseOrigin(upstream).origin;
+ const pool2 = this[kClients].find((pool3) => pool3[kUrl].origin === upstreamOrigin && pool3.closed !== true && pool3.destroyed !== true);
+ if (pool2) {
+ this[kRemoveClient](pool2);
+ }
+ return this;
+ }
+ get upstreams() {
+ return this[kClients].filter((dispatcher) => dispatcher.closed !== true && dispatcher.destroyed !== true).map((p) => p[kUrl].origin);
+ }
+ [kGetDispatcher]() {
+ if (this[kClients].length === 0) {
+ throw new BalancedPoolMissingUpstreamError();
+ }
+ const dispatcher = this[kClients].find((dispatcher2) => !dispatcher2[kNeedDrain] && dispatcher2.closed !== true && dispatcher2.destroyed !== true);
+ if (!dispatcher) {
+ return;
+ }
+ const allClientsBusy = this[kClients].map((pool2) => pool2[kNeedDrain]).reduce((a, b) => a && b, true);
+ if (allClientsBusy) {
+ return;
+ }
+ let counter = 0;
+ let maxWeightIndex = this[kClients].findIndex((pool2) => !pool2[kNeedDrain]);
+ while (counter++ < this[kClients].length) {
+ this[kIndex] = (this[kIndex] + 1) % this[kClients].length;
+ const pool2 = this[kClients][this[kIndex]];
+ if (pool2[kWeight] > this[kClients][maxWeightIndex][kWeight] && !pool2[kNeedDrain]) {
+ maxWeightIndex = this[kIndex];
+ }
+ if (this[kIndex] === 0) {
+ this[kCurrentWeight] = this[kCurrentWeight] - this[kGreatestCommonDivisor];
+ if (this[kCurrentWeight] <= 0) {
+ this[kCurrentWeight] = this[kMaxWeightPerServer];
+ }
+ }
+ if (pool2[kWeight] >= this[kCurrentWeight] && !pool2[kNeedDrain]) {
+ return pool2;
+ }
+ }
+ this[kCurrentWeight] = this[kClients][maxWeightIndex][kWeight];
+ this[kIndex] = maxWeightIndex;
+ return this[kClients][maxWeightIndex];
+ }
+ };
+ __name(BalancedPool, "BalancedPool");
+ module2.exports = BalancedPool;
+ }
+});
+
+// ../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/compat/dispatcher-weakref.js
+var require_dispatcher_weakref = __commonJS({
+ "../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/compat/dispatcher-weakref.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var { kConnected, kSize } = require_symbols();
+ var CompatWeakRef = class {
+ constructor(value) {
+ this.value = value;
+ }
+ deref() {
+ return this.value[kConnected] === 0 && this.value[kSize] === 0 ? void 0 : this.value;
+ }
+ };
+ __name(CompatWeakRef, "CompatWeakRef");
+ var CompatFinalizer = class {
+ constructor(finalizer) {
+ this.finalizer = finalizer;
+ }
+ register(dispatcher, key) {
+ dispatcher.on("disconnect", () => {
+ if (dispatcher[kConnected] === 0 && dispatcher[kSize] === 0) {
+ this.finalizer(key);
+ }
+ });
+ }
+ };
+ __name(CompatFinalizer, "CompatFinalizer");
+ module2.exports = function() {
+ return {
+ WeakRef: global.WeakRef || CompatWeakRef,
+ FinalizationRegistry: global.FinalizationRegistry || CompatFinalizer
+ };
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/agent.js
+var require_agent = __commonJS({
+ "../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/agent.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var { InvalidArgumentError } = require_errors();
+ var { kClients, kRunning, kClose, kDestroy, kDispatch, kInterceptors } = require_symbols();
+ var DispatcherBase = require_dispatcher_base();
+ var Pool = require_pool();
+ var Client = require_client();
+ var util3 = require_util();
+ var createRedirectInterceptor = require_redirectInterceptor();
+ var { WeakRef: WeakRef2, FinalizationRegistry: FinalizationRegistry2 } = require_dispatcher_weakref()();
+ var kOnConnect = Symbol("onConnect");
+ var kOnDisconnect = Symbol("onDisconnect");
+ var kOnConnectionError = Symbol("onConnectionError");
+ var kMaxRedirections = Symbol("maxRedirections");
+ var kOnDrain = Symbol("onDrain");
+ var kFactory = Symbol("factory");
+ var kFinalizer = Symbol("finalizer");
+ var kOptions = Symbol("options");
+ function defaultFactory(origin, opts) {
+ return opts && opts.connections === 1 ? new Client(origin, opts) : new Pool(origin, opts);
+ }
+ __name(defaultFactory, "defaultFactory");
+ var Agent = class extends DispatcherBase {
+ constructor({ factory = defaultFactory, maxRedirections = 0, connect: connect2, ...options14 } = {}) {
+ super();
+ if (typeof factory !== "function") {
+ throw new InvalidArgumentError("factory must be a function.");
+ }
+ if (connect2 != null && typeof connect2 !== "function" && typeof connect2 !== "object") {
+ throw new InvalidArgumentError("connect must be a function or an object");
+ }
+ if (!Number.isInteger(maxRedirections) || maxRedirections < 0) {
+ throw new InvalidArgumentError("maxRedirections must be a positive number");
+ }
+ if (connect2 && typeof connect2 !== "function") {
+ connect2 = { ...connect2 };
+ }
+ this[kInterceptors] = options14.interceptors && options14.interceptors.Agent && Array.isArray(options14.interceptors.Agent) ? options14.interceptors.Agent : [createRedirectInterceptor({ maxRedirections })];
+ this[kOptions] = { ...util3.deepClone(options14), connect: connect2 };
+ this[kOptions].interceptors = options14.interceptors ? { ...options14.interceptors } : void 0;
+ this[kMaxRedirections] = maxRedirections;
+ this[kFactory] = factory;
+ this[kClients] = /* @__PURE__ */ new Map();
+ this[kFinalizer] = new FinalizationRegistry2(
+ /* istanbul ignore next: gc is undeterministic */
+ (key) => {
+ const ref = this[kClients].get(key);
+ if (ref !== void 0 && ref.deref() === void 0) {
+ this[kClients].delete(key);
+ }
+ }
+ );
+ const agent = this;
+ this[kOnDrain] = (origin, targets) => {
+ agent.emit("drain", origin, [agent, ...targets]);
+ };
+ this[kOnConnect] = (origin, targets) => {
+ agent.emit("connect", origin, [agent, ...targets]);
+ };
+ this[kOnDisconnect] = (origin, targets, err) => {
+ agent.emit("disconnect", origin, [agent, ...targets], err);
+ };
+ this[kOnConnectionError] = (origin, targets, err) => {
+ agent.emit("connectionError", origin, [agent, ...targets], err);
+ };
+ }
+ get [kRunning]() {
+ let ret = 0;
+ for (const ref of this[kClients].values()) {
+ const client = ref.deref();
+ if (client) {
+ ret += client[kRunning];
+ }
+ }
+ return ret;
+ }
+ [kDispatch](opts, handler15) {
+ let key;
+ if (opts.origin && (typeof opts.origin === "string" || opts.origin instanceof URL)) {
+ key = String(opts.origin);
+ } else {
+ throw new InvalidArgumentError("opts.origin must be a non-empty string or URL.");
+ }
+ const ref = this[kClients].get(key);
+ let dispatcher = ref ? ref.deref() : null;
+ if (!dispatcher) {
+ dispatcher = this[kFactory](opts.origin, this[kOptions]).on("drain", this[kOnDrain]).on("connect", this[kOnConnect]).on("disconnect", this[kOnDisconnect]).on("connectionError", this[kOnConnectionError]);
+ this[kClients].set(key, new WeakRef2(dispatcher));
+ this[kFinalizer].register(dispatcher, key);
+ }
+ return dispatcher.dispatch(opts, handler15);
+ }
+ async [kClose]() {
+ const closePromises = [];
+ for (const ref of this[kClients].values()) {
+ const client = ref.deref();
+ if (client) {
+ closePromises.push(client.close());
+ }
+ }
+ await Promise.all(closePromises);
+ }
+ async [kDestroy](err) {
+ const destroyPromises = [];
+ for (const ref of this[kClients].values()) {
+ const client = ref.deref();
+ if (client) {
+ destroyPromises.push(client.destroy(err));
+ }
+ }
+ await Promise.all(destroyPromises);
+ }
+ };
+ __name(Agent, "Agent");
+ module2.exports = Agent;
+ }
+});
+
+// ../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/api/readable.js
+var require_readable = __commonJS({
+ "../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/api/readable.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var assert18 = require("assert");
+ var { Readable } = require("stream");
+ var { RequestAbortedError, NotSupportedError } = require_errors();
+ var util3 = require_util();
+ var { ReadableStreamFrom, toUSVString } = require_util();
+ var Blob5;
+ var kConsume = Symbol("kConsume");
+ var kReading = Symbol("kReading");
+ var kBody = Symbol("kBody");
+ var kAbort = Symbol("abort");
+ var kContentType = Symbol("kContentType");
+ module2.exports = /* @__PURE__ */ __name(class BodyReadable extends Readable {
+ constructor(resume, abort, contentType = "") {
+ super({
+ autoDestroy: true,
+ read: resume,
+ highWaterMark: 64 * 1024
+ // Same as nodejs fs streams.
+ });
+ this._readableState.dataEmitted = false;
+ this[kAbort] = abort;
+ this[kConsume] = null;
+ this[kBody] = null;
+ this[kContentType] = contentType;
+ this[kReading] = false;
+ }
+ destroy(err) {
+ if (this.destroyed) {
+ return this;
+ }
+ if (!err && !this._readableState.endEmitted) {
+ err = new RequestAbortedError();
+ }
+ if (err) {
+ this[kAbort]();
+ }
+ return super.destroy(err);
+ }
+ emit(ev, ...args) {
+ if (ev === "data") {
+ this._readableState.dataEmitted = true;
+ } else if (ev === "error") {
+ this._readableState.errorEmitted = true;
+ }
+ return super.emit(ev, ...args);
+ }
+ on(ev, ...args) {
+ if (ev === "data" || ev === "readable") {
+ this[kReading] = true;
+ }
+ return super.on(ev, ...args);
+ }
+ addListener(ev, ...args) {
+ return this.on(ev, ...args);
+ }
+ off(ev, ...args) {
+ const ret = super.off(ev, ...args);
+ if (ev === "data" || ev === "readable") {
+ this[kReading] = this.listenerCount("data") > 0 || this.listenerCount("readable") > 0;
+ }
+ return ret;
+ }
+ removeListener(ev, ...args) {
+ return this.off(ev, ...args);
+ }
+ push(chunk) {
+ if (this[kConsume] && chunk !== null && this.readableLength === 0) {
+ consumePush(this[kConsume], chunk);
+ return this[kReading] ? super.push(chunk) : true;
+ }
+ return super.push(chunk);
+ }
+ // https://fetch.spec.whatwg.org/#dom-body-text
+ async text() {
+ return consume(this, "text");
+ }
+ // https://fetch.spec.whatwg.org/#dom-body-json
+ async json() {
+ return consume(this, "json");
+ }
+ // https://fetch.spec.whatwg.org/#dom-body-blob
+ async blob() {
+ return consume(this, "blob");
+ }
+ // https://fetch.spec.whatwg.org/#dom-body-arraybuffer
+ async arrayBuffer() {
+ return consume(this, "arrayBuffer");
+ }
+ // https://fetch.spec.whatwg.org/#dom-body-formdata
+ async formData() {
+ throw new NotSupportedError();
+ }
+ // https://fetch.spec.whatwg.org/#dom-body-bodyused
+ get bodyUsed() {
+ return util3.isDisturbed(this);
+ }
+ // https://fetch.spec.whatwg.org/#dom-body-body
+ get body() {
+ if (!this[kBody]) {
+ this[kBody] = ReadableStreamFrom(this);
+ if (this[kConsume]) {
+ this[kBody].getReader();
+ assert18(this[kBody].locked);
+ }
+ }
+ return this[kBody];
+ }
+ async dump(opts) {
+ let limit = opts && Number.isFinite(opts.limit) ? opts.limit : 262144;
+ try {
+ for await (const chunk of this) {
+ limit -= Buffer.byteLength(chunk);
+ if (limit < 0) {
+ return;
+ }
+ }
+ } catch {
+ }
+ }
+ }, "BodyReadable");
+ function isLocked(self2) {
+ return self2[kBody] && self2[kBody].locked === true || self2[kConsume];
+ }
+ __name(isLocked, "isLocked");
+ function isUnusable(self2) {
+ return util3.isDisturbed(self2) || isLocked(self2);
+ }
+ __name(isUnusable, "isUnusable");
+ async function consume(stream2, type) {
+ if (isUnusable(stream2)) {
+ throw new TypeError("unusable");
+ }
+ assert18(!stream2[kConsume]);
+ return new Promise((resolve18, reject) => {
+ stream2[kConsume] = {
+ type,
+ stream: stream2,
+ resolve: resolve18,
+ reject,
+ length: 0,
+ body: []
+ };
+ stream2.on("error", function(err) {
+ consumeFinish(this[kConsume], err);
+ }).on("close", function() {
+ if (this[kConsume].body !== null) {
+ consumeFinish(this[kConsume], new RequestAbortedError());
+ }
+ });
+ process.nextTick(consumeStart, stream2[kConsume]);
+ });
+ }
+ __name(consume, "consume");
+ function consumeStart(consume2) {
+ if (consume2.body === null) {
+ return;
+ }
+ const { _readableState: state } = consume2.stream;
+ for (const chunk of state.buffer) {
+ consumePush(consume2, chunk);
+ }
+ if (state.endEmitted) {
+ consumeEnd(this[kConsume]);
+ } else {
+ consume2.stream.on("end", function() {
+ consumeEnd(this[kConsume]);
+ });
+ }
+ consume2.stream.resume();
+ while (consume2.stream.read() != null) {
+ }
+ }
+ __name(consumeStart, "consumeStart");
+ function consumeEnd(consume2) {
+ const { type, body, resolve: resolve18, stream: stream2, length } = consume2;
+ try {
+ if (type === "text") {
+ resolve18(toUSVString(Buffer.concat(body)));
+ } else if (type === "json") {
+ resolve18(JSON.parse(Buffer.concat(body)));
+ } else if (type === "arrayBuffer") {
+ const dst = new Uint8Array(length);
+ let pos = 0;
+ for (const buf of body) {
+ dst.set(buf, pos);
+ pos += buf.byteLength;
+ }
+ resolve18(dst);
+ } else if (type === "blob") {
+ if (!Blob5) {
+ Blob5 = require("buffer").Blob;
+ }
+ resolve18(new Blob5(body, { type: stream2[kContentType] }));
+ }
+ consumeFinish(consume2);
+ } catch (err) {
+ stream2.destroy(err);
+ }
+ }
+ __name(consumeEnd, "consumeEnd");
+ function consumePush(consume2, chunk) {
+ consume2.length += chunk.length;
+ consume2.body.push(chunk);
+ }
+ __name(consumePush, "consumePush");
+ function consumeFinish(consume2, err) {
+ if (consume2.body === null) {
+ return;
+ }
+ if (err) {
+ consume2.reject(err);
+ } else {
+ consume2.resolve();
+ }
+ consume2.type = null;
+ consume2.stream = null;
+ consume2.resolve = null;
+ consume2.reject = null;
+ consume2.length = 0;
+ consume2.body = null;
+ }
+ __name(consumeFinish, "consumeFinish");
+ }
+});
+
+// ../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/api/abort-signal.js
+var require_abort_signal = __commonJS({
+ "../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/api/abort-signal.js"(exports2, module2) {
+ init_import_meta_url();
+ var { RequestAbortedError } = require_errors();
+ var kListener = Symbol("kListener");
+ var kSignal = Symbol("kSignal");
+ function abort(self2) {
+ if (self2.abort) {
+ self2.abort();
+ } else {
+ self2.onError(new RequestAbortedError());
+ }
+ }
+ __name(abort, "abort");
+ function addSignal(self2, signal) {
+ self2[kSignal] = null;
+ self2[kListener] = null;
+ if (!signal) {
+ return;
+ }
+ if (signal.aborted) {
+ abort(self2);
+ return;
+ }
+ self2[kSignal] = signal;
+ self2[kListener] = () => {
+ abort(self2);
+ };
+ if ("addEventListener" in self2[kSignal]) {
+ self2[kSignal].addEventListener("abort", self2[kListener]);
+ } else {
+ self2[kSignal].addListener("abort", self2[kListener]);
+ }
+ }
+ __name(addSignal, "addSignal");
+ function removeSignal(self2) {
+ if (!self2[kSignal]) {
+ return;
+ }
+ if ("removeEventListener" in self2[kSignal]) {
+ self2[kSignal].removeEventListener("abort", self2[kListener]);
+ } else {
+ self2[kSignal].removeListener("abort", self2[kListener]);
+ }
+ self2[kSignal] = null;
+ self2[kListener] = null;
+ }
+ __name(removeSignal, "removeSignal");
+ module2.exports = {
+ addSignal,
+ removeSignal
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/api/api-request.js
+var require_api_request = __commonJS({
+ "../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/api/api-request.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var Readable = require_readable();
+ var {
+ InvalidArgumentError,
+ RequestAbortedError,
+ ResponseStatusCodeError
+ } = require_errors();
+ var util3 = require_util();
+ var { AsyncResource } = require("async_hooks");
+ var { addSignal, removeSignal } = require_abort_signal();
+ var RequestHandler = class extends AsyncResource {
+ constructor(opts, callback) {
+ if (!opts || typeof opts !== "object") {
+ throw new InvalidArgumentError("invalid opts");
+ }
+ const { signal, method, opaque, body, onInfo, responseHeaders, throwOnError } = opts;
+ try {
+ if (typeof callback !== "function") {
+ throw new InvalidArgumentError("invalid callback");
+ }
+ if (signal && typeof signal.on !== "function" && typeof signal.addEventListener !== "function") {
+ throw new InvalidArgumentError("signal must be an EventEmitter or EventTarget");
+ }
+ if (method === "CONNECT") {
+ throw new InvalidArgumentError("invalid method");
+ }
+ if (onInfo && typeof onInfo !== "function") {
+ throw new InvalidArgumentError("invalid onInfo callback");
+ }
+ super("UNDICI_REQUEST");
+ } catch (err) {
+ if (util3.isStream(body)) {
+ util3.destroy(body.on("error", util3.nop), err);
+ }
+ throw err;
+ }
+ this.responseHeaders = responseHeaders || null;
+ this.opaque = opaque || null;
+ this.callback = callback;
+ this.res = null;
+ this.abort = null;
+ this.body = body;
+ this.trailers = {};
+ this.context = null;
+ this.onInfo = onInfo || null;
+ this.throwOnError = throwOnError;
+ if (util3.isStream(body)) {
+ body.on("error", (err) => {
+ this.onError(err);
+ });
+ }
+ addSignal(this, signal);
+ }
+ onConnect(abort, context2) {
+ if (!this.callback) {
+ throw new RequestAbortedError();
+ }
+ this.abort = abort;
+ this.context = context2;
+ }
+ onHeaders(statusCode, rawHeaders, resume, statusMessage) {
+ const { callback, opaque, abort, context: context2 } = this;
+ if (statusCode < 200) {
+ if (this.onInfo) {
+ const headers2 = this.responseHeaders === "raw" ? util3.parseRawHeaders(rawHeaders) : util3.parseHeaders(rawHeaders);
+ this.onInfo({ statusCode, headers: headers2 });
+ }
+ return;
+ }
+ const parsedHeaders = util3.parseHeaders(rawHeaders);
+ const contentType = parsedHeaders["content-type"];
+ const body = new Readable(resume, abort, contentType);
+ this.callback = null;
+ this.res = body;
+ const headers = this.responseHeaders === "raw" ? util3.parseRawHeaders(rawHeaders) : util3.parseHeaders(rawHeaders);
+ if (callback !== null) {
+ if (this.throwOnError && statusCode >= 400) {
+ this.runInAsyncScope(
+ getResolveErrorBodyCallback,
+ null,
+ { callback, body, contentType, statusCode, statusMessage, headers }
+ );
+ return;
+ }
+ this.runInAsyncScope(callback, null, null, {
+ statusCode,
+ headers,
+ trailers: this.trailers,
+ opaque,
+ body,
+ context: context2
+ });
+ }
+ }
+ onData(chunk) {
+ const { res } = this;
+ return res.push(chunk);
+ }
+ onComplete(trailers) {
+ const { res } = this;
+ removeSignal(this);
+ util3.parseHeaders(trailers, this.trailers);
+ res.push(null);
+ }
+ onError(err) {
+ const { res, callback, body, opaque } = this;
+ removeSignal(this);
+ if (callback) {
+ this.callback = null;
+ queueMicrotask(() => {
+ this.runInAsyncScope(callback, null, err, { opaque });
+ });
+ }
+ if (res) {
+ this.res = null;
+ queueMicrotask(() => {
+ util3.destroy(res, err);
+ });
+ }
+ if (body) {
+ this.body = null;
+ util3.destroy(body, err);
+ }
+ }
+ };
+ __name(RequestHandler, "RequestHandler");
+ async function getResolveErrorBodyCallback({ callback, body, contentType, statusCode, statusMessage, headers }) {
+ if (statusCode === 204 || !contentType) {
+ body.dump();
+ process.nextTick(callback, new ResponseStatusCodeError(`Response status code ${statusCode}${statusMessage ? `: ${statusMessage}` : ""}`, statusCode, headers));
+ return;
+ }
+ try {
+ if (contentType.startsWith("application/json")) {
+ const payload = await body.json();
+ process.nextTick(callback, new ResponseStatusCodeError(`Response status code ${statusCode}${statusMessage ? `: ${statusMessage}` : ""}`, statusCode, headers, payload));
+ return;
+ }
+ if (contentType.startsWith("text/")) {
+ const payload = await body.text();
+ process.nextTick(callback, new ResponseStatusCodeError(`Response status code ${statusCode}${statusMessage ? `: ${statusMessage}` : ""}`, statusCode, headers, payload));
+ return;
+ }
+ } catch (err) {
+ }
+ body.dump();
+ process.nextTick(callback, new ResponseStatusCodeError(`Response status code ${statusCode}${statusMessage ? `: ${statusMessage}` : ""}`, statusCode, headers));
+ }
+ __name(getResolveErrorBodyCallback, "getResolveErrorBodyCallback");
+ function request(opts, callback) {
+ if (callback === void 0) {
+ return new Promise((resolve18, reject) => {
+ request.call(this, opts, (err, data) => {
+ return err ? reject(err) : resolve18(data);
+ });
+ });
+ }
+ try {
+ this.dispatch(opts, new RequestHandler(opts, callback));
+ } catch (err) {
+ if (typeof callback !== "function") {
+ throw err;
+ }
+ const opaque = opts && opts.opaque;
+ queueMicrotask(() => callback(err, { opaque }));
+ }
+ }
+ __name(request, "request");
+ module2.exports = request;
+ }
+});
+
+// ../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/api/api-stream.js
+var require_api_stream = __commonJS({
+ "../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/api/api-stream.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var { finished } = require("stream");
+ var {
+ InvalidArgumentError,
+ InvalidReturnValueError,
+ RequestAbortedError
+ } = require_errors();
+ var util3 = require_util();
+ var { AsyncResource } = require("async_hooks");
+ var { addSignal, removeSignal } = require_abort_signal();
+ var StreamHandler = class extends AsyncResource {
+ constructor(opts, factory, callback) {
+ if (!opts || typeof opts !== "object") {
+ throw new InvalidArgumentError("invalid opts");
+ }
+ const { signal, method, opaque, body, onInfo, responseHeaders } = opts;
+ try {
+ if (typeof callback !== "function") {
+ throw new InvalidArgumentError("invalid callback");
+ }
+ if (typeof factory !== "function") {
+ throw new InvalidArgumentError("invalid factory");
+ }
+ if (signal && typeof signal.on !== "function" && typeof signal.addEventListener !== "function") {
+ throw new InvalidArgumentError("signal must be an EventEmitter or EventTarget");
+ }
+ if (method === "CONNECT") {
+ throw new InvalidArgumentError("invalid method");
+ }
+ if (onInfo && typeof onInfo !== "function") {
+ throw new InvalidArgumentError("invalid onInfo callback");
+ }
+ super("UNDICI_STREAM");
+ } catch (err) {
+ if (util3.isStream(body)) {
+ util3.destroy(body.on("error", util3.nop), err);
+ }
+ throw err;
+ }
+ this.responseHeaders = responseHeaders || null;
+ this.opaque = opaque || null;
+ this.factory = factory;
+ this.callback = callback;
+ this.res = null;
+ this.abort = null;
+ this.context = null;
+ this.trailers = null;
+ this.body = body;
+ this.onInfo = onInfo || null;
+ if (util3.isStream(body)) {
+ body.on("error", (err) => {
+ this.onError(err);
+ });
+ }
+ addSignal(this, signal);
+ }
+ onConnect(abort, context2) {
+ if (!this.callback) {
+ throw new RequestAbortedError();
+ }
+ this.abort = abort;
+ this.context = context2;
+ }
+ onHeaders(statusCode, rawHeaders, resume) {
+ const { factory, opaque, context: context2 } = this;
+ if (statusCode < 200) {
+ if (this.onInfo) {
+ const headers2 = this.responseHeaders === "raw" ? util3.parseRawHeaders(rawHeaders) : util3.parseHeaders(rawHeaders);
+ this.onInfo({ statusCode, headers: headers2 });
+ }
+ return;
+ }
+ this.factory = null;
+ const headers = this.responseHeaders === "raw" ? util3.parseRawHeaders(rawHeaders) : util3.parseHeaders(rawHeaders);
+ const res = this.runInAsyncScope(factory, null, {
+ statusCode,
+ headers,
+ opaque,
+ context: context2
+ });
+ if (!res || typeof res.write !== "function" || typeof res.end !== "function" || typeof res.on !== "function") {
+ throw new InvalidReturnValueError("expected Writable");
+ }
+ res.on("drain", resume);
+ finished(res, { readable: false }, (err) => {
+ const { callback, res: res2, opaque: opaque2, trailers, abort } = this;
+ this.res = null;
+ if (err || !res2.readable) {
+ util3.destroy(res2, err);
+ }
+ this.callback = null;
+ this.runInAsyncScope(callback, null, err || null, { opaque: opaque2, trailers });
+ if (err) {
+ abort();
+ }
+ });
+ this.res = res;
+ const needDrain = res.writableNeedDrain !== void 0 ? res.writableNeedDrain : res._writableState && res._writableState.needDrain;
+ return needDrain !== true;
+ }
+ onData(chunk) {
+ const { res } = this;
+ return res.write(chunk);
+ }
+ onComplete(trailers) {
+ const { res } = this;
+ removeSignal(this);
+ this.trailers = util3.parseHeaders(trailers);
+ res.end();
+ }
+ onError(err) {
+ const { res, callback, opaque, body } = this;
+ removeSignal(this);
+ this.factory = null;
+ if (res) {
+ this.res = null;
+ util3.destroy(res, err);
+ } else if (callback) {
+ this.callback = null;
+ queueMicrotask(() => {
+ this.runInAsyncScope(callback, null, err, { opaque });
+ });
+ }
+ if (body) {
+ this.body = null;
+ util3.destroy(body, err);
+ }
+ }
+ };
+ __name(StreamHandler, "StreamHandler");
+ function stream2(opts, factory, callback) {
+ if (callback === void 0) {
+ return new Promise((resolve18, reject) => {
+ stream2.call(this, opts, factory, (err, data) => {
+ return err ? reject(err) : resolve18(data);
+ });
+ });
+ }
+ try {
+ this.dispatch(opts, new StreamHandler(opts, factory, callback));
+ } catch (err) {
+ if (typeof callback !== "function") {
+ throw err;
+ }
+ const opaque = opts && opts.opaque;
+ queueMicrotask(() => callback(err, { opaque }));
+ }
+ }
+ __name(stream2, "stream");
+ module2.exports = stream2;
+ }
+});
+
+// ../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/api/api-pipeline.js
+var require_api_pipeline = __commonJS({
+ "../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/api/api-pipeline.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var {
+ Readable,
+ Duplex,
+ PassThrough
+ } = require("stream");
+ var {
+ InvalidArgumentError,
+ InvalidReturnValueError,
+ RequestAbortedError
+ } = require_errors();
+ var util3 = require_util();
+ var { AsyncResource } = require("async_hooks");
+ var { addSignal, removeSignal } = require_abort_signal();
+ var assert18 = require("assert");
+ var kResume = Symbol("resume");
+ var PipelineRequest = class extends Readable {
+ constructor() {
+ super({ autoDestroy: true });
+ this[kResume] = null;
+ }
+ _read() {
+ const { [kResume]: resume } = this;
+ if (resume) {
+ this[kResume] = null;
+ resume();
+ }
+ }
+ _destroy(err, callback) {
+ this._read();
+ callback(err);
+ }
+ };
+ __name(PipelineRequest, "PipelineRequest");
+ var PipelineResponse = class extends Readable {
+ constructor(resume) {
+ super({ autoDestroy: true });
+ this[kResume] = resume;
+ }
+ _read() {
+ this[kResume]();
+ }
+ _destroy(err, callback) {
+ if (!err && !this._readableState.endEmitted) {
+ err = new RequestAbortedError();
+ }
+ callback(err);
+ }
+ };
+ __name(PipelineResponse, "PipelineResponse");
+ var PipelineHandler = class extends AsyncResource {
+ constructor(opts, handler15) {
+ if (!opts || typeof opts !== "object") {
+ throw new InvalidArgumentError("invalid opts");
+ }
+ if (typeof handler15 !== "function") {
+ throw new InvalidArgumentError("invalid handler");
+ }
+ const { signal, method, opaque, onInfo, responseHeaders } = opts;
+ if (signal && typeof signal.on !== "function" && typeof signal.addEventListener !== "function") {
+ throw new InvalidArgumentError("signal must be an EventEmitter or EventTarget");
+ }
+ if (method === "CONNECT") {
+ throw new InvalidArgumentError("invalid method");
+ }
+ if (onInfo && typeof onInfo !== "function") {
+ throw new InvalidArgumentError("invalid onInfo callback");
+ }
+ super("UNDICI_PIPELINE");
+ this.opaque = opaque || null;
+ this.responseHeaders = responseHeaders || null;
+ this.handler = handler15;
+ this.abort = null;
+ this.context = null;
+ this.onInfo = onInfo || null;
+ this.req = new PipelineRequest().on("error", util3.nop);
+ this.ret = new Duplex({
+ readableObjectMode: opts.objectMode,
+ autoDestroy: true,
+ read: () => {
+ const { body } = this;
+ if (body && body.resume) {
+ body.resume();
+ }
+ },
+ write: (chunk, encoding, callback) => {
+ const { req } = this;
+ if (req.push(chunk, encoding) || req._readableState.destroyed) {
+ callback();
+ } else {
+ req[kResume] = callback;
+ }
+ },
+ destroy: (err, callback) => {
+ const { body, req, res, ret, abort } = this;
+ if (!err && !ret._readableState.endEmitted) {
+ err = new RequestAbortedError();
+ }
+ if (abort && err) {
+ abort();
+ }
+ util3.destroy(body, err);
+ util3.destroy(req, err);
+ util3.destroy(res, err);
+ removeSignal(this);
+ callback(err);
+ }
+ }).on("prefinish", () => {
+ const { req } = this;
+ req.push(null);
+ });
+ this.res = null;
+ addSignal(this, signal);
+ }
+ onConnect(abort, context2) {
+ const { ret, res } = this;
+ assert18(!res, "pipeline cannot be retried");
+ if (ret.destroyed) {
+ throw new RequestAbortedError();
+ }
+ this.abort = abort;
+ this.context = context2;
+ }
+ onHeaders(statusCode, rawHeaders, resume) {
+ const { opaque, handler: handler15, context: context2 } = this;
+ if (statusCode < 200) {
+ if (this.onInfo) {
+ const headers = this.responseHeaders === "raw" ? util3.parseRawHeaders(rawHeaders) : util3.parseHeaders(rawHeaders);
+ this.onInfo({ statusCode, headers });
+ }
+ return;
+ }
+ this.res = new PipelineResponse(resume);
+ let body;
+ try {
+ this.handler = null;
+ const headers = this.responseHeaders === "raw" ? util3.parseRawHeaders(rawHeaders) : util3.parseHeaders(rawHeaders);
+ body = this.runInAsyncScope(handler15, null, {
+ statusCode,
+ headers,
+ opaque,
+ body: this.res,
+ context: context2
+ });
+ } catch (err) {
+ this.res.on("error", util3.nop);
+ throw err;
+ }
+ if (!body || typeof body.on !== "function") {
+ throw new InvalidReturnValueError("expected Readable");
+ }
+ body.on("data", (chunk) => {
+ const { ret, body: body2 } = this;
+ if (!ret.push(chunk) && body2.pause) {
+ body2.pause();
+ }
+ }).on("error", (err) => {
+ const { ret } = this;
+ util3.destroy(ret, err);
+ }).on("end", () => {
+ const { ret } = this;
+ ret.push(null);
+ }).on("close", () => {
+ const { ret } = this;
+ if (!ret._readableState.ended) {
+ util3.destroy(ret, new RequestAbortedError());
+ }
+ });
+ this.body = body;
+ }
+ onData(chunk) {
+ const { res } = this;
+ return res.push(chunk);
+ }
+ onComplete(trailers) {
+ const { res } = this;
+ res.push(null);
+ }
+ onError(err) {
+ const { ret } = this;
+ this.handler = null;
+ util3.destroy(ret, err);
+ }
+ };
+ __name(PipelineHandler, "PipelineHandler");
+ function pipeline(opts, handler15) {
+ try {
+ const pipelineHandler = new PipelineHandler(opts, handler15);
+ this.dispatch({ ...opts, body: pipelineHandler.req }, pipelineHandler);
+ return pipelineHandler.ret;
+ } catch (err) {
+ return new PassThrough().destroy(err);
+ }
+ }
+ __name(pipeline, "pipeline");
+ module2.exports = pipeline;
+ }
+});
+
+// ../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/api/api-upgrade.js
+var require_api_upgrade = __commonJS({
+ "../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/api/api-upgrade.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var { InvalidArgumentError, RequestAbortedError, SocketError } = require_errors();
+ var { AsyncResource } = require("async_hooks");
+ var util3 = require_util();
+ var { addSignal, removeSignal } = require_abort_signal();
+ var assert18 = require("assert");
+ var UpgradeHandler = class extends AsyncResource {
+ constructor(opts, callback) {
+ if (!opts || typeof opts !== "object") {
+ throw new InvalidArgumentError("invalid opts");
+ }
+ if (typeof callback !== "function") {
+ throw new InvalidArgumentError("invalid callback");
+ }
+ const { signal, opaque, responseHeaders } = opts;
+ if (signal && typeof signal.on !== "function" && typeof signal.addEventListener !== "function") {
+ throw new InvalidArgumentError("signal must be an EventEmitter or EventTarget");
+ }
+ super("UNDICI_UPGRADE");
+ this.responseHeaders = responseHeaders || null;
+ this.opaque = opaque || null;
+ this.callback = callback;
+ this.abort = null;
+ this.context = null;
+ addSignal(this, signal);
+ }
+ onConnect(abort, context2) {
+ if (!this.callback) {
+ throw new RequestAbortedError();
+ }
+ this.abort = abort;
+ this.context = null;
+ }
+ onHeaders() {
+ throw new SocketError("bad upgrade", null);
+ }
+ onUpgrade(statusCode, rawHeaders, socket) {
+ const { callback, opaque, context: context2 } = this;
+ assert18.strictEqual(statusCode, 101);
+ removeSignal(this);
+ this.callback = null;
+ const headers = this.responseHeaders === "raw" ? util3.parseRawHeaders(rawHeaders) : util3.parseHeaders(rawHeaders);
+ this.runInAsyncScope(callback, null, null, {
+ headers,
+ socket,
+ opaque,
+ context: context2
+ });
+ }
+ onError(err) {
+ const { callback, opaque } = this;
+ removeSignal(this);
+ if (callback) {
+ this.callback = null;
+ queueMicrotask(() => {
+ this.runInAsyncScope(callback, null, err, { opaque });
+ });
+ }
+ }
+ };
+ __name(UpgradeHandler, "UpgradeHandler");
+ function upgrade(opts, callback) {
+ if (callback === void 0) {
+ return new Promise((resolve18, reject) => {
+ upgrade.call(this, opts, (err, data) => {
+ return err ? reject(err) : resolve18(data);
+ });
+ });
+ }
+ try {
+ const upgradeHandler = new UpgradeHandler(opts, callback);
+ this.dispatch({
+ ...opts,
+ method: opts.method || "GET",
+ upgrade: opts.protocol || "Websocket"
+ }, upgradeHandler);
+ } catch (err) {
+ if (typeof callback !== "function") {
+ throw err;
+ }
+ const opaque = opts && opts.opaque;
+ queueMicrotask(() => callback(err, { opaque }));
+ }
+ }
+ __name(upgrade, "upgrade");
+ module2.exports = upgrade;
+ }
+});
+
+// ../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/api/api-connect.js
+var require_api_connect = __commonJS({
+ "../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/api/api-connect.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var { InvalidArgumentError, RequestAbortedError, SocketError } = require_errors();
+ var { AsyncResource } = require("async_hooks");
+ var util3 = require_util();
+ var { addSignal, removeSignal } = require_abort_signal();
+ var ConnectHandler = class extends AsyncResource {
+ constructor(opts, callback) {
+ if (!opts || typeof opts !== "object") {
+ throw new InvalidArgumentError("invalid opts");
+ }
+ if (typeof callback !== "function") {
+ throw new InvalidArgumentError("invalid callback");
+ }
+ const { signal, opaque, responseHeaders } = opts;
+ if (signal && typeof signal.on !== "function" && typeof signal.addEventListener !== "function") {
+ throw new InvalidArgumentError("signal must be an EventEmitter or EventTarget");
+ }
+ super("UNDICI_CONNECT");
+ this.opaque = opaque || null;
+ this.responseHeaders = responseHeaders || null;
+ this.callback = callback;
+ this.abort = null;
+ addSignal(this, signal);
+ }
+ onConnect(abort, context2) {
+ if (!this.callback) {
+ throw new RequestAbortedError();
+ }
+ this.abort = abort;
+ this.context = context2;
+ }
+ onHeaders() {
+ throw new SocketError("bad connect", null);
+ }
+ onUpgrade(statusCode, rawHeaders, socket) {
+ const { callback, opaque, context: context2 } = this;
+ removeSignal(this);
+ this.callback = null;
+ const headers = this.responseHeaders === "raw" ? util3.parseRawHeaders(rawHeaders) : util3.parseHeaders(rawHeaders);
+ this.runInAsyncScope(callback, null, null, {
+ statusCode,
+ headers,
+ socket,
+ opaque,
+ context: context2
+ });
+ }
+ onError(err) {
+ const { callback, opaque } = this;
+ removeSignal(this);
+ if (callback) {
+ this.callback = null;
+ queueMicrotask(() => {
+ this.runInAsyncScope(callback, null, err, { opaque });
+ });
+ }
+ }
+ };
+ __name(ConnectHandler, "ConnectHandler");
+ function connect2(opts, callback) {
+ if (callback === void 0) {
+ return new Promise((resolve18, reject) => {
+ connect2.call(this, opts, (err, data) => {
+ return err ? reject(err) : resolve18(data);
+ });
+ });
+ }
+ try {
+ const connectHandler = new ConnectHandler(opts, callback);
+ this.dispatch({ ...opts, method: "CONNECT" }, connectHandler);
+ } catch (err) {
+ if (typeof callback !== "function") {
+ throw err;
+ }
+ const opaque = opts && opts.opaque;
+ queueMicrotask(() => callback(err, { opaque }));
+ }
+ }
+ __name(connect2, "connect");
+ module2.exports = connect2;
+ }
+});
+
+// ../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/api/index.js
+var require_api = __commonJS({
+ "../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/api/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ module2.exports.request = require_api_request();
+ module2.exports.stream = require_api_stream();
+ module2.exports.pipeline = require_api_pipeline();
+ module2.exports.upgrade = require_api_upgrade();
+ module2.exports.connect = require_api_connect();
+ }
+});
+
+// ../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/mock/mock-errors.js
+var require_mock_errors = __commonJS({
+ "../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/mock/mock-errors.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var { UndiciError } = require_errors();
+ var MockNotMatchedError = class extends UndiciError {
+ constructor(message) {
+ super(message);
+ Error.captureStackTrace(this, MockNotMatchedError);
+ this.name = "MockNotMatchedError";
+ this.message = message || "The request does not match any registered mock dispatches";
+ this.code = "UND_MOCK_ERR_MOCK_NOT_MATCHED";
+ }
+ };
+ __name(MockNotMatchedError, "MockNotMatchedError");
+ module2.exports = {
+ MockNotMatchedError
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/mock/mock-symbols.js
+var require_mock_symbols = __commonJS({
+ "../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/mock/mock-symbols.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ module2.exports = {
+ kAgent: Symbol("agent"),
+ kOptions: Symbol("options"),
+ kFactory: Symbol("factory"),
+ kDispatches: Symbol("dispatches"),
+ kDispatchKey: Symbol("dispatch key"),
+ kDefaultHeaders: Symbol("default headers"),
+ kDefaultTrailers: Symbol("default trailers"),
+ kContentLength: Symbol("content length"),
+ kMockAgent: Symbol("mock agent"),
+ kMockAgentSet: Symbol("mock agent set"),
+ kMockAgentGet: Symbol("mock agent get"),
+ kMockDispatch: Symbol("mock dispatch"),
+ kClose: Symbol("close"),
+ kOriginalClose: Symbol("original agent close"),
+ kOrigin: Symbol("origin"),
+ kIsMockActive: Symbol("is mock active"),
+ kNetConnect: Symbol("net connect"),
+ kGetNetConnect: Symbol("get net connect"),
+ kConnected: Symbol("connected")
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/mock/mock-utils.js
+var require_mock_utils = __commonJS({
+ "../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/mock/mock-utils.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var { MockNotMatchedError } = require_mock_errors();
+ var {
+ kDispatches,
+ kMockAgent,
+ kOriginalDispatch,
+ kOrigin,
+ kGetNetConnect
+ } = require_mock_symbols();
+ var { buildURL, nop } = require_util();
+ var { STATUS_CODES } = require("http");
+ var {
+ types: {
+ isPromise: isPromise2
+ }
+ } = require("util");
+ function matchValue(match, value) {
+ if (typeof match === "string") {
+ return match === value;
+ }
+ if (match instanceof RegExp) {
+ return match.test(value);
+ }
+ if (typeof match === "function") {
+ return match(value) === true;
+ }
+ return false;
+ }
+ __name(matchValue, "matchValue");
+ function lowerCaseEntries(headers) {
+ return Object.fromEntries(
+ Object.entries(headers).map(([headerName, headerValue]) => {
+ return [headerName.toLocaleLowerCase(), headerValue];
+ })
+ );
+ }
+ __name(lowerCaseEntries, "lowerCaseEntries");
+ function getHeaderByName(headers, key) {
+ if (Array.isArray(headers)) {
+ for (let i = 0; i < headers.length; i += 2) {
+ if (headers[i].toLocaleLowerCase() === key.toLocaleLowerCase()) {
+ return headers[i + 1];
+ }
+ }
+ return void 0;
+ } else if (typeof headers.get === "function") {
+ return headers.get(key);
+ } else {
+ return lowerCaseEntries(headers)[key.toLocaleLowerCase()];
+ }
+ }
+ __name(getHeaderByName, "getHeaderByName");
+ function buildHeadersFromArray(headers) {
+ const clone = headers.slice();
+ const entries = [];
+ for (let index = 0; index < clone.length; index += 2) {
+ entries.push([clone[index], clone[index + 1]]);
+ }
+ return Object.fromEntries(entries);
+ }
+ __name(buildHeadersFromArray, "buildHeadersFromArray");
+ function matchHeaders(mockDispatch2, headers) {
+ if (typeof mockDispatch2.headers === "function") {
+ if (Array.isArray(headers)) {
+ headers = buildHeadersFromArray(headers);
+ }
+ return mockDispatch2.headers(headers ? lowerCaseEntries(headers) : {});
+ }
+ if (typeof mockDispatch2.headers === "undefined") {
+ return true;
+ }
+ if (typeof headers !== "object" || typeof mockDispatch2.headers !== "object") {
+ return false;
+ }
+ for (const [matchHeaderName, matchHeaderValue] of Object.entries(mockDispatch2.headers)) {
+ const headerValue = getHeaderByName(headers, matchHeaderName);
+ if (!matchValue(matchHeaderValue, headerValue)) {
+ return false;
+ }
+ }
+ return true;
+ }
+ __name(matchHeaders, "matchHeaders");
+ function safeUrl(path45) {
+ if (typeof path45 !== "string") {
+ return path45;
+ }
+ const pathSegments = path45.split("?");
+ if (pathSegments.length !== 2) {
+ return path45;
+ }
+ const qp = new URLSearchParams(pathSegments.pop());
+ qp.sort();
+ return [...pathSegments, qp.toString()].join("?");
+ }
+ __name(safeUrl, "safeUrl");
+ function matchKey(mockDispatch2, { path: path45, method, body, headers }) {
+ const pathMatch = matchValue(mockDispatch2.path, path45);
+ const methodMatch = matchValue(mockDispatch2.method, method);
+ const bodyMatch = typeof mockDispatch2.body !== "undefined" ? matchValue(mockDispatch2.body, body) : true;
+ const headersMatch = matchHeaders(mockDispatch2, headers);
+ return pathMatch && methodMatch && bodyMatch && headersMatch;
+ }
+ __name(matchKey, "matchKey");
+ function getResponseData(data) {
+ if (Buffer.isBuffer(data)) {
+ return data;
+ } else if (typeof data === "object") {
+ return JSON.stringify(data);
+ } else {
+ return data.toString();
+ }
+ }
+ __name(getResponseData, "getResponseData");
+ function getMockDispatch(mockDispatches, key) {
+ const basePath = key.query ? buildURL(key.path, key.query) : key.path;
+ const resolvedPath = typeof basePath === "string" ? safeUrl(basePath) : basePath;
+ let matchedMockDispatches = mockDispatches.filter(({ consumed }) => !consumed).filter(({ path: path45 }) => matchValue(safeUrl(path45), resolvedPath));
+ if (matchedMockDispatches.length === 0) {
+ throw new MockNotMatchedError(`Mock dispatch not matched for path '${resolvedPath}'`);
+ }
+ matchedMockDispatches = matchedMockDispatches.filter(({ method }) => matchValue(method, key.method));
+ if (matchedMockDispatches.length === 0) {
+ throw new MockNotMatchedError(`Mock dispatch not matched for method '${key.method}'`);
+ }
+ matchedMockDispatches = matchedMockDispatches.filter(({ body }) => typeof body !== "undefined" ? matchValue(body, key.body) : true);
+ if (matchedMockDispatches.length === 0) {
+ throw new MockNotMatchedError(`Mock dispatch not matched for body '${key.body}'`);
+ }
+ matchedMockDispatches = matchedMockDispatches.filter((mockDispatch2) => matchHeaders(mockDispatch2, key.headers));
+ if (matchedMockDispatches.length === 0) {
+ throw new MockNotMatchedError(`Mock dispatch not matched for headers '${typeof key.headers === "object" ? JSON.stringify(key.headers) : key.headers}'`);
+ }
+ return matchedMockDispatches[0];
+ }
+ __name(getMockDispatch, "getMockDispatch");
+ function addMockDispatch(mockDispatches, key, data) {
+ const baseData = { timesInvoked: 0, times: 1, persist: false, consumed: false };
+ const replyData = typeof data === "function" ? { callback: data } : { ...data };
+ const newMockDispatch = { ...baseData, ...key, pending: true, data: { error: null, ...replyData } };
+ mockDispatches.push(newMockDispatch);
+ return newMockDispatch;
+ }
+ __name(addMockDispatch, "addMockDispatch");
+ function deleteMockDispatch(mockDispatches, key) {
+ const index = mockDispatches.findIndex((dispatch) => {
+ if (!dispatch.consumed) {
+ return false;
+ }
+ return matchKey(dispatch, key);
+ });
+ if (index !== -1) {
+ mockDispatches.splice(index, 1);
+ }
+ }
+ __name(deleteMockDispatch, "deleteMockDispatch");
+ function buildKey(opts) {
+ const { path: path45, method, body, headers, query } = opts;
+ return {
+ path: path45,
+ method,
+ body,
+ headers,
+ query
+ };
+ }
+ __name(buildKey, "buildKey");
+ function generateKeyValues(data) {
+ return Object.entries(data).reduce((keyValuePairs, [key, value]) => [
+ ...keyValuePairs,
+ Buffer.from(`${key}`),
+ Array.isArray(value) ? value.map((x) => Buffer.from(`${x}`)) : Buffer.from(`${value}`)
+ ], []);
+ }
+ __name(generateKeyValues, "generateKeyValues");
+ function getStatusText(statusCode) {
+ return STATUS_CODES[statusCode] || "unknown";
+ }
+ __name(getStatusText, "getStatusText");
+ async function getResponse(body) {
+ const buffers = [];
+ for await (const data of body) {
+ buffers.push(data);
+ }
+ return Buffer.concat(buffers).toString("utf8");
+ }
+ __name(getResponse, "getResponse");
+ function mockDispatch(opts, handler15) {
+ const key = buildKey(opts);
+ const mockDispatch2 = getMockDispatch(this[kDispatches], key);
+ mockDispatch2.timesInvoked++;
+ if (mockDispatch2.data.callback) {
+ mockDispatch2.data = { ...mockDispatch2.data, ...mockDispatch2.data.callback(opts) };
+ }
+ const { data: { statusCode, data, headers, trailers, error }, delay, persist } = mockDispatch2;
+ const { timesInvoked, times } = mockDispatch2;
+ mockDispatch2.consumed = !persist && timesInvoked >= times;
+ mockDispatch2.pending = timesInvoked < times;
+ if (error !== null) {
+ deleteMockDispatch(this[kDispatches], key);
+ handler15.onError(error);
+ return true;
+ }
+ if (typeof delay === "number" && delay > 0) {
+ setTimeout(() => {
+ handleReply(this[kDispatches]);
+ }, delay);
+ } else {
+ handleReply(this[kDispatches]);
+ }
+ function handleReply(mockDispatches, _data = data) {
+ const optsHeaders = Array.isArray(opts.headers) ? buildHeadersFromArray(opts.headers) : opts.headers;
+ const body = typeof _data === "function" ? _data({ ...opts, headers: optsHeaders }) : _data;
+ if (isPromise2(body)) {
+ body.then((newData) => handleReply(mockDispatches, newData));
+ return;
+ }
+ const responseData = getResponseData(body);
+ const responseHeaders = generateKeyValues(headers);
+ const responseTrailers = generateKeyValues(trailers);
+ handler15.abort = nop;
+ handler15.onHeaders(statusCode, responseHeaders, resume, getStatusText(statusCode));
+ handler15.onData(Buffer.from(responseData));
+ handler15.onComplete(responseTrailers);
+ deleteMockDispatch(mockDispatches, key);
+ }
+ __name(handleReply, "handleReply");
+ function resume() {
+ }
+ __name(resume, "resume");
+ return true;
+ }
+ __name(mockDispatch, "mockDispatch");
+ function buildMockDispatch() {
+ const agent = this[kMockAgent];
+ const origin = this[kOrigin];
+ const originalDispatch = this[kOriginalDispatch];
+ return /* @__PURE__ */ __name(function dispatch(opts, handler15) {
+ if (agent.isMockActive) {
+ try {
+ mockDispatch.call(this, opts, handler15);
+ } catch (error) {
+ if (error instanceof MockNotMatchedError) {
+ const netConnect = agent[kGetNetConnect]();
+ if (netConnect === false) {
+ throw new MockNotMatchedError(`${error.message}: subsequent request to origin ${origin} was not allowed (net.connect disabled)`);
+ }
+ if (checkNetConnect(netConnect, origin)) {
+ originalDispatch.call(this, opts, handler15);
+ } else {
+ throw new MockNotMatchedError(`${error.message}: subsequent request to origin ${origin} was not allowed (net.connect is not enabled for this origin)`);
+ }
+ } else {
+ throw error;
+ }
+ }
+ } else {
+ originalDispatch.call(this, opts, handler15);
+ }
+ }, "dispatch");
+ }
+ __name(buildMockDispatch, "buildMockDispatch");
+ function checkNetConnect(netConnect, origin) {
+ const url3 = new URL(origin);
+ if (netConnect === true) {
+ return true;
+ } else if (Array.isArray(netConnect) && netConnect.some((matcher) => matchValue(matcher, url3.host))) {
+ return true;
+ }
+ return false;
+ }
+ __name(checkNetConnect, "checkNetConnect");
+ function buildMockOptions(opts) {
+ if (opts) {
+ const { agent, ...mockOptions } = opts;
+ return mockOptions;
+ }
+ }
+ __name(buildMockOptions, "buildMockOptions");
+ module2.exports = {
+ getResponseData,
+ getMockDispatch,
+ addMockDispatch,
+ deleteMockDispatch,
+ buildKey,
+ generateKeyValues,
+ matchValue,
+ getResponse,
+ getStatusText,
+ mockDispatch,
+ buildMockDispatch,
+ checkNetConnect,
+ buildMockOptions,
+ getHeaderByName
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/mock/mock-interceptor.js
+var require_mock_interceptor = __commonJS({
+ "../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/mock/mock-interceptor.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var { getResponseData, buildKey, addMockDispatch } = require_mock_utils();
+ var {
+ kDispatches,
+ kDispatchKey,
+ kDefaultHeaders,
+ kDefaultTrailers,
+ kContentLength,
+ kMockDispatch
+ } = require_mock_symbols();
+ var { InvalidArgumentError } = require_errors();
+ var { buildURL } = require_util();
+ var MockScope = class {
+ constructor(mockDispatch) {
+ this[kMockDispatch] = mockDispatch;
+ }
+ /**
+ * Delay a reply by a set amount in ms.
+ */
+ delay(waitInMs) {
+ if (typeof waitInMs !== "number" || !Number.isInteger(waitInMs) || waitInMs <= 0) {
+ throw new InvalidArgumentError("waitInMs must be a valid integer > 0");
+ }
+ this[kMockDispatch].delay = waitInMs;
+ return this;
+ }
+ /**
+ * For a defined reply, never mark as consumed.
+ */
+ persist() {
+ this[kMockDispatch].persist = true;
+ return this;
+ }
+ /**
+ * Allow one to define a reply for a set amount of matching requests.
+ */
+ times(repeatTimes) {
+ if (typeof repeatTimes !== "number" || !Number.isInteger(repeatTimes) || repeatTimes <= 0) {
+ throw new InvalidArgumentError("repeatTimes must be a valid integer > 0");
+ }
+ this[kMockDispatch].times = repeatTimes;
+ return this;
+ }
+ };
+ __name(MockScope, "MockScope");
+ var MockInterceptor = class {
+ constructor(opts, mockDispatches) {
+ if (typeof opts !== "object") {
+ throw new InvalidArgumentError("opts must be an object");
+ }
+ if (typeof opts.path === "undefined") {
+ throw new InvalidArgumentError("opts.path must be defined");
+ }
+ if (typeof opts.method === "undefined") {
+ opts.method = "GET";
+ }
+ if (typeof opts.path === "string") {
+ if (opts.query) {
+ opts.path = buildURL(opts.path, opts.query);
+ } else {
+ const parsedURL = new URL(opts.path, "data://");
+ opts.path = parsedURL.pathname + parsedURL.search;
+ }
+ }
+ if (typeof opts.method === "string") {
+ opts.method = opts.method.toUpperCase();
+ }
+ this[kDispatchKey] = buildKey(opts);
+ this[kDispatches] = mockDispatches;
+ this[kDefaultHeaders] = {};
+ this[kDefaultTrailers] = {};
+ this[kContentLength] = false;
+ }
+ createMockScopeDispatchData(statusCode, data, responseOptions = {}) {
+ const responseData = getResponseData(data);
+ const contentLength = this[kContentLength] ? { "content-length": responseData.length } : {};
+ const headers = { ...this[kDefaultHeaders], ...contentLength, ...responseOptions.headers };
+ const trailers = { ...this[kDefaultTrailers], ...responseOptions.trailers };
+ return { statusCode, data, headers, trailers };
+ }
+ validateReplyParameters(statusCode, data, responseOptions) {
+ if (typeof statusCode === "undefined") {
+ throw new InvalidArgumentError("statusCode must be defined");
+ }
+ if (typeof data === "undefined") {
+ throw new InvalidArgumentError("data must be defined");
+ }
+ if (typeof responseOptions !== "object") {
+ throw new InvalidArgumentError("responseOptions must be an object");
+ }
+ }
+ /**
+ * Mock an undici request with a defined reply.
+ */
+ reply(replyData) {
+ if (typeof replyData === "function") {
+ const wrappedDefaultsCallback = /* @__PURE__ */ __name((opts) => {
+ const resolvedData = replyData(opts);
+ if (typeof resolvedData !== "object") {
+ throw new InvalidArgumentError("reply options callback must return an object");
+ }
+ const { statusCode: statusCode2, data: data2 = "", responseOptions: responseOptions2 = {} } = resolvedData;
+ this.validateReplyParameters(statusCode2, data2, responseOptions2);
+ return {
+ ...this.createMockScopeDispatchData(statusCode2, data2, responseOptions2)
+ };
+ }, "wrappedDefaultsCallback");
+ const newMockDispatch2 = addMockDispatch(this[kDispatches], this[kDispatchKey], wrappedDefaultsCallback);
+ return new MockScope(newMockDispatch2);
+ }
+ const [statusCode, data = "", responseOptions = {}] = [...arguments];
+ this.validateReplyParameters(statusCode, data, responseOptions);
+ const dispatchData = this.createMockScopeDispatchData(statusCode, data, responseOptions);
+ const newMockDispatch = addMockDispatch(this[kDispatches], this[kDispatchKey], dispatchData);
+ return new MockScope(newMockDispatch);
+ }
+ /**
+ * Mock an undici request with a defined error.
+ */
+ replyWithError(error) {
+ if (typeof error === "undefined") {
+ throw new InvalidArgumentError("error must be defined");
+ }
+ const newMockDispatch = addMockDispatch(this[kDispatches], this[kDispatchKey], { error });
+ return new MockScope(newMockDispatch);
+ }
+ /**
+ * Set default reply headers on the interceptor for subsequent replies
+ */
+ defaultReplyHeaders(headers) {
+ if (typeof headers === "undefined") {
+ throw new InvalidArgumentError("headers must be defined");
+ }
+ this[kDefaultHeaders] = headers;
+ return this;
+ }
+ /**
+ * Set default reply trailers on the interceptor for subsequent replies
+ */
+ defaultReplyTrailers(trailers) {
+ if (typeof trailers === "undefined") {
+ throw new InvalidArgumentError("trailers must be defined");
+ }
+ this[kDefaultTrailers] = trailers;
+ return this;
+ }
+ /**
+ * Set reply content length header for replies on the interceptor
+ */
+ replyContentLength() {
+ this[kContentLength] = true;
+ return this;
+ }
+ };
+ __name(MockInterceptor, "MockInterceptor");
+ module2.exports.MockInterceptor = MockInterceptor;
+ module2.exports.MockScope = MockScope;
+ }
+});
+
+// ../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/mock/mock-client.js
+var require_mock_client = __commonJS({
+ "../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/mock/mock-client.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var { promisify: promisify2 } = require("util");
+ var Client = require_client();
+ var { buildMockDispatch } = require_mock_utils();
+ var {
+ kDispatches,
+ kMockAgent,
+ kClose,
+ kOriginalClose,
+ kOrigin,
+ kOriginalDispatch,
+ kConnected
+ } = require_mock_symbols();
+ var { MockInterceptor } = require_mock_interceptor();
+ var Symbols = require_symbols();
+ var { InvalidArgumentError } = require_errors();
+ var MockClient = class extends Client {
+ constructor(origin, opts) {
+ super(origin, opts);
+ if (!opts || !opts.agent || typeof opts.agent.dispatch !== "function") {
+ throw new InvalidArgumentError("Argument opts.agent must implement Agent");
+ }
+ this[kMockAgent] = opts.agent;
+ this[kOrigin] = origin;
+ this[kDispatches] = [];
+ this[kConnected] = 1;
+ this[kOriginalDispatch] = this.dispatch;
+ this[kOriginalClose] = this.close.bind(this);
+ this.dispatch = buildMockDispatch.call(this);
+ this.close = this[kClose];
+ }
+ get [Symbols.kConnected]() {
+ return this[kConnected];
+ }
+ /**
+ * Sets up the base interceptor for mocking replies from undici.
+ */
+ intercept(opts) {
+ return new MockInterceptor(opts, this[kDispatches]);
+ }
+ async [kClose]() {
+ await promisify2(this[kOriginalClose])();
+ this[kConnected] = 0;
+ this[kMockAgent][Symbols.kClients].delete(this[kOrigin]);
+ }
+ };
+ __name(MockClient, "MockClient");
+ module2.exports = MockClient;
+ }
+});
+
+// ../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/mock/mock-pool.js
+var require_mock_pool = __commonJS({
+ "../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/mock/mock-pool.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var { promisify: promisify2 } = require("util");
+ var Pool = require_pool();
+ var { buildMockDispatch } = require_mock_utils();
+ var {
+ kDispatches,
+ kMockAgent,
+ kClose,
+ kOriginalClose,
+ kOrigin,
+ kOriginalDispatch,
+ kConnected
+ } = require_mock_symbols();
+ var { MockInterceptor } = require_mock_interceptor();
+ var Symbols = require_symbols();
+ var { InvalidArgumentError } = require_errors();
+ var MockPool = class extends Pool {
+ constructor(origin, opts) {
+ super(origin, opts);
+ if (!opts || !opts.agent || typeof opts.agent.dispatch !== "function") {
+ throw new InvalidArgumentError("Argument opts.agent must implement Agent");
+ }
+ this[kMockAgent] = opts.agent;
+ this[kOrigin] = origin;
+ this[kDispatches] = [];
+ this[kConnected] = 1;
+ this[kOriginalDispatch] = this.dispatch;
+ this[kOriginalClose] = this.close.bind(this);
+ this.dispatch = buildMockDispatch.call(this);
+ this.close = this[kClose];
+ }
+ get [Symbols.kConnected]() {
+ return this[kConnected];
+ }
+ /**
+ * Sets up the base interceptor for mocking replies from undici.
+ */
+ intercept(opts) {
+ return new MockInterceptor(opts, this[kDispatches]);
+ }
+ async [kClose]() {
+ await promisify2(this[kOriginalClose])();
+ this[kConnected] = 0;
+ this[kMockAgent][Symbols.kClients].delete(this[kOrigin]);
+ }
+ };
+ __name(MockPool, "MockPool");
+ module2.exports = MockPool;
+ }
+});
+
+// ../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/mock/pluralizer.js
+var require_pluralizer = __commonJS({
+ "../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/mock/pluralizer.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var singulars = {
+ pronoun: "it",
+ is: "is",
+ was: "was",
+ this: "this"
+ };
+ var plurals = {
+ pronoun: "they",
+ is: "are",
+ was: "were",
+ this: "these"
+ };
+ module2.exports = /* @__PURE__ */ __name(class Pluralizer {
+ constructor(singular, plural) {
+ this.singular = singular;
+ this.plural = plural;
+ }
+ pluralize(count) {
+ const one = count === 1;
+ const keys = one ? singulars : plurals;
+ const noun = one ? this.singular : this.plural;
+ return { ...keys, count, noun };
+ }
+ }, "Pluralizer");
+ }
+});
+
+// ../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/mock/pending-interceptors-formatter.js
+var require_pending_interceptors_formatter = __commonJS({
+ "../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/mock/pending-interceptors-formatter.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var { Transform } = require("stream");
+ var { Console } = require("console");
+ module2.exports = /* @__PURE__ */ __name(class PendingInterceptorsFormatter {
+ constructor({ disableColors } = {}) {
+ this.transform = new Transform({
+ transform(chunk, _enc, cb) {
+ cb(null, chunk);
+ }
+ });
+ this.logger = new Console({
+ stdout: this.transform,
+ inspectOptions: {
+ colors: !disableColors && !process.env.CI
+ }
+ });
+ }
+ format(pendingInterceptors) {
+ const withPrettyHeaders = pendingInterceptors.map(
+ ({ method, path: path45, data: { statusCode }, persist, times, timesInvoked, origin }) => ({
+ Method: method,
+ Origin: origin,
+ Path: path45,
+ "Status code": statusCode,
+ Persistent: persist ? "\u2705" : "\u274C",
+ Invocations: timesInvoked,
+ Remaining: persist ? Infinity : times - timesInvoked
+ })
+ );
+ this.logger.table(withPrettyHeaders);
+ return this.transform.read().toString();
+ }
+ }, "PendingInterceptorsFormatter");
+ }
+});
+
+// ../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/mock/mock-agent.js
+var require_mock_agent = __commonJS({
+ "../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/mock/mock-agent.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var { kClients } = require_symbols();
+ var Agent = require_agent();
+ var {
+ kAgent,
+ kMockAgentSet,
+ kMockAgentGet,
+ kDispatches,
+ kIsMockActive,
+ kNetConnect,
+ kGetNetConnect,
+ kOptions,
+ kFactory
+ } = require_mock_symbols();
+ var MockClient = require_mock_client();
+ var MockPool = require_mock_pool();
+ var { matchValue, buildMockOptions } = require_mock_utils();
+ var { InvalidArgumentError, UndiciError } = require_errors();
+ var Dispatcher = require_dispatcher();
+ var Pluralizer = require_pluralizer();
+ var PendingInterceptorsFormatter = require_pending_interceptors_formatter();
+ var FakeWeakRef = class {
+ constructor(value) {
+ this.value = value;
+ }
+ deref() {
+ return this.value;
+ }
+ };
+ __name(FakeWeakRef, "FakeWeakRef");
+ var MockAgent = class extends Dispatcher {
+ constructor(opts) {
+ super(opts);
+ this[kNetConnect] = true;
+ this[kIsMockActive] = true;
+ if (opts && opts.agent && typeof opts.agent.dispatch !== "function") {
+ throw new InvalidArgumentError("Argument opts.agent must implement Agent");
+ }
+ const agent = opts && opts.agent ? opts.agent : new Agent(opts);
+ this[kAgent] = agent;
+ this[kClients] = agent[kClients];
+ this[kOptions] = buildMockOptions(opts);
+ }
+ get(origin) {
+ let dispatcher = this[kMockAgentGet](origin);
+ if (!dispatcher) {
+ dispatcher = this[kFactory](origin);
+ this[kMockAgentSet](origin, dispatcher);
+ }
+ return dispatcher;
+ }
+ dispatch(opts, handler15) {
+ this.get(opts.origin);
+ return this[kAgent].dispatch(opts, handler15);
+ }
+ async close() {
+ await this[kAgent].close();
+ this[kClients].clear();
+ }
+ deactivate() {
+ this[kIsMockActive] = false;
+ }
+ activate() {
+ this[kIsMockActive] = true;
+ }
+ enableNetConnect(matcher) {
+ if (typeof matcher === "string" || typeof matcher === "function" || matcher instanceof RegExp) {
+ if (Array.isArray(this[kNetConnect])) {
+ this[kNetConnect].push(matcher);
+ } else {
+ this[kNetConnect] = [matcher];
+ }
+ } else if (typeof matcher === "undefined") {
+ this[kNetConnect] = true;
+ } else {
+ throw new InvalidArgumentError("Unsupported matcher. Must be one of String|Function|RegExp.");
+ }
+ }
+ disableNetConnect() {
+ this[kNetConnect] = false;
+ }
+ // This is required to bypass issues caused by using global symbols - see:
+ // https://github.com/nodejs/undici/issues/1447
+ get isMockActive() {
+ return this[kIsMockActive];
+ }
+ [kMockAgentSet](origin, dispatcher) {
+ this[kClients].set(origin, new FakeWeakRef(dispatcher));
+ }
+ [kFactory](origin) {
+ const mockOptions = Object.assign({ agent: this }, this[kOptions]);
+ return this[kOptions] && this[kOptions].connections === 1 ? new MockClient(origin, mockOptions) : new MockPool(origin, mockOptions);
+ }
+ [kMockAgentGet](origin) {
+ const ref = this[kClients].get(origin);
+ if (ref) {
+ return ref.deref();
+ }
+ if (typeof origin !== "string") {
+ const dispatcher = this[kFactory]("http://localhost:9999");
+ this[kMockAgentSet](origin, dispatcher);
+ return dispatcher;
+ }
+ for (const [keyMatcher, nonExplicitRef] of Array.from(this[kClients])) {
+ const nonExplicitDispatcher = nonExplicitRef.deref();
+ if (nonExplicitDispatcher && typeof keyMatcher !== "string" && matchValue(keyMatcher, origin)) {
+ const dispatcher = this[kFactory](origin);
+ this[kMockAgentSet](origin, dispatcher);
+ dispatcher[kDispatches] = nonExplicitDispatcher[kDispatches];
+ return dispatcher;
+ }
+ }
+ }
+ [kGetNetConnect]() {
+ return this[kNetConnect];
+ }
+ pendingInterceptors() {
+ const mockAgentClients = this[kClients];
+ return Array.from(mockAgentClients.entries()).flatMap(([origin, scope]) => scope.deref()[kDispatches].map((dispatch) => ({ ...dispatch, origin }))).filter(({ pending }) => pending);
+ }
+ assertNoPendingInterceptors({ pendingInterceptorsFormatter = new PendingInterceptorsFormatter() } = {}) {
+ const pending = this.pendingInterceptors();
+ if (pending.length === 0) {
+ return;
+ }
+ const pluralizer = new Pluralizer("interceptor", "interceptors").pluralize(pending.length);
+ throw new UndiciError(`
+${pluralizer.count} ${pluralizer.noun} ${pluralizer.is} pending:
+
+${pendingInterceptorsFormatter.format(pending)}
+`.trim());
+ }
+ };
+ __name(MockAgent, "MockAgent");
+ module2.exports = MockAgent;
+ }
+});
+
+// ../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/proxy-agent.js
+var require_proxy_agent = __commonJS({
+ "../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/proxy-agent.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var { kProxy, kClose, kDestroy, kInterceptors } = require_symbols();
+ var { URL: URL4 } = require("url");
+ var Agent = require_agent();
+ var Client = require_client();
+ var DispatcherBase = require_dispatcher_base();
+ var { InvalidArgumentError, RequestAbortedError } = require_errors();
+ var buildConnector = require_connect();
+ var kAgent = Symbol("proxy agent");
+ var kClient = Symbol("proxy client");
+ var kProxyHeaders = Symbol("proxy headers");
+ var kRequestTls = Symbol("request tls settings");
+ var kProxyTls = Symbol("proxy tls settings");
+ var kConnectEndpoint = Symbol("connect endpoint function");
+ function defaultProtocolPort(protocol) {
+ return protocol === "https:" ? 443 : 80;
+ }
+ __name(defaultProtocolPort, "defaultProtocolPort");
+ function buildProxyOptions(opts) {
+ if (typeof opts === "string") {
+ opts = { uri: opts };
+ }
+ if (!opts || !opts.uri) {
+ throw new InvalidArgumentError("Proxy opts.uri is mandatory");
+ }
+ return {
+ uri: opts.uri,
+ protocol: opts.protocol || "https"
+ };
+ }
+ __name(buildProxyOptions, "buildProxyOptions");
+ var ProxyAgent2 = class extends DispatcherBase {
+ constructor(opts) {
+ super(opts);
+ this[kProxy] = buildProxyOptions(opts);
+ this[kAgent] = new Agent(opts);
+ this[kInterceptors] = opts.interceptors && opts.interceptors.ProxyAgent && Array.isArray(opts.interceptors.ProxyAgent) ? opts.interceptors.ProxyAgent : [];
+ if (typeof opts === "string") {
+ opts = { uri: opts };
+ }
+ if (!opts || !opts.uri) {
+ throw new InvalidArgumentError("Proxy opts.uri is mandatory");
+ }
+ this[kRequestTls] = opts.requestTls;
+ this[kProxyTls] = opts.proxyTls;
+ this[kProxyHeaders] = opts.headers || {};
+ if (opts.auth && opts.token) {
+ throw new InvalidArgumentError("opts.auth cannot be used in combination with opts.token");
+ } else if (opts.auth) {
+ this[kProxyHeaders]["proxy-authorization"] = `Basic ${opts.auth}`;
+ } else if (opts.token) {
+ this[kProxyHeaders]["proxy-authorization"] = opts.token;
+ }
+ const resolvedUrl = new URL4(opts.uri);
+ const { origin, port: port2, host } = resolvedUrl;
+ const connect2 = buildConnector({ ...opts.proxyTls });
+ this[kConnectEndpoint] = buildConnector({ ...opts.requestTls });
+ this[kClient] = new Client(resolvedUrl, { connect: connect2 });
+ this[kAgent] = new Agent({
+ ...opts,
+ connect: async (opts2, callback) => {
+ let requestedHost = opts2.host;
+ if (!opts2.port) {
+ requestedHost += `:${defaultProtocolPort(opts2.protocol)}`;
+ }
+ try {
+ const { socket, statusCode } = await this[kClient].connect({
+ origin,
+ port: port2,
+ path: requestedHost,
+ signal: opts2.signal,
+ headers: {
+ ...this[kProxyHeaders],
+ host
+ }
+ });
+ if (statusCode !== 200) {
+ socket.on("error", () => {
+ }).destroy();
+ callback(new RequestAbortedError("Proxy response !== 200 when HTTP Tunneling"));
+ }
+ if (opts2.protocol !== "https:") {
+ callback(null, socket);
+ return;
+ }
+ let servername;
+ if (this[kRequestTls]) {
+ servername = this[kRequestTls].servername;
+ } else {
+ servername = opts2.servername;
+ }
+ this[kConnectEndpoint]({ ...opts2, servername, httpSocket: socket }, callback);
+ } catch (err) {
+ callback(err);
+ }
+ }
+ });
+ }
+ dispatch(opts, handler15) {
+ const { host } = new URL4(opts.origin);
+ const headers = buildHeaders(opts.headers);
+ throwIfProxyAuthIsSent(headers);
+ return this[kAgent].dispatch(
+ {
+ ...opts,
+ headers: {
+ ...headers,
+ host
+ }
+ },
+ handler15
+ );
+ }
+ async [kClose]() {
+ await this[kAgent].close();
+ await this[kClient].close();
+ }
+ async [kDestroy]() {
+ await this[kAgent].destroy();
+ await this[kClient].destroy();
+ }
+ };
+ __name(ProxyAgent2, "ProxyAgent");
+ function buildHeaders(headers) {
+ if (Array.isArray(headers)) {
+ const headersPair = {};
+ for (let i = 0; i < headers.length; i += 2) {
+ headersPair[headers[i]] = headers[i + 1];
+ }
+ return headersPair;
+ }
+ return headers;
+ }
+ __name(buildHeaders, "buildHeaders");
+ function throwIfProxyAuthIsSent(headers) {
+ const existProxyAuth = headers && Object.keys(headers).find((key) => key.toLowerCase() === "proxy-authorization");
+ if (existProxyAuth) {
+ throw new InvalidArgumentError("Proxy-Authorization should be sent in ProxyAgent constructor");
+ }
+ }
+ __name(throwIfProxyAuthIsSent, "throwIfProxyAuthIsSent");
+ module2.exports = ProxyAgent2;
+ }
+});
+
+// ../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/global.js
+var require_global = __commonJS({
+ "../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/global.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var globalDispatcher = Symbol.for("undici.globalDispatcher.1");
+ var { InvalidArgumentError } = require_errors();
+ var Agent = require_agent();
+ if (getGlobalDispatcher() === void 0) {
+ setGlobalDispatcher2(new Agent());
+ }
+ function setGlobalDispatcher2(agent) {
+ if (!agent || typeof agent.dispatch !== "function") {
+ throw new InvalidArgumentError("Argument agent must implement Agent");
+ }
+ Object.defineProperty(globalThis, globalDispatcher, {
+ value: agent,
+ writable: true,
+ enumerable: false,
+ configurable: false
+ });
+ }
+ __name(setGlobalDispatcher2, "setGlobalDispatcher");
+ function getGlobalDispatcher() {
+ return globalThis[globalDispatcher];
+ }
+ __name(getGlobalDispatcher, "getGlobalDispatcher");
+ module2.exports = {
+ setGlobalDispatcher: setGlobalDispatcher2,
+ getGlobalDispatcher
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/handler/DecoratorHandler.js
+var require_DecoratorHandler = __commonJS({
+ "../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/handler/DecoratorHandler.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ module2.exports = /* @__PURE__ */ __name(class DecoratorHandler {
+ constructor(handler15) {
+ this.handler = handler15;
+ }
+ onConnect(...args) {
+ return this.handler.onConnect(...args);
+ }
+ onError(...args) {
+ return this.handler.onError(...args);
+ }
+ onUpgrade(...args) {
+ return this.handler.onUpgrade(...args);
+ }
+ onHeaders(...args) {
+ return this.handler.onHeaders(...args);
+ }
+ onData(...args) {
+ return this.handler.onData(...args);
+ }
+ onComplete(...args) {
+ return this.handler.onComplete(...args);
+ }
+ onBodySent(...args) {
+ return this.handler.onBodySent(...args);
+ }
+ }, "DecoratorHandler");
+ }
+});
+
+// ../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/fetch/headers.js
+var require_headers = __commonJS({
+ "../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/fetch/headers.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var { kHeadersList } = require_symbols();
+ var { kGuard, kHeadersCaseInsensitive } = require_symbols2();
+ var { kEnumerableProperty } = require_util();
+ var {
+ makeIterator,
+ isValidHeaderName,
+ isValidHeaderValue
+ } = require_util2();
+ var { webidl } = require_webidl();
+ var assert18 = require("assert");
+ var kHeadersMap = Symbol("headers map");
+ var kHeadersSortedMap = Symbol("headers map sorted");
+ function headerValueNormalize(potentialValue) {
+ let i = potentialValue.length;
+ while (/[\r\n\t ]/.test(potentialValue.charAt(--i)))
+ ;
+ return potentialValue.slice(0, i + 1).replace(/^[\r\n\t ]+/, "");
+ }
+ __name(headerValueNormalize, "headerValueNormalize");
+ function fill(headers, object) {
+ if (Array.isArray(object)) {
+ for (const header of object) {
+ if (header.length !== 2) {
+ throw webidl.errors.exception({
+ header: "Headers constructor",
+ message: `expected name/value pair to be length 2, found ${header.length}.`
+ });
+ }
+ headers.append(header[0], header[1]);
+ }
+ } else if (typeof object === "object" && object !== null) {
+ for (const [key, value] of Object.entries(object)) {
+ headers.append(key, value);
+ }
+ } else {
+ throw webidl.errors.conversionFailed({
+ prefix: "Headers constructor",
+ argument: "Argument 1",
+ types: ["sequence>", "record"]
+ });
+ }
+ }
+ __name(fill, "fill");
+ var HeadersList = class {
+ /** @type {[string, string][]|null} */
+ cookies = null;
+ constructor(init) {
+ if (init instanceof HeadersList) {
+ this[kHeadersMap] = new Map(init[kHeadersMap]);
+ this[kHeadersSortedMap] = init[kHeadersSortedMap];
+ this.cookies = init.cookies;
+ } else {
+ this[kHeadersMap] = new Map(init);
+ this[kHeadersSortedMap] = null;
+ }
+ }
+ // https://fetch.spec.whatwg.org/#header-list-contains
+ contains(name) {
+ name = name.toLowerCase();
+ return this[kHeadersMap].has(name);
+ }
+ clear() {
+ this[kHeadersMap].clear();
+ this[kHeadersSortedMap] = null;
+ }
+ // https://fetch.spec.whatwg.org/#concept-header-list-append
+ append(name, value) {
+ this[kHeadersSortedMap] = null;
+ const lowercaseName = name.toLowerCase();
+ const exists = this[kHeadersMap].get(lowercaseName);
+ if (exists) {
+ const delimiter = lowercaseName === "cookie" ? "; " : ", ";
+ this[kHeadersMap].set(lowercaseName, {
+ name: exists.name,
+ value: `${exists.value}${delimiter}${value}`
+ });
+ } else {
+ this[kHeadersMap].set(lowercaseName, { name, value });
+ }
+ if (lowercaseName === "set-cookie") {
+ this.cookies ??= [];
+ this.cookies.push(value);
+ }
+ }
+ // https://fetch.spec.whatwg.org/#concept-header-list-set
+ set(name, value) {
+ this[kHeadersSortedMap] = null;
+ const lowercaseName = name.toLowerCase();
+ if (lowercaseName === "set-cookie") {
+ this.cookies = [value];
+ }
+ return this[kHeadersMap].set(lowercaseName, { name, value });
+ }
+ // https://fetch.spec.whatwg.org/#concept-header-list-delete
+ delete(name) {
+ this[kHeadersSortedMap] = null;
+ name = name.toLowerCase();
+ if (name === "set-cookie") {
+ this.cookies = null;
+ }
+ return this[kHeadersMap].delete(name);
+ }
+ // https://fetch.spec.whatwg.org/#concept-header-list-get
+ get(name) {
+ if (!this.contains(name)) {
+ return null;
+ }
+ return this[kHeadersMap].get(name.toLowerCase())?.value ?? null;
+ }
+ *[Symbol.iterator]() {
+ for (const [name, { value }] of this[kHeadersMap]) {
+ yield [name, value];
+ }
+ }
+ get [kHeadersCaseInsensitive]() {
+ const flatList = [];
+ for (const { name, value } of this[kHeadersMap].values()) {
+ flatList.push(name, value);
+ }
+ return flatList;
+ }
+ };
+ __name(HeadersList, "HeadersList");
+ var Headers3 = class {
+ constructor(init = void 0) {
+ this[kHeadersList] = new HeadersList();
+ this[kGuard] = "none";
+ if (init !== void 0) {
+ init = webidl.converters.HeadersInit(init);
+ fill(this, init);
+ }
+ }
+ // https://fetch.spec.whatwg.org/#dom-headers-append
+ append(name, value) {
+ webidl.brandCheck(this, Headers3);
+ webidl.argumentLengthCheck(arguments, 2, { header: "Headers.append" });
+ name = webidl.converters.ByteString(name);
+ value = webidl.converters.ByteString(value);
+ value = headerValueNormalize(value);
+ if (!isValidHeaderName(name)) {
+ throw webidl.errors.invalidArgument({
+ prefix: "Headers.append",
+ value: name,
+ type: "header name"
+ });
+ } else if (!isValidHeaderValue(value)) {
+ throw webidl.errors.invalidArgument({
+ prefix: "Headers.append",
+ value,
+ type: "header value"
+ });
+ }
+ if (this[kGuard] === "immutable") {
+ throw new TypeError("immutable");
+ } else if (this[kGuard] === "request-no-cors") {
+ }
+ return this[kHeadersList].append(name, value);
+ }
+ // https://fetch.spec.whatwg.org/#dom-headers-delete
+ delete(name) {
+ webidl.brandCheck(this, Headers3);
+ webidl.argumentLengthCheck(arguments, 1, { header: "Headers.delete" });
+ name = webidl.converters.ByteString(name);
+ if (!isValidHeaderName(name)) {
+ throw webidl.errors.invalidArgument({
+ prefix: "Headers.delete",
+ value: name,
+ type: "header name"
+ });
+ }
+ if (this[kGuard] === "immutable") {
+ throw new TypeError("immutable");
+ } else if (this[kGuard] === "request-no-cors") {
+ }
+ if (!this[kHeadersList].contains(name)) {
+ return;
+ }
+ return this[kHeadersList].delete(name);
+ }
+ // https://fetch.spec.whatwg.org/#dom-headers-get
+ get(name) {
+ webidl.brandCheck(this, Headers3);
+ webidl.argumentLengthCheck(arguments, 1, { header: "Headers.get" });
+ name = webidl.converters.ByteString(name);
+ if (!isValidHeaderName(name)) {
+ throw webidl.errors.invalidArgument({
+ prefix: "Headers.get",
+ value: name,
+ type: "header name"
+ });
+ }
+ return this[kHeadersList].get(name);
+ }
+ // https://fetch.spec.whatwg.org/#dom-headers-has
+ has(name) {
+ webidl.brandCheck(this, Headers3);
+ webidl.argumentLengthCheck(arguments, 1, { header: "Headers.has" });
+ name = webidl.converters.ByteString(name);
+ if (!isValidHeaderName(name)) {
+ throw webidl.errors.invalidArgument({
+ prefix: "Headers.has",
+ value: name,
+ type: "header name"
+ });
+ }
+ return this[kHeadersList].contains(name);
+ }
+ // https://fetch.spec.whatwg.org/#dom-headers-set
+ set(name, value) {
+ webidl.brandCheck(this, Headers3);
+ webidl.argumentLengthCheck(arguments, 2, { header: "Headers.set" });
+ name = webidl.converters.ByteString(name);
+ value = webidl.converters.ByteString(value);
+ value = headerValueNormalize(value);
+ if (!isValidHeaderName(name)) {
+ throw webidl.errors.invalidArgument({
+ prefix: "Headers.set",
+ value: name,
+ type: "header name"
+ });
+ } else if (!isValidHeaderValue(value)) {
+ throw webidl.errors.invalidArgument({
+ prefix: "Headers.set",
+ value,
+ type: "header value"
+ });
+ }
+ if (this[kGuard] === "immutable") {
+ throw new TypeError("immutable");
+ } else if (this[kGuard] === "request-no-cors") {
+ }
+ return this[kHeadersList].set(name, value);
+ }
+ // https://fetch.spec.whatwg.org/#dom-headers-getsetcookie
+ getSetCookie() {
+ webidl.brandCheck(this, Headers3);
+ const list = this[kHeadersList].cookies;
+ if (list) {
+ return [...list];
+ }
+ return [];
+ }
+ // https://fetch.spec.whatwg.org/#concept-header-list-sort-and-combine
+ get [kHeadersSortedMap]() {
+ if (this[kHeadersList][kHeadersSortedMap]) {
+ return this[kHeadersList][kHeadersSortedMap];
+ }
+ const headers = [];
+ const names = [...this[kHeadersList]].sort((a, b) => a[0] < b[0] ? -1 : 1);
+ const cookies = this[kHeadersList].cookies;
+ for (const [name, value] of names) {
+ if (name === "set-cookie") {
+ for (const value2 of cookies) {
+ headers.push([name, value2]);
+ }
+ } else {
+ assert18(value !== null);
+ headers.push([name, value]);
+ }
+ }
+ this[kHeadersList][kHeadersSortedMap] = headers;
+ return headers;
+ }
+ keys() {
+ webidl.brandCheck(this, Headers3);
+ return makeIterator(
+ () => [...this[kHeadersSortedMap].values()],
+ "Headers",
+ "key"
+ );
+ }
+ values() {
+ webidl.brandCheck(this, Headers3);
+ return makeIterator(
+ () => [...this[kHeadersSortedMap].values()],
+ "Headers",
+ "value"
+ );
+ }
+ entries() {
+ webidl.brandCheck(this, Headers3);
+ return makeIterator(
+ () => [...this[kHeadersSortedMap].values()],
+ "Headers",
+ "key+value"
+ );
+ }
+ /**
+ * @param {(value: string, key: string, self: Headers) => void} callbackFn
+ * @param {unknown} thisArg
+ */
+ forEach(callbackFn, thisArg = globalThis) {
+ webidl.brandCheck(this, Headers3);
+ webidl.argumentLengthCheck(arguments, 1, { header: "Headers.forEach" });
+ if (typeof callbackFn !== "function") {
+ throw new TypeError(
+ "Failed to execute 'forEach' on 'Headers': parameter 1 is not of type 'Function'."
+ );
+ }
+ for (const [key, value] of this) {
+ callbackFn.apply(thisArg, [value, key, this]);
+ }
+ }
+ [Symbol.for("nodejs.util.inspect.custom")]() {
+ webidl.brandCheck(this, Headers3);
+ return this[kHeadersList];
+ }
+ };
+ __name(Headers3, "Headers");
+ Headers3.prototype[Symbol.iterator] = Headers3.prototype.entries;
+ Object.defineProperties(Headers3.prototype, {
+ append: kEnumerableProperty,
+ delete: kEnumerableProperty,
+ get: kEnumerableProperty,
+ has: kEnumerableProperty,
+ set: kEnumerableProperty,
+ keys: kEnumerableProperty,
+ values: kEnumerableProperty,
+ entries: kEnumerableProperty,
+ forEach: kEnumerableProperty,
+ [Symbol.iterator]: { enumerable: false },
+ [Symbol.toStringTag]: {
+ value: "Headers",
+ configurable: true
+ }
+ });
+ webidl.converters.HeadersInit = function(V) {
+ if (webidl.util.Type(V) === "Object") {
+ if (V[Symbol.iterator]) {
+ return webidl.converters["sequence>"](V);
+ }
+ return webidl.converters["record"](V);
+ }
+ throw webidl.errors.conversionFailed({
+ prefix: "Headers constructor",
+ argument: "Argument 1",
+ types: ["sequence>", "record"]
+ });
+ };
+ module2.exports = {
+ fill,
+ Headers: Headers3,
+ HeadersList
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/fetch/global.js
+var require_global2 = __commonJS({
+ "../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/fetch/global.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var globalOrigin = Symbol.for("undici.globalOrigin.1");
+ function getGlobalOrigin() {
+ return globalThis[globalOrigin];
+ }
+ __name(getGlobalOrigin, "getGlobalOrigin");
+ function setGlobalOrigin(newOrigin) {
+ if (newOrigin !== void 0 && typeof newOrigin !== "string" && !(newOrigin instanceof URL)) {
+ throw new Error("Invalid base url");
+ }
+ if (newOrigin === void 0) {
+ Object.defineProperty(globalThis, globalOrigin, {
+ value: void 0,
+ writable: true,
+ enumerable: false,
+ configurable: false
+ });
+ return;
+ }
+ const parsedURL = new URL(newOrigin);
+ if (parsedURL.protocol !== "http:" && parsedURL.protocol !== "https:") {
+ throw new TypeError(`Only http & https urls are allowed, received ${parsedURL.protocol}`);
+ }
+ Object.defineProperty(globalThis, globalOrigin, {
+ value: parsedURL,
+ writable: true,
+ enumerable: false,
+ configurable: false
+ });
+ }
+ __name(setGlobalOrigin, "setGlobalOrigin");
+ module2.exports = {
+ getGlobalOrigin,
+ setGlobalOrigin
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/fetch/response.js
+var require_response = __commonJS({
+ "../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/fetch/response.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var { Headers: Headers3, HeadersList, fill } = require_headers();
+ var { extractBody, cloneBody, mixinBody } = require_body();
+ var util3 = require_util();
+ var { kEnumerableProperty } = util3;
+ var {
+ isValidReasonPhrase,
+ isCancelled,
+ isAborted,
+ isBlobLike,
+ serializeJavascriptValueToJSONString,
+ isErrorLike,
+ isomorphicEncode
+ } = require_util2();
+ var {
+ redirectStatus,
+ nullBodyStatus,
+ DOMException
+ } = require_constants();
+ var { kState, kHeaders, kGuard, kRealm } = require_symbols2();
+ var { webidl } = require_webidl();
+ var { FormData: FormData6 } = require_formdata();
+ var { getGlobalOrigin } = require_global2();
+ var { URLSerializer } = require_dataURL();
+ var { kHeadersList } = require_symbols();
+ var assert18 = require("assert");
+ var { types } = require("util");
+ var ReadableStream2 = globalThis.ReadableStream || require("stream/web").ReadableStream;
+ var Response5 = class {
+ // Creates network error Response.
+ static error() {
+ const relevantRealm = { settingsObject: {} };
+ const responseObject = new Response5();
+ responseObject[kState] = makeNetworkError();
+ responseObject[kRealm] = relevantRealm;
+ responseObject[kHeaders][kHeadersList] = responseObject[kState].headersList;
+ responseObject[kHeaders][kGuard] = "immutable";
+ responseObject[kHeaders][kRealm] = relevantRealm;
+ return responseObject;
+ }
+ // https://fetch.spec.whatwg.org/#dom-response-json
+ static json(data = void 0, init = {}) {
+ webidl.argumentLengthCheck(arguments, 1, { header: "Response.json" });
+ if (init !== null) {
+ init = webidl.converters.ResponseInit(init);
+ }
+ const bytes = new TextEncoder("utf-8").encode(
+ serializeJavascriptValueToJSONString(data)
+ );
+ const body = extractBody(bytes);
+ const relevantRealm = { settingsObject: {} };
+ const responseObject = new Response5();
+ responseObject[kRealm] = relevantRealm;
+ responseObject[kHeaders][kGuard] = "response";
+ responseObject[kHeaders][kRealm] = relevantRealm;
+ initializeResponse(responseObject, init, { body: body[0], type: "application/json" });
+ return responseObject;
+ }
+ // Creates a redirect Response that redirects to url with status status.
+ static redirect(url3, status = 302) {
+ const relevantRealm = { settingsObject: {} };
+ webidl.argumentLengthCheck(arguments, 1, { header: "Response.redirect" });
+ url3 = webidl.converters.USVString(url3);
+ status = webidl.converters["unsigned short"](status);
+ let parsedURL;
+ try {
+ parsedURL = new URL(url3, getGlobalOrigin());
+ } catch (err) {
+ throw Object.assign(new TypeError("Failed to parse URL from " + url3), {
+ cause: err
+ });
+ }
+ if (!redirectStatus.includes(status)) {
+ throw new RangeError("Invalid status code " + status);
+ }
+ const responseObject = new Response5();
+ responseObject[kRealm] = relevantRealm;
+ responseObject[kHeaders][kGuard] = "immutable";
+ responseObject[kHeaders][kRealm] = relevantRealm;
+ responseObject[kState].status = status;
+ const value = isomorphicEncode(URLSerializer(parsedURL));
+ responseObject[kState].headersList.append("location", value);
+ return responseObject;
+ }
+ // https://fetch.spec.whatwg.org/#dom-response
+ constructor(body = null, init = {}) {
+ if (body !== null) {
+ body = webidl.converters.BodyInit(body);
+ }
+ init = webidl.converters.ResponseInit(init);
+ this[kRealm] = { settingsObject: {} };
+ this[kState] = makeResponse({});
+ this[kHeaders] = new Headers3();
+ this[kHeaders][kGuard] = "response";
+ this[kHeaders][kHeadersList] = this[kState].headersList;
+ this[kHeaders][kRealm] = this[kRealm];
+ let bodyWithType = null;
+ if (body != null) {
+ const [extractedBody, type] = extractBody(body);
+ bodyWithType = { body: extractedBody, type };
+ }
+ initializeResponse(this, init, bodyWithType);
+ }
+ // Returns response’s type, e.g., "cors".
+ get type() {
+ webidl.brandCheck(this, Response5);
+ return this[kState].type;
+ }
+ // Returns response’s URL, if it has one; otherwise the empty string.
+ get url() {
+ webidl.brandCheck(this, Response5);
+ const urlList = this[kState].urlList;
+ const url3 = urlList[urlList.length - 1] ?? null;
+ if (url3 === null) {
+ return "";
+ }
+ return URLSerializer(url3, true);
+ }
+ // Returns whether response was obtained through a redirect.
+ get redirected() {
+ webidl.brandCheck(this, Response5);
+ return this[kState].urlList.length > 1;
+ }
+ // Returns response’s status.
+ get status() {
+ webidl.brandCheck(this, Response5);
+ return this[kState].status;
+ }
+ // Returns whether response’s status is an ok status.
+ get ok() {
+ webidl.brandCheck(this, Response5);
+ return this[kState].status >= 200 && this[kState].status <= 299;
+ }
+ // Returns response’s status message.
+ get statusText() {
+ webidl.brandCheck(this, Response5);
+ return this[kState].statusText;
+ }
+ // Returns response’s headers as Headers.
+ get headers() {
+ webidl.brandCheck(this, Response5);
+ return this[kHeaders];
+ }
+ get body() {
+ webidl.brandCheck(this, Response5);
+ return this[kState].body ? this[kState].body.stream : null;
+ }
+ get bodyUsed() {
+ webidl.brandCheck(this, Response5);
+ return !!this[kState].body && util3.isDisturbed(this[kState].body.stream);
+ }
+ // Returns a clone of response.
+ clone() {
+ webidl.brandCheck(this, Response5);
+ if (this.bodyUsed || this.body && this.body.locked) {
+ throw webidl.errors.exception({
+ header: "Response.clone",
+ message: "Body has already been consumed."
+ });
+ }
+ const clonedResponse = cloneResponse(this[kState]);
+ const clonedResponseObject = new Response5();
+ clonedResponseObject[kState] = clonedResponse;
+ clonedResponseObject[kRealm] = this[kRealm];
+ clonedResponseObject[kHeaders][kHeadersList] = clonedResponse.headersList;
+ clonedResponseObject[kHeaders][kGuard] = this[kHeaders][kGuard];
+ clonedResponseObject[kHeaders][kRealm] = this[kHeaders][kRealm];
+ return clonedResponseObject;
+ }
+ };
+ __name(Response5, "Response");
+ mixinBody(Response5);
+ Object.defineProperties(Response5.prototype, {
+ type: kEnumerableProperty,
+ url: kEnumerableProperty,
+ status: kEnumerableProperty,
+ ok: kEnumerableProperty,
+ redirected: kEnumerableProperty,
+ statusText: kEnumerableProperty,
+ headers: kEnumerableProperty,
+ clone: kEnumerableProperty,
+ body: kEnumerableProperty,
+ bodyUsed: kEnumerableProperty,
+ [Symbol.toStringTag]: {
+ value: "Response",
+ configurable: true
+ }
+ });
+ Object.defineProperties(Response5, {
+ json: kEnumerableProperty,
+ redirect: kEnumerableProperty,
+ error: kEnumerableProperty
+ });
+ function cloneResponse(response) {
+ if (response.internalResponse) {
+ return filterResponse(
+ cloneResponse(response.internalResponse),
+ response.type
+ );
+ }
+ const newResponse = makeResponse({ ...response, body: null });
+ if (response.body != null) {
+ newResponse.body = cloneBody(response.body);
+ }
+ return newResponse;
+ }
+ __name(cloneResponse, "cloneResponse");
+ function makeResponse(init) {
+ return {
+ aborted: false,
+ rangeRequested: false,
+ timingAllowPassed: false,
+ requestIncludesCredentials: false,
+ type: "default",
+ status: 200,
+ timingInfo: null,
+ cacheState: "",
+ statusText: "",
+ ...init,
+ headersList: init.headersList ? new HeadersList(init.headersList) : new HeadersList(),
+ urlList: init.urlList ? [...init.urlList] : []
+ };
+ }
+ __name(makeResponse, "makeResponse");
+ function makeNetworkError(reason) {
+ const isError = isErrorLike(reason);
+ return makeResponse({
+ type: "error",
+ status: 0,
+ error: isError ? reason : new Error(reason ? String(reason) : reason, {
+ cause: isError ? reason : void 0
+ }),
+ aborted: reason && reason.name === "AbortError"
+ });
+ }
+ __name(makeNetworkError, "makeNetworkError");
+ function makeFilteredResponse(response, state) {
+ state = {
+ internalResponse: response,
+ ...state
+ };
+ return new Proxy(response, {
+ get(target, p) {
+ return p in state ? state[p] : target[p];
+ },
+ set(target, p, value) {
+ assert18(!(p in state));
+ target[p] = value;
+ return true;
+ }
+ });
+ }
+ __name(makeFilteredResponse, "makeFilteredResponse");
+ function filterResponse(response, type) {
+ if (type === "basic") {
+ return makeFilteredResponse(response, {
+ type: "basic",
+ headersList: response.headersList
+ });
+ } else if (type === "cors") {
+ return makeFilteredResponse(response, {
+ type: "cors",
+ headersList: response.headersList
+ });
+ } else if (type === "opaque") {
+ return makeFilteredResponse(response, {
+ type: "opaque",
+ urlList: Object.freeze([]),
+ status: 0,
+ statusText: "",
+ body: null
+ });
+ } else if (type === "opaqueredirect") {
+ return makeFilteredResponse(response, {
+ type: "opaqueredirect",
+ status: 0,
+ statusText: "",
+ headersList: [],
+ body: null
+ });
+ } else {
+ assert18(false);
+ }
+ }
+ __name(filterResponse, "filterResponse");
+ function makeAppropriateNetworkError(fetchParams) {
+ assert18(isCancelled(fetchParams));
+ return isAborted(fetchParams) ? makeNetworkError(new DOMException("The operation was aborted.", "AbortError")) : makeNetworkError("Request was cancelled.");
+ }
+ __name(makeAppropriateNetworkError, "makeAppropriateNetworkError");
+ function initializeResponse(response, init, body) {
+ if (init.status !== null && (init.status < 200 || init.status > 599)) {
+ throw new RangeError('init["status"] must be in the range of 200 to 599, inclusive.');
+ }
+ if ("statusText" in init && init.statusText != null) {
+ if (!isValidReasonPhrase(String(init.statusText))) {
+ throw new TypeError("Invalid statusText");
+ }
+ }
+ if ("status" in init && init.status != null) {
+ response[kState].status = init.status;
+ }
+ if ("statusText" in init && init.statusText != null) {
+ response[kState].statusText = init.statusText;
+ }
+ if ("headers" in init && init.headers != null) {
+ fill(response[kState].headersList, init.headers);
+ }
+ if (body) {
+ if (nullBodyStatus.includes(response.status)) {
+ throw webidl.errors.exception({
+ header: "Response constructor",
+ message: "Invalid response status code " + response.status
+ });
+ }
+ response[kState].body = body.body;
+ if (body.type != null && !response[kState].headersList.contains("Content-Type")) {
+ response[kState].headersList.append("content-type", body.type);
+ }
+ }
+ }
+ __name(initializeResponse, "initializeResponse");
+ webidl.converters.ReadableStream = webidl.interfaceConverter(
+ ReadableStream2
+ );
+ webidl.converters.FormData = webidl.interfaceConverter(
+ FormData6
+ );
+ webidl.converters.URLSearchParams = webidl.interfaceConverter(
+ URLSearchParams
+ );
+ webidl.converters.XMLHttpRequestBodyInit = function(V) {
+ if (typeof V === "string") {
+ return webidl.converters.USVString(V);
+ }
+ if (isBlobLike(V)) {
+ return webidl.converters.Blob(V, { strict: false });
+ }
+ if (types.isAnyArrayBuffer(V) || types.isTypedArray(V) || types.isDataView(V)) {
+ return webidl.converters.BufferSource(V);
+ }
+ if (util3.isFormDataLike(V)) {
+ return webidl.converters.FormData(V, { strict: false });
+ }
+ if (V instanceof URLSearchParams) {
+ return webidl.converters.URLSearchParams(V);
+ }
+ return webidl.converters.DOMString(V);
+ };
+ webidl.converters.BodyInit = function(V) {
+ if (V instanceof ReadableStream2) {
+ return webidl.converters.ReadableStream(V);
+ }
+ if (V?.[Symbol.asyncIterator]) {
+ return V;
+ }
+ return webidl.converters.XMLHttpRequestBodyInit(V);
+ };
+ webidl.converters.ResponseInit = webidl.dictionaryConverter([
+ {
+ key: "status",
+ converter: webidl.converters["unsigned short"],
+ defaultValue: 200
+ },
+ {
+ key: "statusText",
+ converter: webidl.converters.ByteString,
+ defaultValue: ""
+ },
+ {
+ key: "headers",
+ converter: webidl.converters.HeadersInit
+ }
+ ]);
+ module2.exports = {
+ makeNetworkError,
+ makeResponse,
+ makeAppropriateNetworkError,
+ filterResponse,
+ Response: Response5
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/fetch/request.js
+var require_request2 = __commonJS({
+ "../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/fetch/request.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var { extractBody, mixinBody, cloneBody } = require_body();
+ var { Headers: Headers3, fill: fillHeaders, HeadersList } = require_headers();
+ var { FinalizationRegistry: FinalizationRegistry2 } = require_dispatcher_weakref()();
+ var util3 = require_util();
+ var {
+ isValidHTTPToken,
+ sameOrigin,
+ normalizeMethod
+ } = require_util2();
+ var {
+ forbiddenMethods,
+ corsSafeListedMethods,
+ referrerPolicy,
+ requestRedirect,
+ requestMode,
+ requestCredentials,
+ requestCache,
+ requestDuplex
+ } = require_constants();
+ var { kEnumerableProperty } = util3;
+ var { kHeaders, kSignal, kState, kGuard, kRealm } = require_symbols2();
+ var { webidl } = require_webidl();
+ var { getGlobalOrigin } = require_global2();
+ var { URLSerializer } = require_dataURL();
+ var { kHeadersList } = require_symbols();
+ var assert18 = require("assert");
+ var { setMaxListeners, getEventListeners, defaultMaxListeners } = require("events");
+ var TransformStream = globalThis.TransformStream;
+ var kInit = Symbol("init");
+ var requestFinalizer = new FinalizationRegistry2(({ signal, abort }) => {
+ signal.removeEventListener("abort", abort);
+ });
+ var Request3 = class {
+ // https://fetch.spec.whatwg.org/#dom-request
+ constructor(input, init = {}) {
+ if (input === kInit) {
+ return;
+ }
+ webidl.argumentLengthCheck(arguments, 1, { header: "Request constructor" });
+ input = webidl.converters.RequestInfo(input);
+ init = webidl.converters.RequestInit(init);
+ this[kRealm] = {
+ settingsObject: {
+ baseUrl: getGlobalOrigin()
+ }
+ };
+ let request = null;
+ let fallbackMode = null;
+ const baseUrl = this[kRealm].settingsObject.baseUrl;
+ let signal = null;
+ if (typeof input === "string") {
+ let parsedURL;
+ try {
+ parsedURL = new URL(input, baseUrl);
+ } catch (err) {
+ throw new TypeError("Failed to parse URL from " + input, { cause: err });
+ }
+ if (parsedURL.username || parsedURL.password) {
+ throw new TypeError(
+ "Request cannot be constructed from a URL that includes credentials: " + input
+ );
+ }
+ request = makeRequest({ urlList: [parsedURL] });
+ fallbackMode = "cors";
+ } else {
+ assert18(input instanceof Request3);
+ request = input[kState];
+ signal = input[kSignal];
+ }
+ const origin = this[kRealm].settingsObject.origin;
+ let window2 = "client";
+ if (request.window?.constructor?.name === "EnvironmentSettingsObject" && sameOrigin(request.window, origin)) {
+ window2 = request.window;
+ }
+ if (init.window !== void 0 && init.window != null) {
+ throw new TypeError(`'window' option '${window2}' must be null`);
+ }
+ if (init.window !== void 0) {
+ window2 = "no-window";
+ }
+ request = makeRequest({
+ // URL request’s URL.
+ // undici implementation note: this is set as the first item in request's urlList in makeRequest
+ // method request’s method.
+ method: request.method,
+ // header list A copy of request’s header list.
+ // undici implementation note: headersList is cloned in makeRequest
+ headersList: request.headersList,
+ // unsafe-request flag Set.
+ unsafeRequest: request.unsafeRequest,
+ // client This’s relevant settings object.
+ client: this[kRealm].settingsObject,
+ // window window.
+ window: window2,
+ // priority request’s priority.
+ priority: request.priority,
+ // origin request’s origin. The propagation of the origin is only significant for navigation requests
+ // being handled by a service worker. In this scenario a request can have an origin that is different
+ // from the current client.
+ origin: request.origin,
+ // referrer request’s referrer.
+ referrer: request.referrer,
+ // referrer policy request’s referrer policy.
+ referrerPolicy: request.referrerPolicy,
+ // mode request’s mode.
+ mode: request.mode,
+ // credentials mode request’s credentials mode.
+ credentials: request.credentials,
+ // cache mode request’s cache mode.
+ cache: request.cache,
+ // redirect mode request’s redirect mode.
+ redirect: request.redirect,
+ // integrity metadata request’s integrity metadata.
+ integrity: request.integrity,
+ // keepalive request’s keepalive.
+ keepalive: request.keepalive,
+ // reload-navigation flag request’s reload-navigation flag.
+ reloadNavigation: request.reloadNavigation,
+ // history-navigation flag request’s history-navigation flag.
+ historyNavigation: request.historyNavigation,
+ // URL list A clone of request’s URL list.
+ urlList: [...request.urlList]
+ });
+ if (Object.keys(init).length > 0) {
+ if (request.mode === "navigate") {
+ request.mode = "same-origin";
+ }
+ request.reloadNavigation = false;
+ request.historyNavigation = false;
+ request.origin = "client";
+ request.referrer = "client";
+ request.referrerPolicy = "";
+ request.url = request.urlList[request.urlList.length - 1];
+ request.urlList = [request.url];
+ }
+ if (init.referrer !== void 0) {
+ const referrer = init.referrer;
+ if (referrer === "") {
+ request.referrer = "no-referrer";
+ } else {
+ let parsedReferrer;
+ try {
+ parsedReferrer = new URL(referrer, baseUrl);
+ } catch (err) {
+ throw new TypeError(`Referrer "${referrer}" is not a valid URL.`, { cause: err });
+ }
+ request.referrer = parsedReferrer;
+ }
+ }
+ if (init.referrerPolicy !== void 0) {
+ request.referrerPolicy = init.referrerPolicy;
+ }
+ let mode;
+ if (init.mode !== void 0) {
+ mode = init.mode;
+ } else {
+ mode = fallbackMode;
+ }
+ if (mode === "navigate") {
+ throw webidl.errors.exception({
+ header: "Request constructor",
+ message: "invalid request mode navigate."
+ });
+ }
+ if (mode != null) {
+ request.mode = mode;
+ }
+ if (init.credentials !== void 0) {
+ request.credentials = init.credentials;
+ }
+ if (init.cache !== void 0) {
+ request.cache = init.cache;
+ }
+ if (request.cache === "only-if-cached" && request.mode !== "same-origin") {
+ throw new TypeError(
+ "'only-if-cached' can be set only with 'same-origin' mode"
+ );
+ }
+ if (init.redirect !== void 0) {
+ request.redirect = init.redirect;
+ }
+ if (init.integrity !== void 0 && init.integrity != null) {
+ request.integrity = String(init.integrity);
+ }
+ if (init.keepalive !== void 0) {
+ request.keepalive = Boolean(init.keepalive);
+ }
+ if (init.method !== void 0) {
+ let method = init.method;
+ if (!isValidHTTPToken(init.method)) {
+ throw TypeError(`'${init.method}' is not a valid HTTP method.`);
+ }
+ if (forbiddenMethods.indexOf(method.toUpperCase()) !== -1) {
+ throw TypeError(`'${init.method}' HTTP method is unsupported.`);
+ }
+ method = normalizeMethod(init.method);
+ request.method = method;
+ }
+ if (init.signal !== void 0) {
+ signal = init.signal;
+ }
+ this[kState] = request;
+ const ac = new AbortController();
+ this[kSignal] = ac.signal;
+ this[kSignal][kRealm] = this[kRealm];
+ if (signal != null) {
+ if (!signal || typeof signal.aborted !== "boolean" || typeof signal.addEventListener !== "function") {
+ throw new TypeError(
+ "Failed to construct 'Request': member signal is not of type AbortSignal."
+ );
+ }
+ if (signal.aborted) {
+ ac.abort(signal.reason);
+ } else {
+ const acRef = new WeakRef(ac);
+ const abort = /* @__PURE__ */ __name(function() {
+ acRef.deref()?.abort(this.reason);
+ }, "abort");
+ if (getEventListeners(signal, "abort").length >= defaultMaxListeners) {
+ setMaxListeners(100, signal);
+ }
+ signal.addEventListener("abort", abort, { once: true });
+ requestFinalizer.register(this, { signal, abort });
+ }
+ }
+ this[kHeaders] = new Headers3();
+ this[kHeaders][kHeadersList] = request.headersList;
+ this[kHeaders][kGuard] = "request";
+ this[kHeaders][kRealm] = this[kRealm];
+ if (mode === "no-cors") {
+ if (!corsSafeListedMethods.includes(request.method)) {
+ throw new TypeError(
+ `'${request.method} is unsupported in no-cors mode.`
+ );
+ }
+ this[kHeaders][kGuard] = "request-no-cors";
+ }
+ if (Object.keys(init).length !== 0) {
+ let headers = new Headers3(this[kHeaders]);
+ if (init.headers !== void 0) {
+ headers = init.headers;
+ }
+ this[kHeaders][kHeadersList].clear();
+ if (headers.constructor.name === "Headers") {
+ for (const [key, val] of headers) {
+ this[kHeaders].append(key, val);
+ }
+ } else {
+ fillHeaders(this[kHeaders], headers);
+ }
+ }
+ const inputBody = input instanceof Request3 ? input[kState].body : null;
+ if ((init.body !== void 0 && init.body != null || inputBody != null) && (request.method === "GET" || request.method === "HEAD")) {
+ throw new TypeError("Request with GET/HEAD method cannot have body.");
+ }
+ let initBody = null;
+ if (init.body !== void 0 && init.body != null) {
+ const [extractedBody, contentType] = extractBody(
+ init.body,
+ request.keepalive
+ );
+ initBody = extractedBody;
+ if (contentType && !this[kHeaders][kHeadersList].contains("content-type")) {
+ this[kHeaders].append("content-type", contentType);
+ }
+ }
+ const inputOrInitBody = initBody ?? inputBody;
+ if (inputOrInitBody != null && inputOrInitBody.source == null) {
+ if (initBody != null && init.duplex == null) {
+ throw new TypeError("RequestInit: duplex option is required when sending a body.");
+ }
+ if (request.mode !== "same-origin" && request.mode !== "cors") {
+ throw new TypeError(
+ 'If request is made from ReadableStream, mode should be "same-origin" or "cors"'
+ );
+ }
+ request.useCORSPreflightFlag = true;
+ }
+ let finalBody = inputOrInitBody;
+ if (initBody == null && inputBody != null) {
+ if (util3.isDisturbed(inputBody.stream) || inputBody.stream.locked) {
+ throw new TypeError(
+ "Cannot construct a Request with a Request object that has already been used."
+ );
+ }
+ if (!TransformStream) {
+ TransformStream = require("stream/web").TransformStream;
+ }
+ const identityTransform = new TransformStream();
+ inputBody.stream.pipeThrough(identityTransform);
+ finalBody = {
+ source: inputBody.source,
+ length: inputBody.length,
+ stream: identityTransform.readable
+ };
+ }
+ this[kState].body = finalBody;
+ }
+ // Returns request’s HTTP method, which is "GET" by default.
+ get method() {
+ webidl.brandCheck(this, Request3);
+ return this[kState].method;
+ }
+ // Returns the URL of request as a string.
+ get url() {
+ webidl.brandCheck(this, Request3);
+ return URLSerializer(this[kState].url);
+ }
+ // Returns a Headers object consisting of the headers associated with request.
+ // Note that headers added in the network layer by the user agent will not
+ // be accounted for in this object, e.g., the "Host" header.
+ get headers() {
+ webidl.brandCheck(this, Request3);
+ return this[kHeaders];
+ }
+ // Returns the kind of resource requested by request, e.g., "document"
+ // or "script".
+ get destination() {
+ webidl.brandCheck(this, Request3);
+ return this[kState].destination;
+ }
+ // Returns the referrer of request. Its value can be a same-origin URL if
+ // explicitly set in init, the empty string to indicate no referrer, and
+ // "about:client" when defaulting to the global’s default. This is used
+ // during fetching to determine the value of the `Referer` header of the
+ // request being made.
+ get referrer() {
+ webidl.brandCheck(this, Request3);
+ if (this[kState].referrer === "no-referrer") {
+ return "";
+ }
+ if (this[kState].referrer === "client") {
+ return "about:client";
+ }
+ return this[kState].referrer.toString();
+ }
+ // Returns the referrer policy associated with request.
+ // This is used during fetching to compute the value of the request’s
+ // referrer.
+ get referrerPolicy() {
+ webidl.brandCheck(this, Request3);
+ return this[kState].referrerPolicy;
+ }
+ // Returns the mode associated with request, which is a string indicating
+ // whether the request will use CORS, or will be restricted to same-origin
+ // URLs.
+ get mode() {
+ webidl.brandCheck(this, Request3);
+ return this[kState].mode;
+ }
+ // Returns the credentials mode associated with request,
+ // which is a string indicating whether credentials will be sent with the
+ // request always, never, or only when sent to a same-origin URL.
+ get credentials() {
+ return this[kState].credentials;
+ }
+ // Returns the cache mode associated with request,
+ // which is a string indicating how the request will
+ // interact with the browser’s cache when fetching.
+ get cache() {
+ webidl.brandCheck(this, Request3);
+ return this[kState].cache;
+ }
+ // Returns the redirect mode associated with request,
+ // which is a string indicating how redirects for the
+ // request will be handled during fetching. A request
+ // will follow redirects by default.
+ get redirect() {
+ webidl.brandCheck(this, Request3);
+ return this[kState].redirect;
+ }
+ // Returns request’s subresource integrity metadata, which is a
+ // cryptographic hash of the resource being fetched. Its value
+ // consists of multiple hashes separated by whitespace. [SRI]
+ get integrity() {
+ webidl.brandCheck(this, Request3);
+ return this[kState].integrity;
+ }
+ // Returns a boolean indicating whether or not request can outlive the
+ // global in which it was created.
+ get keepalive() {
+ webidl.brandCheck(this, Request3);
+ return this[kState].keepalive;
+ }
+ // Returns a boolean indicating whether or not request is for a reload
+ // navigation.
+ get isReloadNavigation() {
+ webidl.brandCheck(this, Request3);
+ return this[kState].reloadNavigation;
+ }
+ // Returns a boolean indicating whether or not request is for a history
+ // navigation (a.k.a. back-foward navigation).
+ get isHistoryNavigation() {
+ webidl.brandCheck(this, Request3);
+ return this[kState].historyNavigation;
+ }
+ // Returns the signal associated with request, which is an AbortSignal
+ // object indicating whether or not request has been aborted, and its
+ // abort event handler.
+ get signal() {
+ webidl.brandCheck(this, Request3);
+ return this[kSignal];
+ }
+ get body() {
+ webidl.brandCheck(this, Request3);
+ return this[kState].body ? this[kState].body.stream : null;
+ }
+ get bodyUsed() {
+ webidl.brandCheck(this, Request3);
+ return !!this[kState].body && util3.isDisturbed(this[kState].body.stream);
+ }
+ get duplex() {
+ webidl.brandCheck(this, Request3);
+ return "half";
+ }
+ // Returns a clone of request.
+ clone() {
+ webidl.brandCheck(this, Request3);
+ if (this.bodyUsed || this.body?.locked) {
+ throw new TypeError("unusable");
+ }
+ const clonedRequest = cloneRequest(this[kState]);
+ const clonedRequestObject = new Request3(kInit);
+ clonedRequestObject[kState] = clonedRequest;
+ clonedRequestObject[kRealm] = this[kRealm];
+ clonedRequestObject[kHeaders] = new Headers3();
+ clonedRequestObject[kHeaders][kHeadersList] = clonedRequest.headersList;
+ clonedRequestObject[kHeaders][kGuard] = this[kHeaders][kGuard];
+ clonedRequestObject[kHeaders][kRealm] = this[kHeaders][kRealm];
+ const ac = new AbortController();
+ if (this.signal.aborted) {
+ ac.abort(this.signal.reason);
+ } else {
+ this.signal.addEventListener(
+ "abort",
+ () => {
+ ac.abort(this.signal.reason);
+ },
+ { once: true }
+ );
+ }
+ clonedRequestObject[kSignal] = ac.signal;
+ return clonedRequestObject;
+ }
+ };
+ __name(Request3, "Request");
+ mixinBody(Request3);
+ function makeRequest(init) {
+ const request = {
+ method: "GET",
+ localURLsOnly: false,
+ unsafeRequest: false,
+ body: null,
+ client: null,
+ reservedClient: null,
+ replacesClientId: "",
+ window: "client",
+ keepalive: false,
+ serviceWorkers: "all",
+ initiator: "",
+ destination: "",
+ priority: null,
+ origin: "client",
+ policyContainer: "client",
+ referrer: "client",
+ referrerPolicy: "",
+ mode: "no-cors",
+ useCORSPreflightFlag: false,
+ credentials: "same-origin",
+ useCredentials: false,
+ cache: "default",
+ redirect: "follow",
+ integrity: "",
+ cryptoGraphicsNonceMetadata: "",
+ parserMetadata: "",
+ reloadNavigation: false,
+ historyNavigation: false,
+ userActivation: false,
+ taintedOrigin: false,
+ redirectCount: 0,
+ responseTainting: "basic",
+ preventNoCacheCacheControlHeaderModification: false,
+ done: false,
+ timingAllowFailed: false,
+ ...init,
+ headersList: init.headersList ? new HeadersList(init.headersList) : new HeadersList()
+ };
+ request.url = request.urlList[0];
+ return request;
+ }
+ __name(makeRequest, "makeRequest");
+ function cloneRequest(request) {
+ const newRequest = makeRequest({ ...request, body: null });
+ if (request.body != null) {
+ newRequest.body = cloneBody(request.body);
+ }
+ return newRequest;
+ }
+ __name(cloneRequest, "cloneRequest");
+ Object.defineProperties(Request3.prototype, {
+ method: kEnumerableProperty,
+ url: kEnumerableProperty,
+ headers: kEnumerableProperty,
+ redirect: kEnumerableProperty,
+ clone: kEnumerableProperty,
+ signal: kEnumerableProperty,
+ duplex: kEnumerableProperty,
+ destination: kEnumerableProperty,
+ body: kEnumerableProperty,
+ bodyUsed: kEnumerableProperty,
+ isHistoryNavigation: kEnumerableProperty,
+ isReloadNavigation: kEnumerableProperty,
+ keepalive: kEnumerableProperty,
+ integrity: kEnumerableProperty,
+ cache: kEnumerableProperty,
+ credentials: kEnumerableProperty,
+ attribute: kEnumerableProperty,
+ referrerPolicy: kEnumerableProperty,
+ referrer: kEnumerableProperty,
+ mode: kEnumerableProperty,
+ [Symbol.toStringTag]: {
+ value: "Request",
+ configurable: true
+ }
+ });
+ webidl.converters.Request = webidl.interfaceConverter(
+ Request3
+ );
+ webidl.converters.RequestInfo = function(V) {
+ if (typeof V === "string") {
+ return webidl.converters.USVString(V);
+ }
+ if (V instanceof Request3) {
+ return webidl.converters.Request(V);
+ }
+ return webidl.converters.USVString(V);
+ };
+ webidl.converters.AbortSignal = webidl.interfaceConverter(
+ AbortSignal
+ );
+ webidl.converters.RequestInit = webidl.dictionaryConverter([
+ {
+ key: "method",
+ converter: webidl.converters.ByteString
+ },
+ {
+ key: "headers",
+ converter: webidl.converters.HeadersInit
+ },
+ {
+ key: "body",
+ converter: webidl.nullableConverter(
+ webidl.converters.BodyInit
+ )
+ },
+ {
+ key: "referrer",
+ converter: webidl.converters.USVString
+ },
+ {
+ key: "referrerPolicy",
+ converter: webidl.converters.DOMString,
+ // https://w3c.github.io/webappsec-referrer-policy/#referrer-policy
+ allowedValues: referrerPolicy
+ },
+ {
+ key: "mode",
+ converter: webidl.converters.DOMString,
+ // https://fetch.spec.whatwg.org/#concept-request-mode
+ allowedValues: requestMode
+ },
+ {
+ key: "credentials",
+ converter: webidl.converters.DOMString,
+ // https://fetch.spec.whatwg.org/#requestcredentials
+ allowedValues: requestCredentials
+ },
+ {
+ key: "cache",
+ converter: webidl.converters.DOMString,
+ // https://fetch.spec.whatwg.org/#requestcache
+ allowedValues: requestCache
+ },
+ {
+ key: "redirect",
+ converter: webidl.converters.DOMString,
+ // https://fetch.spec.whatwg.org/#requestredirect
+ allowedValues: requestRedirect
+ },
+ {
+ key: "integrity",
+ converter: webidl.converters.DOMString
+ },
+ {
+ key: "keepalive",
+ converter: webidl.converters.boolean
+ },
+ {
+ key: "signal",
+ converter: webidl.nullableConverter(
+ (signal) => webidl.converters.AbortSignal(
+ signal,
+ { strict: false }
+ )
+ )
+ },
+ {
+ key: "window",
+ converter: webidl.converters.any
+ },
+ {
+ key: "duplex",
+ converter: webidl.converters.DOMString,
+ allowedValues: requestDuplex
+ }
+ ]);
+ module2.exports = { Request: Request3, makeRequest };
+ }
+});
+
+// ../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/fetch/index.js
+var require_fetch = __commonJS({
+ "../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/fetch/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var {
+ Response: Response5,
+ makeNetworkError,
+ makeAppropriateNetworkError,
+ filterResponse,
+ makeResponse
+ } = require_response();
+ var { Headers: Headers3 } = require_headers();
+ var { Request: Request3, makeRequest } = require_request2();
+ var zlib = require("zlib");
+ var {
+ bytesMatch,
+ makePolicyContainer,
+ clonePolicyContainer,
+ requestBadPort,
+ TAOCheck,
+ appendRequestOriginHeader,
+ responseLocationURL,
+ requestCurrentURL,
+ setRequestReferrerPolicyOnRedirect,
+ tryUpgradeRequestToAPotentiallyTrustworthyURL,
+ createOpaqueTimingInfo,
+ appendFetchMetadata,
+ corsCheck,
+ crossOriginResourcePolicyCheck,
+ determineRequestsReferrer,
+ coarsenedSharedCurrentTime,
+ createDeferredPromise,
+ isBlobLike,
+ sameOrigin,
+ isCancelled,
+ isAborted,
+ isErrorLike,
+ fullyReadBody,
+ readableStreamClose,
+ isomorphicEncode
+ } = require_util2();
+ var { kState, kHeaders, kGuard, kRealm, kHeadersCaseInsensitive } = require_symbols2();
+ var assert18 = require("assert");
+ var { safelyExtractBody } = require_body();
+ var {
+ redirectStatus,
+ nullBodyStatus,
+ safeMethods,
+ requestBodyHeader,
+ subresource,
+ DOMException
+ } = require_constants();
+ var { kHeadersList } = require_symbols();
+ var EE = require("events");
+ var { Readable, pipeline } = require("stream");
+ var { isErrored, isReadable, nodeMajor, nodeMinor } = require_util();
+ var { dataURLProcessor, serializeAMimeType } = require_dataURL();
+ var { TransformStream } = require("stream/web");
+ var { getGlobalDispatcher } = require_global();
+ var { webidl } = require_webidl();
+ var { STATUS_CODES } = require("http");
+ var resolveObjectURL;
+ var ReadableStream2 = globalThis.ReadableStream;
+ var Fetch = class extends EE {
+ constructor(dispatcher) {
+ super();
+ this.dispatcher = dispatcher;
+ this.connection = null;
+ this.dump = false;
+ this.state = "ongoing";
+ this.setMaxListeners(21);
+ }
+ terminate(reason) {
+ if (this.state !== "ongoing") {
+ return;
+ }
+ this.state = "terminated";
+ this.connection?.destroy(reason);
+ this.emit("terminated", reason);
+ }
+ // https://fetch.spec.whatwg.org/#fetch-controller-abort
+ abort(error) {
+ if (this.state !== "ongoing") {
+ return;
+ }
+ this.state = "aborted";
+ if (!error) {
+ error = new DOMException("The operation was aborted.", "AbortError");
+ }
+ this.serializedAbortReason = error;
+ this.connection?.destroy(error);
+ this.emit("terminated", error);
+ }
+ };
+ __name(Fetch, "Fetch");
+ async function fetch12(input, init = {}) {
+ webidl.argumentLengthCheck(arguments, 1, { header: "globalThis.fetch" });
+ const p = createDeferredPromise();
+ let requestObject;
+ try {
+ requestObject = new Request3(input, init);
+ } catch (e2) {
+ p.reject(e2);
+ return p.promise;
+ }
+ const request = requestObject[kState];
+ if (requestObject.signal.aborted) {
+ abortFetch(p, request, null, requestObject.signal.reason);
+ return p.promise;
+ }
+ const globalObject = request.client.globalObject;
+ if (globalObject?.constructor?.name === "ServiceWorkerGlobalScope") {
+ request.serviceWorkers = "none";
+ }
+ let responseObject = null;
+ const relevantRealm = null;
+ let locallyAborted = false;
+ let controller = null;
+ requestObject.signal.addEventListener(
+ "abort",
+ () => {
+ locallyAborted = true;
+ abortFetch(p, request, responseObject, requestObject.signal.reason);
+ if (controller != null) {
+ controller.abort();
+ }
+ },
+ { once: true }
+ );
+ const handleFetchDone = /* @__PURE__ */ __name((response) => finalizeAndReportTiming(response, "fetch"), "handleFetchDone");
+ const processResponse = /* @__PURE__ */ __name((response) => {
+ if (locallyAborted) {
+ return;
+ }
+ if (response.aborted) {
+ abortFetch(p, request, responseObject, controller.serializedAbortReason);
+ return;
+ }
+ if (response.type === "error") {
+ p.reject(
+ Object.assign(new TypeError("fetch failed"), { cause: response.error })
+ );
+ return;
+ }
+ responseObject = new Response5();
+ responseObject[kState] = response;
+ responseObject[kRealm] = relevantRealm;
+ responseObject[kHeaders][kHeadersList] = response.headersList;
+ responseObject[kHeaders][kGuard] = "immutable";
+ responseObject[kHeaders][kRealm] = relevantRealm;
+ p.resolve(responseObject);
+ }, "processResponse");
+ controller = fetching({
+ request,
+ processResponseEndOfBody: handleFetchDone,
+ processResponse,
+ dispatcher: init.dispatcher ?? getGlobalDispatcher()
+ // undici
+ });
+ return p.promise;
+ }
+ __name(fetch12, "fetch");
+ function finalizeAndReportTiming(response, initiatorType = "other") {
+ if (response.type === "error" && response.aborted) {
+ return;
+ }
+ if (!response.urlList?.length) {
+ return;
+ }
+ const originalURL = response.urlList[0];
+ let timingInfo = response.timingInfo;
+ let cacheState = response.cacheState;
+ if (!/^https?:/.test(originalURL.protocol)) {
+ return;
+ }
+ if (timingInfo === null) {
+ return;
+ }
+ if (!timingInfo.timingAllowPassed) {
+ timingInfo = createOpaqueTimingInfo({
+ startTime: timingInfo.startTime
+ });
+ cacheState = "";
+ }
+ response.timingInfo.endTime = coarsenedSharedCurrentTime();
+ response.timingInfo = timingInfo;
+ markResourceTiming(
+ timingInfo,
+ originalURL,
+ initiatorType,
+ globalThis,
+ cacheState
+ );
+ }
+ __name(finalizeAndReportTiming, "finalizeAndReportTiming");
+ function markResourceTiming(timingInfo, originalURL, initiatorType, globalThis2, cacheState) {
+ if (nodeMajor >= 18 && nodeMinor >= 2) {
+ performance.markResourceTiming(timingInfo, originalURL, initiatorType, globalThis2, cacheState);
+ }
+ }
+ __name(markResourceTiming, "markResourceTiming");
+ function abortFetch(p, request, responseObject, error) {
+ if (!error) {
+ error = new DOMException("The operation was aborted.", "AbortError");
+ }
+ p.reject(error);
+ if (request.body != null && isReadable(request.body?.stream)) {
+ request.body.stream.cancel(error).catch((err) => {
+ if (err.code === "ERR_INVALID_STATE") {
+ return;
+ }
+ throw err;
+ });
+ }
+ if (responseObject == null) {
+ return;
+ }
+ const response = responseObject[kState];
+ if (response.body != null && isReadable(response.body?.stream)) {
+ response.body.stream.cancel(error).catch((err) => {
+ if (err.code === "ERR_INVALID_STATE") {
+ return;
+ }
+ throw err;
+ });
+ }
+ }
+ __name(abortFetch, "abortFetch");
+ function fetching({
+ request,
+ processRequestBodyChunkLength,
+ processRequestEndOfBody,
+ processResponse,
+ processResponseEndOfBody,
+ processResponseConsumeBody,
+ useParallelQueue = false,
+ dispatcher
+ // undici
+ }) {
+ let taskDestination = null;
+ let crossOriginIsolatedCapability = false;
+ if (request.client != null) {
+ taskDestination = request.client.globalObject;
+ crossOriginIsolatedCapability = request.client.crossOriginIsolatedCapability;
+ }
+ const currenTime = coarsenedSharedCurrentTime(crossOriginIsolatedCapability);
+ const timingInfo = createOpaqueTimingInfo({
+ startTime: currenTime
+ });
+ const fetchParams = {
+ controller: new Fetch(dispatcher),
+ request,
+ timingInfo,
+ processRequestBodyChunkLength,
+ processRequestEndOfBody,
+ processResponse,
+ processResponseConsumeBody,
+ processResponseEndOfBody,
+ taskDestination,
+ crossOriginIsolatedCapability
+ };
+ assert18(!request.body || request.body.stream);
+ if (request.window === "client") {
+ request.window = request.client?.globalObject?.constructor?.name === "Window" ? request.client : "no-window";
+ }
+ if (request.origin === "client") {
+ request.origin = request.client?.origin;
+ }
+ if (request.policyContainer === "client") {
+ if (request.client != null) {
+ request.policyContainer = clonePolicyContainer(
+ request.client.policyContainer
+ );
+ } else {
+ request.policyContainer = makePolicyContainer();
+ }
+ }
+ if (!request.headersList.contains("accept")) {
+ const value = "*/*";
+ request.headersList.append("accept", value);
+ }
+ if (!request.headersList.contains("accept-language")) {
+ request.headersList.append("accept-language", "*");
+ }
+ if (request.priority === null) {
+ }
+ if (subresource.includes(request.destination)) {
+ }
+ mainFetch(fetchParams).catch((err) => {
+ fetchParams.controller.terminate(err);
+ });
+ return fetchParams.controller;
+ }
+ __name(fetching, "fetching");
+ async function mainFetch(fetchParams, recursive = false) {
+ const request = fetchParams.request;
+ let response = null;
+ if (request.localURLsOnly && !/^(about|blob|data):/.test(requestCurrentURL(request).protocol)) {
+ response = makeNetworkError("local URLs only");
+ }
+ tryUpgradeRequestToAPotentiallyTrustworthyURL(request);
+ if (requestBadPort(request) === "blocked") {
+ response = makeNetworkError("bad port");
+ }
+ if (request.referrerPolicy === "") {
+ request.referrerPolicy = request.policyContainer.referrerPolicy;
+ }
+ if (request.referrer !== "no-referrer") {
+ request.referrer = determineRequestsReferrer(request);
+ }
+ if (response === null) {
+ response = await (async () => {
+ const currentURL = requestCurrentURL(request);
+ if (
+ // - request’s current URL’s origin is same origin with request’s origin,
+ // and request’s response tainting is "basic"
+ sameOrigin(currentURL, request.url) && request.responseTainting === "basic" || // request’s current URL’s scheme is "data"
+ currentURL.protocol === "data:" || // - request’s mode is "navigate" or "websocket"
+ (request.mode === "navigate" || request.mode === "websocket")
+ ) {
+ request.responseTainting = "basic";
+ return await schemeFetch(fetchParams);
+ }
+ if (request.mode === "same-origin") {
+ return makeNetworkError('request mode cannot be "same-origin"');
+ }
+ if (request.mode === "no-cors") {
+ if (request.redirect !== "follow") {
+ return makeNetworkError(
+ 'redirect mode cannot be "follow" for "no-cors" request'
+ );
+ }
+ request.responseTainting = "opaque";
+ return await schemeFetch(fetchParams);
+ }
+ if (!/^https?:/.test(requestCurrentURL(request).protocol)) {
+ return makeNetworkError("URL scheme must be a HTTP(S) scheme");
+ }
+ request.responseTainting = "cors";
+ return await httpFetch(fetchParams);
+ })();
+ }
+ if (recursive) {
+ return response;
+ }
+ if (response.status !== 0 && !response.internalResponse) {
+ if (request.responseTainting === "cors") {
+ }
+ if (request.responseTainting === "basic") {
+ response = filterResponse(response, "basic");
+ } else if (request.responseTainting === "cors") {
+ response = filterResponse(response, "cors");
+ } else if (request.responseTainting === "opaque") {
+ response = filterResponse(response, "opaque");
+ } else {
+ assert18(false);
+ }
+ }
+ let internalResponse = response.status === 0 ? response : response.internalResponse;
+ if (internalResponse.urlList.length === 0) {
+ internalResponse.urlList.push(...request.urlList);
+ }
+ if (!request.timingAllowFailed) {
+ response.timingAllowPassed = true;
+ }
+ if (response.type === "opaque" && internalResponse.status === 206 && internalResponse.rangeRequested && !request.headers.contains("range")) {
+ response = internalResponse = makeNetworkError();
+ }
+ if (response.status !== 0 && (request.method === "HEAD" || request.method === "CONNECT" || nullBodyStatus.includes(internalResponse.status))) {
+ internalResponse.body = null;
+ fetchParams.controller.dump = true;
+ }
+ if (request.integrity) {
+ const processBodyError = /* @__PURE__ */ __name((reason) => fetchFinale(fetchParams, makeNetworkError(reason)), "processBodyError");
+ if (request.responseTainting === "opaque" || response.body == null) {
+ processBodyError(response.error);
+ return;
+ }
+ const processBody = /* @__PURE__ */ __name((bytes) => {
+ if (!bytesMatch(bytes, request.integrity)) {
+ processBodyError("integrity mismatch");
+ return;
+ }
+ response.body = safelyExtractBody(bytes)[0];
+ fetchFinale(fetchParams, response);
+ }, "processBody");
+ await fullyReadBody(response.body, processBody, processBodyError);
+ } else {
+ fetchFinale(fetchParams, response);
+ }
+ }
+ __name(mainFetch, "mainFetch");
+ async function schemeFetch(fetchParams) {
+ if (isCancelled(fetchParams) && fetchParams.request.redirectCount === 0) {
+ return makeAppropriateNetworkError(fetchParams);
+ }
+ const { request } = fetchParams;
+ const { protocol: scheme } = requestCurrentURL(request);
+ switch (scheme) {
+ case "about:": {
+ return makeNetworkError("about scheme is not supported");
+ }
+ case "blob:": {
+ if (!resolveObjectURL) {
+ resolveObjectURL = require("buffer").resolveObjectURL;
+ }
+ const blobURLEntry = requestCurrentURL(request);
+ if (blobURLEntry.search.length !== 0) {
+ return makeNetworkError("NetworkError when attempting to fetch resource.");
+ }
+ const blobURLEntryObject = resolveObjectURL(blobURLEntry.toString());
+ if (request.method !== "GET" || !isBlobLike(blobURLEntryObject)) {
+ return makeNetworkError("invalid method");
+ }
+ const bodyWithType = safelyExtractBody(blobURLEntryObject);
+ const body = bodyWithType[0];
+ const length = isomorphicEncode(`${body.length}`);
+ const type = bodyWithType[1] ?? "";
+ const response = makeResponse({
+ statusText: "OK",
+ headersList: [
+ ["content-length", { name: "Content-Length", value: length }],
+ ["content-type", { name: "Content-Type", value: type }]
+ ]
+ });
+ response.body = body;
+ return response;
+ }
+ case "data:": {
+ const currentURL = requestCurrentURL(request);
+ const dataURLStruct = dataURLProcessor(currentURL);
+ if (dataURLStruct === "failure") {
+ return makeNetworkError("failed to fetch the data URL");
+ }
+ const mimeType = serializeAMimeType(dataURLStruct.mimeType);
+ return makeResponse({
+ statusText: "OK",
+ headersList: [
+ ["content-type", { name: "Content-Type", value: mimeType }]
+ ],
+ body: safelyExtractBody(dataURLStruct.body)[0]
+ });
+ }
+ case "file:": {
+ return makeNetworkError("not implemented... yet...");
+ }
+ case "http:":
+ case "https:": {
+ return await httpFetch(fetchParams).catch((err) => makeNetworkError(err));
+ }
+ default: {
+ return makeNetworkError("unknown scheme");
+ }
+ }
+ }
+ __name(schemeFetch, "schemeFetch");
+ function finalizeResponse(fetchParams, response) {
+ fetchParams.request.done = true;
+ if (fetchParams.processResponseDone != null) {
+ queueMicrotask(() => fetchParams.processResponseDone(response));
+ }
+ }
+ __name(finalizeResponse, "finalizeResponse");
+ async function fetchFinale(fetchParams, response) {
+ if (response.type === "error") {
+ response.urlList = [fetchParams.request.urlList[0]];
+ response.timingInfo = createOpaqueTimingInfo({
+ startTime: fetchParams.timingInfo.startTime
+ });
+ }
+ const processResponseEndOfBody = /* @__PURE__ */ __name(() => {
+ fetchParams.request.done = true;
+ if (fetchParams.processResponseEndOfBody != null) {
+ queueMicrotask(() => fetchParams.processResponseEndOfBody(response));
+ }
+ }, "processResponseEndOfBody");
+ if (fetchParams.processResponse != null) {
+ queueMicrotask(() => fetchParams.processResponse(response));
+ }
+ if (response.body == null) {
+ processResponseEndOfBody();
+ } else {
+ const identityTransformAlgorithm = /* @__PURE__ */ __name((chunk, controller) => {
+ controller.enqueue(chunk);
+ }, "identityTransformAlgorithm");
+ const transformStream = new TransformStream({
+ start() {
+ },
+ transform: identityTransformAlgorithm,
+ flush: processResponseEndOfBody
+ }, {
+ size() {
+ return 1;
+ }
+ }, {
+ size() {
+ return 1;
+ }
+ });
+ response.body = { stream: response.body.stream.pipeThrough(transformStream) };
+ }
+ if (fetchParams.processResponseConsumeBody != null) {
+ const processBody = /* @__PURE__ */ __name((nullOrBytes) => fetchParams.processResponseConsumeBody(response, nullOrBytes), "processBody");
+ const processBodyError = /* @__PURE__ */ __name((failure) => fetchParams.processResponseConsumeBody(response, failure), "processBodyError");
+ if (response.body == null) {
+ queueMicrotask(() => processBody(null));
+ } else {
+ await fullyReadBody(response.body, processBody, processBodyError);
+ }
+ }
+ }
+ __name(fetchFinale, "fetchFinale");
+ async function httpFetch(fetchParams) {
+ const request = fetchParams.request;
+ let response = null;
+ let actualResponse = null;
+ const timingInfo = fetchParams.timingInfo;
+ if (request.serviceWorkers === "all") {
+ }
+ if (response === null) {
+ if (request.redirect === "follow") {
+ request.serviceWorkers = "none";
+ }
+ actualResponse = response = await httpNetworkOrCacheFetch(fetchParams);
+ if (request.responseTainting === "cors" && corsCheck(request, response) === "failure") {
+ return makeNetworkError("cors failure");
+ }
+ if (TAOCheck(request, response) === "failure") {
+ request.timingAllowFailed = true;
+ }
+ }
+ if ((request.responseTainting === "opaque" || response.type === "opaque") && crossOriginResourcePolicyCheck(
+ request.origin,
+ request.client,
+ request.destination,
+ actualResponse
+ ) === "blocked") {
+ return makeNetworkError("blocked");
+ }
+ if (redirectStatus.includes(actualResponse.status)) {
+ if (request.redirect !== "manual") {
+ fetchParams.controller.connection.destroy();
+ }
+ if (request.redirect === "error") {
+ response = makeNetworkError("unexpected redirect");
+ } else if (request.redirect === "manual") {
+ response = actualResponse;
+ } else if (request.redirect === "follow") {
+ response = await httpRedirectFetch(fetchParams, response);
+ } else {
+ assert18(false);
+ }
+ }
+ response.timingInfo = timingInfo;
+ return response;
+ }
+ __name(httpFetch, "httpFetch");
+ async function httpRedirectFetch(fetchParams, response) {
+ const request = fetchParams.request;
+ const actualResponse = response.internalResponse ? response.internalResponse : response;
+ let locationURL;
+ try {
+ locationURL = responseLocationURL(
+ actualResponse,
+ requestCurrentURL(request).hash
+ );
+ if (locationURL == null) {
+ return response;
+ }
+ } catch (err) {
+ return makeNetworkError(err);
+ }
+ if (!/^https?:/.test(locationURL.protocol)) {
+ return makeNetworkError("URL scheme must be a HTTP(S) scheme");
+ }
+ if (request.redirectCount === 20) {
+ return makeNetworkError("redirect count exceeded");
+ }
+ request.redirectCount += 1;
+ if (request.mode === "cors" && (locationURL.username || locationURL.password) && !sameOrigin(request, locationURL)) {
+ return makeNetworkError('cross origin not allowed for request mode "cors"');
+ }
+ if (request.responseTainting === "cors" && (locationURL.username || locationURL.password)) {
+ return makeNetworkError(
+ 'URL cannot contain credentials for request mode "cors"'
+ );
+ }
+ if (actualResponse.status !== 303 && request.body != null && request.body.source == null) {
+ return makeNetworkError();
+ }
+ if ([301, 302].includes(actualResponse.status) && request.method === "POST" || actualResponse.status === 303 && !["GET", "HEAD"].includes(request.method)) {
+ request.method = "GET";
+ request.body = null;
+ for (const headerName of requestBodyHeader) {
+ request.headersList.delete(headerName);
+ }
+ }
+ if (!sameOrigin(requestCurrentURL(request), locationURL)) {
+ request.headersList.delete("authorization");
+ }
+ if (request.body != null) {
+ assert18(request.body.source);
+ request.body = safelyExtractBody(request.body.source)[0];
+ }
+ const timingInfo = fetchParams.timingInfo;
+ timingInfo.redirectEndTime = timingInfo.postRedirectStartTime = coarsenedSharedCurrentTime(fetchParams.crossOriginIsolatedCapability);
+ if (timingInfo.redirectStartTime === 0) {
+ timingInfo.redirectStartTime = timingInfo.startTime;
+ }
+ request.urlList.push(locationURL);
+ setRequestReferrerPolicyOnRedirect(request, actualResponse);
+ return mainFetch(fetchParams, true);
+ }
+ __name(httpRedirectFetch, "httpRedirectFetch");
+ async function httpNetworkOrCacheFetch(fetchParams, isAuthenticationFetch = false, isNewConnectionFetch = false) {
+ const request = fetchParams.request;
+ let httpFetchParams = null;
+ let httpRequest = null;
+ let response = null;
+ const httpCache = null;
+ const revalidatingFlag = false;
+ if (request.window === "no-window" && request.redirect === "error") {
+ httpFetchParams = fetchParams;
+ httpRequest = request;
+ } else {
+ httpRequest = makeRequest(request);
+ httpFetchParams = { ...fetchParams };
+ httpFetchParams.request = httpRequest;
+ }
+ const includeCredentials = request.credentials === "include" || request.credentials === "same-origin" && request.responseTainting === "basic";
+ const contentLength = httpRequest.body ? httpRequest.body.length : null;
+ let contentLengthHeaderValue = null;
+ if (httpRequest.body == null && ["POST", "PUT"].includes(httpRequest.method)) {
+ contentLengthHeaderValue = "0";
+ }
+ if (contentLength != null) {
+ contentLengthHeaderValue = isomorphicEncode(`${contentLength}`);
+ }
+ if (contentLengthHeaderValue != null) {
+ httpRequest.headersList.append("content-length", contentLengthHeaderValue);
+ }
+ if (contentLength != null && httpRequest.keepalive) {
+ }
+ if (httpRequest.referrer instanceof URL) {
+ httpRequest.headersList.append("referer", isomorphicEncode(httpRequest.referrer.href));
+ }
+ appendRequestOriginHeader(httpRequest);
+ appendFetchMetadata(httpRequest);
+ if (!httpRequest.headersList.contains("user-agent")) {
+ httpRequest.headersList.append("user-agent", "undici");
+ }
+ if (httpRequest.cache === "default" && (httpRequest.headersList.contains("if-modified-since") || httpRequest.headersList.contains("if-none-match") || httpRequest.headersList.contains("if-unmodified-since") || httpRequest.headersList.contains("if-match") || httpRequest.headersList.contains("if-range"))) {
+ httpRequest.cache = "no-store";
+ }
+ if (httpRequest.cache === "no-cache" && !httpRequest.preventNoCacheCacheControlHeaderModification && !httpRequest.headersList.contains("cache-control")) {
+ httpRequest.headersList.append("cache-control", "max-age=0");
+ }
+ if (httpRequest.cache === "no-store" || httpRequest.cache === "reload") {
+ if (!httpRequest.headersList.contains("pragma")) {
+ httpRequest.headersList.append("pragma", "no-cache");
+ }
+ if (!httpRequest.headersList.contains("cache-control")) {
+ httpRequest.headersList.append("cache-control", "no-cache");
+ }
+ }
+ if (httpRequest.headersList.contains("range")) {
+ httpRequest.headersList.append("accept-encoding", "identity");
+ }
+ if (!httpRequest.headersList.contains("accept-encoding")) {
+ if (/^https:/.test(requestCurrentURL(httpRequest).protocol)) {
+ httpRequest.headersList.append("accept-encoding", "br, gzip, deflate");
+ } else {
+ httpRequest.headersList.append("accept-encoding", "gzip, deflate");
+ }
+ }
+ if (includeCredentials) {
+ }
+ if (httpCache == null) {
+ httpRequest.cache = "no-store";
+ }
+ if (httpRequest.mode !== "no-store" && httpRequest.mode !== "reload") {
+ }
+ if (response == null) {
+ if (httpRequest.mode === "only-if-cached") {
+ return makeNetworkError("only if cached");
+ }
+ const forwardResponse = await httpNetworkFetch(
+ httpFetchParams,
+ includeCredentials,
+ isNewConnectionFetch
+ );
+ if (!safeMethods.includes(httpRequest.method) && forwardResponse.status >= 200 && forwardResponse.status <= 399) {
+ }
+ if (revalidatingFlag && forwardResponse.status === 304) {
+ }
+ if (response == null) {
+ response = forwardResponse;
+ }
+ }
+ response.urlList = [...httpRequest.urlList];
+ if (httpRequest.headersList.contains("range")) {
+ response.rangeRequested = true;
+ }
+ response.requestIncludesCredentials = includeCredentials;
+ if (response.status === 407) {
+ if (request.window === "no-window") {
+ return makeNetworkError();
+ }
+ if (isCancelled(fetchParams)) {
+ return makeAppropriateNetworkError(fetchParams);
+ }
+ return makeNetworkError("proxy authentication required");
+ }
+ if (
+ // response’s status is 421
+ response.status === 421 && // isNewConnectionFetch is false
+ !isNewConnectionFetch && // request’s body is null, or request’s body is non-null and request’s body’s source is non-null
+ (request.body == null || request.body.source != null)
+ ) {
+ if (isCancelled(fetchParams)) {
+ return makeAppropriateNetworkError(fetchParams);
+ }
+ fetchParams.controller.connection.destroy();
+ response = await httpNetworkOrCacheFetch(
+ fetchParams,
+ isAuthenticationFetch,
+ true
+ );
+ }
+ if (isAuthenticationFetch) {
+ }
+ return response;
+ }
+ __name(httpNetworkOrCacheFetch, "httpNetworkOrCacheFetch");
+ async function httpNetworkFetch(fetchParams, includeCredentials = false, forceNewConnection = false) {
+ assert18(!fetchParams.controller.connection || fetchParams.controller.connection.destroyed);
+ fetchParams.controller.connection = {
+ abort: null,
+ destroyed: false,
+ destroy(err) {
+ if (!this.destroyed) {
+ this.destroyed = true;
+ this.abort?.(err ?? new DOMException("The operation was aborted.", "AbortError"));
+ }
+ }
+ };
+ const request = fetchParams.request;
+ let response = null;
+ const timingInfo = fetchParams.timingInfo;
+ const httpCache = null;
+ if (httpCache == null) {
+ request.cache = "no-store";
+ }
+ const newConnection = forceNewConnection ? "yes" : "no";
+ if (request.mode === "websocket") {
+ } else {
+ }
+ let requestBody = null;
+ if (request.body == null && fetchParams.processRequestEndOfBody) {
+ queueMicrotask(() => fetchParams.processRequestEndOfBody());
+ } else if (request.body != null) {
+ const processBodyChunk = /* @__PURE__ */ __name(async function* (bytes) {
+ if (isCancelled(fetchParams)) {
+ return;
+ }
+ yield bytes;
+ fetchParams.processRequestBodyChunkLength?.(bytes.byteLength);
+ }, "processBodyChunk");
+ const processEndOfBody = /* @__PURE__ */ __name(() => {
+ if (isCancelled(fetchParams)) {
+ return;
+ }
+ if (fetchParams.processRequestEndOfBody) {
+ fetchParams.processRequestEndOfBody();
+ }
+ }, "processEndOfBody");
+ const processBodyError = /* @__PURE__ */ __name((e2) => {
+ if (isCancelled(fetchParams)) {
+ return;
+ }
+ if (e2.name === "AbortError") {
+ fetchParams.controller.abort();
+ } else {
+ fetchParams.controller.terminate(e2);
+ }
+ }, "processBodyError");
+ requestBody = async function* () {
+ try {
+ for await (const bytes of request.body.stream) {
+ yield* processBodyChunk(bytes);
+ }
+ processEndOfBody();
+ } catch (err) {
+ processBodyError(err);
+ }
+ }();
+ }
+ try {
+ const { body, status, statusText, headersList, socket } = await dispatch({ body: requestBody });
+ if (socket) {
+ response = makeResponse({ status, statusText, headersList, socket });
+ } else {
+ const iterator = body[Symbol.asyncIterator]();
+ fetchParams.controller.next = () => iterator.next();
+ response = makeResponse({ status, statusText, headersList });
+ }
+ } catch (err) {
+ if (err.name === "AbortError") {
+ fetchParams.controller.connection.destroy();
+ return makeAppropriateNetworkError(fetchParams);
+ }
+ return makeNetworkError(err);
+ }
+ const pullAlgorithm = /* @__PURE__ */ __name(() => {
+ fetchParams.controller.resume();
+ }, "pullAlgorithm");
+ const cancelAlgorithm = /* @__PURE__ */ __name((reason) => {
+ fetchParams.controller.abort(reason);
+ }, "cancelAlgorithm");
+ if (!ReadableStream2) {
+ ReadableStream2 = require("stream/web").ReadableStream;
+ }
+ const stream2 = new ReadableStream2(
+ {
+ async start(controller) {
+ fetchParams.controller.controller = controller;
+ },
+ async pull(controller) {
+ await pullAlgorithm(controller);
+ },
+ async cancel(reason) {
+ await cancelAlgorithm(reason);
+ }
+ },
+ {
+ highWaterMark: 0,
+ size() {
+ return 1;
+ }
+ }
+ );
+ response.body = { stream: stream2 };
+ fetchParams.controller.on("terminated", onAborted);
+ fetchParams.controller.resume = async () => {
+ while (true) {
+ let bytes;
+ try {
+ const { done, value } = await fetchParams.controller.next();
+ if (isAborted(fetchParams)) {
+ break;
+ }
+ bytes = done ? void 0 : value;
+ } catch (err) {
+ if (fetchParams.controller.ended && !timingInfo.encodedBodySize) {
+ bytes = void 0;
+ } else {
+ bytes = err;
+ }
+ }
+ if (bytes === void 0) {
+ readableStreamClose(fetchParams.controller.controller);
+ finalizeResponse(fetchParams, response);
+ return;
+ }
+ timingInfo.decodedBodySize += bytes?.byteLength ?? 0;
+ if (isErrorLike(bytes)) {
+ fetchParams.controller.terminate(bytes);
+ return;
+ }
+ fetchParams.controller.controller.enqueue(new Uint8Array(bytes));
+ if (isErrored(stream2)) {
+ fetchParams.controller.terminate();
+ return;
+ }
+ if (!fetchParams.controller.controller.desiredSize) {
+ return;
+ }
+ }
+ };
+ function onAborted(reason) {
+ if (isAborted(fetchParams)) {
+ response.aborted = true;
+ if (isReadable(stream2)) {
+ fetchParams.controller.controller.error(
+ fetchParams.controller.serializedAbortReason
+ );
+ }
+ } else {
+ if (isReadable(stream2)) {
+ fetchParams.controller.controller.error(new TypeError("terminated", {
+ cause: isErrorLike(reason) ? reason : void 0
+ }));
+ }
+ }
+ fetchParams.controller.connection.destroy();
+ }
+ __name(onAborted, "onAborted");
+ return response;
+ async function dispatch({ body }) {
+ const url3 = requestCurrentURL(request);
+ const agent = fetchParams.controller.dispatcher;
+ return new Promise((resolve18, reject) => agent.dispatch(
+ {
+ path: url3.pathname + url3.search,
+ origin: url3.origin,
+ method: request.method,
+ body: fetchParams.controller.dispatcher.isMockActive ? request.body && request.body.source : body,
+ headers: request.headersList[kHeadersCaseInsensitive],
+ maxRedirections: 0,
+ upgrade: request.mode === "websocket" ? "websocket" : void 0
+ },
+ {
+ body: null,
+ abort: null,
+ onConnect(abort) {
+ const { connection } = fetchParams.controller;
+ if (connection.destroyed) {
+ abort(new DOMException("The operation was aborted.", "AbortError"));
+ } else {
+ fetchParams.controller.on("terminated", abort);
+ this.abort = connection.abort = abort;
+ }
+ },
+ onHeaders(status, headersList, resume, statusText) {
+ if (status < 200) {
+ return;
+ }
+ let codings = [];
+ let location = "";
+ const headers = new Headers3();
+ for (let n = 0; n < headersList.length; n += 2) {
+ const key = headersList[n + 0].toString("latin1");
+ const val = headersList[n + 1].toString("latin1");
+ if (key.toLowerCase() === "content-encoding") {
+ codings = val.split(",").map((x) => x.trim());
+ } else if (key.toLowerCase() === "location") {
+ location = val;
+ }
+ headers.append(key, val);
+ }
+ this.body = new Readable({ read: resume });
+ const decoders = [];
+ const willFollow = request.redirect === "follow" && location && redirectStatus.includes(status);
+ if (request.method !== "HEAD" && request.method !== "CONNECT" && !nullBodyStatus.includes(status) && !willFollow) {
+ for (const coding of codings) {
+ if (/(x-)?gzip/.test(coding)) {
+ decoders.push(zlib.createGunzip());
+ } else if (/(x-)?deflate/.test(coding)) {
+ decoders.push(zlib.createInflate());
+ } else if (coding === "br") {
+ decoders.push(zlib.createBrotliDecompress());
+ } else {
+ decoders.length = 0;
+ break;
+ }
+ }
+ }
+ resolve18({
+ status,
+ statusText,
+ headersList: headers[kHeadersList],
+ body: decoders.length ? pipeline(this.body, ...decoders, () => {
+ }) : this.body.on("error", () => {
+ })
+ });
+ return true;
+ },
+ onData(chunk) {
+ if (fetchParams.controller.dump) {
+ return;
+ }
+ const bytes = chunk;
+ timingInfo.encodedBodySize += bytes.byteLength;
+ return this.body.push(bytes);
+ },
+ onComplete() {
+ if (this.abort) {
+ fetchParams.controller.off("terminated", this.abort);
+ }
+ fetchParams.controller.ended = true;
+ this.body.push(null);
+ },
+ onError(error) {
+ if (this.abort) {
+ fetchParams.controller.off("terminated", this.abort);
+ }
+ this.body?.destroy(error);
+ fetchParams.controller.terminate(error);
+ reject(error);
+ },
+ onUpgrade(status, headersList, socket) {
+ if (status !== 101) {
+ return;
+ }
+ const headers = new Headers3();
+ for (let n = 0; n < headersList.length; n += 2) {
+ const key = headersList[n + 0].toString("latin1");
+ const val = headersList[n + 1].toString("latin1");
+ headers.append(key, val);
+ }
+ resolve18({
+ status,
+ statusText: STATUS_CODES[status],
+ headersList: headers[kHeadersList],
+ socket
+ });
+ return true;
+ }
+ }
+ ));
+ }
+ __name(dispatch, "dispatch");
+ }
+ __name(httpNetworkFetch, "httpNetworkFetch");
+ module2.exports = {
+ fetch: fetch12,
+ Fetch,
+ fetching,
+ finalizeAndReportTiming
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/fileapi/symbols.js
+var require_symbols3 = __commonJS({
+ "../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/fileapi/symbols.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ module2.exports = {
+ kState: Symbol("FileReader state"),
+ kResult: Symbol("FileReader result"),
+ kError: Symbol("FileReader error"),
+ kLastProgressEventFired: Symbol("FileReader last progress event fired timestamp"),
+ kEvents: Symbol("FileReader events"),
+ kAborted: Symbol("FileReader aborted")
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/fileapi/progressevent.js
+var require_progressevent = __commonJS({
+ "../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/fileapi/progressevent.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var { webidl } = require_webidl();
+ var kState = Symbol("ProgressEvent state");
+ var ProgressEvent = class extends Event {
+ constructor(type, eventInitDict = {}) {
+ type = webidl.converters.DOMString(type);
+ eventInitDict = webidl.converters.ProgressEventInit(eventInitDict ?? {});
+ super(type, eventInitDict);
+ this[kState] = {
+ lengthComputable: eventInitDict.lengthComputable,
+ loaded: eventInitDict.loaded,
+ total: eventInitDict.total
+ };
+ }
+ get lengthComputable() {
+ webidl.brandCheck(this, ProgressEvent);
+ return this[kState].lengthComputable;
+ }
+ get loaded() {
+ webidl.brandCheck(this, ProgressEvent);
+ return this[kState].loaded;
+ }
+ get total() {
+ webidl.brandCheck(this, ProgressEvent);
+ return this[kState].total;
+ }
+ };
+ __name(ProgressEvent, "ProgressEvent");
+ webidl.converters.ProgressEventInit = webidl.dictionaryConverter([
+ {
+ key: "lengthComputable",
+ converter: webidl.converters.boolean,
+ defaultValue: false
+ },
+ {
+ key: "loaded",
+ converter: webidl.converters["unsigned long long"],
+ defaultValue: 0
+ },
+ {
+ key: "total",
+ converter: webidl.converters["unsigned long long"],
+ defaultValue: 0
+ },
+ {
+ key: "bubbles",
+ converter: webidl.converters.boolean,
+ defaultValue: false
+ },
+ {
+ key: "cancelable",
+ converter: webidl.converters.boolean,
+ defaultValue: false
+ },
+ {
+ key: "composed",
+ converter: webidl.converters.boolean,
+ defaultValue: false
+ }
+ ]);
+ module2.exports = {
+ ProgressEvent
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/fileapi/encoding.js
+var require_encoding = __commonJS({
+ "../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/fileapi/encoding.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ function getEncoding(label) {
+ switch (label.trim().toLowerCase()) {
+ case "unicode-1-1-utf-8":
+ case "unicode11utf8":
+ case "unicode20utf8":
+ case "utf-8":
+ case "utf8":
+ case "x-unicode20utf8":
+ return "UTF-8";
+ case "866":
+ case "cp866":
+ case "csibm866":
+ case "ibm866":
+ return "IBM866";
+ case "csisolatin2":
+ case "iso-8859-2":
+ case "iso-ir-101":
+ case "iso8859-2":
+ case "iso88592":
+ case "iso_8859-2":
+ case "iso_8859-2:1987":
+ case "l2":
+ case "latin2":
+ return "ISO-8859-2";
+ case "csisolatin3":
+ case "iso-8859-3":
+ case "iso-ir-109":
+ case "iso8859-3":
+ case "iso88593":
+ case "iso_8859-3":
+ case "iso_8859-3:1988":
+ case "l3":
+ case "latin3":
+ return "ISO-8859-3";
+ case "csisolatin4":
+ case "iso-8859-4":
+ case "iso-ir-110":
+ case "iso8859-4":
+ case "iso88594":
+ case "iso_8859-4":
+ case "iso_8859-4:1988":
+ case "l4":
+ case "latin4":
+ return "ISO-8859-4";
+ case "csisolatincyrillic":
+ case "cyrillic":
+ case "iso-8859-5":
+ case "iso-ir-144":
+ case "iso8859-5":
+ case "iso88595":
+ case "iso_8859-5":
+ case "iso_8859-5:1988":
+ return "ISO-8859-5";
+ case "arabic":
+ case "asmo-708":
+ case "csiso88596e":
+ case "csiso88596i":
+ case "csisolatinarabic":
+ case "ecma-114":
+ case "iso-8859-6":
+ case "iso-8859-6-e":
+ case "iso-8859-6-i":
+ case "iso-ir-127":
+ case "iso8859-6":
+ case "iso88596":
+ case "iso_8859-6":
+ case "iso_8859-6:1987":
+ return "ISO-8859-6";
+ case "csisolatingreek":
+ case "ecma-118":
+ case "elot_928":
+ case "greek":
+ case "greek8":
+ case "iso-8859-7":
+ case "iso-ir-126":
+ case "iso8859-7":
+ case "iso88597":
+ case "iso_8859-7":
+ case "iso_8859-7:1987":
+ case "sun_eu_greek":
+ return "ISO-8859-7";
+ case "csiso88598e":
+ case "csisolatinhebrew":
+ case "hebrew":
+ case "iso-8859-8":
+ case "iso-8859-8-e":
+ case "iso-ir-138":
+ case "iso8859-8":
+ case "iso88598":
+ case "iso_8859-8":
+ case "iso_8859-8:1988":
+ case "visual":
+ return "ISO-8859-8";
+ case "csiso88598i":
+ case "iso-8859-8-i":
+ case "logical":
+ return "ISO-8859-8-I";
+ case "csisolatin6":
+ case "iso-8859-10":
+ case "iso-ir-157":
+ case "iso8859-10":
+ case "iso885910":
+ case "l6":
+ case "latin6":
+ return "ISO-8859-10";
+ case "iso-8859-13":
+ case "iso8859-13":
+ case "iso885913":
+ return "ISO-8859-13";
+ case "iso-8859-14":
+ case "iso8859-14":
+ case "iso885914":
+ return "ISO-8859-14";
+ case "csisolatin9":
+ case "iso-8859-15":
+ case "iso8859-15":
+ case "iso885915":
+ case "iso_8859-15":
+ case "l9":
+ return "ISO-8859-15";
+ case "iso-8859-16":
+ return "ISO-8859-16";
+ case "cskoi8r":
+ case "koi":
+ case "koi8":
+ case "koi8-r":
+ case "koi8_r":
+ return "KOI8-R";
+ case "koi8-ru":
+ case "koi8-u":
+ return "KOI8-U";
+ case "csmacintosh":
+ case "mac":
+ case "macintosh":
+ case "x-mac-roman":
+ return "macintosh";
+ case "iso-8859-11":
+ case "iso8859-11":
+ case "iso885911":
+ case "tis-620":
+ case "windows-874":
+ return "windows-874";
+ case "cp1250":
+ case "windows-1250":
+ case "x-cp1250":
+ return "windows-1250";
+ case "cp1251":
+ case "windows-1251":
+ case "x-cp1251":
+ return "windows-1251";
+ case "ansi_x3.4-1968":
+ case "ascii":
+ case "cp1252":
+ case "cp819":
+ case "csisolatin1":
+ case "ibm819":
+ case "iso-8859-1":
+ case "iso-ir-100":
+ case "iso8859-1":
+ case "iso88591":
+ case "iso_8859-1":
+ case "iso_8859-1:1987":
+ case "l1":
+ case "latin1":
+ case "us-ascii":
+ case "windows-1252":
+ case "x-cp1252":
+ return "windows-1252";
+ case "cp1253":
+ case "windows-1253":
+ case "x-cp1253":
+ return "windows-1253";
+ case "cp1254":
+ case "csisolatin5":
+ case "iso-8859-9":
+ case "iso-ir-148":
+ case "iso8859-9":
+ case "iso88599":
+ case "iso_8859-9":
+ case "iso_8859-9:1989":
+ case "l5":
+ case "latin5":
+ case "windows-1254":
+ case "x-cp1254":
+ return "windows-1254";
+ case "cp1255":
+ case "windows-1255":
+ case "x-cp1255":
+ return "windows-1255";
+ case "cp1256":
+ case "windows-1256":
+ case "x-cp1256":
+ return "windows-1256";
+ case "cp1257":
+ case "windows-1257":
+ case "x-cp1257":
+ return "windows-1257";
+ case "cp1258":
+ case "windows-1258":
+ case "x-cp1258":
+ return "windows-1258";
+ case "x-mac-cyrillic":
+ case "x-mac-ukrainian":
+ return "x-mac-cyrillic";
+ case "chinese":
+ case "csgb2312":
+ case "csiso58gb231280":
+ case "gb2312":
+ case "gb_2312":
+ case "gb_2312-80":
+ case "gbk":
+ case "iso-ir-58":
+ case "x-gbk":
+ return "GBK";
+ case "gb18030":
+ return "gb18030";
+ case "big5":
+ case "big5-hkscs":
+ case "cn-big5":
+ case "csbig5":
+ case "x-x-big5":
+ return "Big5";
+ case "cseucpkdfmtjapanese":
+ case "euc-jp":
+ case "x-euc-jp":
+ return "EUC-JP";
+ case "csiso2022jp":
+ case "iso-2022-jp":
+ return "ISO-2022-JP";
+ case "csshiftjis":
+ case "ms932":
+ case "ms_kanji":
+ case "shift-jis":
+ case "shift_jis":
+ case "sjis":
+ case "windows-31j":
+ case "x-sjis":
+ return "Shift_JIS";
+ case "cseuckr":
+ case "csksc56011987":
+ case "euc-kr":
+ case "iso-ir-149":
+ case "korean":
+ case "ks_c_5601-1987":
+ case "ks_c_5601-1989":
+ case "ksc5601":
+ case "ksc_5601":
+ case "windows-949":
+ return "EUC-KR";
+ case "csiso2022kr":
+ case "hz-gb-2312":
+ case "iso-2022-cn":
+ case "iso-2022-cn-ext":
+ case "iso-2022-kr":
+ case "replacement":
+ return "replacement";
+ case "unicodefffe":
+ case "utf-16be":
+ return "UTF-16BE";
+ case "csunicode":
+ case "iso-10646-ucs-2":
+ case "ucs-2":
+ case "unicode":
+ case "unicodefeff":
+ case "utf-16":
+ case "utf-16le":
+ return "UTF-16LE";
+ case "x-user-defined":
+ return "x-user-defined";
+ default:
+ return "failure";
+ }
+ }
+ __name(getEncoding, "getEncoding");
+ module2.exports = {
+ getEncoding
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/fileapi/util.js
+var require_util3 = __commonJS({
+ "../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/fileapi/util.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var {
+ kState,
+ kError,
+ kResult,
+ kAborted,
+ kLastProgressEventFired
+ } = require_symbols3();
+ var { ProgressEvent } = require_progressevent();
+ var { getEncoding } = require_encoding();
+ var { DOMException } = require_constants();
+ var { serializeAMimeType, parseMIMEType } = require_dataURL();
+ var { types } = require("util");
+ var { StringDecoder: StringDecoder2 } = require("string_decoder");
+ var { btoa: btoa2 } = require("buffer");
+ var staticPropertyDescriptors = {
+ enumerable: true,
+ writable: false,
+ configurable: false
+ };
+ function readOperation(fr2, blob, type, encodingName) {
+ if (fr2[kState] === "loading") {
+ throw new DOMException("Invalid state", "InvalidStateError");
+ }
+ fr2[kState] = "loading";
+ fr2[kResult] = null;
+ fr2[kError] = null;
+ const stream2 = blob.stream();
+ const reader = stream2.getReader();
+ const bytes = [];
+ let chunkPromise = reader.read();
+ let isFirstChunk = true;
+ (async () => {
+ while (!fr2[kAborted]) {
+ try {
+ const { done, value } = await chunkPromise;
+ if (isFirstChunk && !fr2[kAborted]) {
+ queueMicrotask(() => {
+ fireAProgressEvent("loadstart", fr2);
+ });
+ }
+ isFirstChunk = false;
+ if (!done && types.isUint8Array(value)) {
+ bytes.push(value);
+ if ((fr2[kLastProgressEventFired] === void 0 || Date.now() - fr2[kLastProgressEventFired] >= 50) && !fr2[kAborted]) {
+ fr2[kLastProgressEventFired] = Date.now();
+ queueMicrotask(() => {
+ fireAProgressEvent("progress", fr2);
+ });
+ }
+ chunkPromise = reader.read();
+ } else if (done) {
+ queueMicrotask(() => {
+ fr2[kState] = "done";
+ try {
+ const result = packageData(bytes, type, blob.type, encodingName);
+ if (fr2[kAborted]) {
+ return;
+ }
+ fr2[kResult] = result;
+ fireAProgressEvent("load", fr2);
+ } catch (error) {
+ fr2[kError] = error;
+ fireAProgressEvent("error", fr2);
+ }
+ if (fr2[kState] !== "loading") {
+ fireAProgressEvent("loadend", fr2);
+ }
+ });
+ break;
+ }
+ } catch (error) {
+ if (fr2[kAborted]) {
+ return;
+ }
+ queueMicrotask(() => {
+ fr2[kState] = "done";
+ fr2[kError] = error;
+ fireAProgressEvent("error", fr2);
+ if (fr2[kState] !== "loading") {
+ fireAProgressEvent("loadend", fr2);
+ }
+ });
+ break;
+ }
+ }
+ })();
+ }
+ __name(readOperation, "readOperation");
+ function fireAProgressEvent(e2, reader) {
+ const event = new ProgressEvent(e2, {
+ bubbles: false,
+ cancelable: false
+ });
+ reader.dispatchEvent(event);
+ }
+ __name(fireAProgressEvent, "fireAProgressEvent");
+ function packageData(bytes, type, mimeType, encodingName) {
+ switch (type) {
+ case "DataURL": {
+ let dataURL = "data:";
+ const parsed = parseMIMEType(mimeType || "application/octet-stream");
+ if (parsed !== "failure") {
+ dataURL += serializeAMimeType(parsed);
+ }
+ dataURL += ";base64,";
+ const decoder = new StringDecoder2("latin1");
+ for (const chunk of bytes) {
+ dataURL += btoa2(decoder.write(chunk));
+ }
+ dataURL += btoa2(decoder.end());
+ return dataURL;
+ }
+ case "Text": {
+ let encoding = "failure";
+ if (encodingName) {
+ encoding = getEncoding(encodingName);
+ }
+ if (encoding === "failure" && mimeType) {
+ const type2 = parseMIMEType(mimeType);
+ if (type2 !== "failure") {
+ encoding = getEncoding(type2.parameters.get("charset"));
+ }
+ }
+ if (encoding === "failure") {
+ encoding = "UTF-8";
+ }
+ return decode(bytes, encoding);
+ }
+ case "ArrayBuffer": {
+ const sequence = combineByteSequences(bytes);
+ return sequence.buffer;
+ }
+ case "BinaryString": {
+ let binaryString = "";
+ const decoder = new StringDecoder2("latin1");
+ for (const chunk of bytes) {
+ binaryString += decoder.write(chunk);
+ }
+ binaryString += decoder.end();
+ return binaryString;
+ }
+ }
+ }
+ __name(packageData, "packageData");
+ function decode(ioQueue, encoding) {
+ const bytes = combineByteSequences(ioQueue);
+ const BOMEncoding = BOMSniffing(bytes);
+ let slice = 0;
+ if (BOMEncoding !== null) {
+ encoding = BOMEncoding;
+ slice = BOMEncoding === "UTF-8" ? 3 : 2;
+ }
+ const sliced = bytes.slice(slice);
+ return new TextDecoder(encoding).decode(sliced);
+ }
+ __name(decode, "decode");
+ function BOMSniffing(ioQueue) {
+ const [a, b, c] = ioQueue;
+ if (a === 239 && b === 187 && c === 191) {
+ return "UTF-8";
+ } else if (a === 254 && b === 255) {
+ return "UTF-16BE";
+ } else if (a === 255 && b === 254) {
+ return "UTF-16LE";
+ }
+ return null;
+ }
+ __name(BOMSniffing, "BOMSniffing");
+ function combineByteSequences(sequences) {
+ const size = sequences.reduce((a, b) => {
+ return a + b.byteLength;
+ }, 0);
+ let offset = 0;
+ return sequences.reduce((a, b) => {
+ a.set(b, offset);
+ offset += b.byteLength;
+ return a;
+ }, new Uint8Array(size));
+ }
+ __name(combineByteSequences, "combineByteSequences");
+ module2.exports = {
+ staticPropertyDescriptors,
+ readOperation,
+ fireAProgressEvent
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/fileapi/filereader.js
+var require_filereader = __commonJS({
+ "../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/fileapi/filereader.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var {
+ staticPropertyDescriptors,
+ readOperation,
+ fireAProgressEvent
+ } = require_util3();
+ var {
+ kState,
+ kError,
+ kResult,
+ kEvents,
+ kAborted
+ } = require_symbols3();
+ var { webidl } = require_webidl();
+ var { kEnumerableProperty } = require_util();
+ var FileReader = class extends EventTarget {
+ constructor() {
+ super();
+ this[kState] = "empty";
+ this[kResult] = null;
+ this[kError] = null;
+ this[kEvents] = {
+ loadend: null,
+ error: null,
+ abort: null,
+ load: null,
+ progress: null,
+ loadstart: null
+ };
+ }
+ /**
+ * @see https://w3c.github.io/FileAPI/#dfn-readAsArrayBuffer
+ * @param {import('buffer').Blob} blob
+ */
+ readAsArrayBuffer(blob) {
+ webidl.brandCheck(this, FileReader);
+ webidl.argumentLengthCheck(arguments, 1, { header: "FileReader.readAsArrayBuffer" });
+ blob = webidl.converters.Blob(blob, { strict: false });
+ readOperation(this, blob, "ArrayBuffer");
+ }
+ /**
+ * @see https://w3c.github.io/FileAPI/#readAsBinaryString
+ * @param {import('buffer').Blob} blob
+ */
+ readAsBinaryString(blob) {
+ webidl.brandCheck(this, FileReader);
+ webidl.argumentLengthCheck(arguments, 1, { header: "FileReader.readAsBinaryString" });
+ blob = webidl.converters.Blob(blob, { strict: false });
+ readOperation(this, blob, "BinaryString");
+ }
+ /**
+ * @see https://w3c.github.io/FileAPI/#readAsDataText
+ * @param {import('buffer').Blob} blob
+ * @param {string?} encoding
+ */
+ readAsText(blob, encoding = void 0) {
+ webidl.brandCheck(this, FileReader);
+ webidl.argumentLengthCheck(arguments, 1, { header: "FileReader.readAsText" });
+ blob = webidl.converters.Blob(blob, { strict: false });
+ if (encoding !== void 0) {
+ encoding = webidl.converters.DOMString(encoding);
+ }
+ readOperation(this, blob, "Text", encoding);
+ }
+ /**
+ * @see https://w3c.github.io/FileAPI/#dfn-readAsDataURL
+ * @param {import('buffer').Blob} blob
+ */
+ readAsDataURL(blob) {
+ webidl.brandCheck(this, FileReader);
+ webidl.argumentLengthCheck(arguments, 1, { header: "FileReader.readAsDataURL" });
+ blob = webidl.converters.Blob(blob, { strict: false });
+ readOperation(this, blob, "DataURL");
+ }
+ /**
+ * @see https://w3c.github.io/FileAPI/#dfn-abort
+ */
+ abort() {
+ if (this[kState] === "empty" || this[kState] === "done") {
+ this[kResult] = null;
+ return;
+ }
+ if (this[kState] === "loading") {
+ this[kState] = "done";
+ this[kResult] = null;
+ }
+ this[kAborted] = true;
+ fireAProgressEvent("abort", this);
+ if (this[kState] !== "loading") {
+ fireAProgressEvent("loadend", this);
+ }
+ }
+ /**
+ * @see https://w3c.github.io/FileAPI/#dom-filereader-readystate
+ */
+ get readyState() {
+ webidl.brandCheck(this, FileReader);
+ switch (this[kState]) {
+ case "empty":
+ return this.EMPTY;
+ case "loading":
+ return this.LOADING;
+ case "done":
+ return this.DONE;
+ }
+ }
+ /**
+ * @see https://w3c.github.io/FileAPI/#dom-filereader-result
+ */
+ get result() {
+ webidl.brandCheck(this, FileReader);
+ return this[kResult];
+ }
+ /**
+ * @see https://w3c.github.io/FileAPI/#dom-filereader-error
+ */
+ get error() {
+ webidl.brandCheck(this, FileReader);
+ return this[kError];
+ }
+ get onloadend() {
+ webidl.brandCheck(this, FileReader);
+ return this[kEvents].loadend;
+ }
+ set onloadend(fn2) {
+ webidl.brandCheck(this, FileReader);
+ if (this[kEvents].loadend) {
+ this.removeEventListener("loadend", this[kEvents].loadend);
+ }
+ if (typeof fn2 === "function") {
+ this[kEvents].loadend = fn2;
+ this.addEventListener("loadend", fn2);
+ } else {
+ this[kEvents].loadend = null;
+ }
+ }
+ get onerror() {
+ webidl.brandCheck(this, FileReader);
+ return this[kEvents].error;
+ }
+ set onerror(fn2) {
+ webidl.brandCheck(this, FileReader);
+ if (this[kEvents].error) {
+ this.removeEventListener("error", this[kEvents].error);
+ }
+ if (typeof fn2 === "function") {
+ this[kEvents].error = fn2;
+ this.addEventListener("error", fn2);
+ } else {
+ this[kEvents].error = null;
+ }
+ }
+ get onloadstart() {
+ webidl.brandCheck(this, FileReader);
+ return this[kEvents].loadstart;
+ }
+ set onloadstart(fn2) {
+ webidl.brandCheck(this, FileReader);
+ if (this[kEvents].loadstart) {
+ this.removeEventListener("loadstart", this[kEvents].loadstart);
+ }
+ if (typeof fn2 === "function") {
+ this[kEvents].loadstart = fn2;
+ this.addEventListener("loadstart", fn2);
+ } else {
+ this[kEvents].loadstart = null;
+ }
+ }
+ get onprogress() {
+ webidl.brandCheck(this, FileReader);
+ return this[kEvents].progress;
+ }
+ set onprogress(fn2) {
+ webidl.brandCheck(this, FileReader);
+ if (this[kEvents].progress) {
+ this.removeEventListener("progress", this[kEvents].progress);
+ }
+ if (typeof fn2 === "function") {
+ this[kEvents].progress = fn2;
+ this.addEventListener("progress", fn2);
+ } else {
+ this[kEvents].progress = null;
+ }
+ }
+ get onload() {
+ webidl.brandCheck(this, FileReader);
+ return this[kEvents].load;
+ }
+ set onload(fn2) {
+ webidl.brandCheck(this, FileReader);
+ if (this[kEvents].load) {
+ this.removeEventListener("load", this[kEvents].load);
+ }
+ if (typeof fn2 === "function") {
+ this[kEvents].load = fn2;
+ this.addEventListener("load", fn2);
+ } else {
+ this[kEvents].load = null;
+ }
+ }
+ get onabort() {
+ webidl.brandCheck(this, FileReader);
+ return this[kEvents].abort;
+ }
+ set onabort(fn2) {
+ webidl.brandCheck(this, FileReader);
+ if (this[kEvents].abort) {
+ this.removeEventListener("abort", this[kEvents].abort);
+ }
+ if (typeof fn2 === "function") {
+ this[kEvents].abort = fn2;
+ this.addEventListener("abort", fn2);
+ } else {
+ this[kEvents].abort = null;
+ }
+ }
+ };
+ __name(FileReader, "FileReader");
+ FileReader.EMPTY = FileReader.prototype.EMPTY = 0;
+ FileReader.LOADING = FileReader.prototype.LOADING = 1;
+ FileReader.DONE = FileReader.prototype.DONE = 2;
+ Object.defineProperties(FileReader.prototype, {
+ EMPTY: staticPropertyDescriptors,
+ LOADING: staticPropertyDescriptors,
+ DONE: staticPropertyDescriptors,
+ readAsArrayBuffer: kEnumerableProperty,
+ readAsBinaryString: kEnumerableProperty,
+ readAsText: kEnumerableProperty,
+ readAsDataURL: kEnumerableProperty,
+ abort: kEnumerableProperty,
+ readyState: kEnumerableProperty,
+ result: kEnumerableProperty,
+ error: kEnumerableProperty,
+ onloadstart: kEnumerableProperty,
+ onprogress: kEnumerableProperty,
+ onload: kEnumerableProperty,
+ onabort: kEnumerableProperty,
+ onerror: kEnumerableProperty,
+ onloadend: kEnumerableProperty,
+ [Symbol.toStringTag]: {
+ value: "FileReader",
+ writable: false,
+ enumerable: false,
+ configurable: true
+ }
+ });
+ Object.defineProperties(FileReader, {
+ EMPTY: staticPropertyDescriptors,
+ LOADING: staticPropertyDescriptors,
+ DONE: staticPropertyDescriptors
+ });
+ module2.exports = {
+ FileReader
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/cookies/constants.js
+var require_constants3 = __commonJS({
+ "../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/cookies/constants.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var maxAttributeValueSize = 1024;
+ var maxNameValuePairSize = 4096;
+ module2.exports = {
+ maxAttributeValueSize,
+ maxNameValuePairSize
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/cookies/util.js
+var require_util4 = __commonJS({
+ "../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/cookies/util.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var assert18 = require("assert");
+ var { kHeadersList } = require_symbols();
+ function isCTLExcludingHtab(value) {
+ if (value.length === 0) {
+ return false;
+ }
+ for (const char of value) {
+ const code = char.charCodeAt(0);
+ if (code >= 0 || code <= 8 || (code >= 10 || code <= 31) || code === 127) {
+ return false;
+ }
+ }
+ }
+ __name(isCTLExcludingHtab, "isCTLExcludingHtab");
+ function validateCookieName(name) {
+ for (const char of name) {
+ const code = char.charCodeAt(0);
+ if (code <= 32 || code > 127 || char === "(" || char === ")" || char === ">" || char === "<" || char === "@" || char === "," || char === ";" || char === ":" || char === "\\" || char === '"' || char === "/" || char === "[" || char === "]" || char === "?" || char === "=" || char === "{" || char === "}") {
+ throw new Error("Invalid cookie name");
+ }
+ }
+ }
+ __name(validateCookieName, "validateCookieName");
+ function validateCookieValue(value) {
+ for (const char of value) {
+ const code = char.charCodeAt(0);
+ if (code < 33 || // exclude CTLs (0-31)
+ code === 34 || code === 44 || code === 59 || code === 92 || code > 126) {
+ throw new Error("Invalid header value");
+ }
+ }
+ }
+ __name(validateCookieValue, "validateCookieValue");
+ function validateCookiePath(path45) {
+ for (const char of path45) {
+ const code = char.charCodeAt(0);
+ if (code < 33 || char === ";") {
+ throw new Error("Invalid cookie path");
+ }
+ }
+ }
+ __name(validateCookiePath, "validateCookiePath");
+ function validateCookieDomain(domain) {
+ if (domain.startsWith("-") || domain.endsWith(".") || domain.endsWith("-")) {
+ throw new Error("Invalid cookie domain");
+ }
+ }
+ __name(validateCookieDomain, "validateCookieDomain");
+ function toIMFDate(date) {
+ if (typeof date === "number") {
+ date = new Date(date);
+ }
+ const days = [
+ "Sun",
+ "Mon",
+ "Tue",
+ "Wed",
+ "Thu",
+ "Fri",
+ "Sat"
+ ];
+ const months = [
+ "Jan",
+ "Feb",
+ "Mar",
+ "Apr",
+ "May",
+ "Jun",
+ "Jul",
+ "Aug",
+ "Sep",
+ "Oct",
+ "Nov",
+ "Dec"
+ ];
+ const dayName = days[date.getUTCDay()];
+ const day2 = date.getUTCDate().toString().padStart(2, "0");
+ const month2 = months[date.getUTCMonth()];
+ const year2 = date.getUTCFullYear();
+ const hour2 = date.getUTCHours().toString().padStart(2, "0");
+ const minute2 = date.getUTCMinutes().toString().padStart(2, "0");
+ const second = date.getUTCSeconds().toString().padStart(2, "0");
+ return `${dayName}, ${day2} ${month2} ${year2} ${hour2}:${minute2}:${second} GMT`;
+ }
+ __name(toIMFDate, "toIMFDate");
+ function validateCookieMaxAge(maxAge) {
+ if (maxAge < 0) {
+ throw new Error("Invalid cookie max-age");
+ }
+ }
+ __name(validateCookieMaxAge, "validateCookieMaxAge");
+ function stringify(cookie) {
+ if (cookie.name.length === 0) {
+ return null;
+ }
+ validateCookieName(cookie.name);
+ validateCookieValue(cookie.value);
+ const out = [`${cookie.name}=${cookie.value}`];
+ if (cookie.name.startsWith("__Secure-")) {
+ cookie.secure = true;
+ }
+ if (cookie.name.startsWith("__Host-")) {
+ cookie.secure = true;
+ cookie.domain = null;
+ cookie.path = "/";
+ }
+ if (cookie.secure) {
+ out.push("Secure");
+ }
+ if (cookie.httpOnly) {
+ out.push("HttpOnly");
+ }
+ if (typeof cookie.maxAge === "number") {
+ validateCookieMaxAge(cookie.maxAge);
+ out.push(`Max-Age=${cookie.maxAge}`);
+ }
+ if (cookie.domain) {
+ validateCookieDomain(cookie.domain);
+ out.push(`Domain=${cookie.domain}`);
+ }
+ if (cookie.path) {
+ validateCookiePath(cookie.path);
+ out.push(`Path=${cookie.path}`);
+ }
+ if (cookie.expires && cookie.expires.toString() !== "Invalid Date") {
+ out.push(`Expires=${toIMFDate(cookie.expires)}`);
+ }
+ if (cookie.sameSite) {
+ out.push(`SameSite=${cookie.sameSite}`);
+ }
+ for (const part of cookie.unparsed) {
+ if (!part.includes("=")) {
+ throw new Error("Invalid unparsed");
+ }
+ const [key, ...value] = part.split("=");
+ out.push(`${key.trim()}=${value.join("=")}`);
+ }
+ return out.join("; ");
+ }
+ __name(stringify, "stringify");
+ var kHeadersListNode;
+ function getHeadersList(headers) {
+ if (headers[kHeadersList]) {
+ return headers[kHeadersList];
+ }
+ if (!kHeadersListNode) {
+ kHeadersListNode = Object.getOwnPropertySymbols(headers).find(
+ (symbol) => symbol.description === "headers list"
+ );
+ assert18(kHeadersListNode, "Headers cannot be parsed");
+ }
+ const headersList = headers[kHeadersListNode];
+ assert18(headersList);
+ return headersList;
+ }
+ __name(getHeadersList, "getHeadersList");
+ module2.exports = {
+ isCTLExcludingHtab,
+ stringify,
+ getHeadersList
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/cookies/parse.js
+var require_parse = __commonJS({
+ "../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/cookies/parse.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var { maxNameValuePairSize, maxAttributeValueSize } = require_constants3();
+ var { isCTLExcludingHtab } = require_util4();
+ var { collectASequenceOfCodePointsFast } = require_dataURL();
+ var assert18 = require("assert");
+ function parseSetCookie(header) {
+ if (isCTLExcludingHtab(header)) {
+ return null;
+ }
+ let nameValuePair = "";
+ let unparsedAttributes = "";
+ let name = "";
+ let value = "";
+ if (header.includes(";")) {
+ const position = { position: 0 };
+ nameValuePair = collectASequenceOfCodePointsFast(";", header, position);
+ unparsedAttributes = header.slice(position.position);
+ } else {
+ nameValuePair = header;
+ }
+ if (!nameValuePair.includes("=")) {
+ value = nameValuePair;
+ } else {
+ const position = { position: 0 };
+ name = collectASequenceOfCodePointsFast(
+ "=",
+ nameValuePair,
+ position
+ );
+ value = nameValuePair.slice(position.position + 1);
+ }
+ name = name.trim();
+ value = value.trim();
+ if (name.length + value.length > maxNameValuePairSize) {
+ return null;
+ }
+ return {
+ name,
+ value,
+ ...parseUnparsedAttributes(unparsedAttributes)
+ };
+ }
+ __name(parseSetCookie, "parseSetCookie");
+ function parseUnparsedAttributes(unparsedAttributes, cookieAttributeList = {}) {
+ if (unparsedAttributes.length === 0) {
+ return cookieAttributeList;
+ }
+ assert18(unparsedAttributes[0] === ";");
+ unparsedAttributes = unparsedAttributes.slice(1);
+ let cookieAv = "";
+ if (unparsedAttributes.includes(";")) {
+ cookieAv = collectASequenceOfCodePointsFast(
+ ";",
+ unparsedAttributes,
+ { position: 0 }
+ );
+ unparsedAttributes = unparsedAttributes.slice(cookieAv.length);
+ } else {
+ cookieAv = unparsedAttributes;
+ unparsedAttributes = "";
+ }
+ let attributeName = "";
+ let attributeValue = "";
+ if (cookieAv.includes("=")) {
+ const position = { position: 0 };
+ attributeName = collectASequenceOfCodePointsFast(
+ "=",
+ cookieAv,
+ position
+ );
+ attributeValue = cookieAv.slice(position.position + 1);
+ } else {
+ attributeName = cookieAv;
+ }
+ attributeName = attributeName.trim();
+ attributeValue = attributeValue.trim();
+ if (attributeValue.length > maxAttributeValueSize) {
+ return parseUnparsedAttributes(unparsedAttributes, cookieAttributeList);
+ }
+ const attributeNameLowercase = attributeName.toLowerCase();
+ if (attributeNameLowercase === "expires") {
+ const expiryTime = new Date(attributeValue);
+ cookieAttributeList.expires = expiryTime;
+ } else if (attributeNameLowercase === "max-age") {
+ const charCode = attributeValue.charCodeAt(0);
+ if ((charCode < 48 || charCode > 57) && attributeValue[0] !== "-") {
+ return parseUnparsedAttributes(unparsedAttributes, cookieAttributeList);
+ }
+ if (!/^\d+$/.test(attributeValue)) {
+ return parseUnparsedAttributes(unparsedAttributes, cookieAttributeList);
+ }
+ const deltaSeconds = Number(attributeValue);
+ cookieAttributeList.maxAge = deltaSeconds;
+ } else if (attributeNameLowercase === "domain") {
+ let cookieDomain = attributeValue;
+ if (cookieDomain[0] === ".") {
+ cookieDomain = cookieDomain.slice(1);
+ }
+ cookieDomain = cookieDomain.toLowerCase();
+ cookieAttributeList.domain = cookieDomain;
+ } else if (attributeNameLowercase === "path") {
+ let cookiePath = "";
+ if (attributeValue.length === 0 || attributeValue[0] !== "/") {
+ cookiePath = "/";
+ } else {
+ cookiePath = attributeValue;
+ }
+ cookieAttributeList.path = cookiePath;
+ } else if (attributeNameLowercase === "secure") {
+ cookieAttributeList.secure = true;
+ } else if (attributeNameLowercase === "httponly") {
+ cookieAttributeList.httpOnly = true;
+ } else if (attributeNameLowercase === "samesite") {
+ let enforcement = "Default";
+ const attributeValueLowercase = attributeValue.toLowerCase();
+ if (attributeValueLowercase.includes("none")) {
+ enforcement = "None";
+ }
+ if (attributeValueLowercase.includes("strict")) {
+ enforcement = "Strict";
+ }
+ if (attributeValueLowercase.includes("lax")) {
+ enforcement = "Lax";
+ }
+ cookieAttributeList.sameSite = enforcement;
+ } else {
+ cookieAttributeList.unparsed ??= [];
+ cookieAttributeList.unparsed.push(`${attributeName}=${attributeValue}`);
+ }
+ return parseUnparsedAttributes(unparsedAttributes, cookieAttributeList);
+ }
+ __name(parseUnparsedAttributes, "parseUnparsedAttributes");
+ module2.exports = {
+ parseSetCookie,
+ parseUnparsedAttributes
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/cookies/index.js
+var require_cookies = __commonJS({
+ "../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/cookies/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var { parseSetCookie } = require_parse();
+ var { stringify, getHeadersList } = require_util4();
+ var { webidl } = require_webidl();
+ var { Headers: Headers3 } = require_headers();
+ function getCookies(headers) {
+ webidl.argumentLengthCheck(arguments, 1, { header: "getCookies" });
+ webidl.brandCheck(headers, Headers3, { strict: false });
+ const cookie = headers.get("cookie");
+ const out = {};
+ if (!cookie) {
+ return out;
+ }
+ for (const piece of cookie.split(";")) {
+ const [name, ...value] = piece.split("=");
+ out[name.trim()] = value.join("=");
+ }
+ return out;
+ }
+ __name(getCookies, "getCookies");
+ function deleteCookie(headers, name, attributes) {
+ webidl.argumentLengthCheck(arguments, 2, { header: "deleteCookie" });
+ webidl.brandCheck(headers, Headers3, { strict: false });
+ name = webidl.converters.DOMString(name);
+ attributes = webidl.converters.DeleteCookieAttributes(attributes);
+ setCookie(headers, {
+ name,
+ value: "",
+ expires: /* @__PURE__ */ new Date(0),
+ ...attributes
+ });
+ }
+ __name(deleteCookie, "deleteCookie");
+ function getSetCookies(headers) {
+ webidl.argumentLengthCheck(arguments, 1, { header: "getSetCookies" });
+ webidl.brandCheck(headers, Headers3, { strict: false });
+ const cookies = getHeadersList(headers).cookies;
+ if (!cookies) {
+ return [];
+ }
+ return cookies.map((pair) => parseSetCookie(Array.isArray(pair) ? pair[1] : pair));
+ }
+ __name(getSetCookies, "getSetCookies");
+ function setCookie(headers, cookie) {
+ webidl.argumentLengthCheck(arguments, 2, { header: "setCookie" });
+ webidl.brandCheck(headers, Headers3, { strict: false });
+ cookie = webidl.converters.Cookie(cookie);
+ const str = stringify(cookie);
+ if (str) {
+ headers.append("Set-Cookie", stringify(cookie));
+ }
+ }
+ __name(setCookie, "setCookie");
+ webidl.converters.DeleteCookieAttributes = webidl.dictionaryConverter([
+ {
+ converter: webidl.nullableConverter(webidl.converters.DOMString),
+ key: "path",
+ defaultValue: null
+ },
+ {
+ converter: webidl.nullableConverter(webidl.converters.DOMString),
+ key: "domain",
+ defaultValue: null
+ }
+ ]);
+ webidl.converters.Cookie = webidl.dictionaryConverter([
+ {
+ converter: webidl.converters.DOMString,
+ key: "name"
+ },
+ {
+ converter: webidl.converters.DOMString,
+ key: "value"
+ },
+ {
+ converter: webidl.nullableConverter((value) => {
+ if (typeof value === "number") {
+ return webidl.converters["unsigned long long"](value);
+ }
+ return new Date(value);
+ }),
+ key: "expires",
+ defaultValue: null
+ },
+ {
+ converter: webidl.nullableConverter(webidl.converters["long long"]),
+ key: "maxAge",
+ defaultValue: null
+ },
+ {
+ converter: webidl.nullableConverter(webidl.converters.DOMString),
+ key: "domain",
+ defaultValue: null
+ },
+ {
+ converter: webidl.nullableConverter(webidl.converters.DOMString),
+ key: "path",
+ defaultValue: null
+ },
+ {
+ converter: webidl.nullableConverter(webidl.converters.boolean),
+ key: "secure",
+ defaultValue: null
+ },
+ {
+ converter: webidl.nullableConverter(webidl.converters.boolean),
+ key: "httpOnly",
+ defaultValue: null
+ },
+ {
+ converter: webidl.converters.USVString,
+ key: "sameSite",
+ allowedValues: ["Strict", "Lax", "None"]
+ },
+ {
+ converter: webidl.sequenceConverter(webidl.converters.DOMString),
+ key: "unparsed",
+ defaultValue: []
+ }
+ ]);
+ module2.exports = {
+ getCookies,
+ deleteCookie,
+ getSetCookies,
+ setCookie
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/websocket/constants.js
+var require_constants4 = __commonJS({
+ "../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/websocket/constants.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var uid = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
+ var staticPropertyDescriptors = {
+ enumerable: true,
+ writable: false,
+ configurable: false
+ };
+ var states = {
+ CONNECTING: 0,
+ OPEN: 1,
+ CLOSING: 2,
+ CLOSED: 3
+ };
+ var opcodes = {
+ CONTINUATION: 0,
+ TEXT: 1,
+ BINARY: 2,
+ CLOSE: 8,
+ PING: 9,
+ PONG: 10
+ };
+ var maxUnsigned16Bit = 2 ** 16 - 1;
+ var parserStates = {
+ INFO: 0,
+ PAYLOADLENGTH_16: 2,
+ PAYLOADLENGTH_64: 3,
+ READ_DATA: 4
+ };
+ var emptyBuffer = Buffer.allocUnsafe(0);
+ module2.exports = {
+ uid,
+ staticPropertyDescriptors,
+ states,
+ opcodes,
+ maxUnsigned16Bit,
+ parserStates,
+ emptyBuffer
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/websocket/symbols.js
+var require_symbols4 = __commonJS({
+ "../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/websocket/symbols.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ module2.exports = {
+ kWebSocketURL: Symbol("url"),
+ kReadyState: Symbol("ready state"),
+ kController: Symbol("controller"),
+ kResponse: Symbol("response"),
+ kExtensions: Symbol("extensions"),
+ kProtocol: Symbol("protocol"),
+ kBinaryType: Symbol("binary type"),
+ kClosingFrame: Symbol("closing frame"),
+ kSentClose: Symbol("sent close"),
+ kReceivedClose: Symbol("received close"),
+ kByteParser: Symbol("byte parser")
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/websocket/events.js
+var require_events = __commonJS({
+ "../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/websocket/events.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var { webidl } = require_webidl();
+ var { kEnumerableProperty } = require_util();
+ var { MessagePort } = require("worker_threads");
+ var MessageEvent = class extends Event {
+ #eventInit;
+ constructor(type, eventInitDict = {}) {
+ webidl.argumentLengthCheck(arguments, 1, { header: "MessageEvent constructor" });
+ type = webidl.converters.DOMString(type);
+ eventInitDict = webidl.converters.MessageEventInit(eventInitDict);
+ super(type, eventInitDict);
+ this.#eventInit = eventInitDict;
+ }
+ get data() {
+ webidl.brandCheck(this, MessageEvent);
+ return this.#eventInit.data;
+ }
+ get origin() {
+ webidl.brandCheck(this, MessageEvent);
+ return this.#eventInit.origin;
+ }
+ get lastEventId() {
+ webidl.brandCheck(this, MessageEvent);
+ return this.#eventInit.lastEventId;
+ }
+ get source() {
+ webidl.brandCheck(this, MessageEvent);
+ return this.#eventInit.source;
+ }
+ get ports() {
+ webidl.brandCheck(this, MessageEvent);
+ if (!Object.isFrozen(this.#eventInit.ports)) {
+ Object.freeze(this.#eventInit.ports);
+ }
+ return this.#eventInit.ports;
+ }
+ initMessageEvent(type, bubbles = false, cancelable = false, data = null, origin = "", lastEventId = "", source = null, ports = []) {
+ webidl.brandCheck(this, MessageEvent);
+ webidl.argumentLengthCheck(arguments, 1, { header: "MessageEvent.initMessageEvent" });
+ return new MessageEvent(type, {
+ bubbles,
+ cancelable,
+ data,
+ origin,
+ lastEventId,
+ source,
+ ports
+ });
+ }
+ };
+ __name(MessageEvent, "MessageEvent");
+ var CloseEvent = class extends Event {
+ #eventInit;
+ constructor(type, eventInitDict = {}) {
+ webidl.argumentLengthCheck(arguments, 1, { header: "CloseEvent constructor" });
+ type = webidl.converters.DOMString(type);
+ eventInitDict = webidl.converters.CloseEventInit(eventInitDict);
+ super(type, eventInitDict);
+ this.#eventInit = eventInitDict;
+ }
+ get wasClean() {
+ webidl.brandCheck(this, CloseEvent);
+ return this.#eventInit.wasClean;
+ }
+ get code() {
+ webidl.brandCheck(this, CloseEvent);
+ return this.#eventInit.code;
+ }
+ get reason() {
+ webidl.brandCheck(this, CloseEvent);
+ return this.#eventInit.reason;
+ }
+ };
+ __name(CloseEvent, "CloseEvent");
+ var ErrorEvent2 = class extends Event {
+ #eventInit;
+ constructor(type, eventInitDict) {
+ webidl.argumentLengthCheck(arguments, 1, { header: "ErrorEvent constructor" });
+ super(type, eventInitDict);
+ type = webidl.converters.DOMString(type);
+ eventInitDict = webidl.converters.ErrorEventInit(eventInitDict ?? {});
+ this.#eventInit = eventInitDict;
+ }
+ get message() {
+ webidl.brandCheck(this, ErrorEvent2);
+ return this.#eventInit.message;
+ }
+ get filename() {
+ webidl.brandCheck(this, ErrorEvent2);
+ return this.#eventInit.filename;
+ }
+ get lineno() {
+ webidl.brandCheck(this, ErrorEvent2);
+ return this.#eventInit.lineno;
+ }
+ get colno() {
+ webidl.brandCheck(this, ErrorEvent2);
+ return this.#eventInit.colno;
+ }
+ get error() {
+ webidl.brandCheck(this, ErrorEvent2);
+ return this.#eventInit.error;
+ }
+ };
+ __name(ErrorEvent2, "ErrorEvent");
+ Object.defineProperties(MessageEvent.prototype, {
+ [Symbol.toStringTag]: {
+ value: "MessageEvent",
+ configurable: true
+ },
+ data: kEnumerableProperty,
+ origin: kEnumerableProperty,
+ lastEventId: kEnumerableProperty,
+ source: kEnumerableProperty,
+ ports: kEnumerableProperty,
+ initMessageEvent: kEnumerableProperty
+ });
+ Object.defineProperties(CloseEvent.prototype, {
+ [Symbol.toStringTag]: {
+ value: "CloseEvent",
+ configurable: true
+ },
+ reason: kEnumerableProperty,
+ code: kEnumerableProperty,
+ wasClean: kEnumerableProperty
+ });
+ Object.defineProperties(ErrorEvent2.prototype, {
+ [Symbol.toStringTag]: {
+ value: "ErrorEvent",
+ configurable: true
+ },
+ message: kEnumerableProperty,
+ filename: kEnumerableProperty,
+ lineno: kEnumerableProperty,
+ colno: kEnumerableProperty,
+ error: kEnumerableProperty
+ });
+ webidl.converters.MessagePort = webidl.interfaceConverter(MessagePort);
+ webidl.converters["sequence"] = webidl.sequenceConverter(
+ webidl.converters.MessagePort
+ );
+ var eventInit = [
+ {
+ key: "bubbles",
+ converter: webidl.converters.boolean,
+ defaultValue: false
+ },
+ {
+ key: "cancelable",
+ converter: webidl.converters.boolean,
+ defaultValue: false
+ },
+ {
+ key: "composed",
+ converter: webidl.converters.boolean,
+ defaultValue: false
+ }
+ ];
+ webidl.converters.MessageEventInit = webidl.dictionaryConverter([
+ ...eventInit,
+ {
+ key: "data",
+ converter: webidl.converters.any,
+ defaultValue: null
+ },
+ {
+ key: "origin",
+ converter: webidl.converters.USVString,
+ defaultValue: ""
+ },
+ {
+ key: "lastEventId",
+ converter: webidl.converters.DOMString,
+ defaultValue: ""
+ },
+ {
+ key: "source",
+ // Node doesn't implement WindowProxy or ServiceWorker, so the only
+ // valid value for source is a MessagePort.
+ converter: webidl.nullableConverter(webidl.converters.MessagePort),
+ defaultValue: null
+ },
+ {
+ key: "ports",
+ converter: webidl.converters["sequence"],
+ get defaultValue() {
+ return [];
+ }
+ }
+ ]);
+ webidl.converters.CloseEventInit = webidl.dictionaryConverter([
+ ...eventInit,
+ {
+ key: "wasClean",
+ converter: webidl.converters.boolean,
+ defaultValue: false
+ },
+ {
+ key: "code",
+ converter: webidl.converters["unsigned short"],
+ defaultValue: 0
+ },
+ {
+ key: "reason",
+ converter: webidl.converters.USVString,
+ defaultValue: ""
+ }
+ ]);
+ webidl.converters.ErrorEventInit = webidl.dictionaryConverter([
+ ...eventInit,
+ {
+ key: "message",
+ converter: webidl.converters.DOMString,
+ defaultValue: ""
+ },
+ {
+ key: "filename",
+ converter: webidl.converters.USVString,
+ defaultValue: ""
+ },
+ {
+ key: "lineno",
+ converter: webidl.converters["unsigned long"],
+ defaultValue: 0
+ },
+ {
+ key: "colno",
+ converter: webidl.converters["unsigned long"],
+ defaultValue: 0
+ },
+ {
+ key: "error",
+ converter: webidl.converters.any
+ }
+ ]);
+ module2.exports = {
+ MessageEvent,
+ CloseEvent,
+ ErrorEvent: ErrorEvent2
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/websocket/util.js
+var require_util5 = __commonJS({
+ "../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/websocket/util.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var { kReadyState, kController, kResponse, kBinaryType, kWebSocketURL } = require_symbols4();
+ var { states, opcodes } = require_constants4();
+ var { MessageEvent, ErrorEvent: ErrorEvent2 } = require_events();
+ function isEstablished(ws) {
+ return ws[kReadyState] === states.OPEN;
+ }
+ __name(isEstablished, "isEstablished");
+ function isClosing(ws) {
+ return ws[kReadyState] === states.CLOSING;
+ }
+ __name(isClosing, "isClosing");
+ function isClosed(ws) {
+ return ws[kReadyState] === states.CLOSED;
+ }
+ __name(isClosed, "isClosed");
+ function fireEvent(e2, target, eventConstructor = Event, eventInitDict) {
+ const event = new eventConstructor(e2, eventInitDict);
+ target.dispatchEvent(event);
+ }
+ __name(fireEvent, "fireEvent");
+ function websocketMessageReceived(ws, type, data) {
+ if (ws[kReadyState] !== states.OPEN) {
+ return;
+ }
+ let dataForEvent;
+ if (type === opcodes.TEXT) {
+ try {
+ dataForEvent = new TextDecoder("utf-8", { fatal: true }).decode(data);
+ } catch {
+ failWebsocketConnection(ws, "Received invalid UTF-8 in text frame.");
+ return;
+ }
+ } else if (type === opcodes.BINARY) {
+ if (ws[kBinaryType] === "blob") {
+ dataForEvent = new Blob([data]);
+ } else {
+ dataForEvent = new Uint8Array(data).buffer;
+ }
+ }
+ fireEvent("message", ws, MessageEvent, {
+ origin: ws[kWebSocketURL].origin,
+ data: dataForEvent
+ });
+ }
+ __name(websocketMessageReceived, "websocketMessageReceived");
+ function isValidSubprotocol(protocol) {
+ if (protocol.length === 0) {
+ return false;
+ }
+ for (const char of protocol) {
+ const code = char.charCodeAt(0);
+ if (code < 33 || code > 126 || char === "(" || char === ")" || char === "<" || char === ">" || char === "@" || char === "," || char === ";" || char === ":" || char === "\\" || char === '"' || char === "/" || char === "[" || char === "]" || char === "?" || char === "=" || char === "{" || char === "}" || code === 32 || // SP
+ code === 9) {
+ return false;
+ }
+ }
+ return true;
+ }
+ __name(isValidSubprotocol, "isValidSubprotocol");
+ function isValidStatusCode(code) {
+ if (code >= 1e3 && code < 1015) {
+ return code !== 1004 && // reserved
+ code !== 1005 && // "MUST NOT be set as a status code"
+ code !== 1006;
+ }
+ return code >= 3e3 && code <= 4999;
+ }
+ __name(isValidStatusCode, "isValidStatusCode");
+ function failWebsocketConnection(ws, reason) {
+ const { [kController]: controller, [kResponse]: response } = ws;
+ controller.abort();
+ if (response?.socket && !response.socket.destroyed) {
+ response.socket.destroy();
+ }
+ if (reason) {
+ fireEvent("error", ws, ErrorEvent2, {
+ error: new Error(reason)
+ });
+ }
+ }
+ __name(failWebsocketConnection, "failWebsocketConnection");
+ module2.exports = {
+ isEstablished,
+ isClosing,
+ isClosed,
+ fireEvent,
+ isValidSubprotocol,
+ isValidStatusCode,
+ failWebsocketConnection,
+ websocketMessageReceived
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/websocket/frame.js
+var require_frame = __commonJS({
+ "../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/websocket/frame.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var { randomBytes } = require("crypto");
+ var { maxUnsigned16Bit } = require_constants4();
+ var WebsocketFrameSend = class {
+ /**
+ * @param {Buffer|undefined} data
+ */
+ constructor(data) {
+ this.frameData = data;
+ this.maskKey = randomBytes(4);
+ }
+ createFrame(opcode) {
+ const bodyLength = this.frameData?.byteLength ?? 0;
+ let payloadLength = bodyLength;
+ let offset = 6;
+ if (bodyLength > maxUnsigned16Bit) {
+ offset += 8;
+ payloadLength = 127;
+ } else if (bodyLength > 125) {
+ offset += 2;
+ payloadLength = 126;
+ }
+ const buffer = Buffer.allocUnsafe(bodyLength + offset);
+ buffer[0] = buffer[1] = 0;
+ buffer[0] |= 128;
+ buffer[0] = (buffer[0] & 240) + opcode;
+ buffer[offset - 4] = this.maskKey[0];
+ buffer[offset - 3] = this.maskKey[1];
+ buffer[offset - 2] = this.maskKey[2];
+ buffer[offset - 1] = this.maskKey[3];
+ buffer[1] = payloadLength;
+ if (payloadLength === 126) {
+ new DataView(buffer.buffer).setUint16(2, bodyLength);
+ } else if (payloadLength === 127) {
+ buffer[2] = buffer[3] = 0;
+ buffer.writeUIntBE(bodyLength, 4, 6);
+ }
+ buffer[1] |= 128;
+ for (let i = 0; i < bodyLength; i++) {
+ buffer[offset + i] = this.frameData[i] ^ this.maskKey[i % 4];
+ }
+ return buffer;
+ }
+ };
+ __name(WebsocketFrameSend, "WebsocketFrameSend");
+ module2.exports = {
+ WebsocketFrameSend
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/websocket/receiver.js
+var require_receiver = __commonJS({
+ "../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/websocket/receiver.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var { Writable } = require("stream");
+ var diagnosticsChannel = require("diagnostics_channel");
+ var { parserStates, opcodes, states, emptyBuffer } = require_constants4();
+ var { kReadyState, kSentClose, kResponse, kReceivedClose } = require_symbols4();
+ var { isValidStatusCode, failWebsocketConnection, websocketMessageReceived } = require_util5();
+ var { WebsocketFrameSend } = require_frame();
+ var channels = {};
+ channels.ping = diagnosticsChannel.channel("undici:websocket:ping");
+ channels.pong = diagnosticsChannel.channel("undici:websocket:pong");
+ var ByteParser = class extends Writable {
+ #buffers = [];
+ #byteOffset = 0;
+ #state = parserStates.INFO;
+ #info = {};
+ #fragments = [];
+ constructor(ws) {
+ super();
+ this.ws = ws;
+ }
+ /**
+ * @param {Buffer} chunk
+ * @param {() => void} callback
+ */
+ _write(chunk, _2, callback) {
+ this.#buffers.push(chunk);
+ this.#byteOffset += chunk.length;
+ this.run(callback);
+ }
+ /**
+ * Runs whenever a new chunk is received.
+ * Callback is called whenever there are no more chunks buffering,
+ * or not enough bytes are buffered to parse.
+ */
+ run(callback) {
+ while (true) {
+ if (this.#state === parserStates.INFO) {
+ if (this.#byteOffset < 2) {
+ return callback();
+ }
+ const buffer = this.consume(2);
+ this.#info.fin = (buffer[0] & 128) !== 0;
+ this.#info.opcode = buffer[0] & 15;
+ this.#info.originalOpcode ??= this.#info.opcode;
+ this.#info.fragmented = !this.#info.fin && this.#info.opcode !== opcodes.CONTINUATION;
+ if (this.#info.fragmented && this.#info.opcode !== opcodes.BINARY && this.#info.opcode !== opcodes.TEXT) {
+ failWebsocketConnection(this.ws, "Invalid frame type was fragmented.");
+ return;
+ }
+ const payloadLength = buffer[1] & 127;
+ if (payloadLength <= 125) {
+ this.#info.payloadLength = payloadLength;
+ this.#state = parserStates.READ_DATA;
+ } else if (payloadLength === 126) {
+ this.#state = parserStates.PAYLOADLENGTH_16;
+ } else if (payloadLength === 127) {
+ this.#state = parserStates.PAYLOADLENGTH_64;
+ }
+ if (this.#info.fragmented && payloadLength > 125) {
+ failWebsocketConnection(this.ws, "Fragmented frame exceeded 125 bytes.");
+ return;
+ } else if ((this.#info.opcode === opcodes.PING || this.#info.opcode === opcodes.PONG || this.#info.opcode === opcodes.CLOSE) && payloadLength > 125) {
+ failWebsocketConnection(this.ws, "Payload length for control frame exceeded 125 bytes.");
+ return;
+ } else if (this.#info.opcode === opcodes.CLOSE) {
+ if (payloadLength === 1) {
+ failWebsocketConnection(this.ws, "Received close frame with a 1-byte body.");
+ return;
+ }
+ const body = this.consume(payloadLength);
+ this.#info.closeInfo = this.parseCloseBody(false, body);
+ if (!this.ws[kSentClose]) {
+ const body2 = Buffer.allocUnsafe(2);
+ body2.writeUInt16BE(this.#info.closeInfo.code, 0);
+ const closeFrame = new WebsocketFrameSend(body2);
+ this.ws[kResponse].socket.write(
+ closeFrame.createFrame(opcodes.CLOSE),
+ (err) => {
+ if (!err) {
+ this.ws[kSentClose] = true;
+ }
+ }
+ );
+ }
+ this.ws[kReadyState] = states.CLOSING;
+ this.ws[kReceivedClose] = true;
+ this.end();
+ return;
+ } else if (this.#info.opcode === opcodes.PING) {
+ const body = this.consume(payloadLength);
+ if (!this.ws[kReceivedClose]) {
+ const frame = new WebsocketFrameSend(body);
+ this.ws[kResponse].socket.write(frame.createFrame(opcodes.PONG));
+ if (channels.ping.hasSubscribers) {
+ channels.ping.publish({
+ payload: body
+ });
+ }
+ }
+ this.#state = parserStates.INFO;
+ if (this.#byteOffset > 0) {
+ continue;
+ } else {
+ callback();
+ return;
+ }
+ } else if (this.#info.opcode === opcodes.PONG) {
+ const body = this.consume(payloadLength);
+ if (channels.pong.hasSubscribers) {
+ channels.pong.publish({
+ payload: body
+ });
+ }
+ if (this.#byteOffset > 0) {
+ continue;
+ } else {
+ callback();
+ return;
+ }
+ }
+ } else if (this.#state === parserStates.PAYLOADLENGTH_16) {
+ if (this.#byteOffset < 2) {
+ return callback();
+ }
+ const buffer = this.consume(2);
+ this.#info.payloadLength = buffer.readUInt16BE(0);
+ this.#state = parserStates.READ_DATA;
+ } else if (this.#state === parserStates.PAYLOADLENGTH_64) {
+ if (this.#byteOffset < 8) {
+ return callback();
+ }
+ const buffer = this.consume(8);
+ const upper = buffer.readUInt32BE(0);
+ if (upper > 2 ** 31 - 1) {
+ failWebsocketConnection(this.ws, "Received payload length > 2^31 bytes.");
+ return;
+ }
+ const lower = buffer.readUInt32BE(4);
+ this.#info.payloadLength = (upper << 8) + lower;
+ this.#state = parserStates.READ_DATA;
+ } else if (this.#state === parserStates.READ_DATA) {
+ if (this.#byteOffset < this.#info.payloadLength) {
+ return callback();
+ } else if (this.#byteOffset >= this.#info.payloadLength) {
+ const body = this.consume(this.#info.payloadLength);
+ this.#fragments.push(body);
+ if (!this.#info.fragmented || this.#info.fin && this.#info.opcode === opcodes.CONTINUATION) {
+ const fullMessage = Buffer.concat(this.#fragments);
+ websocketMessageReceived(this.ws, this.#info.originalOpcode, fullMessage);
+ this.#info = {};
+ this.#fragments.length = 0;
+ }
+ this.#state = parserStates.INFO;
+ }
+ }
+ if (this.#byteOffset > 0) {
+ continue;
+ } else {
+ callback();
+ break;
+ }
+ }
+ }
+ /**
+ * Take n bytes from the buffered Buffers
+ * @param {number} n
+ * @returns {Buffer|null}
+ */
+ consume(n) {
+ if (n > this.#byteOffset) {
+ return null;
+ } else if (n === 0) {
+ return emptyBuffer;
+ }
+ if (this.#buffers[0].length === n) {
+ this.#byteOffset -= this.#buffers[0].length;
+ return this.#buffers.shift();
+ }
+ const buffer = Buffer.allocUnsafe(n);
+ let offset = 0;
+ while (offset !== n) {
+ const next = this.#buffers[0];
+ const { length } = next;
+ if (length + offset === n) {
+ buffer.set(this.#buffers.shift(), offset);
+ break;
+ } else if (length + offset > n) {
+ buffer.set(next.subarray(0, n - offset), offset);
+ this.#buffers[0] = next.subarray(n - offset);
+ break;
+ } else {
+ buffer.set(this.#buffers.shift(), offset);
+ offset += next.length;
+ }
+ }
+ this.#byteOffset -= n;
+ return buffer;
+ }
+ parseCloseBody(onlyCode, data) {
+ let code;
+ if (data.length >= 2) {
+ code = data.readUInt16BE(0);
+ }
+ if (onlyCode) {
+ if (!isValidStatusCode(code)) {
+ return null;
+ }
+ return { code };
+ }
+ let reason = data.subarray(2);
+ if (reason[0] === 239 && reason[1] === 187 && reason[2] === 191) {
+ reason = reason.subarray(3);
+ }
+ if (code !== void 0 && !isValidStatusCode(code)) {
+ return null;
+ }
+ try {
+ reason = new TextDecoder("utf-8", { fatal: true }).decode(reason);
+ } catch {
+ return null;
+ }
+ return { code, reason };
+ }
+ get closingInfo() {
+ return this.#info.closeInfo;
+ }
+ };
+ __name(ByteParser, "ByteParser");
+ module2.exports = {
+ ByteParser
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/websocket/connection.js
+var require_connection = __commonJS({
+ "../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/websocket/connection.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var { randomBytes, createHash } = require("crypto");
+ var diagnosticsChannel = require("diagnostics_channel");
+ var { uid, states } = require_constants4();
+ var {
+ kReadyState,
+ kResponse,
+ kExtensions,
+ kProtocol,
+ kSentClose,
+ kByteParser,
+ kReceivedClose
+ } = require_symbols4();
+ var { fireEvent, failWebsocketConnection } = require_util5();
+ var { CloseEvent } = require_events();
+ var { ByteParser } = require_receiver();
+ var { makeRequest } = require_request2();
+ var { fetching } = require_fetch();
+ var { getGlobalDispatcher } = require_undici();
+ var channels = {};
+ channels.open = diagnosticsChannel.channel("undici:websocket:open");
+ channels.close = diagnosticsChannel.channel("undici:websocket:close");
+ channels.socketError = diagnosticsChannel.channel("undici:websocket:socket_error");
+ function establishWebSocketConnection(url3, protocols, ws) {
+ const requestURL = url3;
+ requestURL.protocol = url3.protocol === "ws:" ? "http:" : "https:";
+ const request = makeRequest({
+ urlList: [requestURL],
+ serviceWorkers: "none",
+ referrer: "no-referrer",
+ mode: "websocket",
+ credentials: "include",
+ cache: "no-store",
+ redirect: "error"
+ });
+ const keyValue = randomBytes(16).toString("base64");
+ request.headersList.append("sec-websocket-key", keyValue);
+ request.headersList.append("sec-websocket-version", "13");
+ for (const protocol of protocols) {
+ request.headersList.append("sec-websocket-protocol", protocol);
+ }
+ const permessageDeflate = "";
+ const controller = fetching({
+ request,
+ useParallelQueue: true,
+ dispatcher: getGlobalDispatcher(),
+ processResponse(response) {
+ if (response.type === "error" || response.status !== 101) {
+ failWebsocketConnection(ws, "Received network error or non-101 status code.");
+ return;
+ }
+ if (protocols.length !== 0 && !response.headersList.get("Sec-WebSocket-Protocol")) {
+ failWebsocketConnection(ws, "Server did not respond with sent protocols.");
+ return;
+ }
+ if (response.headersList.get("Upgrade")?.toLowerCase() !== "websocket") {
+ failWebsocketConnection(ws, 'Server did not set Upgrade header to "websocket".');
+ return;
+ }
+ if (response.headersList.get("Connection")?.toLowerCase() !== "upgrade") {
+ failWebsocketConnection(ws, 'Server did not set Connection header to "upgrade".');
+ return;
+ }
+ const secWSAccept = response.headersList.get("Sec-WebSocket-Accept");
+ const digest = createHash("sha1").update(keyValue + uid).digest("base64");
+ if (secWSAccept !== digest) {
+ failWebsocketConnection(ws, "Incorrect hash received in Sec-WebSocket-Accept header.");
+ return;
+ }
+ const secExtension = response.headersList.get("Sec-WebSocket-Extensions");
+ if (secExtension !== null && secExtension !== permessageDeflate) {
+ failWebsocketConnection(ws, "Received different permessage-deflate than the one set.");
+ return;
+ }
+ const secProtocol = response.headersList.get("Sec-WebSocket-Protocol");
+ if (secProtocol !== null && secProtocol !== request.headersList.get("Sec-WebSocket-Protocol")) {
+ failWebsocketConnection(ws, "Protocol was not set in the opening handshake.");
+ return;
+ }
+ ws[kResponse] = response;
+ const parser2 = new ByteParser(ws);
+ response.socket.ws = ws;
+ ws[kByteParser] = parser2;
+ whenConnectionEstablished(ws);
+ response.socket.on("data", onSocketData);
+ response.socket.on("close", onSocketClose);
+ response.socket.on("error", onSocketError);
+ parser2.on("drain", onParserDrain);
+ }
+ });
+ return controller;
+ }
+ __name(establishWebSocketConnection, "establishWebSocketConnection");
+ function whenConnectionEstablished(ws) {
+ const { [kResponse]: response } = ws;
+ ws[kReadyState] = states.OPEN;
+ const extensions = response.headersList.get("sec-websocket-extensions");
+ if (extensions !== null) {
+ ws[kExtensions] = extensions;
+ }
+ const protocol = response.headersList.get("sec-websocket-protocol");
+ if (protocol !== null) {
+ ws[kProtocol] = protocol;
+ }
+ fireEvent("open", ws);
+ if (channels.open.hasSubscribers) {
+ channels.open.publish({
+ address: response.socket.address(),
+ protocol,
+ extensions
+ });
+ }
+ }
+ __name(whenConnectionEstablished, "whenConnectionEstablished");
+ function onSocketData(chunk) {
+ if (!this.ws[kByteParser].write(chunk)) {
+ this.pause();
+ }
+ }
+ __name(onSocketData, "onSocketData");
+ function onParserDrain() {
+ this.ws[kResponse].socket.resume();
+ }
+ __name(onParserDrain, "onParserDrain");
+ function onSocketClose() {
+ const { ws } = this;
+ const wasClean = ws[kSentClose] && ws[kReceivedClose];
+ let code = 1005;
+ let reason = "";
+ const result = ws[kByteParser].closingInfo;
+ if (result) {
+ code = result.code ?? 1005;
+ reason = result.reason;
+ } else if (!ws[kSentClose]) {
+ code = 1006;
+ }
+ ws[kReadyState] = states.CLOSED;
+ fireEvent("close", ws, CloseEvent, {
+ wasClean,
+ code,
+ reason
+ });
+ if (channels.close.hasSubscribers) {
+ channels.close.publish({
+ websocket: ws,
+ code,
+ reason
+ });
+ }
+ }
+ __name(onSocketClose, "onSocketClose");
+ function onSocketError(error) {
+ const { ws } = this;
+ ws[kReadyState] = states.CLOSING;
+ if (channels.socketError.hasSubscribers) {
+ channels.socketError.publish(error);
+ }
+ this.destroy();
+ }
+ __name(onSocketError, "onSocketError");
+ module2.exports = {
+ establishWebSocketConnection
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/websocket/websocket.js
+var require_websocket = __commonJS({
+ "../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/lib/websocket/websocket.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var { webidl } = require_webidl();
+ var { DOMException } = require_constants();
+ var { URLSerializer } = require_dataURL();
+ var { staticPropertyDescriptors, states, opcodes, emptyBuffer } = require_constants4();
+ var {
+ kWebSocketURL,
+ kReadyState,
+ kController,
+ kExtensions,
+ kProtocol,
+ kBinaryType,
+ kResponse,
+ kSentClose
+ } = require_symbols4();
+ var { isEstablished, isClosing, isValidSubprotocol, failWebsocketConnection } = require_util5();
+ var { establishWebSocketConnection } = require_connection();
+ var { WebsocketFrameSend } = require_frame();
+ var { kEnumerableProperty, isBlobLike } = require_util();
+ var { types } = require("util");
+ var experimentalWarned = false;
+ var WebSocket2 = class extends EventTarget {
+ #events = {
+ open: null,
+ error: null,
+ close: null,
+ message: null
+ };
+ #bufferedAmount = 0;
+ /**
+ * @param {string} url
+ * @param {string|string[]} protocols
+ */
+ constructor(url3, protocols = []) {
+ super();
+ webidl.argumentLengthCheck(arguments, 1, { header: "WebSocket constructor" });
+ if (!experimentalWarned) {
+ experimentalWarned = true;
+ process.emitWarning("WebSockets are experimental, expect them to change at any time.", {
+ code: "UNDICI-WS"
+ });
+ }
+ url3 = webidl.converters.USVString(url3);
+ protocols = webidl.converters["DOMString or sequence"](protocols);
+ let urlRecord;
+ try {
+ urlRecord = new URL(url3);
+ } catch (e2) {
+ throw new DOMException(e2, "SyntaxError");
+ }
+ if (urlRecord.protocol !== "ws:" && urlRecord.protocol !== "wss:") {
+ throw new DOMException(
+ `Expected a ws: or wss: protocol, got ${urlRecord.protocol}`,
+ "SyntaxError"
+ );
+ }
+ if (urlRecord.hash) {
+ throw new DOMException("Got fragment", "SyntaxError");
+ }
+ if (typeof protocols === "string") {
+ protocols = [protocols];
+ }
+ if (protocols.length !== new Set(protocols.map((p) => p.toLowerCase())).size) {
+ throw new DOMException("Invalid Sec-WebSocket-Protocol value", "SyntaxError");
+ }
+ if (protocols.length > 0 && !protocols.every((p) => isValidSubprotocol(p))) {
+ throw new DOMException("Invalid Sec-WebSocket-Protocol value", "SyntaxError");
+ }
+ this[kWebSocketURL] = urlRecord;
+ this[kController] = establishWebSocketConnection(urlRecord, protocols, this);
+ this[kReadyState] = WebSocket2.CONNECTING;
+ this[kExtensions] = "";
+ this[kProtocol] = "";
+ this[kBinaryType] = "blob";
+ }
+ /**
+ * @see https://websockets.spec.whatwg.org/#dom-websocket-close
+ * @param {number|undefined} code
+ * @param {string|undefined} reason
+ */
+ close(code = void 0, reason = void 0) {
+ webidl.brandCheck(this, WebSocket2);
+ if (code !== void 0) {
+ code = webidl.converters["unsigned short"](code, { clamp: true });
+ }
+ if (reason !== void 0) {
+ reason = webidl.converters.USVString(reason);
+ }
+ if (code !== void 0) {
+ if (code !== 1e3 && (code < 3e3 || code > 4999)) {
+ throw new DOMException("invalid code", "InvalidAccessError");
+ }
+ }
+ let reasonByteLength = 0;
+ if (reason !== void 0) {
+ reasonByteLength = Buffer.byteLength(reason);
+ if (reasonByteLength > 123) {
+ throw new DOMException(
+ `Reason must be less than 123 bytes; received ${reasonByteLength}`,
+ "SyntaxError"
+ );
+ }
+ }
+ if (this[kReadyState] === WebSocket2.CLOSING || this[kReadyState] === WebSocket2.CLOSED) {
+ } else if (!isEstablished(this)) {
+ failWebsocketConnection(this, "Connection was closed before it was established.");
+ this[kReadyState] = WebSocket2.CLOSING;
+ } else if (!isClosing(this)) {
+ const frame = new WebsocketFrameSend();
+ if (code !== void 0 && reason === void 0) {
+ frame.frameData = Buffer.allocUnsafe(2);
+ frame.frameData.writeUInt16BE(code, 0);
+ } else if (code !== void 0 && reason !== void 0) {
+ frame.frameData = Buffer.allocUnsafe(2 + reasonByteLength);
+ frame.frameData.writeUInt16BE(code, 0);
+ frame.frameData.write(reason, 2, "utf-8");
+ } else {
+ frame.frameData = emptyBuffer;
+ }
+ const socket = this[kResponse].socket;
+ socket.write(frame.createFrame(opcodes.CLOSE), (err) => {
+ if (!err) {
+ this[kSentClose] = true;
+ }
+ });
+ this[kReadyState] = states.CLOSING;
+ } else {
+ this[kReadyState] = WebSocket2.CLOSING;
+ }
+ }
+ /**
+ * @see https://websockets.spec.whatwg.org/#dom-websocket-send
+ * @param {NodeJS.TypedArray|ArrayBuffer|Blob|string} data
+ */
+ send(data) {
+ webidl.brandCheck(this, WebSocket2);
+ webidl.argumentLengthCheck(arguments, 1, { header: "WebSocket.send" });
+ data = webidl.converters.WebSocketSendData(data);
+ if (this[kReadyState] === WebSocket2.CONNECTING) {
+ throw new DOMException("Sent before connected.", "InvalidStateError");
+ }
+ if (!isEstablished(this) || isClosing(this)) {
+ return;
+ }
+ const socket = this[kResponse].socket;
+ if (typeof data === "string") {
+ const value = Buffer.from(data);
+ const frame = new WebsocketFrameSend(value);
+ const buffer = frame.createFrame(opcodes.TEXT);
+ this.#bufferedAmount += value.byteLength;
+ socket.write(buffer, () => {
+ this.#bufferedAmount -= value.byteLength;
+ });
+ } else if (types.isArrayBuffer(data)) {
+ const value = Buffer.from(data);
+ const frame = new WebsocketFrameSend(value);
+ const buffer = frame.createFrame(opcodes.BINARY);
+ this.#bufferedAmount += value.byteLength;
+ socket.write(buffer, () => {
+ this.#bufferedAmount -= value.byteLength;
+ });
+ } else if (ArrayBuffer.isView(data)) {
+ const ab = Buffer.from(data, data.byteOffset, data.byteLength);
+ const frame = new WebsocketFrameSend(ab);
+ const buffer = frame.createFrame(opcodes.BINARY);
+ this.#bufferedAmount += ab.byteLength;
+ socket.write(buffer, () => {
+ this.#bufferedAmount -= ab.byteLength;
+ });
+ } else if (isBlobLike(data)) {
+ const frame = new WebsocketFrameSend();
+ data.arrayBuffer().then((ab) => {
+ const value = Buffer.from(ab);
+ frame.frameData = value;
+ const buffer = frame.createFrame(opcodes.BINARY);
+ this.#bufferedAmount += value.byteLength;
+ socket.write(buffer, () => {
+ this.#bufferedAmount -= value.byteLength;
+ });
+ });
+ }
+ }
+ get readyState() {
+ webidl.brandCheck(this, WebSocket2);
+ return this[kReadyState];
+ }
+ get bufferedAmount() {
+ webidl.brandCheck(this, WebSocket2);
+ return this.#bufferedAmount;
+ }
+ get url() {
+ webidl.brandCheck(this, WebSocket2);
+ return URLSerializer(this[kWebSocketURL]);
+ }
+ get extensions() {
+ webidl.brandCheck(this, WebSocket2);
+ return this[kExtensions];
+ }
+ get protocol() {
+ webidl.brandCheck(this, WebSocket2);
+ return this[kProtocol];
+ }
+ get onopen() {
+ webidl.brandCheck(this, WebSocket2);
+ return this.#events.open;
+ }
+ set onopen(fn2) {
+ webidl.brandCheck(this, WebSocket2);
+ if (this.#events.open) {
+ this.removeEventListener("open", this.#events.open);
+ }
+ if (typeof fn2 === "function") {
+ this.#events.open = fn2;
+ this.addEventListener("open", fn2);
+ } else {
+ this.#events.open = null;
+ }
+ }
+ get onerror() {
+ webidl.brandCheck(this, WebSocket2);
+ return this.#events.error;
+ }
+ set onerror(fn2) {
+ webidl.brandCheck(this, WebSocket2);
+ if (this.#events.error) {
+ this.removeEventListener("error", this.#events.error);
+ }
+ if (typeof fn2 === "function") {
+ this.#events.error = fn2;
+ this.addEventListener("error", fn2);
+ } else {
+ this.#events.error = null;
+ }
+ }
+ get onclose() {
+ webidl.brandCheck(this, WebSocket2);
+ return this.#events.close;
+ }
+ set onclose(fn2) {
+ webidl.brandCheck(this, WebSocket2);
+ if (this.#events.close) {
+ this.removeEventListener("close", this.#events.close);
+ }
+ if (typeof fn2 === "function") {
+ this.#events.close = fn2;
+ this.addEventListener("close", fn2);
+ } else {
+ this.#events.close = null;
+ }
+ }
+ get onmessage() {
+ webidl.brandCheck(this, WebSocket2);
+ return this.#events.message;
+ }
+ set onmessage(fn2) {
+ webidl.brandCheck(this, WebSocket2);
+ if (this.#events.message) {
+ this.removeEventListener("message", this.#events.message);
+ }
+ if (typeof fn2 === "function") {
+ this.#events.message = fn2;
+ this.addEventListener("message", fn2);
+ } else {
+ this.#events.message = null;
+ }
+ }
+ get binaryType() {
+ webidl.brandCheck(this, WebSocket2);
+ return this[kBinaryType];
+ }
+ set binaryType(type) {
+ webidl.brandCheck(this, WebSocket2);
+ if (type !== "blob" && type !== "arraybuffer") {
+ this[kBinaryType] = "blob";
+ } else {
+ this[kBinaryType] = type;
+ }
+ }
+ };
+ __name(WebSocket2, "WebSocket");
+ WebSocket2.CONNECTING = WebSocket2.prototype.CONNECTING = states.CONNECTING;
+ WebSocket2.OPEN = WebSocket2.prototype.OPEN = states.OPEN;
+ WebSocket2.CLOSING = WebSocket2.prototype.CLOSING = states.CLOSING;
+ WebSocket2.CLOSED = WebSocket2.prototype.CLOSED = states.CLOSED;
+ Object.defineProperties(WebSocket2.prototype, {
+ CONNECTING: staticPropertyDescriptors,
+ OPEN: staticPropertyDescriptors,
+ CLOSING: staticPropertyDescriptors,
+ CLOSED: staticPropertyDescriptors,
+ url: kEnumerableProperty,
+ readyState: kEnumerableProperty,
+ bufferedAmount: kEnumerableProperty,
+ onopen: kEnumerableProperty,
+ onerror: kEnumerableProperty,
+ onclose: kEnumerableProperty,
+ close: kEnumerableProperty,
+ onmessage: kEnumerableProperty,
+ binaryType: kEnumerableProperty,
+ send: kEnumerableProperty,
+ extensions: kEnumerableProperty,
+ protocol: kEnumerableProperty,
+ [Symbol.toStringTag]: {
+ value: "WebSocket",
+ writable: false,
+ enumerable: false,
+ configurable: true
+ }
+ });
+ Object.defineProperties(WebSocket2, {
+ CONNECTING: staticPropertyDescriptors,
+ OPEN: staticPropertyDescriptors,
+ CLOSING: staticPropertyDescriptors,
+ CLOSED: staticPropertyDescriptors
+ });
+ webidl.converters["sequence"] = webidl.sequenceConverter(
+ webidl.converters.DOMString
+ );
+ webidl.converters["DOMString or sequence"] = function(V) {
+ if (webidl.util.Type(V) === "Object" && Symbol.iterator in V) {
+ return webidl.converters["sequence"](V);
+ }
+ return webidl.converters.DOMString(V);
+ };
+ webidl.converters.WebSocketSendData = function(V) {
+ if (webidl.util.Type(V) === "Object") {
+ if (isBlobLike(V)) {
+ return webidl.converters.Blob(V, { strict: false });
+ }
+ if (ArrayBuffer.isView(V) || types.isAnyArrayBuffer(V)) {
+ return webidl.converters.BufferSource(V);
+ }
+ }
+ return webidl.converters.USVString(V);
+ };
+ module2.exports = {
+ WebSocket: WebSocket2
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/index.js
+var require_undici = __commonJS({
+ "../../node_modules/.pnpm/undici@5.20.0/node_modules/undici/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var Client = require_client();
+ var Dispatcher = require_dispatcher();
+ var errors = require_errors();
+ var Pool = require_pool();
+ var BalancedPool = require_balanced_pool();
+ var Agent = require_agent();
+ var util3 = require_util();
+ var { InvalidArgumentError } = errors;
+ var api = require_api();
+ var buildConnector = require_connect();
+ var MockClient = require_mock_client();
+ var MockAgent = require_mock_agent();
+ var MockPool = require_mock_pool();
+ var mockErrors = require_mock_errors();
+ var ProxyAgent2 = require_proxy_agent();
+ var { getGlobalDispatcher, setGlobalDispatcher: setGlobalDispatcher2 } = require_global();
+ var DecoratorHandler = require_DecoratorHandler();
+ var RedirectHandler = require_RedirectHandler();
+ var createRedirectInterceptor = require_redirectInterceptor();
+ var hasCrypto;
+ try {
+ require("crypto");
+ hasCrypto = true;
+ } catch {
+ hasCrypto = false;
+ }
+ Object.assign(Dispatcher.prototype, api);
+ module2.exports.Dispatcher = Dispatcher;
+ module2.exports.Client = Client;
+ module2.exports.Pool = Pool;
+ module2.exports.BalancedPool = BalancedPool;
+ module2.exports.Agent = Agent;
+ module2.exports.ProxyAgent = ProxyAgent2;
+ module2.exports.DecoratorHandler = DecoratorHandler;
+ module2.exports.RedirectHandler = RedirectHandler;
+ module2.exports.createRedirectInterceptor = createRedirectInterceptor;
+ module2.exports.buildConnector = buildConnector;
+ module2.exports.errors = errors;
+ function makeDispatcher(fn2) {
+ return (url3, opts, handler15) => {
+ if (typeof opts === "function") {
+ handler15 = opts;
+ opts = null;
+ }
+ if (!url3 || typeof url3 !== "string" && typeof url3 !== "object" && !(url3 instanceof URL)) {
+ throw new InvalidArgumentError("invalid url");
+ }
+ if (opts != null && typeof opts !== "object") {
+ throw new InvalidArgumentError("invalid opts");
+ }
+ if (opts && opts.path != null) {
+ if (typeof opts.path !== "string") {
+ throw new InvalidArgumentError("invalid opts.path");
+ }
+ let path45 = opts.path;
+ if (!opts.path.startsWith("/")) {
+ path45 = `/${path45}`;
+ }
+ url3 = new URL(util3.parseOrigin(url3).origin + path45);
+ } else {
+ if (!opts) {
+ opts = typeof url3 === "object" ? url3 : {};
+ }
+ url3 = util3.parseURL(url3);
+ }
+ const { agent, dispatcher = getGlobalDispatcher() } = opts;
+ if (agent) {
+ throw new InvalidArgumentError("unsupported opts.agent. Did you mean opts.client?");
+ }
+ return fn2.call(dispatcher, {
+ ...opts,
+ origin: url3.origin,
+ path: url3.search ? `${url3.pathname}${url3.search}` : url3.pathname,
+ method: opts.method || (opts.body ? "PUT" : "GET")
+ }, handler15);
+ };
+ }
+ __name(makeDispatcher, "makeDispatcher");
+ module2.exports.setGlobalDispatcher = setGlobalDispatcher2;
+ module2.exports.getGlobalDispatcher = getGlobalDispatcher;
+ if (util3.nodeMajor > 16 || util3.nodeMajor === 16 && util3.nodeMinor >= 8) {
+ let fetchImpl = null;
+ module2.exports.fetch = /* @__PURE__ */ __name(async function fetch12(resource) {
+ if (!fetchImpl) {
+ fetchImpl = require_fetch().fetch;
+ }
+ try {
+ return await fetchImpl(...arguments);
+ } catch (err) {
+ Error.captureStackTrace(err, this);
+ throw err;
+ }
+ }, "fetch");
+ module2.exports.Headers = require_headers().Headers;
+ module2.exports.Response = require_response().Response;
+ module2.exports.Request = require_request2().Request;
+ module2.exports.FormData = require_formdata().FormData;
+ module2.exports.File = require_file().File;
+ module2.exports.FileReader = require_filereader().FileReader;
+ const { setGlobalOrigin, getGlobalOrigin } = require_global2();
+ module2.exports.setGlobalOrigin = setGlobalOrigin;
+ module2.exports.getGlobalOrigin = getGlobalOrigin;
+ }
+ if (util3.nodeMajor >= 16) {
+ const { deleteCookie, getCookies, getSetCookies, setCookie } = require_cookies();
+ module2.exports.deleteCookie = deleteCookie;
+ module2.exports.getCookies = getCookies;
+ module2.exports.getSetCookies = getSetCookies;
+ module2.exports.setCookie = setCookie;
+ const { parseMIMEType, serializeAMimeType } = require_dataURL();
+ module2.exports.parseMIMEType = parseMIMEType;
+ module2.exports.serializeAMimeType = serializeAMimeType;
+ }
+ if (util3.nodeMajor >= 18 && hasCrypto) {
+ const { WebSocket: WebSocket2 } = require_websocket();
+ module2.exports.WebSocket = WebSocket2;
+ }
+ module2.exports.request = makeDispatcher(api.request);
+ module2.exports.stream = makeDispatcher(api.stream);
+ module2.exports.pipeline = makeDispatcher(api.pipeline);
+ module2.exports.connect = makeDispatcher(api.connect);
+ module2.exports.upgrade = makeDispatcher(api.upgrade);
+ module2.exports.MockClient = MockClient;
+ module2.exports.MockPool = MockPool;
+ module2.exports.MockAgent = MockAgent;
+ module2.exports.mockErrors = mockErrors;
+ }
+});
+
+// ../../node_modules/.pnpm/@webcontainer+env@1.1.0/node_modules/@webcontainer/env/dist/index.js
+var require_dist = __commonJS({
+ "../../node_modules/.pnpm/@webcontainer+env@1.1.0/node_modules/@webcontainer/env/dist/index.js"(exports2, module2) {
+ init_import_meta_url();
+ var c = Object.defineProperty;
+ var g = Object.getOwnPropertyDescriptor;
+ var y = Object.getOwnPropertyNames;
+ var d = Object.prototype.hasOwnProperty;
+ var a = /* @__PURE__ */ __name((e2, t2) => c(e2, "name", { value: t2, configurable: true }), "a");
+ var b = /* @__PURE__ */ __name((e2, t2) => {
+ for (var o in t2)
+ c(e2, o, { get: t2[o], enumerable: true });
+ }, "b");
+ var P = /* @__PURE__ */ __name((e2, t2, o, u) => {
+ if (t2 && typeof t2 == "object" || typeof t2 == "function")
+ for (let s of y(t2))
+ !d.call(e2, s) && s !== o && c(e2, s, { get: () => t2[s], enumerable: !(u = g(t2, s)) || u.enumerable });
+ return e2;
+ }, "P");
+ var U = /* @__PURE__ */ __name((e2) => P(c({}, "__esModule", { value: true }), e2), "U");
+ var x = {};
+ b(x, { HostURL: () => n, isWebContainer: () => h });
+ module2.exports = U(x);
+ var r;
+ try {
+ r = require("@blitz/internal/env");
+ } catch (e2) {
+ }
+ function h() {
+ return r != null && process.versions.webcontainer != null;
+ }
+ __name(h, "h");
+ a(h, "isWebContainer");
+ function p(e2) {
+ let t2 = r == null ? void 0 : r.createServiceHostname(e2);
+ if (!t2)
+ throw new Error("Failed to construct service hostname");
+ return t2;
+ }
+ __name(p, "p");
+ a(p, "_createServiceHostname");
+ function f(e2) {
+ return r == null ? void 0 : r.isServiceUrl(e2);
+ }
+ __name(f, "f");
+ a(f, "_isServiceUrl");
+ function l(e2) {
+ return r == null ? void 0 : r.isLocalhost(e2);
+ }
+ __name(l, "l");
+ a(l, "_isLocalhost");
+ var n = /* @__PURE__ */ __name(class {
+ constructor(t2) {
+ this._url = t2;
+ if (this._port = this._url.port, h() && l(this._url.hostname)) {
+ let o = p(this._port);
+ this._url.host = o, this._port === this._url.port && (this._url.port = "");
+ }
+ }
+ static parse(t2) {
+ return t2 = typeof t2 == "string" ? new URL(t2) : t2, new n(t2);
+ }
+ get port() {
+ return h() ? this._port : this._url.port;
+ }
+ get hash() {
+ return this._url.hash;
+ }
+ get host() {
+ return this._url.host;
+ }
+ get hostname() {
+ return this._url.hostname;
+ }
+ get href() {
+ return this._url.href;
+ }
+ get origin() {
+ return this._url.origin;
+ }
+ get username() {
+ return this._url.username;
+ }
+ get password() {
+ return this._url.password;
+ }
+ get pathname() {
+ return this._url.pathname;
+ }
+ get protocol() {
+ return this._url.protocol;
+ }
+ get search() {
+ return this._url.search;
+ }
+ get searchParams() {
+ return this._url.searchParams;
+ }
+ update(t2) {
+ var u;
+ let o = h();
+ for (let s in t2) {
+ let i = (u = t2[s]) != null ? u : "";
+ if (o)
+ switch (s) {
+ case "port": {
+ if (this._port = i, (l(this._url.hostname) || f(this._url.hostname)) && (this._url.host = p(i), this._port !== this._url.port))
+ continue;
+ break;
+ }
+ case "host": {
+ let [m, _2 = this._port] = i.split(":");
+ this._port = _2, l(m) && (i = p(_2));
+ break;
+ }
+ case "hostname": {
+ if (l(i)) {
+ if (/\/|:/.test(i))
+ continue;
+ i = p(this._port);
+ } else
+ this._url.port = this._port;
+ break;
+ }
+ case "href": {
+ this._url = n.parse(i);
+ continue;
+ }
+ }
+ this._url[s] = i;
+ }
+ return this;
+ }
+ toString() {
+ return this._url.toString();
+ }
+ toJSON() {
+ return this._url.toJSON();
+ }
+ }, "n");
+ a(n, "HostURL");
+ }
+});
+
+// ../../node_modules/.pnpm/escape-string-regexp@1.0.5/node_modules/escape-string-regexp/index.js
+var require_escape_string_regexp = __commonJS({
+ "../../node_modules/.pnpm/escape-string-regexp@1.0.5/node_modules/escape-string-regexp/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var matchOperatorsRe = /[|\\{}()[\]^$+*?.]/g;
+ module2.exports = function(str) {
+ if (typeof str !== "string") {
+ throw new TypeError("Expected a string");
+ }
+ return str.replace(matchOperatorsRe, "\\$&");
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/color-name@1.1.3/node_modules/color-name/index.js
+var require_color_name = __commonJS({
+ "../../node_modules/.pnpm/color-name@1.1.3/node_modules/color-name/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ 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]
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/color-convert@1.9.3/node_modules/color-convert/conversions.js
+var require_conversions = __commonJS({
+ "../../node_modules/.pnpm/color-convert@1.9.3/node_modules/color-convert/conversions.js"(exports2, module2) {
+ init_import_meta_url();
+ var cssKeywords = require_color_name();
+ var reverseKeywords = {};
+ for (key in cssKeywords) {
+ if (cssKeywords.hasOwnProperty(key)) {
+ reverseKeywords[cssKeywords[key]] = key;
+ }
+ }
+ var key;
+ var convert = module2.exports = {
+ 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"] }
+ };
+ for (model in convert) {
+ if (convert.hasOwnProperty(model)) {
+ 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);
+ }
+ channels = convert[model].channels;
+ labels = convert[model].labels;
+ delete convert[model].channels;
+ delete convert[model].labels;
+ Object.defineProperty(convert[model], "channels", { value: channels });
+ Object.defineProperty(convert[model], "labels", { value: labels });
+ }
+ }
+ var channels;
+ var labels;
+ var model;
+ convert.rgb.hsl = function(rgb) {
+ var r = rgb[0] / 255;
+ var g = rgb[1] / 255;
+ var b = rgb[2] / 255;
+ var min = Math.min(r, g, b);
+ var max = Math.max(r, g, b);
+ var delta = max - min;
+ var h;
+ var s;
+ var l;
+ 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;
+ }
+ 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) {
+ var rdif;
+ var gdif;
+ var bdif;
+ var h;
+ var s;
+ var r = rgb[0] / 255;
+ var g = rgb[1] / 255;
+ var b = rgb[2] / 255;
+ var v = Math.max(r, g, b);
+ var diff = v - Math.min(r, g, b);
+ var diffc = /* @__PURE__ */ __name(function(c) {
+ return (v - c) / 6 / diff + 1 / 2;
+ }, "diffc");
+ if (diff === 0) {
+ h = 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) {
+ var r = rgb[0];
+ var g = rgb[1];
+ var b = rgb[2];
+ var h = convert.rgb.hsl(rgb)[0];
+ var 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) {
+ var r = rgb[0] / 255;
+ var g = rgb[1] / 255;
+ var b = rgb[2] / 255;
+ var c;
+ var m;
+ var y;
+ var k;
+ k = Math.min(1 - r, 1 - g, 1 - b);
+ c = (1 - r - k) / (1 - k) || 0;
+ m = (1 - g - k) / (1 - k) || 0;
+ y = (1 - b - k) / (1 - k) || 0;
+ return [c * 100, m * 100, y * 100, k * 100];
+ };
+ function comparativeDistance(x, y) {
+ return Math.pow(x[0] - y[0], 2) + Math.pow(x[1] - y[1], 2) + Math.pow(x[2] - y[2], 2);
+ }
+ __name(comparativeDistance, "comparativeDistance");
+ convert.rgb.keyword = function(rgb) {
+ var reversed = reverseKeywords[rgb];
+ if (reversed) {
+ return reversed;
+ }
+ var currentClosestDistance = Infinity;
+ var currentClosestKeyword;
+ for (var keyword in cssKeywords) {
+ if (cssKeywords.hasOwnProperty(keyword)) {
+ var value = cssKeywords[keyword];
+ var 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) {
+ var r = rgb[0] / 255;
+ var g = rgb[1] / 255;
+ var b = rgb[2] / 255;
+ r = r > 0.04045 ? Math.pow((r + 0.055) / 1.055, 2.4) : r / 12.92;
+ g = g > 0.04045 ? Math.pow((g + 0.055) / 1.055, 2.4) : g / 12.92;
+ b = b > 0.04045 ? Math.pow((b + 0.055) / 1.055, 2.4) : b / 12.92;
+ var x = r * 0.4124 + g * 0.3576 + b * 0.1805;
+ var y = r * 0.2126 + g * 0.7152 + b * 0.0722;
+ var z = r * 0.0193 + g * 0.1192 + b * 0.9505;
+ return [x * 100, y * 100, z * 100];
+ };
+ convert.rgb.lab = function(rgb) {
+ var xyz = convert.rgb.xyz(rgb);
+ var x = xyz[0];
+ var y = xyz[1];
+ var z = xyz[2];
+ var l;
+ var a;
+ var b;
+ x /= 95.047;
+ y /= 100;
+ z /= 108.883;
+ x = x > 8856e-6 ? Math.pow(x, 1 / 3) : 7.787 * x + 16 / 116;
+ y = y > 8856e-6 ? Math.pow(y, 1 / 3) : 7.787 * y + 16 / 116;
+ z = z > 8856e-6 ? Math.pow(z, 1 / 3) : 7.787 * z + 16 / 116;
+ l = 116 * y - 16;
+ a = 500 * (x - y);
+ b = 200 * (y - z);
+ return [l, a, b];
+ };
+ convert.hsl.rgb = function(hsl) {
+ var h = hsl[0] / 360;
+ var s = hsl[1] / 100;
+ var l = hsl[2] / 100;
+ var t1;
+ var t2;
+ var t3;
+ var rgb;
+ var 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;
+ }
+ t1 = 2 * l - t2;
+ rgb = [0, 0, 0];
+ for (var 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) {
+ var h = hsl[0];
+ var s = hsl[1] / 100;
+ var l = hsl[2] / 100;
+ var smin = s;
+ var lmin = Math.max(l, 0.01);
+ var sv;
+ var v;
+ l *= 2;
+ s *= l <= 1 ? l : 2 - l;
+ smin *= lmin <= 1 ? lmin : 2 - lmin;
+ v = (l + s) / 2;
+ sv = l === 0 ? 2 * smin / (lmin + smin) : 2 * s / (l + s);
+ return [h, sv * 100, v * 100];
+ };
+ convert.hsv.rgb = function(hsv) {
+ var h = hsv[0] / 60;
+ var s = hsv[1] / 100;
+ var v = hsv[2] / 100;
+ var hi = Math.floor(h) % 6;
+ var f = h - Math.floor(h);
+ var p = 255 * v * (1 - s);
+ var q = 255 * v * (1 - s * f);
+ var t2 = 255 * v * (1 - s * (1 - f));
+ v *= 255;
+ switch (hi) {
+ case 0:
+ return [v, t2, p];
+ case 1:
+ return [q, v, p];
+ case 2:
+ return [p, v, t2];
+ case 3:
+ return [p, q, v];
+ case 4:
+ return [t2, p, v];
+ case 5:
+ return [v, p, q];
+ }
+ };
+ convert.hsv.hsl = function(hsv) {
+ var h = hsv[0];
+ var s = hsv[1] / 100;
+ var v = hsv[2] / 100;
+ var vmin = Math.max(v, 0.01);
+ var lmin;
+ var sl2;
+ var l;
+ l = (2 - s) * v;
+ lmin = (2 - s) * vmin;
+ sl2 = s * vmin;
+ sl2 /= lmin <= 1 ? lmin : 2 - lmin;
+ sl2 = sl2 || 0;
+ l /= 2;
+ return [h, sl2 * 100, l * 100];
+ };
+ convert.hwb.rgb = function(hwb) {
+ var h = hwb[0] / 360;
+ var wh = hwb[1] / 100;
+ var bl = hwb[2] / 100;
+ var ratio = wh + bl;
+ var i;
+ var v;
+ var f;
+ var n;
+ if (ratio > 1) {
+ wh /= ratio;
+ bl /= ratio;
+ }
+ i = Math.floor(6 * h);
+ v = 1 - bl;
+ f = 6 * h - i;
+ if ((i & 1) !== 0) {
+ f = 1 - f;
+ }
+ n = wh + f * (v - wh);
+ var r;
+ var g;
+ var 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) {
+ var c = cmyk[0] / 100;
+ var m = cmyk[1] / 100;
+ var y = cmyk[2] / 100;
+ var k = cmyk[3] / 100;
+ var r;
+ var g;
+ var b;
+ r = 1 - Math.min(1, c * (1 - k) + k);
+ g = 1 - Math.min(1, m * (1 - k) + k);
+ b = 1 - Math.min(1, y * (1 - k) + k);
+ return [r * 255, g * 255, b * 255];
+ };
+ convert.xyz.rgb = function(xyz) {
+ var x = xyz[0] / 100;
+ var y = xyz[1] / 100;
+ var z = xyz[2] / 100;
+ var r;
+ var g;
+ var b;
+ r = x * 3.2406 + y * -1.5372 + z * -0.4986;
+ g = x * -0.9689 + y * 1.8758 + z * 0.0415;
+ b = x * 0.0557 + y * -0.204 + z * 1.057;
+ r = r > 31308e-7 ? 1.055 * Math.pow(r, 1 / 2.4) - 0.055 : r * 12.92;
+ g = g > 31308e-7 ? 1.055 * Math.pow(g, 1 / 2.4) - 0.055 : g * 12.92;
+ b = b > 31308e-7 ? 1.055 * Math.pow(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) {
+ var x = xyz[0];
+ var y = xyz[1];
+ var z = xyz[2];
+ var l;
+ var a;
+ var b;
+ x /= 95.047;
+ y /= 100;
+ z /= 108.883;
+ x = x > 8856e-6 ? Math.pow(x, 1 / 3) : 7.787 * x + 16 / 116;
+ y = y > 8856e-6 ? Math.pow(y, 1 / 3) : 7.787 * y + 16 / 116;
+ z = z > 8856e-6 ? Math.pow(z, 1 / 3) : 7.787 * z + 16 / 116;
+ l = 116 * y - 16;
+ a = 500 * (x - y);
+ b = 200 * (y - z);
+ return [l, a, b];
+ };
+ convert.lab.xyz = function(lab) {
+ var l = lab[0];
+ var a = lab[1];
+ var b = lab[2];
+ var x;
+ var y;
+ var z;
+ y = (l + 16) / 116;
+ x = a / 500 + y;
+ z = y - b / 200;
+ var y2 = Math.pow(y, 3);
+ var x2 = Math.pow(x, 3);
+ var z2 = Math.pow(z, 3);
+ y = y2 > 8856e-6 ? y2 : (y - 16 / 116) / 7.787;
+ x = x2 > 8856e-6 ? x2 : (x - 16 / 116) / 7.787;
+ z = z2 > 8856e-6 ? z2 : (z - 16 / 116) / 7.787;
+ x *= 95.047;
+ y *= 100;
+ z *= 108.883;
+ return [x, y, z];
+ };
+ convert.lab.lch = function(lab) {
+ var l = lab[0];
+ var a = lab[1];
+ var b = lab[2];
+ var hr;
+ var h;
+ var c;
+ hr = Math.atan2(b, a);
+ h = hr * 360 / 2 / Math.PI;
+ if (h < 0) {
+ h += 360;
+ }
+ c = Math.sqrt(a * a + b * b);
+ return [l, c, h];
+ };
+ convert.lch.lab = function(lch) {
+ var l = lch[0];
+ var c = lch[1];
+ var h = lch[2];
+ var a;
+ var b;
+ var hr;
+ hr = h / 360 * 2 * Math.PI;
+ a = c * Math.cos(hr);
+ b = c * Math.sin(hr);
+ return [l, a, b];
+ };
+ convert.rgb.ansi16 = function(args) {
+ var r = args[0];
+ var g = args[1];
+ var b = args[2];
+ var value = 1 in arguments ? arguments[1] : convert.rgb.hsv(args)[2];
+ value = Math.round(value / 50);
+ if (value === 0) {
+ return 30;
+ }
+ var ansi2 = 30 + (Math.round(b / 255) << 2 | Math.round(g / 255) << 1 | Math.round(r / 255));
+ if (value === 2) {
+ ansi2 += 60;
+ }
+ return ansi2;
+ };
+ convert.hsv.ansi16 = function(args) {
+ return convert.rgb.ansi16(convert.hsv.rgb(args), args[2]);
+ };
+ convert.rgb.ansi256 = function(args) {
+ var r = args[0];
+ var g = args[1];
+ var 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;
+ }
+ var ansi2 = 16 + 36 * Math.round(r / 255 * 5) + 6 * Math.round(g / 255 * 5) + Math.round(b / 255 * 5);
+ return ansi2;
+ };
+ convert.ansi16.rgb = function(args) {
+ var color = args % 10;
+ if (color === 0 || color === 7) {
+ if (args > 50) {
+ color += 3.5;
+ }
+ color = color / 10.5 * 255;
+ return [color, color, color];
+ }
+ var mult = (~~(args > 50) + 1) * 0.5;
+ var r = (color & 1) * mult * 255;
+ var g = (color >> 1 & 1) * mult * 255;
+ var b = (color >> 2 & 1) * mult * 255;
+ return [r, g, b];
+ };
+ convert.ansi256.rgb = function(args) {
+ if (args >= 232) {
+ var c = (args - 232) * 10 + 8;
+ return [c, c, c];
+ }
+ args -= 16;
+ var rem;
+ var r = Math.floor(args / 36) / 5 * 255;
+ var g = Math.floor((rem = args % 36) / 6) / 5 * 255;
+ var b = rem % 6 / 5 * 255;
+ return [r, g, b];
+ };
+ convert.rgb.hex = function(args) {
+ var integer = ((Math.round(args[0]) & 255) << 16) + ((Math.round(args[1]) & 255) << 8) + (Math.round(args[2]) & 255);
+ var string = integer.toString(16).toUpperCase();
+ return "000000".substring(string.length) + string;
+ };
+ convert.hex.rgb = function(args) {
+ var match = args.toString(16).match(/[a-f0-9]{6}|[a-f0-9]{3}/i);
+ if (!match) {
+ return [0, 0, 0];
+ }
+ var colorString = match[0];
+ if (match[0].length === 3) {
+ colorString = colorString.split("").map(function(char) {
+ return char + char;
+ }).join("");
+ }
+ var integer = parseInt(colorString, 16);
+ var r = integer >> 16 & 255;
+ var g = integer >> 8 & 255;
+ var b = integer & 255;
+ return [r, g, b];
+ };
+ convert.rgb.hcg = function(rgb) {
+ var r = rgb[0] / 255;
+ var g = rgb[1] / 255;
+ var b = rgb[2] / 255;
+ var max = Math.max(Math.max(r, g), b);
+ var min = Math.min(Math.min(r, g), b);
+ var chroma = max - min;
+ var grayscale;
+ var 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 + 4;
+ }
+ hue /= 6;
+ hue %= 1;
+ return [hue * 360, chroma * 100, grayscale * 100];
+ };
+ convert.hsl.hcg = function(hsl) {
+ var s = hsl[1] / 100;
+ var l = hsl[2] / 100;
+ var c = 1;
+ var f = 0;
+ if (l < 0.5) {
+ c = 2 * s * l;
+ } else {
+ c = 2 * s * (1 - l);
+ }
+ if (c < 1) {
+ f = (l - 0.5 * c) / (1 - c);
+ }
+ return [hsl[0], c * 100, f * 100];
+ };
+ convert.hsv.hcg = function(hsv) {
+ var s = hsv[1] / 100;
+ var v = hsv[2] / 100;
+ var c = s * v;
+ var f = 0;
+ if (c < 1) {
+ f = (v - c) / (1 - c);
+ }
+ return [hsv[0], c * 100, f * 100];
+ };
+ convert.hcg.rgb = function(hcg) {
+ var h = hcg[0] / 360;
+ var c = hcg[1] / 100;
+ var g = hcg[2] / 100;
+ if (c === 0) {
+ return [g * 255, g * 255, g * 255];
+ }
+ var pure = [0, 0, 0];
+ var hi = h % 1 * 6;
+ var v = hi % 1;
+ var w = 1 - v;
+ var 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) {
+ var c = hcg[1] / 100;
+ var g = hcg[2] / 100;
+ var v = c + g * (1 - c);
+ var f = 0;
+ if (v > 0) {
+ f = c / v;
+ }
+ return [hcg[0], f * 100, v * 100];
+ };
+ convert.hcg.hsl = function(hcg) {
+ var c = hcg[1] / 100;
+ var g = hcg[2] / 100;
+ var l = g * (1 - c) + 0.5 * c;
+ var 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) {
+ var c = hcg[1] / 100;
+ var g = hcg[2] / 100;
+ var v = c + g * (1 - c);
+ return [hcg[0], (v - c) * 100, (1 - v) * 100];
+ };
+ convert.hwb.hcg = function(hwb) {
+ var w = hwb[1] / 100;
+ var b = hwb[2] / 100;
+ var v = 1 - b;
+ var c = v - w;
+ var 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 = convert.gray.hsv = function(args) {
+ return [0, 0, args[0]];
+ };
+ 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) {
+ var val = Math.round(gray[0] / 100 * 255) & 255;
+ var integer = (val << 16) + (val << 8) + val;
+ var string = integer.toString(16).toUpperCase();
+ return "000000".substring(string.length) + string;
+ };
+ convert.rgb.gray = function(rgb) {
+ var val = (rgb[0] + rgb[1] + rgb[2]) / 3;
+ return [val / 255 * 100];
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/color-convert@1.9.3/node_modules/color-convert/route.js
+var require_route = __commonJS({
+ "../../node_modules/.pnpm/color-convert@1.9.3/node_modules/color-convert/route.js"(exports2, module2) {
+ init_import_meta_url();
+ var conversions = require_conversions();
+ function buildGraph() {
+ var graph = {};
+ var models = Object.keys(conversions);
+ for (var 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;
+ }
+ __name(buildGraph, "buildGraph");
+ function deriveBFS(fromModel) {
+ var graph = buildGraph();
+ var queue = [fromModel];
+ graph[fromModel].distance = 0;
+ while (queue.length) {
+ var current = queue.pop();
+ var adjacents = Object.keys(conversions[current]);
+ for (var len = adjacents.length, i = 0; i < len; i++) {
+ var adjacent = adjacents[i];
+ var node = graph[adjacent];
+ if (node.distance === -1) {
+ node.distance = graph[current].distance + 1;
+ node.parent = current;
+ queue.unshift(adjacent);
+ }
+ }
+ }
+ return graph;
+ }
+ __name(deriveBFS, "deriveBFS");
+ function link(from, to) {
+ return function(args) {
+ return to(from(args));
+ };
+ }
+ __name(link, "link");
+ function wrapConversion(toModel, graph) {
+ var path45 = [graph[toModel].parent, toModel];
+ var fn2 = conversions[graph[toModel].parent][toModel];
+ var cur = graph[toModel].parent;
+ while (graph[cur].parent) {
+ path45.unshift(graph[cur].parent);
+ fn2 = link(conversions[graph[cur].parent][cur], fn2);
+ cur = graph[cur].parent;
+ }
+ fn2.conversion = path45;
+ return fn2;
+ }
+ __name(wrapConversion, "wrapConversion");
+ module2.exports = function(fromModel) {
+ var graph = deriveBFS(fromModel);
+ var conversion = {};
+ var models = Object.keys(graph);
+ for (var len = models.length, i = 0; i < len; i++) {
+ var toModel = models[i];
+ var node = graph[toModel];
+ if (node.parent === null) {
+ continue;
+ }
+ conversion[toModel] = wrapConversion(toModel, graph);
+ }
+ return conversion;
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/color-convert@1.9.3/node_modules/color-convert/index.js
+var require_color_convert = __commonJS({
+ "../../node_modules/.pnpm/color-convert@1.9.3/node_modules/color-convert/index.js"(exports2, module2) {
+ init_import_meta_url();
+ var conversions = require_conversions();
+ var route2 = require_route();
+ var convert = {};
+ var models = Object.keys(conversions);
+ function wrapRaw(fn2) {
+ var wrappedFn = /* @__PURE__ */ __name(function(args) {
+ if (args === void 0 || args === null) {
+ return args;
+ }
+ if (arguments.length > 1) {
+ args = Array.prototype.slice.call(arguments);
+ }
+ return fn2(args);
+ }, "wrappedFn");
+ if ("conversion" in fn2) {
+ wrappedFn.conversion = fn2.conversion;
+ }
+ return wrappedFn;
+ }
+ __name(wrapRaw, "wrapRaw");
+ function wrapRounded(fn2) {
+ var wrappedFn = /* @__PURE__ */ __name(function(args) {
+ if (args === void 0 || args === null) {
+ return args;
+ }
+ if (arguments.length > 1) {
+ args = Array.prototype.slice.call(arguments);
+ }
+ var result = fn2(args);
+ if (typeof result === "object") {
+ for (var len = result.length, i = 0; i < len; i++) {
+ result[i] = Math.round(result[i]);
+ }
+ }
+ return result;
+ }, "wrappedFn");
+ if ("conversion" in fn2) {
+ wrappedFn.conversion = fn2.conversion;
+ }
+ return wrappedFn;
+ }
+ __name(wrapRounded, "wrapRounded");
+ models.forEach(function(fromModel) {
+ convert[fromModel] = {};
+ Object.defineProperty(convert[fromModel], "channels", { value: conversions[fromModel].channels });
+ Object.defineProperty(convert[fromModel], "labels", { value: conversions[fromModel].labels });
+ var routes = route2(fromModel);
+ var routeModels = Object.keys(routes);
+ routeModels.forEach(function(toModel) {
+ var fn2 = routes[toModel];
+ convert[fromModel][toModel] = wrapRounded(fn2);
+ convert[fromModel][toModel].raw = wrapRaw(fn2);
+ });
+ });
+ module2.exports = convert;
+ }
+});
+
+// ../../node_modules/.pnpm/ansi-styles@3.2.1/node_modules/ansi-styles/index.js
+var require_ansi_styles = __commonJS({
+ "../../node_modules/.pnpm/ansi-styles@3.2.1/node_modules/ansi-styles/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var colorConvert = require_color_convert();
+ var wrapAnsi16 = /* @__PURE__ */ __name((fn2, offset) => function() {
+ const code = fn2.apply(colorConvert, arguments);
+ return `\x1B[${code + offset}m`;
+ }, "wrapAnsi16");
+ var wrapAnsi256 = /* @__PURE__ */ __name((fn2, offset) => function() {
+ const code = fn2.apply(colorConvert, arguments);
+ return `\x1B[${38 + offset};5;${code}m`;
+ }, "wrapAnsi256");
+ var wrapAnsi16m = /* @__PURE__ */ __name((fn2, offset) => function() {
+ const rgb = fn2.apply(colorConvert, arguments);
+ return `\x1B[${38 + offset};2;${rgb[0]};${rgb[1]};${rgb[2]}m`;
+ }, "wrapAnsi16m");
+ function assembleStyles() {
+ const codes = /* @__PURE__ */ new Map();
+ const 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],
+ 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],
+ gray: [90, 39],
+ // Bright color
+ 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]
+ }
+ };
+ styles.color.grey = styles.color.gray;
+ for (const groupName of Object.keys(styles)) {
+ const group = styles[groupName];
+ for (const styleName of Object.keys(group)) {
+ const style = group[styleName];
+ 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
+ });
+ }
+ const ansi2ansi = /* @__PURE__ */ __name((n) => n, "ansi2ansi");
+ const rgb2rgb = /* @__PURE__ */ __name((r, g, b) => [r, g, b], "rgb2rgb");
+ styles.color.close = "\x1B[39m";
+ styles.bgColor.close = "\x1B[49m";
+ styles.color.ansi = {
+ ansi: wrapAnsi16(ansi2ansi, 0)
+ };
+ styles.color.ansi256 = {
+ ansi256: wrapAnsi256(ansi2ansi, 0)
+ };
+ styles.color.ansi16m = {
+ rgb: wrapAnsi16m(rgb2rgb, 0)
+ };
+ styles.bgColor.ansi = {
+ ansi: wrapAnsi16(ansi2ansi, 10)
+ };
+ styles.bgColor.ansi256 = {
+ ansi256: wrapAnsi256(ansi2ansi, 10)
+ };
+ styles.bgColor.ansi16m = {
+ rgb: wrapAnsi16m(rgb2rgb, 10)
+ };
+ for (let key of Object.keys(colorConvert)) {
+ if (typeof colorConvert[key] !== "object") {
+ continue;
+ }
+ const suite = colorConvert[key];
+ if (key === "ansi16") {
+ key = "ansi";
+ }
+ if ("ansi16" in suite) {
+ styles.color.ansi[key] = wrapAnsi16(suite.ansi16, 0);
+ styles.bgColor.ansi[key] = wrapAnsi16(suite.ansi16, 10);
+ }
+ if ("ansi256" in suite) {
+ styles.color.ansi256[key] = wrapAnsi256(suite.ansi256, 0);
+ styles.bgColor.ansi256[key] = wrapAnsi256(suite.ansi256, 10);
+ }
+ if ("rgb" in suite) {
+ styles.color.ansi16m[key] = wrapAnsi16m(suite.rgb, 0);
+ styles.bgColor.ansi16m[key] = wrapAnsi16m(suite.rgb, 10);
+ }
+ }
+ return styles;
+ }
+ __name(assembleStyles, "assembleStyles");
+ Object.defineProperty(module2, "exports", {
+ enumerable: true,
+ get: assembleStyles
+ });
+ }
+});
+
+// ../../node_modules/.pnpm/has-flag@3.0.0/node_modules/has-flag/index.js
+var require_has_flag = __commonJS({
+ "../../node_modules/.pnpm/has-flag@3.0.0/node_modules/has-flag/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ module2.exports = (flag, argv) => {
+ argv = argv || process.argv;
+ const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
+ const pos = argv.indexOf(prefix + flag);
+ const terminatorPos = argv.indexOf("--");
+ return pos !== -1 && (terminatorPos === -1 ? true : pos < terminatorPos);
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/supports-color@5.5.0/node_modules/supports-color/index.js
+var require_supports_color = __commonJS({
+ "../../node_modules/.pnpm/supports-color@5.5.0/node_modules/supports-color/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var os9 = require("os");
+ var hasFlag2 = require_has_flag();
+ var env5 = process.env;
+ var forceColor;
+ if (hasFlag2("no-color") || hasFlag2("no-colors") || hasFlag2("color=false")) {
+ forceColor = false;
+ } else if (hasFlag2("color") || hasFlag2("colors") || hasFlag2("color=true") || hasFlag2("color=always")) {
+ forceColor = true;
+ }
+ if ("FORCE_COLOR" in env5) {
+ forceColor = env5.FORCE_COLOR.length === 0 || parseInt(env5.FORCE_COLOR, 10) !== 0;
+ }
+ function translateLevel2(level) {
+ if (level === 0) {
+ return false;
+ }
+ return {
+ level,
+ hasBasic: true,
+ has256: level >= 2,
+ has16m: level >= 3
+ };
+ }
+ __name(translateLevel2, "translateLevel");
+ function supportsColor2(stream2) {
+ if (forceColor === false) {
+ return 0;
+ }
+ if (hasFlag2("color=16m") || hasFlag2("color=full") || hasFlag2("color=truecolor")) {
+ return 3;
+ }
+ if (hasFlag2("color=256")) {
+ return 2;
+ }
+ if (stream2 && !stream2.isTTY && forceColor !== true) {
+ return 0;
+ }
+ const min = forceColor ? 1 : 0;
+ if (process.platform === "win32") {
+ const osRelease = os9.release().split(".");
+ if (Number(process.versions.node.split(".")[0]) >= 8 && Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
+ return Number(osRelease[2]) >= 14931 ? 3 : 2;
+ }
+ return 1;
+ }
+ if ("CI" in env5) {
+ if (["TRAVIS", "CIRCLECI", "APPVEYOR", "GITLAB_CI"].some((sign) => sign in env5) || env5.CI_NAME === "codeship") {
+ return 1;
+ }
+ return min;
+ }
+ if ("TEAMCITY_VERSION" in env5) {
+ return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env5.TEAMCITY_VERSION) ? 1 : 0;
+ }
+ if (env5.COLORTERM === "truecolor") {
+ return 3;
+ }
+ if ("TERM_PROGRAM" in env5) {
+ const version2 = parseInt((env5.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+ switch (env5.TERM_PROGRAM) {
+ case "iTerm.app":
+ return version2 >= 3 ? 3 : 2;
+ case "Apple_Terminal":
+ return 2;
+ }
+ }
+ if (/-256(color)?$/i.test(env5.TERM)) {
+ return 2;
+ }
+ if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env5.TERM)) {
+ return 1;
+ }
+ if ("COLORTERM" in env5) {
+ return 1;
+ }
+ if (env5.TERM === "dumb") {
+ return min;
+ }
+ return min;
+ }
+ __name(supportsColor2, "supportsColor");
+ function getSupportLevel(stream2) {
+ const level = supportsColor2(stream2);
+ return translateLevel2(level);
+ }
+ __name(getSupportLevel, "getSupportLevel");
+ module2.exports = {
+ supportsColor: getSupportLevel,
+ stdout: getSupportLevel(process.stdout),
+ stderr: getSupportLevel(process.stderr)
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/chalk@2.4.2/node_modules/chalk/templates.js
+var require_templates = __commonJS({
+ "../../node_modules/.pnpm/chalk@2.4.2/node_modules/chalk/templates.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var TEMPLATE_REGEX2 = /(?:\\(u[a-f\d]{4}|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}|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) {
+ if (c[0] === "u" && c.length === 5 || c[0] === "x" && c.length === 3) {
+ return String.fromCharCode(parseInt(c.slice(1), 16));
+ }
+ return ESCAPES.get(c) || c;
+ }
+ __name(unescape2, "unescape");
+ function parseArguments(name, args) {
+ const results = [];
+ const chunks = args.trim().split(/\s*,\s*/g);
+ let matches;
+ for (const chunk of chunks) {
+ if (!isNaN(chunk)) {
+ results.push(Number(chunk));
+ } else if (matches = chunk.match(STRING_REGEX)) {
+ results.push(matches[2].replace(ESCAPE_REGEX, (m, escape2, chr) => escape2 ? unescape2(escape2) : chr));
+ } else {
+ throw new Error(`Invalid Chalk template style argument: ${chunk} (in style '${name}')`);
+ }
+ }
+ return results;
+ }
+ __name(parseArguments, "parseArguments");
+ 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;
+ }
+ __name(parseStyle, "parseStyle");
+ function buildStyle(chalk17, styles) {
+ const enabled = {};
+ for (const layer of styles) {
+ for (const style of layer.styles) {
+ enabled[style[0]] = layer.inverse ? null : style.slice(1);
+ }
+ }
+ let current = chalk17;
+ for (const styleName of Object.keys(enabled)) {
+ if (Array.isArray(enabled[styleName])) {
+ if (!(styleName in current)) {
+ throw new Error(`Unknown Chalk style: ${styleName}`);
+ }
+ if (enabled[styleName].length > 0) {
+ current = current[styleName].apply(current, enabled[styleName]);
+ } else {
+ current = current[styleName];
+ }
+ }
+ }
+ return current;
+ }
+ __name(buildStyle, "buildStyle");
+ module2.exports = (chalk17, tmp5) => {
+ const styles = [];
+ const chunks = [];
+ let chunk = [];
+ tmp5.replace(TEMPLATE_REGEX2, (m, escapeChar, inverse, style, close, chr) => {
+ if (escapeChar) {
+ chunk.push(unescape2(escapeChar));
+ } else if (style) {
+ const str = chunk.join("");
+ chunk = [];
+ chunks.push(styles.length === 0 ? str : buildStyle(chalk17, styles)(str));
+ styles.push({ inverse, styles: parseStyle(style) });
+ } else if (close) {
+ if (styles.length === 0) {
+ throw new Error("Found extraneous } in Chalk template literal");
+ }
+ chunks.push(buildStyle(chalk17, styles)(chunk.join("")));
+ chunk = [];
+ styles.pop();
+ } else {
+ chunk.push(chr);
+ }
+ });
+ chunks.push(chunk.join(""));
+ if (styles.length > 0) {
+ const errMsg = `Chalk template literal is missing ${styles.length} closing bracket${styles.length === 1 ? "" : "s"} (\`}\`)`;
+ throw new Error(errMsg);
+ }
+ return chunks.join("");
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/chalk@2.4.2/node_modules/chalk/index.js
+var require_chalk = __commonJS({
+ "../../node_modules/.pnpm/chalk@2.4.2/node_modules/chalk/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var escapeStringRegexp = require_escape_string_regexp();
+ var ansiStyles = require_ansi_styles();
+ var stdoutColor = require_supports_color().stdout;
+ var template = require_templates();
+ var isSimpleWindowsTerm = process.platform === "win32" && !(process.env.TERM || "").toLowerCase().startsWith("xterm");
+ var levelMapping = ["ansi", "ansi", "ansi256", "ansi16m"];
+ var skipModels = /* @__PURE__ */ new Set(["gray"]);
+ var styles = /* @__PURE__ */ Object.create(null);
+ function applyOptions(obj, options14) {
+ options14 = options14 || {};
+ const scLevel = stdoutColor ? stdoutColor.level : 0;
+ obj.level = options14.level === void 0 ? scLevel : options14.level;
+ obj.enabled = "enabled" in options14 ? options14.enabled : obj.level > 0;
+ }
+ __name(applyOptions, "applyOptions");
+ function Chalk(options14) {
+ if (!this || !(this instanceof Chalk) || this.template) {
+ const chalk17 = {};
+ applyOptions(chalk17, options14);
+ chalk17.template = function() {
+ const args = [].slice.call(arguments);
+ return chalkTag.apply(null, [chalk17.template].concat(args));
+ };
+ Object.setPrototypeOf(chalk17, Chalk.prototype);
+ Object.setPrototypeOf(chalk17.template, chalk17);
+ chalk17.template.constructor = Chalk;
+ return chalk17.template;
+ }
+ applyOptions(this, options14);
+ }
+ __name(Chalk, "Chalk");
+ if (isSimpleWindowsTerm) {
+ ansiStyles.blue.open = "\x1B[94m";
+ }
+ for (const key of Object.keys(ansiStyles)) {
+ ansiStyles[key].closeRe = new RegExp(escapeStringRegexp(ansiStyles[key].close), "g");
+ styles[key] = {
+ get() {
+ const codes = ansiStyles[key];
+ return build5.call(this, this._styles ? this._styles.concat(codes) : [codes], this._empty, key);
+ }
+ };
+ }
+ styles.visible = {
+ get() {
+ return build5.call(this, this._styles || [], true, "visible");
+ }
+ };
+ ansiStyles.color.closeRe = new RegExp(escapeStringRegexp(ansiStyles.color.close), "g");
+ for (const model of Object.keys(ansiStyles.color.ansi)) {
+ if (skipModels.has(model)) {
+ continue;
+ }
+ styles[model] = {
+ get() {
+ const level = this.level;
+ return function() {
+ const open3 = ansiStyles.color[levelMapping[level]][model].apply(null, arguments);
+ const codes = {
+ open: open3,
+ close: ansiStyles.color.close,
+ closeRe: ansiStyles.color.closeRe
+ };
+ return build5.call(this, this._styles ? this._styles.concat(codes) : [codes], this._empty, model);
+ };
+ }
+ };
+ }
+ ansiStyles.bgColor.closeRe = new RegExp(escapeStringRegexp(ansiStyles.bgColor.close), "g");
+ for (const model of Object.keys(ansiStyles.bgColor.ansi)) {
+ if (skipModels.has(model)) {
+ continue;
+ }
+ const bgModel = "bg" + model[0].toUpperCase() + model.slice(1);
+ styles[bgModel] = {
+ get() {
+ const level = this.level;
+ return function() {
+ const open3 = ansiStyles.bgColor[levelMapping[level]][model].apply(null, arguments);
+ const codes = {
+ open: open3,
+ close: ansiStyles.bgColor.close,
+ closeRe: ansiStyles.bgColor.closeRe
+ };
+ return build5.call(this, this._styles ? this._styles.concat(codes) : [codes], this._empty, model);
+ };
+ }
+ };
+ }
+ var proto = Object.defineProperties(() => {
+ }, styles);
+ function build5(_styles, _empty, key) {
+ const builder = /* @__PURE__ */ __name(function() {
+ return applyStyle.apply(builder, arguments);
+ }, "builder");
+ builder._styles = _styles;
+ builder._empty = _empty;
+ const self2 = this;
+ Object.defineProperty(builder, "level", {
+ enumerable: true,
+ get() {
+ return self2.level;
+ },
+ set(level) {
+ self2.level = level;
+ }
+ });
+ Object.defineProperty(builder, "enabled", {
+ enumerable: true,
+ get() {
+ return self2.enabled;
+ },
+ set(enabled) {
+ self2.enabled = enabled;
+ }
+ });
+ builder.hasGrey = this.hasGrey || key === "gray" || key === "grey";
+ builder.__proto__ = proto;
+ return builder;
+ }
+ __name(build5, "build");
+ function applyStyle() {
+ const args = arguments;
+ const argsLen = args.length;
+ let str = String(arguments[0]);
+ if (argsLen === 0) {
+ return "";
+ }
+ if (argsLen > 1) {
+ for (let a = 1; a < argsLen; a++) {
+ str += " " + args[a];
+ }
+ }
+ if (!this.enabled || this.level <= 0 || !str) {
+ return this._empty ? "" : str;
+ }
+ const originalDim = ansiStyles.dim.open;
+ if (isSimpleWindowsTerm && this.hasGrey) {
+ ansiStyles.dim.open = "";
+ }
+ for (const code of this._styles.slice().reverse()) {
+ str = code.open + str.replace(code.closeRe, code.open) + code.close;
+ str = str.replace(/\r?\n/g, `${code.close}$&${code.open}`);
+ }
+ ansiStyles.dim.open = originalDim;
+ return str;
+ }
+ __name(applyStyle, "applyStyle");
+ function chalkTag(chalk17, strings) {
+ if (!Array.isArray(strings)) {
+ return [].slice.call(arguments, 1).join(" ");
+ }
+ const args = [].slice.call(arguments, 2);
+ const parts = [strings.raw[0]];
+ for (let i = 1; i < strings.length; i++) {
+ parts.push(String(args[i - 1]).replace(/[{}\\]/g, "\\$&"));
+ parts.push(String(strings.raw[i]));
+ }
+ return template(chalk17, parts.join(""));
+ }
+ __name(chalkTag, "chalkTag");
+ Object.defineProperties(Chalk.prototype, styles);
+ module2.exports = Chalk();
+ module2.exports.supportsColor = stdoutColor;
+ module2.exports.default = module2.exports;
+ }
+});
+
+// ../../node_modules/.pnpm/object-assign@4.1.1/node_modules/object-assign/index.js
+var require_object_assign = __commonJS({
+ "../../node_modules/.pnpm/object-assign@4.1.1/node_modules/object-assign/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var getOwnPropertySymbols = Object.getOwnPropertySymbols;
+ var hasOwnProperty2 = 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);
+ }
+ __name(toObject, "toObject");
+ 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 (err) {
+ return false;
+ }
+ }
+ __name(shouldUseNative, "shouldUseNative");
+ 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 (hasOwnProperty2.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;
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/react@17.0.2/node_modules/react/cjs/react.production.min.js
+var require_react_production_min = __commonJS({
+ "../../node_modules/.pnpm/react@17.0.2/node_modules/react/cjs/react.production.min.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ var l = require_object_assign();
+ var n = 60103;
+ var p = 60106;
+ exports2.Fragment = 60107;
+ exports2.StrictMode = 60108;
+ exports2.Profiler = 60114;
+ var q = 60109;
+ var r = 60110;
+ var t2 = 60112;
+ exports2.Suspense = 60113;
+ var u = 60115;
+ var v = 60116;
+ if ("function" === typeof Symbol && Symbol.for) {
+ w = Symbol.for;
+ n = w("react.element");
+ p = w("react.portal");
+ exports2.Fragment = w("react.fragment");
+ exports2.StrictMode = w("react.strict_mode");
+ exports2.Profiler = w("react.profiler");
+ q = w("react.provider");
+ r = w("react.context");
+ t2 = w("react.forward_ref");
+ exports2.Suspense = w("react.suspense");
+ u = w("react.memo");
+ v = w("react.lazy");
+ }
+ var w;
+ var x = "function" === typeof Symbol && Symbol.iterator;
+ function y(a) {
+ if (null === a || "object" !== typeof a)
+ return null;
+ a = x && a[x] || a["@@iterator"];
+ return "function" === typeof a ? a : null;
+ }
+ __name(y, "y");
+ function z(a) {
+ for (var b = "https://reactjs.org/docs/error-decoder.html?invariant=" + a, c = 1; c < arguments.length; c++)
+ b += "&args[]=" + encodeURIComponent(arguments[c]);
+ return "Minified React error #" + a + "; visit " + b + " for the full message or use the non-minified dev environment for full errors and additional helpful warnings.";
+ }
+ __name(z, "z");
+ var A = { isMounted: function() {
+ return false;
+ }, enqueueForceUpdate: function() {
+ }, enqueueReplaceState: function() {
+ }, enqueueSetState: function() {
+ } };
+ var B = {};
+ function C(a, b, c) {
+ this.props = a;
+ this.context = b;
+ this.refs = B;
+ this.updater = c || A;
+ }
+ __name(C, "C");
+ C.prototype.isReactComponent = {};
+ C.prototype.setState = function(a, b) {
+ if ("object" !== typeof a && "function" !== typeof a && null != a)
+ throw Error(z(85));
+ this.updater.enqueueSetState(this, a, b, "setState");
+ };
+ C.prototype.forceUpdate = function(a) {
+ this.updater.enqueueForceUpdate(this, a, "forceUpdate");
+ };
+ function D() {
+ }
+ __name(D, "D");
+ D.prototype = C.prototype;
+ function E(a, b, c) {
+ this.props = a;
+ this.context = b;
+ this.refs = B;
+ this.updater = c || A;
+ }
+ __name(E, "E");
+ var F = E.prototype = new D();
+ F.constructor = E;
+ l(F, C.prototype);
+ F.isPureReactComponent = true;
+ var G = { current: null };
+ var H = Object.prototype.hasOwnProperty;
+ var I = { key: true, ref: true, __self: true, __source: true };
+ function J(a, b, c) {
+ var e2, d = {}, k = null, h = null;
+ if (null != b)
+ for (e2 in void 0 !== b.ref && (h = b.ref), void 0 !== b.key && (k = "" + b.key), b)
+ H.call(b, e2) && !I.hasOwnProperty(e2) && (d[e2] = b[e2]);
+ var g = arguments.length - 2;
+ if (1 === g)
+ d.children = c;
+ else if (1 < g) {
+ for (var f = Array(g), m = 0; m < g; m++)
+ f[m] = arguments[m + 2];
+ d.children = f;
+ }
+ if (a && a.defaultProps)
+ for (e2 in g = a.defaultProps, g)
+ void 0 === d[e2] && (d[e2] = g[e2]);
+ return { $$typeof: n, type: a, key: k, ref: h, props: d, _owner: G.current };
+ }
+ __name(J, "J");
+ function K(a, b) {
+ return { $$typeof: n, type: a.type, key: b, ref: a.ref, props: a.props, _owner: a._owner };
+ }
+ __name(K, "K");
+ function L(a) {
+ return "object" === typeof a && null !== a && a.$$typeof === n;
+ }
+ __name(L, "L");
+ function escape2(a) {
+ var b = { "=": "=0", ":": "=2" };
+ return "$" + a.replace(/[=:]/g, function(a2) {
+ return b[a2];
+ });
+ }
+ __name(escape2, "escape");
+ var M = /\/+/g;
+ function N(a, b) {
+ return "object" === typeof a && null !== a && null != a.key ? escape2("" + a.key) : b.toString(36);
+ }
+ __name(N, "N");
+ function O(a, b, c, e2, d) {
+ var k = typeof a;
+ if ("undefined" === k || "boolean" === k)
+ a = null;
+ var h = false;
+ if (null === a)
+ h = true;
+ else
+ switch (k) {
+ case "string":
+ case "number":
+ h = true;
+ break;
+ case "object":
+ switch (a.$$typeof) {
+ case n:
+ case p:
+ h = true;
+ }
+ }
+ if (h)
+ return h = a, d = d(h), a = "" === e2 ? "." + N(h, 0) : e2, Array.isArray(d) ? (c = "", null != a && (c = a.replace(M, "$&/") + "/"), O(d, b, c, "", function(a2) {
+ return a2;
+ })) : null != d && (L(d) && (d = K(d, c + (!d.key || h && h.key === d.key ? "" : ("" + d.key).replace(M, "$&/") + "/") + a)), b.push(d)), 1;
+ h = 0;
+ e2 = "" === e2 ? "." : e2 + ":";
+ if (Array.isArray(a))
+ for (var g = 0; g < a.length; g++) {
+ k = a[g];
+ var f = e2 + N(k, g);
+ h += O(k, b, c, f, d);
+ }
+ else if (f = y(a), "function" === typeof f)
+ for (a = f.call(a), g = 0; !(k = a.next()).done; )
+ k = k.value, f = e2 + N(k, g++), h += O(k, b, c, f, d);
+ else if ("object" === k)
+ throw b = "" + a, Error(z(31, "[object Object]" === b ? "object with keys {" + Object.keys(a).join(", ") + "}" : b));
+ return h;
+ }
+ __name(O, "O");
+ function P(a, b, c) {
+ if (null == a)
+ return a;
+ var e2 = [], d = 0;
+ O(a, e2, "", "", function(a2) {
+ return b.call(c, a2, d++);
+ });
+ return e2;
+ }
+ __name(P, "P");
+ function Q(a) {
+ if (-1 === a._status) {
+ var b = a._result;
+ b = b();
+ a._status = 0;
+ a._result = b;
+ b.then(function(b2) {
+ 0 === a._status && (b2 = b2.default, a._status = 1, a._result = b2);
+ }, function(b2) {
+ 0 === a._status && (a._status = 2, a._result = b2);
+ });
+ }
+ if (1 === a._status)
+ return a._result;
+ throw a._result;
+ }
+ __name(Q, "Q");
+ var R = { current: null };
+ function S() {
+ var a = R.current;
+ if (null === a)
+ throw Error(z(321));
+ return a;
+ }
+ __name(S, "S");
+ var T = { ReactCurrentDispatcher: R, ReactCurrentBatchConfig: { transition: 0 }, ReactCurrentOwner: G, IsSomeRendererActing: { current: false }, assign: l };
+ exports2.Children = { map: P, forEach: function(a, b, c) {
+ P(a, function() {
+ b.apply(this, arguments);
+ }, c);
+ }, count: function(a) {
+ var b = 0;
+ P(a, function() {
+ b++;
+ });
+ return b;
+ }, toArray: function(a) {
+ return P(a, function(a2) {
+ return a2;
+ }) || [];
+ }, only: function(a) {
+ if (!L(a))
+ throw Error(z(143));
+ return a;
+ } };
+ exports2.Component = C;
+ exports2.PureComponent = E;
+ exports2.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = T;
+ exports2.cloneElement = function(a, b, c) {
+ if (null === a || void 0 === a)
+ throw Error(z(267, a));
+ var e2 = l({}, a.props), d = a.key, k = a.ref, h = a._owner;
+ if (null != b) {
+ void 0 !== b.ref && (k = b.ref, h = G.current);
+ void 0 !== b.key && (d = "" + b.key);
+ if (a.type && a.type.defaultProps)
+ var g = a.type.defaultProps;
+ for (f in b)
+ H.call(b, f) && !I.hasOwnProperty(f) && (e2[f] = void 0 === b[f] && void 0 !== g ? g[f] : b[f]);
+ }
+ var f = arguments.length - 2;
+ if (1 === f)
+ e2.children = c;
+ else if (1 < f) {
+ g = Array(f);
+ for (var m = 0; m < f; m++)
+ g[m] = arguments[m + 2];
+ e2.children = g;
+ }
+ return {
+ $$typeof: n,
+ type: a.type,
+ key: d,
+ ref: k,
+ props: e2,
+ _owner: h
+ };
+ };
+ exports2.createContext = function(a, b) {
+ void 0 === b && (b = null);
+ a = { $$typeof: r, _calculateChangedBits: b, _currentValue: a, _currentValue2: a, _threadCount: 0, Provider: null, Consumer: null };
+ a.Provider = { $$typeof: q, _context: a };
+ return a.Consumer = a;
+ };
+ exports2.createElement = J;
+ exports2.createFactory = function(a) {
+ var b = J.bind(null, a);
+ b.type = a;
+ return b;
+ };
+ exports2.createRef = function() {
+ return { current: null };
+ };
+ exports2.forwardRef = function(a) {
+ return { $$typeof: t2, render: a };
+ };
+ exports2.isValidElement = L;
+ exports2.lazy = function(a) {
+ return { $$typeof: v, _payload: { _status: -1, _result: a }, _init: Q };
+ };
+ exports2.memo = function(a, b) {
+ return { $$typeof: u, type: a, compare: void 0 === b ? null : b };
+ };
+ exports2.useCallback = function(a, b) {
+ return S().useCallback(a, b);
+ };
+ exports2.useContext = function(a, b) {
+ return S().useContext(a, b);
+ };
+ exports2.useDebugValue = function() {
+ };
+ exports2.useEffect = function(a, b) {
+ return S().useEffect(a, b);
+ };
+ exports2.useImperativeHandle = function(a, b, c) {
+ return S().useImperativeHandle(a, b, c);
+ };
+ exports2.useLayoutEffect = function(a, b) {
+ return S().useLayoutEffect(a, b);
+ };
+ exports2.useMemo = function(a, b) {
+ return S().useMemo(a, b);
+ };
+ exports2.useReducer = function(a, b, c) {
+ return S().useReducer(a, b, c);
+ };
+ exports2.useRef = function(a) {
+ return S().useRef(a);
+ };
+ exports2.useState = function(a) {
+ return S().useState(a);
+ };
+ exports2.version = "17.0.2";
+ }
+});
+
+// ../../node_modules/.pnpm/react@17.0.2/node_modules/react/index.js
+var require_react = __commonJS({
+ "../../node_modules/.pnpm/react@17.0.2/node_modules/react/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ if (true) {
+ module2.exports = require_react_production_min();
+ } else {
+ module2.exports = null;
+ }
+ }
+});
+
+// ../../node_modules/.pnpm/lodash@4.17.21/node_modules/lodash/lodash.js
+var require_lodash = __commonJS({
+ "../../node_modules/.pnpm/lodash@4.17.21/node_modules/lodash/lodash.js"(exports2, module2) {
+ init_import_meta_url();
+ (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 INFINITY2 = 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 (e2) {
+ }
+ }();
+ 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);
+ }
+ __name(apply, "apply");
+ 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;
+ }
+ __name(arrayAggregator, "arrayAggregator");
+ 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;
+ }
+ __name(arrayEach, "arrayEach");
+ function arrayEachRight(array, iteratee) {
+ var length = array == null ? 0 : array.length;
+ while (length--) {
+ if (iteratee(array[length], length, array) === false) {
+ break;
+ }
+ }
+ return array;
+ }
+ __name(arrayEachRight, "arrayEachRight");
+ 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;
+ }
+ __name(arrayEvery, "arrayEvery");
+ 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;
+ }
+ __name(arrayFilter, "arrayFilter");
+ function arrayIncludes(array, value) {
+ var length = array == null ? 0 : array.length;
+ return !!length && baseIndexOf(array, value, 0) > -1;
+ }
+ __name(arrayIncludes, "arrayIncludes");
+ 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;
+ }
+ __name(arrayIncludesWith, "arrayIncludesWith");
+ 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;
+ }
+ __name(arrayMap, "arrayMap");
+ function arrayPush(array, values) {
+ var index = -1, length = values.length, offset = array.length;
+ while (++index < length) {
+ array[offset + index] = values[index];
+ }
+ return array;
+ }
+ __name(arrayPush, "arrayPush");
+ 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;
+ }
+ __name(arrayReduce, "arrayReduce");
+ 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;
+ }
+ __name(arrayReduceRight, "arrayReduceRight");
+ 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;
+ }
+ __name(arraySome, "arraySome");
+ var asciiSize = baseProperty("length");
+ function asciiToArray(string) {
+ return string.split("");
+ }
+ __name(asciiToArray, "asciiToArray");
+ function asciiWords(string) {
+ return string.match(reAsciiWord) || [];
+ }
+ __name(asciiWords, "asciiWords");
+ function baseFindKey(collection, predicate, eachFunc) {
+ var result;
+ eachFunc(collection, function(value, key, collection2) {
+ if (predicate(value, key, collection2)) {
+ result = key;
+ return false;
+ }
+ });
+ return result;
+ }
+ __name(baseFindKey, "baseFindKey");
+ 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;
+ }
+ __name(baseFindIndex, "baseFindIndex");
+ function baseIndexOf(array, value, fromIndex) {
+ return value === value ? strictIndexOf(array, value, fromIndex) : baseFindIndex(array, baseIsNaN, fromIndex);
+ }
+ __name(baseIndexOf, "baseIndexOf");
+ 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;
+ }
+ __name(baseIndexOfWith, "baseIndexOfWith");
+ function baseIsNaN(value) {
+ return value !== value;
+ }
+ __name(baseIsNaN, "baseIsNaN");
+ function baseMean(array, iteratee) {
+ var length = array == null ? 0 : array.length;
+ return length ? baseSum(array, iteratee) / length : NAN;
+ }
+ __name(baseMean, "baseMean");
+ function baseProperty(key) {
+ return function(object) {
+ return object == null ? undefined2 : object[key];
+ };
+ }
+ __name(baseProperty, "baseProperty");
+ function basePropertyOf(object) {
+ return function(key) {
+ return object == null ? undefined2 : object[key];
+ };
+ }
+ __name(basePropertyOf, "basePropertyOf");
+ 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;
+ }
+ __name(baseReduce, "baseReduce");
+ function baseSortBy(array, comparer) {
+ var length = array.length;
+ array.sort(comparer);
+ while (length--) {
+ array[length] = array[length].value;
+ }
+ return array;
+ }
+ __name(baseSortBy, "baseSortBy");
+ 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;
+ }
+ __name(baseSum, "baseSum");
+ function baseTimes(n, iteratee) {
+ var index = -1, result = Array(n);
+ while (++index < n) {
+ result[index] = iteratee(index);
+ }
+ return result;
+ }
+ __name(baseTimes, "baseTimes");
+ function baseToPairs(object, props) {
+ return arrayMap(props, function(key) {
+ return [key, object[key]];
+ });
+ }
+ __name(baseToPairs, "baseToPairs");
+ function baseTrim(string) {
+ return string ? string.slice(0, trimmedEndIndex(string) + 1).replace(reTrimStart, "") : string;
+ }
+ __name(baseTrim, "baseTrim");
+ function baseUnary(func) {
+ return function(value) {
+ return func(value);
+ };
+ }
+ __name(baseUnary, "baseUnary");
+ function baseValues(object, props) {
+ return arrayMap(props, function(key) {
+ return object[key];
+ });
+ }
+ __name(baseValues, "baseValues");
+ function cacheHas(cache2, key) {
+ return cache2.has(key);
+ }
+ __name(cacheHas, "cacheHas");
+ function charsStartIndex(strSymbols, chrSymbols) {
+ var index = -1, length = strSymbols.length;
+ while (++index < length && baseIndexOf(chrSymbols, strSymbols[index], 0) > -1) {
+ }
+ return index;
+ }
+ __name(charsStartIndex, "charsStartIndex");
+ function charsEndIndex(strSymbols, chrSymbols) {
+ var index = strSymbols.length;
+ while (index-- && baseIndexOf(chrSymbols, strSymbols[index], 0) > -1) {
+ }
+ return index;
+ }
+ __name(charsEndIndex, "charsEndIndex");
+ function countHolders(array, placeholder) {
+ var length = array.length, result = 0;
+ while (length--) {
+ if (array[length] === placeholder) {
+ ++result;
+ }
+ }
+ return result;
+ }
+ __name(countHolders, "countHolders");
+ var deburrLetter = basePropertyOf(deburredLetters);
+ var escapeHtmlChar = basePropertyOf(htmlEscapes);
+ function escapeStringChar(chr) {
+ return "\\" + stringEscapes[chr];
+ }
+ __name(escapeStringChar, "escapeStringChar");
+ function getValue(object, key) {
+ return object == null ? undefined2 : object[key];
+ }
+ __name(getValue, "getValue");
+ function hasUnicode(string) {
+ return reHasUnicode.test(string);
+ }
+ __name(hasUnicode, "hasUnicode");
+ function hasUnicodeWord(string) {
+ return reHasUnicodeWord.test(string);
+ }
+ __name(hasUnicodeWord, "hasUnicodeWord");
+ function iteratorToArray(iterator) {
+ var data, result = [];
+ while (!(data = iterator.next()).done) {
+ result.push(data.value);
+ }
+ return result;
+ }
+ __name(iteratorToArray, "iteratorToArray");
+ function mapToArray(map) {
+ var index = -1, result = Array(map.size);
+ map.forEach(function(value, key) {
+ result[++index] = [key, value];
+ });
+ return result;
+ }
+ __name(mapToArray, "mapToArray");
+ function overArg(func, transform) {
+ return function(arg) {
+ return func(transform(arg));
+ };
+ }
+ __name(overArg, "overArg");
+ 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;
+ }
+ __name(replaceHolders, "replaceHolders");
+ function setToArray(set) {
+ var index = -1, result = Array(set.size);
+ set.forEach(function(value) {
+ result[++index] = value;
+ });
+ return result;
+ }
+ __name(setToArray, "setToArray");
+ function setToPairs(set) {
+ var index = -1, result = Array(set.size);
+ set.forEach(function(value) {
+ result[++index] = [value, value];
+ });
+ return result;
+ }
+ __name(setToPairs, "setToPairs");
+ function strictIndexOf(array, value, fromIndex) {
+ var index = fromIndex - 1, length = array.length;
+ while (++index < length) {
+ if (array[index] === value) {
+ return index;
+ }
+ }
+ return -1;
+ }
+ __name(strictIndexOf, "strictIndexOf");
+ function strictLastIndexOf(array, value, fromIndex) {
+ var index = fromIndex + 1;
+ while (index--) {
+ if (array[index] === value) {
+ return index;
+ }
+ }
+ return index;
+ }
+ __name(strictLastIndexOf, "strictLastIndexOf");
+ function stringSize(string) {
+ return hasUnicode(string) ? unicodeSize(string) : asciiSize(string);
+ }
+ __name(stringSize, "stringSize");
+ function stringToArray(string) {
+ return hasUnicode(string) ? unicodeToArray(string) : asciiToArray(string);
+ }
+ __name(stringToArray, "stringToArray");
+ function trimmedEndIndex(string) {
+ var index = string.length;
+ while (index-- && reWhitespace.test(string.charAt(index))) {
+ }
+ return index;
+ }
+ __name(trimmedEndIndex, "trimmedEndIndex");
+ var unescapeHtmlChar = basePropertyOf(htmlUnescapes);
+ function unicodeSize(string) {
+ var result = reUnicode.lastIndex = 0;
+ while (reUnicode.test(string)) {
+ ++result;
+ }
+ return result;
+ }
+ __name(unicodeSize, "unicodeSize");
+ function unicodeToArray(string) {
+ return string.match(reUnicode) || [];
+ }
+ __name(unicodeToArray, "unicodeToArray");
+ function unicodeWords(string) {
+ return string.match(reUnicodeWord) || [];
+ }
+ __name(unicodeWords, "unicodeWords");
+ var runInContext = /* @__PURE__ */ __name(function runInContext2(context2) {
+ context2 = context2 == null ? root : _2.defaults(root.Object(), context2, _2.pick(root, contextProps));
+ var Array2 = context2.Array, Date2 = context2.Date, Error2 = context2.Error, Function2 = context2.Function, Math2 = context2.Math, Object2 = context2.Object, RegExp2 = context2.RegExp, String2 = context2.String, TypeError2 = context2.TypeError;
+ var arrayProto = Array2.prototype, funcProto = Function2.prototype, objectProto = Object2.prototype;
+ var coreJsData = context2["__core-js_shared__"];
+ var funcToString = funcProto.toString;
+ var hasOwnProperty2 = 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(hasOwnProperty2).replace(reRegExpChar, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$"
+ );
+ var Buffer3 = moduleExports ? context2.Buffer : undefined2, Symbol2 = context2.Symbol, Uint8Array2 = context2.Uint8Array, allocUnsafe = Buffer3 ? Buffer3.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 defineProperty2 = function() {
+ try {
+ var func = getNative(Object2, "defineProperty");
+ func({}, "", {});
+ return func;
+ } catch (e2) {
+ }
+ }();
+ var ctxClearTimeout = context2.clearTimeout !== root.clearTimeout && context2.clearTimeout, ctxNow = Date2 && Date2.now !== root.Date.now && Date2.now, ctxSetTimeout = context2.setTimeout !== root.setTimeout && context2.setTimeout;
+ var nativeCeil = Math2.ceil, nativeFloor = Math2.floor, nativeGetSymbols = Object2.getOwnPropertySymbols, nativeIsBuffer = Buffer3 ? Buffer3.isBuffer : undefined2, nativeIsFinite = context2.isFinite, nativeJoin = arrayProto.join, nativeKeys = overArg(Object2.keys, Object2), nativeMax = Math2.max, nativeMin = Math2.min, nativeNow = Date2.now, nativeParseInt = context2.parseInt, nativeRandom = Math2.random, nativeReverse = arrayProto.reverse;
+ var DataView2 = getNative(context2, "DataView"), Map2 = getNative(context2, "Map"), Promise2 = getNative(context2, "Promise"), Set2 = getNative(context2, "Set"), WeakMap2 = getNative(context2, "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 (hasOwnProperty2.call(value, "__wrapped__")) {
+ return wrapperClone(value);
+ }
+ }
+ return new LodashWrapper(value);
+ }
+ __name(lodash, "lodash");
+ var baseCreate = function() {
+ function object() {
+ }
+ __name(object, "object");
+ return function(proto) {
+ if (!isObject2(proto)) {
+ return {};
+ }
+ if (objectCreate) {
+ return objectCreate(proto);
+ }
+ object.prototype = proto;
+ var result2 = new object();
+ object.prototype = undefined2;
+ return result2;
+ };
+ }();
+ function baseLodash() {
+ }
+ __name(baseLodash, "baseLodash");
+ function LodashWrapper(value, chainAll) {
+ this.__wrapped__ = value;
+ this.__actions__ = [];
+ this.__chain__ = !!chainAll;
+ this.__index__ = 0;
+ this.__values__ = undefined2;
+ }
+ __name(LodashWrapper, "LodashWrapper");
+ 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__ = [];
+ }
+ __name(LazyWrapper, "LazyWrapper");
+ 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;
+ }
+ __name(lazyClone, "lazyClone");
+ 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;
+ }
+ __name(lazyReverse, "lazyReverse");
+ 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;
+ }
+ __name(lazyValue, "lazyValue");
+ 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 entry = entries[index];
+ this.set(entry[0], entry[1]);
+ }
+ }
+ __name(Hash, "Hash");
+ function hashClear() {
+ this.__data__ = nativeCreate ? nativeCreate(null) : {};
+ this.size = 0;
+ }
+ __name(hashClear, "hashClear");
+ function hashDelete(key) {
+ var result2 = this.has(key) && delete this.__data__[key];
+ this.size -= result2 ? 1 : 0;
+ return result2;
+ }
+ __name(hashDelete, "hashDelete");
+ function hashGet(key) {
+ var data = this.__data__;
+ if (nativeCreate) {
+ var result2 = data[key];
+ return result2 === HASH_UNDEFINED ? undefined2 : result2;
+ }
+ return hasOwnProperty2.call(data, key) ? data[key] : undefined2;
+ }
+ __name(hashGet, "hashGet");
+ function hashHas(key) {
+ var data = this.__data__;
+ return nativeCreate ? data[key] !== undefined2 : hasOwnProperty2.call(data, key);
+ }
+ __name(hashHas, "hashHas");
+ 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;
+ }
+ __name(hashSet, "hashSet");
+ 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 entry = entries[index];
+ this.set(entry[0], entry[1]);
+ }
+ }
+ __name(ListCache, "ListCache");
+ function listCacheClear() {
+ this.__data__ = [];
+ this.size = 0;
+ }
+ __name(listCacheClear, "listCacheClear");
+ 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;
+ }
+ __name(listCacheDelete, "listCacheDelete");
+ function listCacheGet(key) {
+ var data = this.__data__, index = assocIndexOf(data, key);
+ return index < 0 ? undefined2 : data[index][1];
+ }
+ __name(listCacheGet, "listCacheGet");
+ function listCacheHas(key) {
+ return assocIndexOf(this.__data__, key) > -1;
+ }
+ __name(listCacheHas, "listCacheHas");
+ 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;
+ }
+ __name(listCacheSet, "listCacheSet");
+ 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 entry = entries[index];
+ this.set(entry[0], entry[1]);
+ }
+ }
+ __name(MapCache, "MapCache");
+ function mapCacheClear() {
+ this.size = 0;
+ this.__data__ = {
+ "hash": new Hash(),
+ "map": new (Map2 || ListCache)(),
+ "string": new Hash()
+ };
+ }
+ __name(mapCacheClear, "mapCacheClear");
+ function mapCacheDelete(key) {
+ var result2 = getMapData(this, key)["delete"](key);
+ this.size -= result2 ? 1 : 0;
+ return result2;
+ }
+ __name(mapCacheDelete, "mapCacheDelete");
+ function mapCacheGet(key) {
+ return getMapData(this, key).get(key);
+ }
+ __name(mapCacheGet, "mapCacheGet");
+ function mapCacheHas(key) {
+ return getMapData(this, key).has(key);
+ }
+ __name(mapCacheHas, "mapCacheHas");
+ 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;
+ }
+ __name(mapCacheSet, "mapCacheSet");
+ 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]);
+ }
+ }
+ __name(SetCache, "SetCache");
+ function setCacheAdd(value) {
+ this.__data__.set(value, HASH_UNDEFINED);
+ return this;
+ }
+ __name(setCacheAdd, "setCacheAdd");
+ function setCacheHas(value) {
+ return this.__data__.has(value);
+ }
+ __name(setCacheHas, "setCacheHas");
+ 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;
+ }
+ __name(Stack, "Stack");
+ function stackClear() {
+ this.__data__ = new ListCache();
+ this.size = 0;
+ }
+ __name(stackClear, "stackClear");
+ function stackDelete(key) {
+ var data = this.__data__, result2 = data["delete"](key);
+ this.size = data.size;
+ return result2;
+ }
+ __name(stackDelete, "stackDelete");
+ function stackGet(key) {
+ return this.__data__.get(key);
+ }
+ __name(stackGet, "stackGet");
+ function stackHas(key) {
+ return this.__data__.has(key);
+ }
+ __name(stackHas, "stackHas");
+ 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;
+ }
+ __name(stackSet, "stackSet");
+ 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 || hasOwnProperty2.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;
+ }
+ __name(arrayLikeKeys, "arrayLikeKeys");
+ function arraySample(array) {
+ var length = array.length;
+ return length ? array[baseRandom(0, length - 1)] : undefined2;
+ }
+ __name(arraySample, "arraySample");
+ function arraySampleSize(array, n) {
+ return shuffleSelf(copyArray(array), baseClamp(n, 0, array.length));
+ }
+ __name(arraySampleSize, "arraySampleSize");
+ function arrayShuffle(array) {
+ return shuffleSelf(copyArray(array));
+ }
+ __name(arrayShuffle, "arrayShuffle");
+ function assignMergeValue(object, key, value) {
+ if (value !== undefined2 && !eq(object[key], value) || value === undefined2 && !(key in object)) {
+ baseAssignValue(object, key, value);
+ }
+ }
+ __name(assignMergeValue, "assignMergeValue");
+ function assignValue(object, key, value) {
+ var objValue = object[key];
+ if (!(hasOwnProperty2.call(object, key) && eq(objValue, value)) || value === undefined2 && !(key in object)) {
+ baseAssignValue(object, key, value);
+ }
+ }
+ __name(assignValue, "assignValue");
+ function assocIndexOf(array, key) {
+ var length = array.length;
+ while (length--) {
+ if (eq(array[length][0], key)) {
+ return length;
+ }
+ }
+ return -1;
+ }
+ __name(assocIndexOf, "assocIndexOf");
+ function baseAggregator(collection, setter, iteratee2, accumulator) {
+ baseEach(collection, function(value, key, collection2) {
+ setter(accumulator, value, iteratee2(value), collection2);
+ });
+ return accumulator;
+ }
+ __name(baseAggregator, "baseAggregator");
+ function baseAssign(object, source) {
+ return object && copyObject(source, keys(source), object);
+ }
+ __name(baseAssign, "baseAssign");
+ function baseAssignIn(object, source) {
+ return object && copyObject(source, keysIn(source), object);
+ }
+ __name(baseAssignIn, "baseAssignIn");
+ function baseAssignValue(object, key, value) {
+ if (key == "__proto__" && defineProperty2) {
+ defineProperty2(object, key, {
+ "configurable": true,
+ "enumerable": true,
+ "value": value,
+ "writable": true
+ });
+ } else {
+ object[key] = value;
+ }
+ }
+ __name(baseAssignValue, "baseAssignValue");
+ 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;
+ }
+ __name(baseAt, "baseAt");
+ 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;
+ }
+ __name(baseClamp, "baseClamp");
+ 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 (!isObject2(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;
+ }
+ __name(baseClone, "baseClone");
+ function baseConforms(source) {
+ var props = keys(source);
+ return function(object) {
+ return baseConformsTo(object, source, props);
+ };
+ }
+ __name(baseConforms, "baseConforms");
+ 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;
+ }
+ __name(baseConformsTo, "baseConformsTo");
+ function baseDelay(func, wait, args) {
+ if (typeof func != "function") {
+ throw new TypeError2(FUNC_ERROR_TEXT);
+ }
+ return setTimeout4(function() {
+ func.apply(undefined2, args);
+ }, wait);
+ }
+ __name(baseDelay, "baseDelay");
+ 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;
+ }
+ __name(baseDifference, "baseDifference");
+ 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;
+ }
+ __name(baseEvery, "baseEvery");
+ 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;
+ }
+ __name(baseExtremum, "baseExtremum");
+ 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;
+ }
+ __name(baseFill, "baseFill");
+ function baseFilter(collection, predicate) {
+ var result2 = [];
+ baseEach(collection, function(value, index, collection2) {
+ if (predicate(value, index, collection2)) {
+ result2.push(value);
+ }
+ });
+ return result2;
+ }
+ __name(baseFilter, "baseFilter");
+ 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;
+ }
+ __name(baseFlatten, "baseFlatten");
+ var baseFor = createBaseFor();
+ var baseForRight = createBaseFor(true);
+ function baseForOwn(object, iteratee2) {
+ return object && baseFor(object, iteratee2, keys);
+ }
+ __name(baseForOwn, "baseForOwn");
+ function baseForOwnRight(object, iteratee2) {
+ return object && baseForRight(object, iteratee2, keys);
+ }
+ __name(baseForOwnRight, "baseForOwnRight");
+ function baseFunctions(object, props) {
+ return arrayFilter(props, function(key) {
+ return isFunction2(object[key]);
+ });
+ }
+ __name(baseFunctions, "baseFunctions");
+ function baseGet(object, path45) {
+ path45 = castPath(path45, object);
+ var index = 0, length = path45.length;
+ while (object != null && index < length) {
+ object = object[toKey(path45[index++])];
+ }
+ return index && index == length ? object : undefined2;
+ }
+ __name(baseGet, "baseGet");
+ function baseGetAllKeys(object, keysFunc, symbolsFunc) {
+ var result2 = keysFunc(object);
+ return isArray(object) ? result2 : arrayPush(result2, symbolsFunc(object));
+ }
+ __name(baseGetAllKeys, "baseGetAllKeys");
+ function baseGetTag(value) {
+ if (value == null) {
+ return value === undefined2 ? undefinedTag : nullTag;
+ }
+ return symToStringTag && symToStringTag in Object2(value) ? getRawTag(value) : objectToString(value);
+ }
+ __name(baseGetTag, "baseGetTag");
+ function baseGt(value, other) {
+ return value > other;
+ }
+ __name(baseGt, "baseGt");
+ function baseHas(object, key) {
+ return object != null && hasOwnProperty2.call(object, key);
+ }
+ __name(baseHas, "baseHas");
+ function baseHasIn(object, key) {
+ return object != null && key in Object2(object);
+ }
+ __name(baseHasIn, "baseHasIn");
+ function baseInRange(number, start, end) {
+ return number >= nativeMin(start, end) && number < nativeMax(start, end);
+ }
+ __name(baseInRange, "baseInRange");
+ 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 cache2 = caches[othIndex];
+ if (!(cache2 ? cacheHas(cache2, computed) : includes2(arrays[othIndex], computed, comparator))) {
+ continue outer;
+ }
+ }
+ if (seen) {
+ seen.push(computed);
+ }
+ result2.push(value);
+ }
+ }
+ return result2;
+ }
+ __name(baseIntersection, "baseIntersection");
+ function baseInverter(object, setter, iteratee2, accumulator) {
+ baseForOwn(object, function(value, key, object2) {
+ setter(accumulator, iteratee2(value), key, object2);
+ });
+ return accumulator;
+ }
+ __name(baseInverter, "baseInverter");
+ function baseInvoke(object, path45, args) {
+ path45 = castPath(path45, object);
+ object = parent(object, path45);
+ var func = object == null ? object : object[toKey(last(path45))];
+ return func == null ? undefined2 : apply(func, object, args);
+ }
+ __name(baseInvoke, "baseInvoke");
+ function baseIsArguments(value) {
+ return isObjectLike(value) && baseGetTag(value) == argsTag;
+ }
+ __name(baseIsArguments, "baseIsArguments");
+ function baseIsArrayBuffer(value) {
+ return isObjectLike(value) && baseGetTag(value) == arrayBufferTag;
+ }
+ __name(baseIsArrayBuffer, "baseIsArrayBuffer");
+ function baseIsDate(value) {
+ return isObjectLike(value) && baseGetTag(value) == dateTag;
+ }
+ __name(baseIsDate, "baseIsDate");
+ 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);
+ }
+ __name(baseIsEqual, "baseIsEqual");
+ 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 && hasOwnProperty2.call(object, "__wrapped__"), othIsWrapped = othIsObj && hasOwnProperty2.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);
+ }
+ __name(baseIsEqualDeep, "baseIsEqualDeep");
+ function baseIsMap(value) {
+ return isObjectLike(value) && getTag(value) == mapTag;
+ }
+ __name(baseIsMap, "baseIsMap");
+ 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;
+ }
+ __name(baseIsMatch, "baseIsMatch");
+ function baseIsNative(value) {
+ if (!isObject2(value) || isMasked(value)) {
+ return false;
+ }
+ var pattern = isFunction2(value) ? reIsNative : reIsHostCtor;
+ return pattern.test(toSource(value));
+ }
+ __name(baseIsNative, "baseIsNative");
+ function baseIsRegExp(value) {
+ return isObjectLike(value) && baseGetTag(value) == regexpTag;
+ }
+ __name(baseIsRegExp, "baseIsRegExp");
+ function baseIsSet(value) {
+ return isObjectLike(value) && getTag(value) == setTag;
+ }
+ __name(baseIsSet, "baseIsSet");
+ function baseIsTypedArray(value) {
+ return isObjectLike(value) && isLength(value.length) && !!typedArrayTags[baseGetTag(value)];
+ }
+ __name(baseIsTypedArray, "baseIsTypedArray");
+ 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);
+ }
+ __name(baseIteratee, "baseIteratee");
+ function baseKeys(object) {
+ if (!isPrototype(object)) {
+ return nativeKeys(object);
+ }
+ var result2 = [];
+ for (var key in Object2(object)) {
+ if (hasOwnProperty2.call(object, key) && key != "constructor") {
+ result2.push(key);
+ }
+ }
+ return result2;
+ }
+ __name(baseKeys, "baseKeys");
+ function baseKeysIn(object) {
+ if (!isObject2(object)) {
+ return nativeKeysIn(object);
+ }
+ var isProto = isPrototype(object), result2 = [];
+ for (var key in object) {
+ if (!(key == "constructor" && (isProto || !hasOwnProperty2.call(object, key)))) {
+ result2.push(key);
+ }
+ }
+ return result2;
+ }
+ __name(baseKeysIn, "baseKeysIn");
+ function baseLt(value, other) {
+ return value < other;
+ }
+ __name(baseLt, "baseLt");
+ 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;
+ }
+ __name(baseMap, "baseMap");
+ 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);
+ };
+ }
+ __name(baseMatches, "baseMatches");
+ function baseMatchesProperty(path45, srcValue) {
+ if (isKey(path45) && isStrictComparable(srcValue)) {
+ return matchesStrictComparable(toKey(path45), srcValue);
+ }
+ return function(object) {
+ var objValue = get(object, path45);
+ return objValue === undefined2 && objValue === srcValue ? hasIn(object, path45) : baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG);
+ };
+ }
+ __name(baseMatchesProperty, "baseMatchesProperty");
+ function baseMerge(object, source, srcIndex, customizer, stack) {
+ if (object === source) {
+ return;
+ }
+ baseFor(source, function(srcValue, key) {
+ stack || (stack = new Stack());
+ if (isObject2(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);
+ }
+ __name(baseMerge, "baseMerge");
+ 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 (!isObject2(objValue) || isFunction2(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);
+ }
+ __name(baseMergeDeep, "baseMergeDeep");
+ function baseNth(array, n) {
+ var length = array.length;
+ if (!length) {
+ return;
+ }
+ n += n < 0 ? length : 0;
+ return isIndex(n, length) ? array[n] : undefined2;
+ }
+ __name(baseNth, "baseNth");
+ 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);
+ });
+ }
+ __name(baseOrderBy, "baseOrderBy");
+ function basePick(object, paths) {
+ return basePickBy(object, paths, function(value, path45) {
+ return hasIn(object, path45);
+ });
+ }
+ __name(basePick, "basePick");
+ function basePickBy(object, paths, predicate) {
+ var index = -1, length = paths.length, result2 = {};
+ while (++index < length) {
+ var path45 = paths[index], value = baseGet(object, path45);
+ if (predicate(value, path45)) {
+ baseSet(result2, castPath(path45, object), value);
+ }
+ }
+ return result2;
+ }
+ __name(basePickBy, "basePickBy");
+ function basePropertyDeep(path45) {
+ return function(object) {
+ return baseGet(object, path45);
+ };
+ }
+ __name(basePropertyDeep, "basePropertyDeep");
+ 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;
+ }
+ __name(basePullAll, "basePullAll");
+ 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;
+ }
+ __name(basePullAt, "basePullAt");
+ function baseRandom(lower, upper) {
+ return lower + nativeFloor(nativeRandom() * (upper - lower + 1));
+ }
+ __name(baseRandom, "baseRandom");
+ 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;
+ }
+ __name(baseRange, "baseRange");
+ 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;
+ }
+ __name(baseRepeat, "baseRepeat");
+ function baseRest(func, start) {
+ return setToString(overRest(func, start, identity), func + "");
+ }
+ __name(baseRest, "baseRest");
+ function baseSample(collection) {
+ return arraySample(values(collection));
+ }
+ __name(baseSample, "baseSample");
+ function baseSampleSize(collection, n) {
+ var array = values(collection);
+ return shuffleSelf(array, baseClamp(n, 0, array.length));
+ }
+ __name(baseSampleSize, "baseSampleSize");
+ function baseSet(object, path45, value, customizer) {
+ if (!isObject2(object)) {
+ return object;
+ }
+ path45 = castPath(path45, object);
+ var index = -1, length = path45.length, lastIndex = length - 1, nested = object;
+ while (nested != null && ++index < length) {
+ var key = toKey(path45[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 = isObject2(objValue) ? objValue : isIndex(path45[index + 1]) ? [] : {};
+ }
+ }
+ assignValue(nested, key, newValue);
+ nested = nested[key];
+ }
+ return object;
+ }
+ __name(baseSet, "baseSet");
+ var baseSetData = !metaMap ? identity : function(func, data) {
+ metaMap.set(func, data);
+ return func;
+ };
+ var baseSetToString = !defineProperty2 ? identity : function(func, string) {
+ return defineProperty2(func, "toString", {
+ "configurable": true,
+ "enumerable": false,
+ "value": constant(string),
+ "writable": true
+ });
+ };
+ function baseShuffle(collection) {
+ return shuffleSelf(values(collection));
+ }
+ __name(baseShuffle, "baseShuffle");
+ 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;
+ }
+ __name(baseSlice, "baseSlice");
+ function baseSome(collection, predicate) {
+ var result2;
+ baseEach(collection, function(value, index, collection2) {
+ result2 = predicate(value, index, collection2);
+ return !result2;
+ });
+ return !!result2;
+ }
+ __name(baseSome, "baseSome");
+ 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);
+ }
+ __name(baseSortedIndex, "baseSortedIndex");
+ 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);
+ }
+ __name(baseSortedIndexBy, "baseSortedIndexBy");
+ 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;
+ }
+ __name(baseSortedUniq, "baseSortedUniq");
+ function baseToNumber(value) {
+ if (typeof value == "number") {
+ return value;
+ }
+ if (isSymbol(value)) {
+ return NAN;
+ }
+ return +value;
+ }
+ __name(baseToNumber, "baseToNumber");
+ 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 == -INFINITY2 ? "-0" : result2;
+ }
+ __name(baseToString, "baseToString");
+ 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;
+ }
+ __name(baseUniq, "baseUniq");
+ function baseUnset(object, path45) {
+ path45 = castPath(path45, object);
+ object = parent(object, path45);
+ return object == null || delete object[toKey(last(path45))];
+ }
+ __name(baseUnset, "baseUnset");
+ function baseUpdate(object, path45, updater, customizer) {
+ return baseSet(object, path45, updater(baseGet(object, path45)), customizer);
+ }
+ __name(baseUpdate, "baseUpdate");
+ 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);
+ }
+ __name(baseWhile, "baseWhile");
+ 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);
+ }
+ __name(baseWrapperValue, "baseWrapperValue");
+ 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);
+ }
+ __name(baseXor, "baseXor");
+ 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;
+ }
+ __name(baseZipObject, "baseZipObject");
+ function castArrayLikeObject(value) {
+ return isArrayLikeObject(value) ? value : [];
+ }
+ __name(castArrayLikeObject, "castArrayLikeObject");
+ function castFunction(value) {
+ return typeof value == "function" ? value : identity;
+ }
+ __name(castFunction, "castFunction");
+ function castPath(value, object) {
+ if (isArray(value)) {
+ return value;
+ }
+ return isKey(value, object) ? [value] : stringToPath(toString(value));
+ }
+ __name(castPath, "castPath");
+ 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);
+ }
+ __name(castSlice, "castSlice");
+ 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;
+ }
+ __name(cloneBuffer, "cloneBuffer");
+ function cloneArrayBuffer(arrayBuffer2) {
+ var result2 = new arrayBuffer2.constructor(arrayBuffer2.byteLength);
+ new Uint8Array2(result2).set(new Uint8Array2(arrayBuffer2));
+ return result2;
+ }
+ __name(cloneArrayBuffer, "cloneArrayBuffer");
+ function cloneDataView(dataView, isDeep) {
+ var buffer = isDeep ? cloneArrayBuffer(dataView.buffer) : dataView.buffer;
+ return new dataView.constructor(buffer, dataView.byteOffset, dataView.byteLength);
+ }
+ __name(cloneDataView, "cloneDataView");
+ function cloneRegExp(regexp) {
+ var result2 = new regexp.constructor(regexp.source, reFlags.exec(regexp));
+ result2.lastIndex = regexp.lastIndex;
+ return result2;
+ }
+ __name(cloneRegExp, "cloneRegExp");
+ function cloneSymbol(symbol) {
+ return symbolValueOf ? Object2(symbolValueOf.call(symbol)) : {};
+ }
+ __name(cloneSymbol, "cloneSymbol");
+ function cloneTypedArray(typedArray, isDeep) {
+ var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer;
+ return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);
+ }
+ __name(cloneTypedArray, "cloneTypedArray");
+ 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;
+ }
+ __name(compareAscending, "compareAscending");
+ 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;
+ }
+ __name(compareMultiple, "compareMultiple");
+ 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;
+ }
+ __name(composeArgs, "composeArgs");
+ 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;
+ }
+ __name(composeArgsRight, "composeArgsRight");
+ function copyArray(source, array) {
+ var index = -1, length = source.length;
+ array || (array = Array2(length));
+ while (++index < length) {
+ array[index] = source[index];
+ }
+ return array;
+ }
+ __name(copyArray, "copyArray");
+ 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;
+ }
+ __name(copyObject, "copyObject");
+ function copySymbols(source, object) {
+ return copyObject(source, getSymbols(source), object);
+ }
+ __name(copySymbols, "copySymbols");
+ function copySymbolsIn(source, object) {
+ return copyObject(source, getSymbolsIn(source), object);
+ }
+ __name(copySymbolsIn, "copySymbolsIn");
+ 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);
+ };
+ }
+ __name(createAggregator, "createAggregator");
+ 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;
+ });
+ }
+ __name(createAssigner, "createAssigner");
+ 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;
+ };
+ }
+ __name(createBaseEach, "createBaseEach");
+ 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;
+ };
+ }
+ __name(createBaseFor, "createBaseFor");
+ function createBind(func, bitmask, thisArg) {
+ var isBind = bitmask & WRAP_BIND_FLAG, Ctor = createCtor(func);
+ function wrapper() {
+ var fn2 = this && this !== root && this instanceof wrapper ? Ctor : func;
+ return fn2.apply(isBind ? thisArg : this, arguments);
+ }
+ __name(wrapper, "wrapper");
+ return wrapper;
+ }
+ __name(createBind, "createBind");
+ 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;
+ };
+ }
+ __name(createCaseFirst, "createCaseFirst");
+ function createCompounder(callback) {
+ return function(string) {
+ return arrayReduce(words(deburr(string).replace(reApos, "")), callback, "");
+ };
+ }
+ __name(createCompounder, "createCompounder");
+ 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 isObject2(result2) ? result2 : thisBinding;
+ };
+ }
+ __name(createCtor, "createCtor");
+ 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 fn2 = this && this !== root && this instanceof wrapper ? Ctor : func;
+ return apply(fn2, this, args);
+ }
+ __name(wrapper, "wrapper");
+ return wrapper;
+ }
+ __name(createCurry, "createCurry");
+ function createFind(findIndexFunc) {
+ return function(collection, predicate, fromIndex) {
+ var iterable = Object2(collection);
+ if (!isArrayLike(collection)) {
+ var iteratee2 = getIteratee(predicate, 3);
+ collection = keys(collection);
+ predicate = /* @__PURE__ */ __name(function(key) {
+ return iteratee2(iterable[key], key, iterable);
+ }, "predicate");
+ }
+ var index = findIndexFunc(collection, predicate, fromIndex);
+ return index > -1 ? iterable[iteratee2 ? collection[index] : index] : undefined2;
+ };
+ }
+ __name(createFind, "createFind");
+ 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;
+ };
+ });
+ }
+ __name(createFlow, "createFlow");
+ 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, fn2 = 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) {
+ fn2 = Ctor || createCtor(fn2);
+ }
+ return fn2.apply(thisBinding, args);
+ }
+ __name(wrapper, "wrapper");
+ return wrapper;
+ }
+ __name(createHybrid, "createHybrid");
+ function createInverter(setter, toIteratee) {
+ return function(object, iteratee2) {
+ return baseInverter(object, setter, toIteratee(iteratee2), {});
+ };
+ }
+ __name(createInverter, "createInverter");
+ 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;
+ };
+ }
+ __name(createMathOperation, "createMathOperation");
+ 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);
+ });
+ });
+ });
+ }
+ __name(createOver, "createOver");
+ 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);
+ }
+ __name(createPadding, "createPadding");
+ 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), fn2 = this && this !== root && this instanceof wrapper ? Ctor : func;
+ while (++leftIndex < leftLength) {
+ args[leftIndex] = partials[leftIndex];
+ }
+ while (argsLength--) {
+ args[leftIndex++] = arguments[++argsIndex];
+ }
+ return apply(fn2, isBind ? thisArg : this, args);
+ }
+ __name(wrapper, "wrapper");
+ return wrapper;
+ }
+ __name(createPartial, "createPartial");
+ 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);
+ };
+ }
+ __name(createRange, "createRange");
+ function createRelationalOperation(operator) {
+ return function(value, other) {
+ if (!(typeof value == "string" && typeof other == "string")) {
+ value = toNumber(value);
+ other = toNumber(other);
+ }
+ return operator(value, other);
+ };
+ }
+ __name(createRelationalOperation, "createRelationalOperation");
+ 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);
+ }
+ __name(createRecurry, "createRecurry");
+ 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);
+ };
+ }
+ __name(createRound, "createRound");
+ var createSet = !(Set2 && 1 / setToArray(new Set2([, -0]))[1] == INFINITY2) ? 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));
+ };
+ }
+ __name(createToPairs, "createToPairs");
+ 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);
+ }
+ __name(createWrap, "createWrap");
+ function customDefaultsAssignIn(objValue, srcValue, key, object) {
+ if (objValue === undefined2 || eq(objValue, objectProto[key]) && !hasOwnProperty2.call(object, key)) {
+ return srcValue;
+ }
+ return objValue;
+ }
+ __name(customDefaultsAssignIn, "customDefaultsAssignIn");
+ function customDefaultsMerge(objValue, srcValue, key, object, source, stack) {
+ if (isObject2(objValue) && isObject2(srcValue)) {
+ stack.set(srcValue, objValue);
+ baseMerge(objValue, srcValue, undefined2, customDefaultsMerge, stack);
+ stack["delete"](srcValue);
+ }
+ return objValue;
+ }
+ __name(customDefaultsMerge, "customDefaultsMerge");
+ function customOmitClone(value) {
+ return isPlainObject(value) ? undefined2 : value;
+ }
+ __name(customOmitClone, "customOmitClone");
+ 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;
+ }
+ __name(equalArrays, "equalArrays");
+ 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;
+ }
+ __name(equalByTag, "equalByTag");
+ 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 : hasOwnProperty2.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;
+ }
+ __name(equalObjects, "equalObjects");
+ function flatRest(func) {
+ return setToString(overRest(func, undefined2, flatten), func + "");
+ }
+ __name(flatRest, "flatRest");
+ function getAllKeys(object) {
+ return baseGetAllKeys(object, keys, getSymbols);
+ }
+ __name(getAllKeys, "getAllKeys");
+ function getAllKeysIn(object) {
+ return baseGetAllKeys(object, keysIn, getSymbolsIn);
+ }
+ __name(getAllKeysIn, "getAllKeysIn");
+ var getData = !metaMap ? noop : function(func) {
+ return metaMap.get(func);
+ };
+ function getFuncName(func) {
+ var result2 = func.name + "", array = realNames[result2], length = hasOwnProperty2.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;
+ }
+ __name(getFuncName, "getFuncName");
+ function getHolder(func) {
+ var object = hasOwnProperty2.call(lodash, "placeholder") ? lodash : func;
+ return object.placeholder;
+ }
+ __name(getHolder, "getHolder");
+ function getIteratee() {
+ var result2 = lodash.iteratee || iteratee;
+ result2 = result2 === iteratee ? baseIteratee : result2;
+ return arguments.length ? result2(arguments[0], arguments[1]) : result2;
+ }
+ __name(getIteratee, "getIteratee");
+ function getMapData(map2, key) {
+ var data = map2.__data__;
+ return isKeyable(key) ? data[typeof key == "string" ? "string" : "hash"] : data.map;
+ }
+ __name(getMapData, "getMapData");
+ 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;
+ }
+ __name(getMatchData, "getMatchData");
+ function getNative(object, key) {
+ var value = getValue(object, key);
+ return baseIsNative(value) ? value : undefined2;
+ }
+ __name(getNative, "getNative");
+ function getRawTag(value) {
+ var isOwn = hasOwnProperty2.call(value, symToStringTag), tag = value[symToStringTag];
+ try {
+ value[symToStringTag] = undefined2;
+ var unmasked = true;
+ } catch (e2) {
+ }
+ var result2 = nativeObjectToString.call(value);
+ if (unmasked) {
+ if (isOwn) {
+ value[symToStringTag] = tag;
+ } else {
+ delete value[symToStringTag];
+ }
+ }
+ return result2;
+ }
+ __name(getRawTag, "getRawTag");
+ 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 = /* @__PURE__ */ __name(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;
+ }, "getTag");
+ }
+ 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 };
+ }
+ __name(getView, "getView");
+ function getWrapDetails(source) {
+ var match = source.match(reWrapDetails);
+ return match ? match[1].split(reSplitDetails) : [];
+ }
+ __name(getWrapDetails, "getWrapDetails");
+ function hasPath(object, path45, hasFunc) {
+ path45 = castPath(path45, object);
+ var index = -1, length = path45.length, result2 = false;
+ while (++index < length) {
+ var key = toKey(path45[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));
+ }
+ __name(hasPath, "hasPath");
+ function initCloneArray(array) {
+ var length = array.length, result2 = new array.constructor(length);
+ if (length && typeof array[0] == "string" && hasOwnProperty2.call(array, "index")) {
+ result2.index = array.index;
+ result2.input = array.input;
+ }
+ return result2;
+ }
+ __name(initCloneArray, "initCloneArray");
+ function initCloneObject(object) {
+ return typeof object.constructor == "function" && !isPrototype(object) ? baseCreate(getPrototype(object)) : {};
+ }
+ __name(initCloneObject, "initCloneObject");
+ 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);
+ }
+ }
+ __name(initCloneByTag, "initCloneByTag");
+ 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");
+ }
+ __name(insertWrapDetails, "insertWrapDetails");
+ function isFlattenable(value) {
+ return isArray(value) || isArguments(value) || !!(spreadableSymbol && value && value[spreadableSymbol]);
+ }
+ __name(isFlattenable, "isFlattenable");
+ 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);
+ }
+ __name(isIndex, "isIndex");
+ function isIterateeCall(value, index, object) {
+ if (!isObject2(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;
+ }
+ __name(isIterateeCall, "isIterateeCall");
+ 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);
+ }
+ __name(isKey, "isKey");
+ function isKeyable(value) {
+ var type = typeof value;
+ return type == "string" || type == "number" || type == "symbol" || type == "boolean" ? value !== "__proto__" : value === null;
+ }
+ __name(isKeyable, "isKeyable");
+ 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];
+ }
+ __name(isLaziable, "isLaziable");
+ function isMasked(func) {
+ return !!maskSrcKey && maskSrcKey in func;
+ }
+ __name(isMasked, "isMasked");
+ var isMaskable = coreJsData ? isFunction2 : stubFalse;
+ function isPrototype(value) {
+ var Ctor = value && value.constructor, proto = typeof Ctor == "function" && Ctor.prototype || objectProto;
+ return value === proto;
+ }
+ __name(isPrototype, "isPrototype");
+ function isStrictComparable(value) {
+ return value === value && !isObject2(value);
+ }
+ __name(isStrictComparable, "isStrictComparable");
+ function matchesStrictComparable(key, srcValue) {
+ return function(object) {
+ if (object == null) {
+ return false;
+ }
+ return object[key] === srcValue && (srcValue !== undefined2 || key in Object2(object));
+ };
+ }
+ __name(matchesStrictComparable, "matchesStrictComparable");
+ function memoizeCapped(func) {
+ var result2 = memoize(func, function(key) {
+ if (cache2.size === MAX_MEMOIZE_SIZE) {
+ cache2.clear();
+ }
+ return key;
+ });
+ var cache2 = result2.cache;
+ return result2;
+ }
+ __name(memoizeCapped, "memoizeCapped");
+ 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;
+ }
+ __name(mergeData, "mergeData");
+ function nativeKeysIn(object) {
+ var result2 = [];
+ if (object != null) {
+ for (var key in Object2(object)) {
+ result2.push(key);
+ }
+ }
+ return result2;
+ }
+ __name(nativeKeysIn, "nativeKeysIn");
+ function objectToString(value) {
+ return nativeObjectToString.call(value);
+ }
+ __name(objectToString, "objectToString");
+ 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);
+ };
+ }
+ __name(overRest, "overRest");
+ function parent(object, path45) {
+ return path45.length < 2 ? object : baseGet(object, baseSlice(path45, 0, -1));
+ }
+ __name(parent, "parent");
+ 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;
+ }
+ __name(reorder, "reorder");
+ function safeGet(object, key) {
+ if (key === "constructor" && typeof object[key] === "function") {
+ return;
+ }
+ if (key == "__proto__") {
+ return;
+ }
+ return object[key];
+ }
+ __name(safeGet, "safeGet");
+ var setData = shortOut(baseSetData);
+ var setTimeout4 = 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)));
+ }
+ __name(setWrapToString, "setWrapToString");
+ 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);
+ };
+ }
+ __name(shortOut, "shortOut");
+ 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;
+ }
+ __name(shuffleSelf, "shuffleSelf");
+ 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 == -INFINITY2 ? "-0" : result2;
+ }
+ __name(toKey, "toKey");
+ function toSource(func) {
+ if (func != null) {
+ try {
+ return funcToString.call(func);
+ } catch (e2) {
+ }
+ try {
+ return func + "";
+ } catch (e2) {
+ }
+ }
+ return "";
+ }
+ __name(toSource, "toSource");
+ 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();
+ }
+ __name(updateWrapDetails, "updateWrapDetails");
+ 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;
+ }
+ __name(wrapperClone, "wrapperClone");
+ 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;
+ }
+ __name(chunk, "chunk");
+ 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;
+ }
+ __name(compact, "compact");
+ 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));
+ }
+ __name(concat, "concat");
+ 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);
+ }
+ __name(drop, "drop");
+ 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);
+ }
+ __name(dropRight, "dropRight");
+ function dropRightWhile(array, predicate) {
+ return array && array.length ? baseWhile(array, getIteratee(predicate, 3), true, true) : [];
+ }
+ __name(dropRightWhile, "dropRightWhile");
+ function dropWhile(array, predicate) {
+ return array && array.length ? baseWhile(array, getIteratee(predicate, 3), true) : [];
+ }
+ __name(dropWhile, "dropWhile");
+ 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);
+ }
+ __name(fill, "fill");
+ 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);
+ }
+ __name(findIndex, "findIndex");
+ 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);
+ }
+ __name(findLastIndex, "findLastIndex");
+ function flatten(array) {
+ var length = array == null ? 0 : array.length;
+ return length ? baseFlatten(array, 1) : [];
+ }
+ __name(flatten, "flatten");
+ function flattenDeep(array) {
+ var length = array == null ? 0 : array.length;
+ return length ? baseFlatten(array, INFINITY2) : [];
+ }
+ __name(flattenDeep, "flattenDeep");
+ function flattenDepth(array, depth) {
+ var length = array == null ? 0 : array.length;
+ if (!length) {
+ return [];
+ }
+ depth = depth === undefined2 ? 1 : toInteger(depth);
+ return baseFlatten(array, depth);
+ }
+ __name(flattenDepth, "flattenDepth");
+ 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;
+ }
+ __name(fromPairs, "fromPairs");
+ function head(array) {
+ return array && array.length ? array[0] : undefined2;
+ }
+ __name(head, "head");
+ 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);
+ }
+ __name(indexOf, "indexOf");
+ function initial(array) {
+ var length = array == null ? 0 : array.length;
+ return length ? baseSlice(array, 0, -1) : [];
+ }
+ __name(initial, "initial");
+ 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 join12(array, separator) {
+ return array == null ? "" : nativeJoin.call(array, separator);
+ }
+ __name(join12, "join");
+ function last(array) {
+ var length = array == null ? 0 : array.length;
+ return length ? array[length - 1] : undefined2;
+ }
+ __name(last, "last");
+ 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);
+ }
+ __name(lastIndexOf, "lastIndexOf");
+ function nth(array, n) {
+ return array && array.length ? baseNth(array, toInteger(n)) : undefined2;
+ }
+ __name(nth, "nth");
+ var pull = baseRest(pullAll);
+ function pullAll(array, values2) {
+ return array && array.length && values2 && values2.length ? basePullAll(array, values2) : array;
+ }
+ __name(pullAll, "pullAll");
+ function pullAllBy(array, values2, iteratee2) {
+ return array && array.length && values2 && values2.length ? basePullAll(array, values2, getIteratee(iteratee2, 2)) : array;
+ }
+ __name(pullAllBy, "pullAllBy");
+ function pullAllWith(array, values2, comparator) {
+ return array && array.length && values2 && values2.length ? basePullAll(array, values2, undefined2, comparator) : array;
+ }
+ __name(pullAllWith, "pullAllWith");
+ 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;
+ }
+ __name(remove, "remove");
+ function reverse(array) {
+ return array == null ? array : nativeReverse.call(array);
+ }
+ __name(reverse, "reverse");
+ 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);
+ }
+ __name(slice, "slice");
+ function sortedIndex(array, value) {
+ return baseSortedIndex(array, value);
+ }
+ __name(sortedIndex, "sortedIndex");
+ function sortedIndexBy(array, value, iteratee2) {
+ return baseSortedIndexBy(array, value, getIteratee(iteratee2, 2));
+ }
+ __name(sortedIndexBy, "sortedIndexBy");
+ 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;
+ }
+ __name(sortedIndexOf, "sortedIndexOf");
+ function sortedLastIndex(array, value) {
+ return baseSortedIndex(array, value, true);
+ }
+ __name(sortedLastIndex, "sortedLastIndex");
+ function sortedLastIndexBy(array, value, iteratee2) {
+ return baseSortedIndexBy(array, value, getIteratee(iteratee2, 2), true);
+ }
+ __name(sortedLastIndexBy, "sortedLastIndexBy");
+ 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;
+ }
+ __name(sortedLastIndexOf, "sortedLastIndexOf");
+ function sortedUniq(array) {
+ return array && array.length ? baseSortedUniq(array) : [];
+ }
+ __name(sortedUniq, "sortedUniq");
+ function sortedUniqBy(array, iteratee2) {
+ return array && array.length ? baseSortedUniq(array, getIteratee(iteratee2, 2)) : [];
+ }
+ __name(sortedUniqBy, "sortedUniqBy");
+ function tail(array) {
+ var length = array == null ? 0 : array.length;
+ return length ? baseSlice(array, 1, length) : [];
+ }
+ __name(tail, "tail");
+ 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);
+ }
+ __name(take, "take");
+ 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);
+ }
+ __name(takeRight, "takeRight");
+ function takeRightWhile(array, predicate) {
+ return array && array.length ? baseWhile(array, getIteratee(predicate, 3), false, true) : [];
+ }
+ __name(takeRightWhile, "takeRightWhile");
+ function takeWhile(array, predicate) {
+ return array && array.length ? baseWhile(array, getIteratee(predicate, 3)) : [];
+ }
+ __name(takeWhile, "takeWhile");
+ 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) : [];
+ }
+ __name(uniq, "uniq");
+ function uniqBy(array, iteratee2) {
+ return array && array.length ? baseUniq(array, getIteratee(iteratee2, 2)) : [];
+ }
+ __name(uniqBy, "uniqBy");
+ function uniqWith(array, comparator) {
+ comparator = typeof comparator == "function" ? comparator : undefined2;
+ return array && array.length ? baseUniq(array, undefined2, comparator) : [];
+ }
+ __name(uniqWith, "uniqWith");
+ 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));
+ });
+ }
+ __name(unzip, "unzip");
+ 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);
+ });
+ }
+ __name(unzipWith, "unzipWith");
+ 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);
+ }
+ __name(zipObject, "zipObject");
+ function zipObjectDeep(props, values2) {
+ return baseZipObject(props || [], values2 || [], baseSet);
+ }
+ __name(zipObjectDeep, "zipObjectDeep");
+ 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;
+ }
+ __name(chain, "chain");
+ function tap(value, interceptor) {
+ interceptor(value);
+ return value;
+ }
+ __name(tap, "tap");
+ function thru(value, interceptor) {
+ return interceptor(value);
+ }
+ __name(thru, "thru");
+ var wrapperAt = flatRest(function(paths) {
+ var length = paths.length, start = length ? paths[0] : 0, value = this.__wrapped__, interceptor = /* @__PURE__ */ __name(function(object) {
+ return baseAt(object, paths);
+ }, "interceptor");
+ 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);
+ }
+ __name(wrapperChain, "wrapperChain");
+ function wrapperCommit() {
+ return new LodashWrapper(this.value(), this.__chain__);
+ }
+ __name(wrapperCommit, "wrapperCommit");
+ 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 };
+ }
+ __name(wrapperNext, "wrapperNext");
+ function wrapperToIterator() {
+ return this;
+ }
+ __name(wrapperToIterator, "wrapperToIterator");
+ 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;
+ }
+ __name(wrapperPlant, "wrapperPlant");
+ 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);
+ }
+ __name(wrapperReverse, "wrapperReverse");
+ function wrapperValue() {
+ return baseWrapperValue(this.__wrapped__, this.__actions__);
+ }
+ __name(wrapperValue, "wrapperValue");
+ var countBy = createAggregator(function(result2, value, key) {
+ if (hasOwnProperty2.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));
+ }
+ __name(every, "every");
+ function filter(collection, predicate) {
+ var func = isArray(collection) ? arrayFilter : baseFilter;
+ return func(collection, getIteratee(predicate, 3));
+ }
+ __name(filter, "filter");
+ var find = createFind(findIndex);
+ var findLast = createFind(findLastIndex);
+ function flatMap(collection, iteratee2) {
+ return baseFlatten(map(collection, iteratee2), 1);
+ }
+ __name(flatMap, "flatMap");
+ function flatMapDeep(collection, iteratee2) {
+ return baseFlatten(map(collection, iteratee2), INFINITY2);
+ }
+ __name(flatMapDeep, "flatMapDeep");
+ function flatMapDepth(collection, iteratee2, depth) {
+ depth = depth === undefined2 ? 1 : toInteger(depth);
+ return baseFlatten(map(collection, iteratee2), depth);
+ }
+ __name(flatMapDepth, "flatMapDepth");
+ function forEach(collection, iteratee2) {
+ var func = isArray(collection) ? arrayEach : baseEach;
+ return func(collection, getIteratee(iteratee2, 3));
+ }
+ __name(forEach, "forEach");
+ function forEachRight(collection, iteratee2) {
+ var func = isArray(collection) ? arrayEachRight : baseEachRight;
+ return func(collection, getIteratee(iteratee2, 3));
+ }
+ __name(forEachRight, "forEachRight");
+ var groupBy = createAggregator(function(result2, value, key) {
+ if (hasOwnProperty2.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 isString2(collection) ? fromIndex <= length && collection.indexOf(value, fromIndex) > -1 : !!length && baseIndexOf(collection, value, fromIndex) > -1;
+ }
+ __name(includes, "includes");
+ var invokeMap = baseRest(function(collection, path45, args) {
+ var index = -1, isFunc = typeof path45 == "function", result2 = isArrayLike(collection) ? Array2(collection.length) : [];
+ baseEach(collection, function(value) {
+ result2[++index] = isFunc ? apply(path45, value, args) : baseInvoke(value, path45, 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));
+ }
+ __name(map, "map");
+ 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);
+ }
+ __name(orderBy, "orderBy");
+ 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);
+ }
+ __name(reduce, "reduce");
+ function reduceRight(collection, iteratee2, accumulator) {
+ var func = isArray(collection) ? arrayReduceRight : baseReduce, initAccum = arguments.length < 3;
+ return func(collection, getIteratee(iteratee2, 4), accumulator, initAccum, baseEachRight);
+ }
+ __name(reduceRight, "reduceRight");
+ function reject(collection, predicate) {
+ var func = isArray(collection) ? arrayFilter : baseFilter;
+ return func(collection, negate(getIteratee(predicate, 3)));
+ }
+ __name(reject, "reject");
+ function sample(collection) {
+ var func = isArray(collection) ? arraySample : baseSample;
+ return func(collection);
+ }
+ __name(sample, "sample");
+ 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);
+ }
+ __name(sampleSize, "sampleSize");
+ function shuffle(collection) {
+ var func = isArray(collection) ? arrayShuffle : baseShuffle;
+ return func(collection);
+ }
+ __name(shuffle, "shuffle");
+ function size(collection) {
+ if (collection == null) {
+ return 0;
+ }
+ if (isArrayLike(collection)) {
+ return isString2(collection) ? stringSize(collection) : collection.length;
+ }
+ var tag = getTag(collection);
+ if (tag == mapTag || tag == setTag) {
+ return collection.size;
+ }
+ return baseKeys(collection).length;
+ }
+ __name(size, "size");
+ 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));
+ }
+ __name(some, "some");
+ 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);
+ }
+ };
+ }
+ __name(after, "after");
+ 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);
+ }
+ __name(ary, "ary");
+ 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;
+ };
+ }
+ __name(before, "before");
+ 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;
+ }
+ __name(curry, "curry");
+ 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;
+ }
+ __name(curryRight, "curryRight");
+ function debounce(func, wait, options14) {
+ 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 (isObject2(options14)) {
+ leading = !!options14.leading;
+ maxing = "maxWait" in options14;
+ maxWait = maxing ? nativeMax(toNumber(options14.maxWait) || 0, wait) : maxWait;
+ trailing = "trailing" in options14 ? !!options14.trailing : trailing;
+ }
+ function invokeFunc(time) {
+ var args = lastArgs, thisArg = lastThis;
+ lastArgs = lastThis = undefined2;
+ lastInvokeTime = time;
+ result2 = func.apply(thisArg, args);
+ return result2;
+ }
+ __name(invokeFunc, "invokeFunc");
+ function leadingEdge(time) {
+ lastInvokeTime = time;
+ timerId = setTimeout4(timerExpired, wait);
+ return leading ? invokeFunc(time) : result2;
+ }
+ __name(leadingEdge, "leadingEdge");
+ function remainingWait(time) {
+ var timeSinceLastCall = time - lastCallTime, timeSinceLastInvoke = time - lastInvokeTime, timeWaiting = wait - timeSinceLastCall;
+ return maxing ? nativeMin(timeWaiting, maxWait - timeSinceLastInvoke) : timeWaiting;
+ }
+ __name(remainingWait, "remainingWait");
+ function shouldInvoke(time) {
+ var timeSinceLastCall = time - lastCallTime, timeSinceLastInvoke = time - lastInvokeTime;
+ return lastCallTime === undefined2 || timeSinceLastCall >= wait || timeSinceLastCall < 0 || maxing && timeSinceLastInvoke >= maxWait;
+ }
+ __name(shouldInvoke, "shouldInvoke");
+ function timerExpired() {
+ var time = now();
+ if (shouldInvoke(time)) {
+ return trailingEdge(time);
+ }
+ timerId = setTimeout4(timerExpired, remainingWait(time));
+ }
+ __name(timerExpired, "timerExpired");
+ function trailingEdge(time) {
+ timerId = undefined2;
+ if (trailing && lastArgs) {
+ return invokeFunc(time);
+ }
+ lastArgs = lastThis = undefined2;
+ return result2;
+ }
+ __name(trailingEdge, "trailingEdge");
+ function cancel2() {
+ if (timerId !== undefined2) {
+ clearTimeout2(timerId);
+ }
+ lastInvokeTime = 0;
+ lastArgs = lastCallTime = lastThis = timerId = undefined2;
+ }
+ __name(cancel2, "cancel");
+ function flush() {
+ return timerId === undefined2 ? result2 : trailingEdge(now());
+ }
+ __name(flush, "flush");
+ 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 = setTimeout4(timerExpired, wait);
+ return invokeFunc(lastCallTime);
+ }
+ }
+ if (timerId === undefined2) {
+ timerId = setTimeout4(timerExpired, wait);
+ }
+ return result2;
+ }
+ __name(debounced, "debounced");
+ debounced.cancel = cancel2;
+ debounced.flush = flush;
+ return debounced;
+ }
+ __name(debounce, "debounce");
+ 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);
+ }
+ __name(flip, "flip");
+ function memoize(func, resolver) {
+ if (typeof func != "function" || resolver != null && typeof resolver != "function") {
+ throw new TypeError2(FUNC_ERROR_TEXT);
+ }
+ var memoized = /* @__PURE__ */ __name(function() {
+ var args = arguments, key = resolver ? resolver.apply(this, args) : args[0], cache2 = memoized.cache;
+ if (cache2.has(key)) {
+ return cache2.get(key);
+ }
+ var result2 = func.apply(this, args);
+ memoized.cache = cache2.set(key, result2) || cache2;
+ return result2;
+ }, "memoized");
+ memoized.cache = new (memoize.Cache || MapCache)();
+ return memoized;
+ }
+ __name(memoize, "memoize");
+ 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);
+ };
+ }
+ __name(negate, "negate");
+ function once(func) {
+ return before(2, func);
+ }
+ __name(once, "once");
+ 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);
+ }
+ __name(rest, "rest");
+ 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);
+ });
+ }
+ __name(spread, "spread");
+ function throttle(func, wait, options14) {
+ var leading = true, trailing = true;
+ if (typeof func != "function") {
+ throw new TypeError2(FUNC_ERROR_TEXT);
+ }
+ if (isObject2(options14)) {
+ leading = "leading" in options14 ? !!options14.leading : leading;
+ trailing = "trailing" in options14 ? !!options14.trailing : trailing;
+ }
+ return debounce(func, wait, {
+ "leading": leading,
+ "maxWait": wait,
+ "trailing": trailing
+ });
+ }
+ __name(throttle, "throttle");
+ function unary(func) {
+ return ary(func, 1);
+ }
+ __name(unary, "unary");
+ function wrap2(value, wrapper) {
+ return partial(castFunction(wrapper), value);
+ }
+ __name(wrap2, "wrap");
+ function castArray() {
+ if (!arguments.length) {
+ return [];
+ }
+ var value = arguments[0];
+ return isArray(value) ? value : [value];
+ }
+ __name(castArray, "castArray");
+ function clone(value) {
+ return baseClone(value, CLONE_SYMBOLS_FLAG);
+ }
+ __name(clone, "clone");
+ function cloneWith(value, customizer) {
+ customizer = typeof customizer == "function" ? customizer : undefined2;
+ return baseClone(value, CLONE_SYMBOLS_FLAG, customizer);
+ }
+ __name(cloneWith, "cloneWith");
+ function cloneDeep(value) {
+ return baseClone(value, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG);
+ }
+ __name(cloneDeep, "cloneDeep");
+ function cloneDeepWith(value, customizer) {
+ customizer = typeof customizer == "function" ? customizer : undefined2;
+ return baseClone(value, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG, customizer);
+ }
+ __name(cloneDeepWith, "cloneDeepWith");
+ function conformsTo(object, source) {
+ return source == null || baseConformsTo(object, source, keys(source));
+ }
+ __name(conformsTo, "conformsTo");
+ function eq(value, other) {
+ return value === other || value !== value && other !== other;
+ }
+ __name(eq, "eq");
+ var gt = createRelationalOperation(baseGt);
+ var gte = createRelationalOperation(function(value, other) {
+ return value >= other;
+ });
+ var isArguments = baseIsArguments(function() {
+ return arguments;
+ }()) ? baseIsArguments : function(value) {
+ return isObjectLike(value) && hasOwnProperty2.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) && !isFunction2(value);
+ }
+ __name(isArrayLike, "isArrayLike");
+ function isArrayLikeObject(value) {
+ return isObjectLike(value) && isArrayLike(value);
+ }
+ __name(isArrayLikeObject, "isArrayLikeObject");
+ function isBoolean3(value) {
+ return value === true || value === false || isObjectLike(value) && baseGetTag(value) == boolTag;
+ }
+ __name(isBoolean3, "isBoolean");
+ var isBuffer = nativeIsBuffer || stubFalse;
+ var isDate = nodeIsDate ? baseUnary(nodeIsDate) : baseIsDate;
+ function isElement(value) {
+ return isObjectLike(value) && value.nodeType === 1 && !isPlainObject(value);
+ }
+ __name(isElement, "isElement");
+ 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 (hasOwnProperty2.call(value, key)) {
+ return false;
+ }
+ }
+ return true;
+ }
+ __name(isEmpty, "isEmpty");
+ function isEqual(value, other) {
+ return baseIsEqual(value, other);
+ }
+ __name(isEqual, "isEqual");
+ 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;
+ }
+ __name(isEqualWith, "isEqualWith");
+ 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);
+ }
+ __name(isError, "isError");
+ function isFinite2(value) {
+ return typeof value == "number" && nativeIsFinite(value);
+ }
+ __name(isFinite2, "isFinite");
+ function isFunction2(value) {
+ if (!isObject2(value)) {
+ return false;
+ }
+ var tag = baseGetTag(value);
+ return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
+ }
+ __name(isFunction2, "isFunction");
+ function isInteger2(value) {
+ return typeof value == "number" && value == toInteger(value);
+ }
+ __name(isInteger2, "isInteger");
+ function isLength(value) {
+ return typeof value == "number" && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
+ }
+ __name(isLength, "isLength");
+ function isObject2(value) {
+ var type = typeof value;
+ return value != null && (type == "object" || type == "function");
+ }
+ __name(isObject2, "isObject");
+ function isObjectLike(value) {
+ return value != null && typeof value == "object";
+ }
+ __name(isObjectLike, "isObjectLike");
+ var isMap = nodeIsMap ? baseUnary(nodeIsMap) : baseIsMap;
+ function isMatch(object, source) {
+ return object === source || baseIsMatch(object, source, getMatchData(source));
+ }
+ __name(isMatch, "isMatch");
+ function isMatchWith(object, source, customizer) {
+ customizer = typeof customizer == "function" ? customizer : undefined2;
+ return baseIsMatch(object, source, getMatchData(source), customizer);
+ }
+ __name(isMatchWith, "isMatchWith");
+ function isNaN2(value) {
+ return isNumber(value) && value != +value;
+ }
+ __name(isNaN2, "isNaN");
+ function isNative(value) {
+ if (isMaskable(value)) {
+ throw new Error2(CORE_ERROR_TEXT);
+ }
+ return baseIsNative(value);
+ }
+ __name(isNative, "isNative");
+ function isNull(value) {
+ return value === null;
+ }
+ __name(isNull, "isNull");
+ function isNil(value) {
+ return value == null;
+ }
+ __name(isNil, "isNil");
+ function isNumber(value) {
+ return typeof value == "number" || isObjectLike(value) && baseGetTag(value) == numberTag;
+ }
+ __name(isNumber, "isNumber");
+ function isPlainObject(value) {
+ if (!isObjectLike(value) || baseGetTag(value) != objectTag) {
+ return false;
+ }
+ var proto = getPrototype(value);
+ if (proto === null) {
+ return true;
+ }
+ var Ctor = hasOwnProperty2.call(proto, "constructor") && proto.constructor;
+ return typeof Ctor == "function" && Ctor instanceof Ctor && funcToString.call(Ctor) == objectCtorString;
+ }
+ __name(isPlainObject, "isPlainObject");
+ var isRegExp = nodeIsRegExp ? baseUnary(nodeIsRegExp) : baseIsRegExp;
+ function isSafeInteger(value) {
+ return isInteger2(value) && value >= -MAX_SAFE_INTEGER && value <= MAX_SAFE_INTEGER;
+ }
+ __name(isSafeInteger, "isSafeInteger");
+ var isSet = nodeIsSet ? baseUnary(nodeIsSet) : baseIsSet;
+ function isString2(value) {
+ return typeof value == "string" || !isArray(value) && isObjectLike(value) && baseGetTag(value) == stringTag;
+ }
+ __name(isString2, "isString");
+ function isSymbol(value) {
+ return typeof value == "symbol" || isObjectLike(value) && baseGetTag(value) == symbolTag;
+ }
+ __name(isSymbol, "isSymbol");
+ var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;
+ function isUndefined(value) {
+ return value === undefined2;
+ }
+ __name(isUndefined, "isUndefined");
+ function isWeakMap(value) {
+ return isObjectLike(value) && getTag(value) == weakMapTag;
+ }
+ __name(isWeakMap, "isWeakMap");
+ function isWeakSet(value) {
+ return isObjectLike(value) && baseGetTag(value) == weakSetTag;
+ }
+ __name(isWeakSet, "isWeakSet");
+ var lt2 = createRelationalOperation(baseLt);
+ var lte = createRelationalOperation(function(value, other) {
+ return value <= other;
+ });
+ function toArray(value) {
+ if (!value) {
+ return [];
+ }
+ if (isArrayLike(value)) {
+ return isString2(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);
+ }
+ __name(toArray, "toArray");
+ function toFinite(value) {
+ if (!value) {
+ return value === 0 ? value : 0;
+ }
+ value = toNumber(value);
+ if (value === INFINITY2 || value === -INFINITY2) {
+ var sign = value < 0 ? -1 : 1;
+ return sign * MAX_INTEGER;
+ }
+ return value === value ? value : 0;
+ }
+ __name(toFinite, "toFinite");
+ function toInteger(value) {
+ var result2 = toFinite(value), remainder = result2 % 1;
+ return result2 === result2 ? remainder ? result2 - remainder : result2 : 0;
+ }
+ __name(toInteger, "toInteger");
+ function toLength(value) {
+ return value ? baseClamp(toInteger(value), 0, MAX_ARRAY_LENGTH) : 0;
+ }
+ __name(toLength, "toLength");
+ function toNumber(value) {
+ if (typeof value == "number") {
+ return value;
+ }
+ if (isSymbol(value)) {
+ return NAN;
+ }
+ if (isObject2(value)) {
+ var other = typeof value.valueOf == "function" ? value.valueOf() : value;
+ value = isObject2(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;
+ }
+ __name(toNumber, "toNumber");
+ function toPlainObject(value) {
+ return copyObject(value, keysIn(value));
+ }
+ __name(toPlainObject, "toPlainObject");
+ function toSafeInteger(value) {
+ return value ? baseClamp(toInteger(value), -MAX_SAFE_INTEGER, MAX_SAFE_INTEGER) : value === 0 ? value : 0;
+ }
+ __name(toSafeInteger, "toSafeInteger");
+ function toString(value) {
+ return value == null ? "" : baseToString(value);
+ }
+ __name(toString, "toString");
+ var assign = createAssigner(function(object, source) {
+ if (isPrototype(source) || isArrayLike(source)) {
+ copyObject(source, keys(source), object);
+ return;
+ }
+ for (var key in source) {
+ if (hasOwnProperty2.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);
+ }
+ __name(create, "create");
+ 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]) && !hasOwnProperty2.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);
+ }
+ __name(findKey, "findKey");
+ function findLastKey(object, predicate) {
+ return baseFindKey(object, getIteratee(predicate, 3), baseForOwnRight);
+ }
+ __name(findLastKey, "findLastKey");
+ function forIn(object, iteratee2) {
+ return object == null ? object : baseFor(object, getIteratee(iteratee2, 3), keysIn);
+ }
+ __name(forIn, "forIn");
+ function forInRight(object, iteratee2) {
+ return object == null ? object : baseForRight(object, getIteratee(iteratee2, 3), keysIn);
+ }
+ __name(forInRight, "forInRight");
+ function forOwn(object, iteratee2) {
+ return object && baseForOwn(object, getIteratee(iteratee2, 3));
+ }
+ __name(forOwn, "forOwn");
+ function forOwnRight(object, iteratee2) {
+ return object && baseForOwnRight(object, getIteratee(iteratee2, 3));
+ }
+ __name(forOwnRight, "forOwnRight");
+ function functions(object) {
+ return object == null ? [] : baseFunctions(object, keys(object));
+ }
+ __name(functions, "functions");
+ function functionsIn(object) {
+ return object == null ? [] : baseFunctions(object, keysIn(object));
+ }
+ __name(functionsIn, "functionsIn");
+ function get(object, path45, defaultValue) {
+ var result2 = object == null ? undefined2 : baseGet(object, path45);
+ return result2 === undefined2 ? defaultValue : result2;
+ }
+ __name(get, "get");
+ function has(object, path45) {
+ return object != null && hasPath(object, path45, baseHas);
+ }
+ __name(has, "has");
+ function hasIn(object, path45) {
+ return object != null && hasPath(object, path45, baseHasIn);
+ }
+ __name(hasIn, "hasIn");
+ 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 (hasOwnProperty2.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);
+ }
+ __name(keys, "keys");
+ function keysIn(object) {
+ return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object);
+ }
+ __name(keysIn, "keysIn");
+ 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;
+ }
+ __name(mapKeys, "mapKeys");
+ 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;
+ }
+ __name(mapValues, "mapValues");
+ 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(path45) {
+ path45 = castPath(path45, object);
+ isDeep || (isDeep = path45.length > 1);
+ return path45;
+ });
+ 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)));
+ }
+ __name(omitBy, "omitBy");
+ 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, path45) {
+ return predicate(value, path45[0]);
+ });
+ }
+ __name(pickBy, "pickBy");
+ function result(object, path45, defaultValue) {
+ path45 = castPath(path45, object);
+ var index = -1, length = path45.length;
+ if (!length) {
+ length = 1;
+ object = undefined2;
+ }
+ while (++index < length) {
+ var value = object == null ? undefined2 : object[toKey(path45[index])];
+ if (value === undefined2) {
+ index = length;
+ value = defaultValue;
+ }
+ object = isFunction2(value) ? value.call(object) : value;
+ }
+ return object;
+ }
+ __name(result, "result");
+ function set(object, path45, value) {
+ return object == null ? object : baseSet(object, path45, value);
+ }
+ __name(set, "set");
+ function setWith(object, path45, value, customizer) {
+ customizer = typeof customizer == "function" ? customizer : undefined2;
+ return object == null ? object : baseSet(object, path45, value, customizer);
+ }
+ __name(setWith, "setWith");
+ 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 (isObject2(object)) {
+ accumulator = isFunction2(Ctor) ? baseCreate(getPrototype(object)) : {};
+ } else {
+ accumulator = {};
+ }
+ }
+ (isArrLike ? arrayEach : baseForOwn)(object, function(value, index, object2) {
+ return iteratee2(accumulator, value, index, object2);
+ });
+ return accumulator;
+ }
+ __name(transform, "transform");
+ function unset(object, path45) {
+ return object == null ? true : baseUnset(object, path45);
+ }
+ __name(unset, "unset");
+ function update(object, path45, updater) {
+ return object == null ? object : baseUpdate(object, path45, castFunction(updater));
+ }
+ __name(update, "update");
+ function updateWith(object, path45, updater, customizer) {
+ customizer = typeof customizer == "function" ? customizer : undefined2;
+ return object == null ? object : baseUpdate(object, path45, castFunction(updater), customizer);
+ }
+ __name(updateWith, "updateWith");
+ function values(object) {
+ return object == null ? [] : baseValues(object, keys(object));
+ }
+ __name(values, "values");
+ function valuesIn(object) {
+ return object == null ? [] : baseValues(object, keysIn(object));
+ }
+ __name(valuesIn, "valuesIn");
+ 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);
+ }
+ __name(clamp, "clamp");
+ 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);
+ }
+ __name(inRange, "inRange");
+ 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);
+ }
+ __name(random, "random");
+ var camelCase2 = createCompounder(function(result2, word, index) {
+ word = word.toLowerCase();
+ return result2 + (index ? capitalize(word) : word);
+ });
+ function capitalize(string) {
+ return upperFirst(toString(string).toLowerCase());
+ }
+ __name(capitalize, "capitalize");
+ function deburr(string) {
+ string = toString(string);
+ return string && string.replace(reLatin, deburrLetter).replace(reComboMark, "");
+ }
+ __name(deburr, "deburr");
+ 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;
+ }
+ __name(endsWith, "endsWith");
+ function escape2(string) {
+ string = toString(string);
+ return string && reHasUnescapedHtml.test(string) ? string.replace(reUnescapedHtml, escapeHtmlChar) : string;
+ }
+ __name(escape2, "escape");
+ function escapeRegExp(string) {
+ string = toString(string);
+ return string && reHasRegExpChar.test(string) ? string.replace(reRegExpChar, "\\$&") : string;
+ }
+ __name(escapeRegExp, "escapeRegExp");
+ 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 pad2(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);
+ }
+ __name(pad2, "pad");
+ 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;
+ }
+ __name(padEnd, "padEnd");
+ 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;
+ }
+ __name(padStart, "padStart");
+ function parseInt2(string, radix, guard) {
+ if (guard || radix == null) {
+ radix = 0;
+ } else if (radix) {
+ radix = +radix;
+ }
+ return nativeParseInt(toString(string).replace(reTrimStart, ""), radix || 0);
+ }
+ __name(parseInt2, "parseInt");
+ function repeat(string, n, guard) {
+ if (guard ? isIterateeCall(string, n, guard) : n === undefined2) {
+ n = 1;
+ } else {
+ n = toInteger(n);
+ }
+ return baseRepeat(toString(string), n);
+ }
+ __name(repeat, "repeat");
+ function replace() {
+ var args = arguments, string = toString(args[0]);
+ return args.length < 3 ? string : string.replace(args[1], args[2]);
+ }
+ __name(replace, "replace");
+ 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);
+ }
+ __name(split, "split");
+ 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;
+ }
+ __name(startsWith, "startsWith");
+ function template(string, options14, guard) {
+ var settings = lodash.templateSettings;
+ if (guard && isIterateeCall(string, options14, guard)) {
+ options14 = undefined2;
+ }
+ string = toString(string);
+ options14 = assignInWith({}, options14, settings, customDefaultsAssignIn);
+ var imports = assignInWith({}, options14.imports, settings.imports, customDefaultsAssignIn), importsKeys = keys(imports), importsValues = baseValues(imports, importsKeys);
+ var isEscaping, isEvaluating, index = 0, interpolate = options14.interpolate || reNoMatch, source = "__p += '";
+ var reDelimiters = RegExp2(
+ (options14.escape || reNoMatch).source + "|" + interpolate.source + "|" + (interpolate === reInterpolate ? reEsTemplate : reNoMatch).source + "|" + (options14.evaluate || reNoMatch).source + "|$",
+ "g"
+ );
+ var sourceURL = "//# sourceURL=" + (hasOwnProperty2.call(options14, "sourceURL") ? (options14.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 = hasOwnProperty2.call(options14, "variable") && options14.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;
+ }
+ __name(template, "template");
+ function toLower(value) {
+ return toString(value).toLowerCase();
+ }
+ __name(toLower, "toLower");
+ function toUpper(value) {
+ return toString(value).toUpperCase();
+ }
+ __name(toUpper, "toUpper");
+ 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("");
+ }
+ __name(trim, "trim");
+ 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("");
+ }
+ __name(trimEnd, "trimEnd");
+ 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("");
+ }
+ __name(trimStart, "trimStart");
+ function truncate2(string, options14) {
+ var length = DEFAULT_TRUNC_LENGTH, omission = DEFAULT_TRUNC_OMISSION;
+ if (isObject2(options14)) {
+ var separator = "separator" in options14 ? options14.separator : separator;
+ length = "length" in options14 ? toInteger(options14.length) : length;
+ omission = "omission" in options14 ? baseToString(options14.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;
+ }
+ __name(truncate2, "truncate");
+ function unescape2(string) {
+ string = toString(string);
+ return string && reHasEscapedHtml.test(string) ? string.replace(reEscapedHtml, unescapeHtmlChar) : string;
+ }
+ __name(unescape2, "unescape");
+ 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) || [];
+ }
+ __name(words, "words");
+ var attempt = baseRest(function(func, args) {
+ try {
+ return apply(func, undefined2, args);
+ } catch (e2) {
+ return isError(e2) ? e2 : new Error2(e2);
+ }
+ });
+ 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);
+ }
+ }
+ });
+ }
+ __name(cond, "cond");
+ function conforms(source) {
+ return baseConforms(baseClone(source, CLONE_DEEP_FLAG));
+ }
+ __name(conforms, "conforms");
+ function constant(value) {
+ return function() {
+ return value;
+ };
+ }
+ __name(constant, "constant");
+ function defaultTo(value, defaultValue) {
+ return value == null || value !== value ? defaultValue : value;
+ }
+ __name(defaultTo, "defaultTo");
+ var flow = createFlow();
+ var flowRight = createFlow(true);
+ function identity(value) {
+ return value;
+ }
+ __name(identity, "identity");
+ function iteratee(func) {
+ return baseIteratee(typeof func == "function" ? func : baseClone(func, CLONE_DEEP_FLAG));
+ }
+ __name(iteratee, "iteratee");
+ function matches(source) {
+ return baseMatches(baseClone(source, CLONE_DEEP_FLAG));
+ }
+ __name(matches, "matches");
+ function matchesProperty(path45, srcValue) {
+ return baseMatchesProperty(path45, baseClone(srcValue, CLONE_DEEP_FLAG));
+ }
+ __name(matchesProperty, "matchesProperty");
+ var method = baseRest(function(path45, args) {
+ return function(object) {
+ return baseInvoke(object, path45, args);
+ };
+ });
+ var methodOf = baseRest(function(object, args) {
+ return function(path45) {
+ return baseInvoke(object, path45, args);
+ };
+ });
+ function mixin3(object, source, options14) {
+ var props = keys(source), methodNames = baseFunctions(source, props);
+ if (options14 == null && !(isObject2(source) && (methodNames.length || !props.length))) {
+ options14 = source;
+ source = object;
+ object = this;
+ methodNames = baseFunctions(source, keys(source));
+ }
+ var chain2 = !(isObject2(options14) && "chain" in options14) || !!options14.chain, isFunc = isFunction2(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;
+ }
+ __name(mixin3, "mixin");
+ function noConflict() {
+ if (root._ === this) {
+ root._ = oldDash;
+ }
+ return this;
+ }
+ __name(noConflict, "noConflict");
+ function noop() {
+ }
+ __name(noop, "noop");
+ function nthArg(n) {
+ n = toInteger(n);
+ return baseRest(function(args) {
+ return baseNth(args, n);
+ });
+ }
+ __name(nthArg, "nthArg");
+ var over = createOver(arrayMap);
+ var overEvery = createOver(arrayEvery);
+ var overSome = createOver(arraySome);
+ function property(path45) {
+ return isKey(path45) ? baseProperty(toKey(path45)) : basePropertyDeep(path45);
+ }
+ __name(property, "property");
+ function propertyOf(object) {
+ return function(path45) {
+ return object == null ? undefined2 : baseGet(object, path45);
+ };
+ }
+ __name(propertyOf, "propertyOf");
+ var range = createRange();
+ var rangeRight = createRange(true);
+ function stubArray() {
+ return [];
+ }
+ __name(stubArray, "stubArray");
+ function stubFalse() {
+ return false;
+ }
+ __name(stubFalse, "stubFalse");
+ function stubObject() {
+ return {};
+ }
+ __name(stubObject, "stubObject");
+ function stubString() {
+ return "";
+ }
+ __name(stubString, "stubString");
+ function stubTrue() {
+ return true;
+ }
+ __name(stubTrue, "stubTrue");
+ 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;
+ }
+ __name(times, "times");
+ function toPath3(value) {
+ if (isArray(value)) {
+ return arrayMap(value, toKey);
+ }
+ return isSymbol(value) ? [value] : copyArray(stringToPath(toString(value)));
+ }
+ __name(toPath3, "toPath");
+ function uniqueId(prefix) {
+ var id = ++idCounter;
+ return toString(prefix) + id;
+ }
+ __name(uniqueId, "uniqueId");
+ 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;
+ }
+ __name(max, "max");
+ function maxBy(array, iteratee2) {
+ return array && array.length ? baseExtremum(array, getIteratee(iteratee2, 2), baseGt) : undefined2;
+ }
+ __name(maxBy, "maxBy");
+ function mean(array) {
+ return baseMean(array, identity);
+ }
+ __name(mean, "mean");
+ function meanBy(array, iteratee2) {
+ return baseMean(array, getIteratee(iteratee2, 2));
+ }
+ __name(meanBy, "meanBy");
+ function min(array) {
+ return array && array.length ? baseExtremum(array, identity, baseLt) : undefined2;
+ }
+ __name(min, "min");
+ function minBy(array, iteratee2) {
+ return array && array.length ? baseExtremum(array, getIteratee(iteratee2, 2), baseLt) : undefined2;
+ }
+ __name(minBy, "minBy");
+ 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;
+ }
+ __name(sum, "sum");
+ function sumBy(array, iteratee2) {
+ return array && array.length ? baseSum(array, getIteratee(iteratee2, 2)) : 0;
+ }
+ __name(sumBy, "sumBy");
+ 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 = mixin3;
+ 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 = toPath3;
+ 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 = wrap2;
+ 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;
+ mixin3(lodash, lodash);
+ lodash.add = add;
+ lodash.attempt = attempt;
+ lodash.camelCase = camelCase2;
+ 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 = isBoolean3;
+ 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 = isFunction2;
+ lodash.isInteger = isInteger2;
+ 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 = isObject2;
+ lodash.isObjectLike = isObjectLike;
+ lodash.isPlainObject = isPlainObject;
+ lodash.isRegExp = isRegExp;
+ lodash.isSafeInteger = isSafeInteger;
+ lodash.isSet = isSet;
+ lodash.isString = isString2;
+ lodash.isSymbol = isSymbol;
+ lodash.isTypedArray = isTypedArray;
+ lodash.isUndefined = isUndefined;
+ lodash.isWeakMap = isWeakMap;
+ lodash.isWeakSet = isWeakSet;
+ lodash.join = join12;
+ lodash.kebabCase = kebabCase;
+ lodash.last = last;
+ lodash.lastIndexOf = lastIndexOf;
+ lodash.lowerCase = lowerCase;
+ lodash.lowerFirst = lowerFirst;
+ lodash.lt = lt2;
+ 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 = pad2;
+ 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 = truncate2;
+ lodash.unescape = unescape2;
+ lodash.uniqueId = uniqueId;
+ lodash.upperCase = upperCase;
+ lodash.upperFirst = upperFirst;
+ lodash.each = forEach;
+ lodash.eachRight = forEachRight;
+ lodash.first = head;
+ mixin3(lodash, function() {
+ var source = {};
+ baseForOwn(lodash, function(func, methodName) {
+ if (!hasOwnProperty2.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 takeName2 = "take" + (index ? "Right" : "");
+ LazyWrapper.prototype[methodName] = function() {
+ return this[takeName2](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(path45, args) {
+ if (typeof path45 == "function") {
+ return new LazyWrapper(this);
+ }
+ return this.map(function(value) {
+ return baseInvoke(value, path45, 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 = /* @__PURE__ */ __name(function(value2) {
+ var result3 = lodashFunc.apply(lodash, arrayPush([value2], args));
+ return isTaker && chainAll ? result3[0] : result3;
+ }, "interceptor");
+ 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 (!hasOwnProperty2.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;
+ }, "runInContext");
+ 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);
+ }
+});
+
+// ../../node_modules/.pnpm/ansi-escapes@4.3.2/node_modules/ansi-escapes/index.js
+var require_ansi_escapes = __commonJS({
+ "../../node_modules/.pnpm/ansi-escapes@4.3.2/node_modules/ansi-escapes/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var ansiEscapes = module2.exports;
+ module2.exports.default = ansiEscapes;
+ var ESC = "\x1B[";
+ var OSC = "\x1B]";
+ var BEL = "\x07";
+ var SEP = ";";
+ var isTerminalApp = process.env.TERM_PROGRAM === "Apple_Terminal";
+ ansiEscapes.cursorTo = (x, y) => {
+ if (typeof x !== "number") {
+ throw new TypeError("The `x` argument is required");
+ }
+ if (typeof y !== "number") {
+ return ESC + (x + 1) + "G";
+ }
+ return ESC + (y + 1) + ";" + (x + 1) + "H";
+ };
+ ansiEscapes.cursorMove = (x, y) => {
+ if (typeof x !== "number") {
+ throw new TypeError("The `x` argument is required");
+ }
+ let ret = "";
+ if (x < 0) {
+ ret += ESC + -x + "D";
+ } else if (x > 0) {
+ ret += ESC + x + "C";
+ }
+ if (y < 0) {
+ ret += ESC + -y + "A";
+ } else if (y > 0) {
+ ret += ESC + y + "B";
+ }
+ return ret;
+ };
+ ansiEscapes.cursorUp = (count = 1) => ESC + count + "A";
+ ansiEscapes.cursorDown = (count = 1) => ESC + count + "B";
+ ansiEscapes.cursorForward = (count = 1) => ESC + count + "C";
+ ansiEscapes.cursorBackward = (count = 1) => ESC + count + "D";
+ ansiEscapes.cursorLeft = ESC + "G";
+ ansiEscapes.cursorSavePosition = isTerminalApp ? "\x1B7" : ESC + "s";
+ ansiEscapes.cursorRestorePosition = isTerminalApp ? "\x1B8" : ESC + "u";
+ ansiEscapes.cursorGetPosition = ESC + "6n";
+ ansiEscapes.cursorNextLine = ESC + "E";
+ ansiEscapes.cursorPrevLine = ESC + "F";
+ ansiEscapes.cursorHide = ESC + "?25l";
+ ansiEscapes.cursorShow = ESC + "?25h";
+ ansiEscapes.eraseLines = (count) => {
+ let clear = "";
+ for (let i = 0; i < count; i++) {
+ clear += ansiEscapes.eraseLine + (i < count - 1 ? ansiEscapes.cursorUp() : "");
+ }
+ if (count) {
+ clear += ansiEscapes.cursorLeft;
+ }
+ return clear;
+ };
+ ansiEscapes.eraseEndLine = ESC + "K";
+ ansiEscapes.eraseStartLine = ESC + "1K";
+ ansiEscapes.eraseLine = ESC + "2K";
+ ansiEscapes.eraseDown = ESC + "J";
+ ansiEscapes.eraseUp = ESC + "1J";
+ ansiEscapes.eraseScreen = ESC + "2J";
+ ansiEscapes.scrollUp = ESC + "S";
+ ansiEscapes.scrollDown = ESC + "T";
+ ansiEscapes.clearScreen = "\x1Bc";
+ ansiEscapes.clearTerminal = process.platform === "win32" ? `${ansiEscapes.eraseScreen}${ESC}0f` : (
+ // 1. Erases the screen (Only done in case `2` is not supported)
+ // 2. Erases the whole screen including scrollback buffer
+ // 3. Moves cursor to the top-left position
+ // More info: https://www.real-world-systems.com/docs/ANSIcode.html
+ `${ansiEscapes.eraseScreen}${ESC}3J${ESC}H`
+ );
+ ansiEscapes.beep = BEL;
+ ansiEscapes.link = (text, url3) => {
+ return [
+ OSC,
+ "8",
+ SEP,
+ SEP,
+ url3,
+ BEL,
+ text,
+ OSC,
+ "8",
+ SEP,
+ SEP,
+ BEL
+ ].join("");
+ };
+ ansiEscapes.image = (buffer, options14 = {}) => {
+ let ret = `${OSC}1337;File=inline=1`;
+ if (options14.width) {
+ ret += `;width=${options14.width}`;
+ }
+ if (options14.height) {
+ ret += `;height=${options14.height}`;
+ }
+ if (options14.preserveAspectRatio === false) {
+ ret += ";preserveAspectRatio=0";
+ }
+ return ret + ":" + buffer.toString("base64") + BEL;
+ };
+ ansiEscapes.iTerm = {
+ setCwd: (cwd2 = process.cwd()) => `${OSC}50;CurrentDir=${cwd2}${BEL}`,
+ annotation: (message, options14 = {}) => {
+ let ret = `${OSC}1337;`;
+ const hasX = typeof options14.x !== "undefined";
+ const hasY = typeof options14.y !== "undefined";
+ if ((hasX || hasY) && !(hasX && hasY && typeof options14.length !== "undefined")) {
+ throw new Error("`x`, `y` and `length` must be defined when `x` or `y` is defined");
+ }
+ message = message.replace(/\|/g, "");
+ ret += options14.isHidden ? "AddHiddenAnnotation=" : "AddAnnotation=";
+ if (options14.length > 0) {
+ ret += (hasX ? [message, options14.length, options14.x, options14.y] : [options14.length, message]).join("|");
+ } else {
+ ret += message;
+ }
+ return ret + BEL;
+ }
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/mimic-fn@2.1.0/node_modules/mimic-fn/index.js
+var require_mimic_fn = __commonJS({
+ "../../node_modules/.pnpm/mimic-fn@2.1.0/node_modules/mimic-fn/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var mimicFn = /* @__PURE__ */ __name((to, from) => {
+ for (const prop of Reflect.ownKeys(from)) {
+ Object.defineProperty(to, prop, Object.getOwnPropertyDescriptor(from, prop));
+ }
+ return to;
+ }, "mimicFn");
+ module2.exports = mimicFn;
+ module2.exports.default = mimicFn;
+ }
+});
+
+// ../../node_modules/.pnpm/onetime@5.1.2/node_modules/onetime/index.js
+var require_onetime = __commonJS({
+ "../../node_modules/.pnpm/onetime@5.1.2/node_modules/onetime/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var mimicFn = require_mimic_fn();
+ var calledFunctions2 = /* @__PURE__ */ new WeakMap();
+ var onetime2 = /* @__PURE__ */ __name((function_, options14 = {}) => {
+ if (typeof function_ !== "function") {
+ throw new TypeError("Expected a function");
+ }
+ let returnValue;
+ let callCount = 0;
+ const functionName = function_.displayName || function_.name || "";
+ const onetime3 = /* @__PURE__ */ __name(function(...arguments_) {
+ calledFunctions2.set(onetime3, ++callCount);
+ if (callCount === 1) {
+ returnValue = function_.apply(this, arguments_);
+ function_ = null;
+ } else if (options14.throw === true) {
+ throw new Error(`Function \`${functionName}\` can only be called once`);
+ }
+ return returnValue;
+ }, "onetime");
+ mimicFn(onetime3, function_);
+ calledFunctions2.set(onetime3, callCount);
+ return onetime3;
+ }, "onetime");
+ module2.exports = onetime2;
+ module2.exports.default = onetime2;
+ module2.exports.callCount = (function_) => {
+ if (!calledFunctions2.has(function_)) {
+ throw new Error(`The given function \`${function_.name}\` is not wrapped by the \`onetime\` package`);
+ }
+ return calledFunctions2.get(function_);
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/signal-exit@3.0.7/node_modules/signal-exit/signals.js
+var require_signals = __commonJS({
+ "../../node_modules/.pnpm/signal-exit@3.0.7/node_modules/signal-exit/signals.js"(exports2, module2) {
+ init_import_meta_url();
+ module2.exports = [
+ "SIGABRT",
+ "SIGALRM",
+ "SIGHUP",
+ "SIGINT",
+ "SIGTERM"
+ ];
+ if (process.platform !== "win32") {
+ module2.exports.push(
+ "SIGVTALRM",
+ "SIGXCPU",
+ "SIGXFSZ",
+ "SIGUSR2",
+ "SIGTRAP",
+ "SIGSYS",
+ "SIGQUIT",
+ "SIGIOT"
+ // should detect profiler and enable/disable accordingly.
+ // see #21
+ // 'SIGPROF'
+ );
+ }
+ if (process.platform === "linux") {
+ module2.exports.push(
+ "SIGIO",
+ "SIGPOLL",
+ "SIGPWR",
+ "SIGSTKFLT",
+ "SIGUNUSED"
+ );
+ }
+ }
+});
+
+// ../../node_modules/.pnpm/signal-exit@3.0.7/node_modules/signal-exit/index.js
+var require_signal_exit = __commonJS({
+ "../../node_modules/.pnpm/signal-exit@3.0.7/node_modules/signal-exit/index.js"(exports2, module2) {
+ init_import_meta_url();
+ var process8 = global.process;
+ var processOk = /* @__PURE__ */ __name(function(process9) {
+ return process9 && typeof process9 === "object" && typeof process9.removeListener === "function" && typeof process9.emit === "function" && typeof process9.reallyExit === "function" && typeof process9.listeners === "function" && typeof process9.kill === "function" && typeof process9.pid === "number" && typeof process9.on === "function";
+ }, "processOk");
+ if (!processOk(process8)) {
+ module2.exports = function() {
+ return function() {
+ };
+ };
+ } else {
+ assert18 = require("assert");
+ signals = require_signals();
+ isWin = /^win/i.test(process8.platform);
+ EE = require("events");
+ if (typeof EE !== "function") {
+ EE = EE.EventEmitter;
+ }
+ if (process8.__signal_exit_emitter__) {
+ emitter = process8.__signal_exit_emitter__;
+ } else {
+ emitter = process8.__signal_exit_emitter__ = new EE();
+ emitter.count = 0;
+ emitter.emitted = {};
+ }
+ if (!emitter.infinite) {
+ emitter.setMaxListeners(Infinity);
+ emitter.infinite = true;
+ }
+ module2.exports = function(cb, opts) {
+ if (!processOk(global.process)) {
+ return function() {
+ };
+ }
+ assert18.equal(typeof cb, "function", "a callback must be provided for exit handler");
+ if (loaded === false) {
+ load();
+ }
+ var ev = "exit";
+ if (opts && opts.alwaysLast) {
+ ev = "afterexit";
+ }
+ var remove = /* @__PURE__ */ __name(function() {
+ emitter.removeListener(ev, cb);
+ if (emitter.listeners("exit").length === 0 && emitter.listeners("afterexit").length === 0) {
+ unload();
+ }
+ }, "remove");
+ emitter.on(ev, cb);
+ return remove;
+ };
+ unload = /* @__PURE__ */ __name(function unload2() {
+ if (!loaded || !processOk(global.process)) {
+ return;
+ }
+ loaded = false;
+ signals.forEach(function(sig) {
+ try {
+ process8.removeListener(sig, sigListeners[sig]);
+ } catch (er) {
+ }
+ });
+ process8.emit = originalProcessEmit;
+ process8.reallyExit = originalProcessReallyExit;
+ emitter.count -= 1;
+ }, "unload");
+ module2.exports.unload = unload;
+ emit = /* @__PURE__ */ __name(function emit2(event, code, signal) {
+ if (emitter.emitted[event]) {
+ return;
+ }
+ emitter.emitted[event] = true;
+ emitter.emit(event, code, signal);
+ }, "emit");
+ sigListeners = {};
+ signals.forEach(function(sig) {
+ sigListeners[sig] = /* @__PURE__ */ __name(function listener() {
+ if (!processOk(global.process)) {
+ return;
+ }
+ var listeners = process8.listeners(sig);
+ if (listeners.length === emitter.count) {
+ unload();
+ emit("exit", null, sig);
+ emit("afterexit", null, sig);
+ if (isWin && sig === "SIGHUP") {
+ sig = "SIGINT";
+ }
+ process8.kill(process8.pid, sig);
+ }
+ }, "listener");
+ });
+ module2.exports.signals = function() {
+ return signals;
+ };
+ loaded = false;
+ load = /* @__PURE__ */ __name(function load2() {
+ if (loaded || !processOk(global.process)) {
+ return;
+ }
+ loaded = true;
+ emitter.count += 1;
+ signals = signals.filter(function(sig) {
+ try {
+ process8.on(sig, sigListeners[sig]);
+ return true;
+ } catch (er) {
+ return false;
+ }
+ });
+ process8.emit = processEmit;
+ process8.reallyExit = processReallyExit;
+ }, "load");
+ module2.exports.load = load;
+ originalProcessReallyExit = process8.reallyExit;
+ processReallyExit = /* @__PURE__ */ __name(function processReallyExit2(code) {
+ if (!processOk(global.process)) {
+ return;
+ }
+ process8.exitCode = code || /* istanbul ignore next */
+ 0;
+ emit("exit", process8.exitCode, null);
+ emit("afterexit", process8.exitCode, null);
+ originalProcessReallyExit.call(process8, process8.exitCode);
+ }, "processReallyExit");
+ originalProcessEmit = process8.emit;
+ processEmit = /* @__PURE__ */ __name(function processEmit2(ev, arg) {
+ if (ev === "exit" && processOk(global.process)) {
+ if (arg !== void 0) {
+ process8.exitCode = arg;
+ }
+ var ret = originalProcessEmit.apply(this, arguments);
+ emit("exit", process8.exitCode, null);
+ emit("afterexit", process8.exitCode, null);
+ return ret;
+ } else {
+ return originalProcessEmit.apply(this, arguments);
+ }
+ }, "processEmit");
+ }
+ var assert18;
+ var signals;
+ var isWin;
+ var EE;
+ var emitter;
+ var unload;
+ var emit;
+ var sigListeners;
+ var loaded;
+ var load;
+ var originalProcessReallyExit;
+ var processReallyExit;
+ var originalProcessEmit;
+ var processEmit;
+ }
+});
+
+// ../../node_modules/.pnpm/restore-cursor@3.1.0/node_modules/restore-cursor/index.js
+var require_restore_cursor = __commonJS({
+ "../../node_modules/.pnpm/restore-cursor@3.1.0/node_modules/restore-cursor/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var onetime2 = require_onetime();
+ var signalExit = require_signal_exit();
+ module2.exports = onetime2(() => {
+ signalExit(() => {
+ process.stderr.write("\x1B[?25h");
+ }, { alwaysLast: true });
+ });
+ }
+});
+
+// ../../node_modules/.pnpm/cli-cursor@3.1.0/node_modules/cli-cursor/index.js
+var require_cli_cursor = __commonJS({
+ "../../node_modules/.pnpm/cli-cursor@3.1.0/node_modules/cli-cursor/index.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ var restoreCursor = require_restore_cursor();
+ var isHidden = false;
+ exports2.show = (writableStream = process.stderr) => {
+ if (!writableStream.isTTY) {
+ return;
+ }
+ isHidden = false;
+ writableStream.write("\x1B[?25h");
+ };
+ exports2.hide = (writableStream = process.stderr) => {
+ if (!writableStream.isTTY) {
+ return;
+ }
+ restoreCursor();
+ isHidden = true;
+ writableStream.write("\x1B[?25l");
+ };
+ exports2.toggle = (force, writableStream) => {
+ if (force !== void 0) {
+ isHidden = force;
+ }
+ if (isHidden) {
+ exports2.show(writableStream);
+ } else {
+ exports2.hide(writableStream);
+ }
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/log-update.js
+var require_log_update = __commonJS({
+ "../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/log-update.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ var __importDefault = exports2 && exports2.__importDefault || function(mod) {
+ return mod && mod.__esModule ? mod : { "default": mod };
+ };
+ Object.defineProperty(exports2, "__esModule", { value: true });
+ var ansi_escapes_1 = __importDefault(require_ansi_escapes());
+ var cli_cursor_1 = __importDefault(require_cli_cursor());
+ var create = /* @__PURE__ */ __name((stream2, { showCursor = false } = {}) => {
+ let previousLineCount = 0;
+ let previousOutput = "";
+ let hasHiddenCursor = false;
+ const render7 = /* @__PURE__ */ __name((str) => {
+ if (!showCursor && !hasHiddenCursor) {
+ cli_cursor_1.default.hide();
+ hasHiddenCursor = true;
+ }
+ const output = str + "\n";
+ if (output === previousOutput) {
+ return;
+ }
+ previousOutput = output;
+ stream2.write(ansi_escapes_1.default.eraseLines(previousLineCount) + output);
+ previousLineCount = output.split("\n").length;
+ }, "render");
+ render7.clear = () => {
+ stream2.write(ansi_escapes_1.default.eraseLines(previousLineCount));
+ previousOutput = "";
+ previousLineCount = 0;
+ };
+ render7.done = () => {
+ previousOutput = "";
+ previousLineCount = 0;
+ if (!showCursor) {
+ cli_cursor_1.default.show();
+ hasHiddenCursor = false;
+ }
+ };
+ return render7;
+ }, "create");
+ exports2.default = { create };
+ }
+});
+
+// ../../node_modules/.pnpm/ci-info@2.0.0/node_modules/ci-info/vendors.json
+var require_vendors = __commonJS({
+ "../../node_modules/.pnpm/ci-info@2.0.0/node_modules/ci-info/vendors.json"(exports2, module2) {
+ module2.exports = [
+ {
+ name: "AppVeyor",
+ constant: "APPVEYOR",
+ env: "APPVEYOR",
+ pr: "APPVEYOR_PULL_REQUEST_NUMBER"
+ },
+ {
+ name: "Azure Pipelines",
+ constant: "AZURE_PIPELINES",
+ env: "SYSTEM_TEAMFOUNDATIONCOLLECTIONURI",
+ pr: "SYSTEM_PULLREQUEST_PULLREQUESTID"
+ },
+ {
+ name: "Bamboo",
+ constant: "BAMBOO",
+ env: "bamboo_planKey"
+ },
+ {
+ name: "Bitbucket Pipelines",
+ constant: "BITBUCKET",
+ env: "BITBUCKET_COMMIT",
+ pr: "BITBUCKET_PR_ID"
+ },
+ {
+ name: "Bitrise",
+ constant: "BITRISE",
+ env: "BITRISE_IO",
+ pr: "BITRISE_PULL_REQUEST"
+ },
+ {
+ name: "Buddy",
+ constant: "BUDDY",
+ env: "BUDDY_WORKSPACE_ID",
+ pr: "BUDDY_EXECUTION_PULL_REQUEST_ID"
+ },
+ {
+ name: "Buildkite",
+ constant: "BUILDKITE",
+ env: "BUILDKITE",
+ pr: { env: "BUILDKITE_PULL_REQUEST", ne: "false" }
+ },
+ {
+ name: "CircleCI",
+ constant: "CIRCLE",
+ env: "CIRCLECI",
+ pr: "CIRCLE_PULL_REQUEST"
+ },
+ {
+ name: "Cirrus CI",
+ constant: "CIRRUS",
+ env: "CIRRUS_CI",
+ pr: "CIRRUS_PR"
+ },
+ {
+ name: "AWS CodeBuild",
+ constant: "CODEBUILD",
+ env: "CODEBUILD_BUILD_ARN"
+ },
+ {
+ name: "Codeship",
+ constant: "CODESHIP",
+ env: { CI_NAME: "codeship" }
+ },
+ {
+ name: "Drone",
+ constant: "DRONE",
+ env: "DRONE",
+ pr: { DRONE_BUILD_EVENT: "pull_request" }
+ },
+ {
+ name: "dsari",
+ constant: "DSARI",
+ env: "DSARI"
+ },
+ {
+ name: "GitLab CI",
+ constant: "GITLAB",
+ env: "GITLAB_CI"
+ },
+ {
+ name: "GoCD",
+ constant: "GOCD",
+ env: "GO_PIPELINE_LABEL"
+ },
+ {
+ name: "Hudson",
+ constant: "HUDSON",
+ env: "HUDSON_URL"
+ },
+ {
+ name: "Jenkins",
+ constant: "JENKINS",
+ env: ["JENKINS_URL", "BUILD_ID"],
+ pr: { any: ["ghprbPullId", "CHANGE_ID"] }
+ },
+ {
+ name: "Magnum CI",
+ constant: "MAGNUM",
+ env: "MAGNUM"
+ },
+ {
+ name: "Netlify CI",
+ constant: "NETLIFY",
+ env: "NETLIFY_BUILD_BASE",
+ pr: { env: "PULL_REQUEST", ne: "false" }
+ },
+ {
+ name: "Sail CI",
+ constant: "SAIL",
+ env: "SAILCI",
+ pr: "SAIL_PULL_REQUEST_NUMBER"
+ },
+ {
+ name: "Semaphore",
+ constant: "SEMAPHORE",
+ env: "SEMAPHORE",
+ pr: "PULL_REQUEST_NUMBER"
+ },
+ {
+ name: "Shippable",
+ constant: "SHIPPABLE",
+ env: "SHIPPABLE",
+ pr: { IS_PULL_REQUEST: "true" }
+ },
+ {
+ name: "Solano CI",
+ constant: "SOLANO",
+ env: "TDDIUM",
+ pr: "TDDIUM_PR_ID"
+ },
+ {
+ name: "Strider CD",
+ constant: "STRIDER",
+ env: "STRIDER"
+ },
+ {
+ name: "TaskCluster",
+ constant: "TASKCLUSTER",
+ env: ["TASK_ID", "RUN_ID"]
+ },
+ {
+ name: "TeamCity",
+ constant: "TEAMCITY",
+ env: "TEAMCITY_VERSION"
+ },
+ {
+ name: "Travis CI",
+ constant: "TRAVIS",
+ env: "TRAVIS",
+ pr: { env: "TRAVIS_PULL_REQUEST", ne: "false" }
+ }
+ ];
+ }
+});
+
+// ../../node_modules/.pnpm/ci-info@2.0.0/node_modules/ci-info/index.js
+var require_ci_info = __commonJS({
+ "../../node_modules/.pnpm/ci-info@2.0.0/node_modules/ci-info/index.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ var vendors = require_vendors();
+ var env5 = process.env;
+ Object.defineProperty(exports2, "_vendors", {
+ value: vendors.map(function(v) {
+ return v.constant;
+ })
+ });
+ exports2.name = null;
+ exports2.isPR = null;
+ vendors.forEach(function(vendor) {
+ var envs = Array.isArray(vendor.env) ? vendor.env : [vendor.env];
+ var isCI2 = envs.every(function(obj) {
+ return checkEnv(obj);
+ });
+ exports2[vendor.constant] = isCI2;
+ if (isCI2) {
+ exports2.name = vendor.name;
+ switch (typeof vendor.pr) {
+ case "string":
+ exports2.isPR = !!env5[vendor.pr];
+ break;
+ case "object":
+ if ("env" in vendor.pr) {
+ exports2.isPR = vendor.pr.env in env5 && env5[vendor.pr.env] !== vendor.pr.ne;
+ } else if ("any" in vendor.pr) {
+ exports2.isPR = vendor.pr.any.some(function(key) {
+ return !!env5[key];
+ });
+ } else {
+ exports2.isPR = checkEnv(vendor.pr);
+ }
+ break;
+ default:
+ exports2.isPR = null;
+ }
+ }
+ });
+ exports2.isCI = !!(env5.CI || // Travis CI, CircleCI, Cirrus CI, Gitlab CI, Appveyor, CodeShip, dsari
+ env5.CONTINUOUS_INTEGRATION || // Travis CI, Cirrus CI
+ env5.BUILD_NUMBER || // Jenkins, TeamCity
+ env5.RUN_ID || // TaskCluster, dsari
+ exports2.name || false);
+ function checkEnv(obj) {
+ if (typeof obj === "string")
+ return !!env5[obj];
+ return Object.keys(obj).every(function(k) {
+ return env5[k] === obj[k];
+ });
+ }
+ __name(checkEnv, "checkEnv");
+ }
+});
+
+// ../../node_modules/.pnpm/is-ci@2.0.0/node_modules/is-ci/index.js
+var require_is_ci = __commonJS({
+ "../../node_modules/.pnpm/is-ci@2.0.0/node_modules/is-ci/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ module2.exports = require_ci_info().isCI;
+ }
+});
+
+// ../../node_modules/.pnpm/auto-bind@4.0.0/node_modules/auto-bind/index.js
+var require_auto_bind = __commonJS({
+ "../../node_modules/.pnpm/auto-bind@4.0.0/node_modules/auto-bind/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var getAllProperties = /* @__PURE__ */ __name((object) => {
+ const properties = /* @__PURE__ */ new Set();
+ do {
+ for (const key of Reflect.ownKeys(object)) {
+ properties.add([object, key]);
+ }
+ } while ((object = Reflect.getPrototypeOf(object)) && object !== Object.prototype);
+ return properties;
+ }, "getAllProperties");
+ module2.exports = (self2, { include, exclude } = {}) => {
+ const filter = /* @__PURE__ */ __name((key) => {
+ const match = /* @__PURE__ */ __name((pattern) => typeof pattern === "string" ? key === pattern : pattern.test(key), "match");
+ if (include) {
+ return include.some(match);
+ }
+ if (exclude) {
+ return !exclude.some(match);
+ }
+ return true;
+ }, "filter");
+ for (const [object, key] of getAllProperties(self2.constructor.prototype)) {
+ if (key === "constructor" || !filter(key)) {
+ continue;
+ }
+ const descriptor2 = Reflect.getOwnPropertyDescriptor(object, key);
+ if (descriptor2 && typeof descriptor2.value === "function") {
+ self2[key] = self2[key].bind(self2);
+ }
+ }
+ return self2;
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/scheduler@0.20.2/node_modules/scheduler/cjs/scheduler.production.min.js
+var require_scheduler_production_min = __commonJS({
+ "../../node_modules/.pnpm/scheduler@0.20.2/node_modules/scheduler/cjs/scheduler.production.min.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ var f;
+ var g;
+ var h;
+ var k;
+ if ("object" === typeof performance && "function" === typeof performance.now) {
+ l = performance;
+ exports2.unstable_now = function() {
+ return l.now();
+ };
+ } else {
+ p = Date, q = p.now();
+ exports2.unstable_now = function() {
+ return p.now() - q;
+ };
+ }
+ var l;
+ var p;
+ var q;
+ if ("undefined" === typeof window || "function" !== typeof MessageChannel) {
+ t2 = null, u = null, w = /* @__PURE__ */ __name(function() {
+ if (null !== t2)
+ try {
+ var a = exports2.unstable_now();
+ t2(true, a);
+ t2 = null;
+ } catch (b) {
+ throw setTimeout(w, 0), b;
+ }
+ }, "w");
+ f = /* @__PURE__ */ __name(function(a) {
+ null !== t2 ? setTimeout(f, 0, a) : (t2 = a, setTimeout(w, 0));
+ }, "f");
+ g = /* @__PURE__ */ __name(function(a, b) {
+ u = setTimeout(a, b);
+ }, "g");
+ h = /* @__PURE__ */ __name(function() {
+ clearTimeout(u);
+ }, "h");
+ exports2.unstable_shouldYield = function() {
+ return false;
+ };
+ k = exports2.unstable_forceFrameRate = function() {
+ };
+ } else {
+ x = window.setTimeout, y = window.clearTimeout;
+ if ("undefined" !== typeof console) {
+ z = window.cancelAnimationFrame;
+ "function" !== typeof window.requestAnimationFrame && console.error("This browser doesn't support requestAnimationFrame. Make sure that you load a polyfill in older browsers. https://reactjs.org/link/react-polyfills");
+ "function" !== typeof z && console.error("This browser doesn't support cancelAnimationFrame. Make sure that you load a polyfill in older browsers. https://reactjs.org/link/react-polyfills");
+ }
+ A = false, B = null, C = -1, D = 5, E = 0;
+ exports2.unstable_shouldYield = function() {
+ return exports2.unstable_now() >= E;
+ };
+ k = /* @__PURE__ */ __name(function() {
+ }, "k");
+ exports2.unstable_forceFrameRate = function(a) {
+ 0 > a || 125 < a ? console.error("forceFrameRate takes a positive int between 0 and 125, forcing frame rates higher than 125 fps is not supported") : D = 0 < a ? Math.floor(1e3 / a) : 5;
+ };
+ F = new MessageChannel(), G = F.port2;
+ F.port1.onmessage = function() {
+ if (null !== B) {
+ var a = exports2.unstable_now();
+ E = a + D;
+ try {
+ B(true, a) ? G.postMessage(null) : (A = false, B = null);
+ } catch (b) {
+ throw G.postMessage(null), b;
+ }
+ } else
+ A = false;
+ };
+ f = /* @__PURE__ */ __name(function(a) {
+ B = a;
+ A || (A = true, G.postMessage(null));
+ }, "f");
+ g = /* @__PURE__ */ __name(function(a, b) {
+ C = x(function() {
+ a(exports2.unstable_now());
+ }, b);
+ }, "g");
+ h = /* @__PURE__ */ __name(function() {
+ y(C);
+ C = -1;
+ }, "h");
+ }
+ var t2;
+ var u;
+ var w;
+ var x;
+ var y;
+ var z;
+ var A;
+ var B;
+ var C;
+ var D;
+ var E;
+ var F;
+ var G;
+ function H(a, b) {
+ var c = a.length;
+ a.push(b);
+ a:
+ for (; ; ) {
+ var d = c - 1 >>> 1, e2 = a[d];
+ if (void 0 !== e2 && 0 < I(e2, b))
+ a[d] = b, a[c] = e2, c = d;
+ else
+ break a;
+ }
+ }
+ __name(H, "H");
+ function J(a) {
+ a = a[0];
+ return void 0 === a ? null : a;
+ }
+ __name(J, "J");
+ function K(a) {
+ var b = a[0];
+ if (void 0 !== b) {
+ var c = a.pop();
+ if (c !== b) {
+ a[0] = c;
+ a:
+ for (var d = 0, e2 = a.length; d < e2; ) {
+ var m = 2 * (d + 1) - 1, n = a[m], v = m + 1, r = a[v];
+ if (void 0 !== n && 0 > I(n, c))
+ void 0 !== r && 0 > I(r, n) ? (a[d] = r, a[v] = c, d = v) : (a[d] = n, a[m] = c, d = m);
+ else if (void 0 !== r && 0 > I(r, c))
+ a[d] = r, a[v] = c, d = v;
+ else
+ break a;
+ }
+ }
+ return b;
+ }
+ return null;
+ }
+ __name(K, "K");
+ function I(a, b) {
+ var c = a.sortIndex - b.sortIndex;
+ return 0 !== c ? c : a.id - b.id;
+ }
+ __name(I, "I");
+ var L = [];
+ var M = [];
+ var N = 1;
+ var O = null;
+ var P = 3;
+ var Q = false;
+ var R = false;
+ var S = false;
+ function T(a) {
+ for (var b = J(M); null !== b; ) {
+ if (null === b.callback)
+ K(M);
+ else if (b.startTime <= a)
+ K(M), b.sortIndex = b.expirationTime, H(L, b);
+ else
+ break;
+ b = J(M);
+ }
+ }
+ __name(T, "T");
+ function U(a) {
+ S = false;
+ T(a);
+ if (!R)
+ if (null !== J(L))
+ R = true, f(V);
+ else {
+ var b = J(M);
+ null !== b && g(U, b.startTime - a);
+ }
+ }
+ __name(U, "U");
+ function V(a, b) {
+ R = false;
+ S && (S = false, h());
+ Q = true;
+ var c = P;
+ try {
+ T(b);
+ for (O = J(L); null !== O && (!(O.expirationTime > b) || a && !exports2.unstable_shouldYield()); ) {
+ var d = O.callback;
+ if ("function" === typeof d) {
+ O.callback = null;
+ P = O.priorityLevel;
+ var e2 = d(O.expirationTime <= b);
+ b = exports2.unstable_now();
+ "function" === typeof e2 ? O.callback = e2 : O === J(L) && K(L);
+ T(b);
+ } else
+ K(L);
+ O = J(L);
+ }
+ if (null !== O)
+ var m = true;
+ else {
+ var n = J(M);
+ null !== n && g(U, n.startTime - b);
+ m = false;
+ }
+ return m;
+ } finally {
+ O = null, P = c, Q = false;
+ }
+ }
+ __name(V, "V");
+ var W = k;
+ exports2.unstable_IdlePriority = 5;
+ exports2.unstable_ImmediatePriority = 1;
+ exports2.unstable_LowPriority = 4;
+ exports2.unstable_NormalPriority = 3;
+ exports2.unstable_Profiling = null;
+ exports2.unstable_UserBlockingPriority = 2;
+ exports2.unstable_cancelCallback = function(a) {
+ a.callback = null;
+ };
+ exports2.unstable_continueExecution = function() {
+ R || Q || (R = true, f(V));
+ };
+ exports2.unstable_getCurrentPriorityLevel = function() {
+ return P;
+ };
+ exports2.unstable_getFirstCallbackNode = function() {
+ return J(L);
+ };
+ exports2.unstable_next = function(a) {
+ switch (P) {
+ case 1:
+ case 2:
+ case 3:
+ var b = 3;
+ break;
+ default:
+ b = P;
+ }
+ var c = P;
+ P = b;
+ try {
+ return a();
+ } finally {
+ P = c;
+ }
+ };
+ exports2.unstable_pauseExecution = function() {
+ };
+ exports2.unstable_requestPaint = W;
+ exports2.unstable_runWithPriority = function(a, b) {
+ switch (a) {
+ case 1:
+ case 2:
+ case 3:
+ case 4:
+ case 5:
+ break;
+ default:
+ a = 3;
+ }
+ var c = P;
+ P = a;
+ try {
+ return b();
+ } finally {
+ P = c;
+ }
+ };
+ exports2.unstable_scheduleCallback = function(a, b, c) {
+ var d = exports2.unstable_now();
+ "object" === typeof c && null !== c ? (c = c.delay, c = "number" === typeof c && 0 < c ? d + c : d) : c = d;
+ switch (a) {
+ case 1:
+ var e2 = -1;
+ break;
+ case 2:
+ e2 = 250;
+ break;
+ case 5:
+ e2 = 1073741823;
+ break;
+ case 4:
+ e2 = 1e4;
+ break;
+ default:
+ e2 = 5e3;
+ }
+ e2 = c + e2;
+ a = { id: N++, callback: b, priorityLevel: a, startTime: c, expirationTime: e2, sortIndex: -1 };
+ c > d ? (a.sortIndex = c, H(M, a), null === J(L) && a === J(M) && (S ? h() : S = true, g(U, c - d))) : (a.sortIndex = e2, H(L, a), R || Q || (R = true, f(V)));
+ return a;
+ };
+ exports2.unstable_wrapCallback = function(a) {
+ var b = P;
+ return function() {
+ var c = P;
+ P = b;
+ try {
+ return a.apply(this, arguments);
+ } finally {
+ P = c;
+ }
+ };
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/scheduler@0.20.2/node_modules/scheduler/index.js
+var require_scheduler = __commonJS({
+ "../../node_modules/.pnpm/scheduler@0.20.2/node_modules/scheduler/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ if (true) {
+ module2.exports = require_scheduler_production_min();
+ } else {
+ module2.exports = null;
+ }
+ }
+});
+
+// ../../node_modules/.pnpm/react-reconciler@0.26.2_react@17.0.2/node_modules/react-reconciler/cjs/react-reconciler.production.min.js
+var require_react_reconciler_production_min = __commonJS({
+ "../../node_modules/.pnpm/react-reconciler@0.26.2_react@17.0.2/node_modules/react-reconciler/cjs/react-reconciler.production.min.js"(exports2, module2) {
+ init_import_meta_url();
+ module2.exports = /* @__PURE__ */ __name(function $$$reconciler($$$hostConfig) {
+ var exports3 = {};
+ "use strict";
+ var aa = require_object_assign(), ba = require_react(), m = require_scheduler();
+ function q(a) {
+ for (var b = "https://reactjs.org/docs/error-decoder.html?invariant=" + a, c = 1; c < arguments.length; c++)
+ b += "&args[]=" + encodeURIComponent(arguments[c]);
+ return "Minified React error #" + a + "; visit " + b + " for the full message or use the non-minified dev environment for full errors and additional helpful warnings.";
+ }
+ __name(q, "q");
+ var ca = ba.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED, da2 = 60103, ea = 60106, fa = 60107, ha = 60108, ia = 60114, ja = 60109, ka = 60110, la = 60112, ma = 60113, na = 60120, oa = 60115, pa2 = 60116, qa = 60121, ra = 60129, sa = 60130, ta = 60131;
+ if ("function" === typeof Symbol && Symbol.for) {
+ var r = Symbol.for;
+ da2 = r("react.element");
+ ea = r("react.portal");
+ fa = r("react.fragment");
+ ha = r("react.strict_mode");
+ ia = r("react.profiler");
+ ja = r("react.provider");
+ ka = r("react.context");
+ la = r("react.forward_ref");
+ ma = r("react.suspense");
+ na = r("react.suspense_list");
+ oa = r("react.memo");
+ pa2 = r("react.lazy");
+ qa = r("react.block");
+ r("react.scope");
+ ra = r("react.debug_trace_mode");
+ sa = r("react.offscreen");
+ ta = r("react.legacy_hidden");
+ }
+ var ua = "function" === typeof Symbol && Symbol.iterator;
+ function va(a) {
+ if (null === a || "object" !== typeof a)
+ return null;
+ a = ua && a[ua] || a["@@iterator"];
+ return "function" === typeof a ? a : null;
+ }
+ __name(va, "va");
+ function wa(a) {
+ if (null == a)
+ return null;
+ if ("function" === typeof a)
+ return a.displayName || a.name || null;
+ if ("string" === typeof a)
+ return a;
+ switch (a) {
+ case fa:
+ return "Fragment";
+ case ea:
+ return "Portal";
+ case ia:
+ return "Profiler";
+ case ha:
+ return "StrictMode";
+ case ma:
+ return "Suspense";
+ case na:
+ return "SuspenseList";
+ }
+ if ("object" === typeof a)
+ switch (a.$$typeof) {
+ case ka:
+ return (a.displayName || "Context") + ".Consumer";
+ case ja:
+ return (a._context.displayName || "Context") + ".Provider";
+ case la:
+ var b = a.render;
+ b = b.displayName || b.name || "";
+ return a.displayName || ("" !== b ? "ForwardRef(" + b + ")" : "ForwardRef");
+ case oa:
+ return wa(a.type);
+ case qa:
+ return wa(a._render);
+ case pa2:
+ b = a._payload;
+ a = a._init;
+ try {
+ return wa(a(b));
+ } catch (c) {
+ }
+ }
+ return null;
+ }
+ __name(wa, "wa");
+ function xa(a) {
+ var b = a, c = a;
+ if (a.alternate)
+ for (; b.return; )
+ b = b.return;
+ else {
+ a = b;
+ do
+ b = a, 0 !== (b.flags & 1026) && (c = b.return), a = b.return;
+ while (a);
+ }
+ return 3 === b.tag ? c : null;
+ }
+ __name(xa, "xa");
+ function ya(a) {
+ if (xa(a) !== a)
+ throw Error(q(188));
+ }
+ __name(ya, "ya");
+ function za(a) {
+ var b = a.alternate;
+ if (!b) {
+ b = xa(a);
+ if (null === b)
+ throw Error(q(188));
+ return b !== a ? null : a;
+ }
+ for (var c = a, d = b; ; ) {
+ var e2 = c.return;
+ if (null === e2)
+ break;
+ var f = e2.alternate;
+ if (null === f) {
+ d = e2.return;
+ if (null !== d) {
+ c = d;
+ continue;
+ }
+ break;
+ }
+ if (e2.child === f.child) {
+ for (f = e2.child; f; ) {
+ if (f === c)
+ return ya(e2), a;
+ if (f === d)
+ return ya(e2), b;
+ f = f.sibling;
+ }
+ throw Error(q(188));
+ }
+ if (c.return !== d.return)
+ c = e2, d = f;
+ else {
+ for (var g = false, h = e2.child; h; ) {
+ if (h === c) {
+ g = true;
+ c = e2;
+ d = f;
+ break;
+ }
+ if (h === d) {
+ g = true;
+ d = e2;
+ c = f;
+ break;
+ }
+ h = h.sibling;
+ }
+ if (!g) {
+ for (h = f.child; h; ) {
+ if (h === c) {
+ g = true;
+ c = f;
+ d = e2;
+ break;
+ }
+ if (h === d) {
+ g = true;
+ d = f;
+ c = e2;
+ break;
+ }
+ h = h.sibling;
+ }
+ if (!g)
+ throw Error(q(189));
+ }
+ }
+ if (c.alternate !== d)
+ throw Error(q(190));
+ }
+ if (3 !== c.tag)
+ throw Error(q(188));
+ return c.stateNode.current === c ? a : b;
+ }
+ __name(za, "za");
+ function Aa(a) {
+ a = za(a);
+ if (!a)
+ return null;
+ for (var b = a; ; ) {
+ if (5 === b.tag || 6 === b.tag)
+ return b;
+ if (b.child)
+ b.child.return = b, b = b.child;
+ else {
+ if (b === a)
+ break;
+ for (; !b.sibling; ) {
+ if (!b.return || b.return === a)
+ return null;
+ b = b.return;
+ }
+ b.sibling.return = b.return;
+ b = b.sibling;
+ }
+ }
+ return null;
+ }
+ __name(Aa, "Aa");
+ function Ba(a) {
+ a = za(a);
+ if (!a)
+ return null;
+ for (var b = a; ; ) {
+ if (5 === b.tag || 6 === b.tag)
+ return b;
+ if (b.child && 4 !== b.tag)
+ b.child.return = b, b = b.child;
+ else {
+ if (b === a)
+ break;
+ for (; !b.sibling; ) {
+ if (!b.return || b.return === a)
+ return null;
+ b = b.return;
+ }
+ b.sibling.return = b.return;
+ b = b.sibling;
+ }
+ }
+ return null;
+ }
+ __name(Ba, "Ba");
+ function Ca(a, b) {
+ for (var c = a.alternate; null !== b; ) {
+ if (b === a || b === c)
+ return true;
+ b = b.return;
+ }
+ return false;
+ }
+ __name(Ca, "Ca");
+ var Da = $$$hostConfig.getPublicInstance, Ea = $$$hostConfig.getRootHostContext, Fa = $$$hostConfig.getChildHostContext, Ga = $$$hostConfig.prepareForCommit, Ha = $$$hostConfig.resetAfterCommit, Ia = $$$hostConfig.createInstance, Ja = $$$hostConfig.appendInitialChild, Ka = $$$hostConfig.finalizeInitialChildren, La = $$$hostConfig.prepareUpdate, Ma = $$$hostConfig.shouldSetTextContent, Na = $$$hostConfig.createTextInstance, Pa = $$$hostConfig.scheduleTimeout, Qa = $$$hostConfig.cancelTimeout, Ra = $$$hostConfig.noTimeout, Sa = $$$hostConfig.isPrimaryRenderer, Ta = $$$hostConfig.supportsMutation, Ua = $$$hostConfig.supportsPersistence, Va = $$$hostConfig.supportsHydration, Wa = $$$hostConfig.getInstanceFromNode, Xa = $$$hostConfig.makeOpaqueHydratingObject, Ya = $$$hostConfig.makeClientId, Za = $$$hostConfig.beforeActiveInstanceBlur, $a = $$$hostConfig.afterActiveInstanceBlur, ab = $$$hostConfig.preparePortalMount, bb = $$$hostConfig.supportsTestSelectors, cb = $$$hostConfig.findFiberRoot, db = $$$hostConfig.getBoundingRect, eb = $$$hostConfig.getTextContent, fb = $$$hostConfig.isHiddenSubtree, gb = $$$hostConfig.matchAccessibilityRole, hb = $$$hostConfig.setFocusIfFocusable, ib = $$$hostConfig.setupIntersectionObserver, jb = $$$hostConfig.appendChild, kb = $$$hostConfig.appendChildToContainer, lb = $$$hostConfig.commitTextUpdate, mb = $$$hostConfig.commitMount, nb = $$$hostConfig.commitUpdate, ob = $$$hostConfig.insertBefore, pb = $$$hostConfig.insertInContainerBefore, qb = $$$hostConfig.removeChild, rb = $$$hostConfig.removeChildFromContainer, sb = $$$hostConfig.resetTextContent, tb = $$$hostConfig.hideInstance, ub = $$$hostConfig.hideTextInstance, vb = $$$hostConfig.unhideInstance, wb = $$$hostConfig.unhideTextInstance, xb = $$$hostConfig.clearContainer, yb = $$$hostConfig.cloneInstance, zb = $$$hostConfig.createContainerChildSet, Ab = $$$hostConfig.appendChildToContainerChildSet, Bb = $$$hostConfig.finalizeContainerChildren, Cb = $$$hostConfig.replaceContainerChildren, Db = $$$hostConfig.cloneHiddenInstance, Eb = $$$hostConfig.cloneHiddenTextInstance, Fb = $$$hostConfig.canHydrateInstance, Gb = $$$hostConfig.canHydrateTextInstance, Hb = $$$hostConfig.isSuspenseInstancePending, Ib = $$$hostConfig.isSuspenseInstanceFallback, Jb = $$$hostConfig.getNextHydratableSibling, Kb = $$$hostConfig.getFirstHydratableChild, Lb = $$$hostConfig.hydrateInstance, Mb = $$$hostConfig.hydrateTextInstance, Nb = $$$hostConfig.getNextHydratableInstanceAfterSuspenseInstance, Ob = $$$hostConfig.commitHydratedContainer, Pb = $$$hostConfig.commitHydratedSuspenseInstance, Qb;
+ function Rb(a) {
+ if (void 0 === Qb)
+ try {
+ throw Error();
+ } catch (c) {
+ var b = c.stack.trim().match(/\n( *(at )?)/);
+ Qb = b && b[1] || "";
+ }
+ return "\n" + Qb + a;
+ }
+ __name(Rb, "Rb");
+ var Sb = false;
+ function Tb(a, b) {
+ if (!a || Sb)
+ return "";
+ Sb = true;
+ var c = Error.prepareStackTrace;
+ Error.prepareStackTrace = void 0;
+ try {
+ if (b)
+ if (b = /* @__PURE__ */ __name(function() {
+ throw Error();
+ }, "b"), Object.defineProperty(b.prototype, "props", { set: function() {
+ throw Error();
+ } }), "object" === typeof Reflect && Reflect.construct) {
+ try {
+ Reflect.construct(b, []);
+ } catch (k) {
+ var d = k;
+ }
+ Reflect.construct(a, [], b);
+ } else {
+ try {
+ b.call();
+ } catch (k) {
+ d = k;
+ }
+ a.call(b.prototype);
+ }
+ else {
+ try {
+ throw Error();
+ } catch (k) {
+ d = k;
+ }
+ a();
+ }
+ } catch (k) {
+ if (k && d && "string" === typeof k.stack) {
+ for (var e2 = k.stack.split("\n"), f = d.stack.split("\n"), g = e2.length - 1, h = f.length - 1; 1 <= g && 0 <= h && e2[g] !== f[h]; )
+ h--;
+ for (; 1 <= g && 0 <= h; g--, h--)
+ if (e2[g] !== f[h]) {
+ if (1 !== g || 1 !== h) {
+ do
+ if (g--, h--, 0 > h || e2[g] !== f[h])
+ return "\n" + e2[g].replace(" at new ", " at ");
+ while (1 <= g && 0 <= h);
+ }
+ break;
+ }
+ }
+ } finally {
+ Sb = false, Error.prepareStackTrace = c;
+ }
+ return (a = a ? a.displayName || a.name : "") ? Rb(a) : "";
+ }
+ __name(Tb, "Tb");
+ var Ub = [], Vb = -1;
+ function Wb(a) {
+ return { current: a };
+ }
+ __name(Wb, "Wb");
+ function z(a) {
+ 0 > Vb || (a.current = Ub[Vb], Ub[Vb] = null, Vb--);
+ }
+ __name(z, "z");
+ function A(a, b) {
+ Vb++;
+ Ub[Vb] = a.current;
+ a.current = b;
+ }
+ __name(A, "A");
+ var Xb = {}, B = Wb(Xb), D = Wb(false), Yb = Xb;
+ function Zb(a, b) {
+ var c = a.type.contextTypes;
+ if (!c)
+ return Xb;
+ var d = a.stateNode;
+ if (d && d.__reactInternalMemoizedUnmaskedChildContext === b)
+ return d.__reactInternalMemoizedMaskedChildContext;
+ var e2 = {}, f;
+ for (f in c)
+ e2[f] = b[f];
+ d && (a = a.stateNode, a.__reactInternalMemoizedUnmaskedChildContext = b, a.__reactInternalMemoizedMaskedChildContext = e2);
+ return e2;
+ }
+ __name(Zb, "Zb");
+ function E(a) {
+ a = a.childContextTypes;
+ return null !== a && void 0 !== a;
+ }
+ __name(E, "E");
+ function $b() {
+ z(D);
+ z(B);
+ }
+ __name($b, "$b");
+ function ac(a, b, c) {
+ if (B.current !== Xb)
+ throw Error(q(168));
+ A(B, b);
+ A(D, c);
+ }
+ __name(ac, "ac");
+ function bc(a, b, c) {
+ var d = a.stateNode;
+ a = b.childContextTypes;
+ if ("function" !== typeof d.getChildContext)
+ return c;
+ d = d.getChildContext();
+ for (var e2 in d)
+ if (!(e2 in a))
+ throw Error(q(108, wa(b) || "Unknown", e2));
+ return aa({}, c, d);
+ }
+ __name(bc, "bc");
+ function cc(a) {
+ a = (a = a.stateNode) && a.__reactInternalMemoizedMergedChildContext || Xb;
+ Yb = B.current;
+ A(B, a);
+ A(D, D.current);
+ return true;
+ }
+ __name(cc, "cc");
+ function dc(a, b, c) {
+ var d = a.stateNode;
+ if (!d)
+ throw Error(q(169));
+ c ? (a = bc(a, b, Yb), d.__reactInternalMemoizedMergedChildContext = a, z(D), z(B), A(B, a)) : z(D);
+ A(D, c);
+ }
+ __name(dc, "dc");
+ var ec = null, fc = null, gc = m.unstable_now;
+ gc();
+ var hc = 0, F = 8;
+ function ic(a) {
+ if (0 !== (1 & a))
+ return F = 15, 1;
+ if (0 !== (2 & a))
+ return F = 14, 2;
+ if (0 !== (4 & a))
+ return F = 13, 4;
+ var b = 24 & a;
+ if (0 !== b)
+ return F = 12, b;
+ if (0 !== (a & 32))
+ return F = 11, 32;
+ b = 192 & a;
+ if (0 !== b)
+ return F = 10, b;
+ if (0 !== (a & 256))
+ return F = 9, 256;
+ b = 3584 & a;
+ if (0 !== b)
+ return F = 8, b;
+ if (0 !== (a & 4096))
+ return F = 7, 4096;
+ b = 4186112 & a;
+ if (0 !== b)
+ return F = 6, b;
+ b = 62914560 & a;
+ if (0 !== b)
+ return F = 5, b;
+ if (a & 67108864)
+ return F = 4, 67108864;
+ if (0 !== (a & 134217728))
+ return F = 3, 134217728;
+ b = 805306368 & a;
+ if (0 !== b)
+ return F = 2, b;
+ if (0 !== (1073741824 & a))
+ return F = 1, 1073741824;
+ F = 8;
+ return a;
+ }
+ __name(ic, "ic");
+ function jc(a) {
+ switch (a) {
+ case 99:
+ return 15;
+ case 98:
+ return 10;
+ case 97:
+ case 96:
+ return 8;
+ case 95:
+ return 2;
+ default:
+ return 0;
+ }
+ }
+ __name(jc, "jc");
+ function kc(a) {
+ switch (a) {
+ case 15:
+ case 14:
+ return 99;
+ case 13:
+ case 12:
+ case 11:
+ case 10:
+ return 98;
+ case 9:
+ case 8:
+ case 7:
+ case 6:
+ case 4:
+ case 5:
+ return 97;
+ case 3:
+ case 2:
+ case 1:
+ return 95;
+ case 0:
+ return 90;
+ default:
+ throw Error(q(358, a));
+ }
+ }
+ __name(kc, "kc");
+ function lc(a, b) {
+ var c = a.pendingLanes;
+ if (0 === c)
+ return F = 0;
+ var d = 0, e2 = 0, f = a.expiredLanes, g = a.suspendedLanes, h = a.pingedLanes;
+ if (0 !== f)
+ d = f, e2 = F = 15;
+ else if (f = c & 134217727, 0 !== f) {
+ var k = f & ~g;
+ 0 !== k ? (d = ic(k), e2 = F) : (h &= f, 0 !== h && (d = ic(h), e2 = F));
+ } else
+ f = c & ~g, 0 !== f ? (d = ic(f), e2 = F) : 0 !== h && (d = ic(h), e2 = F);
+ if (0 === d)
+ return 0;
+ d = 31 - mc(d);
+ d = c & ((0 > d ? 0 : 1 << d) << 1) - 1;
+ if (0 !== b && b !== d && 0 === (b & g)) {
+ ic(b);
+ if (e2 <= F)
+ return b;
+ F = e2;
+ }
+ b = a.entangledLanes;
+ if (0 !== b)
+ for (a = a.entanglements, b &= d; 0 < b; )
+ c = 31 - mc(b), e2 = 1 << c, d |= a[c], b &= ~e2;
+ return d;
+ }
+ __name(lc, "lc");
+ function nc(a) {
+ a = a.pendingLanes & -1073741825;
+ return 0 !== a ? a : a & 1073741824 ? 1073741824 : 0;
+ }
+ __name(nc, "nc");
+ function oc(a, b) {
+ switch (a) {
+ case 15:
+ return 1;
+ case 14:
+ return 2;
+ case 12:
+ return a = pc(24 & ~b), 0 === a ? oc(10, b) : a;
+ case 10:
+ return a = pc(192 & ~b), 0 === a ? oc(8, b) : a;
+ case 8:
+ return a = pc(3584 & ~b), 0 === a && (a = pc(4186112 & ~b), 0 === a && (a = 512)), a;
+ case 2:
+ return b = pc(805306368 & ~b), 0 === b && (b = 268435456), b;
+ }
+ throw Error(q(358, a));
+ }
+ __name(oc, "oc");
+ function pc(a) {
+ return a & -a;
+ }
+ __name(pc, "pc");
+ function qc(a) {
+ for (var b = [], c = 0; 31 > c; c++)
+ b.push(a);
+ return b;
+ }
+ __name(qc, "qc");
+ function rc(a, b, c) {
+ a.pendingLanes |= b;
+ var d = b - 1;
+ a.suspendedLanes &= d;
+ a.pingedLanes &= d;
+ a = a.eventTimes;
+ b = 31 - mc(b);
+ a[b] = c;
+ }
+ __name(rc, "rc");
+ var mc = Math.clz32 ? Math.clz32 : sc, tc = Math.log, uc = Math.LN2;
+ function sc(a) {
+ return 0 === a ? 32 : 31 - (tc(a) / uc | 0) | 0;
+ }
+ __name(sc, "sc");
+ var vc = m.unstable_runWithPriority, wc = m.unstable_scheduleCallback, xc = m.unstable_cancelCallback, yc = m.unstable_shouldYield, zc = m.unstable_requestPaint, Ac = m.unstable_now, Bc = m.unstable_getCurrentPriorityLevel, Cc = m.unstable_ImmediatePriority, Dc = m.unstable_UserBlockingPriority, Ec = m.unstable_NormalPriority, Fc = m.unstable_LowPriority, Gc = m.unstable_IdlePriority, Hc = {}, Ic = void 0 !== zc ? zc : function() {
+ }, Jc = null, Kc = null, Lc = false, Mc = Ac(), G = 1e4 > Mc ? Ac : function() {
+ return Ac() - Mc;
+ };
+ function Nc() {
+ switch (Bc()) {
+ case Cc:
+ return 99;
+ case Dc:
+ return 98;
+ case Ec:
+ return 97;
+ case Fc:
+ return 96;
+ case Gc:
+ return 95;
+ default:
+ throw Error(q(332));
+ }
+ }
+ __name(Nc, "Nc");
+ function Oc(a) {
+ switch (a) {
+ case 99:
+ return Cc;
+ case 98:
+ return Dc;
+ case 97:
+ return Ec;
+ case 96:
+ return Fc;
+ case 95:
+ return Gc;
+ default:
+ throw Error(q(332));
+ }
+ }
+ __name(Oc, "Oc");
+ function Pc(a, b) {
+ a = Oc(a);
+ return vc(a, b);
+ }
+ __name(Pc, "Pc");
+ function Qc(a, b, c) {
+ a = Oc(a);
+ return wc(a, b, c);
+ }
+ __name(Qc, "Qc");
+ function H() {
+ if (null !== Kc) {
+ var a = Kc;
+ Kc = null;
+ xc(a);
+ }
+ Rc();
+ }
+ __name(H, "H");
+ function Rc() {
+ if (!Lc && null !== Jc) {
+ Lc = true;
+ var a = 0;
+ try {
+ var b = Jc;
+ Pc(99, function() {
+ for (; a < b.length; a++) {
+ var c = b[a];
+ do
+ c = c(true);
+ while (null !== c);
+ }
+ });
+ Jc = null;
+ } catch (c) {
+ throw null !== Jc && (Jc = Jc.slice(a + 1)), wc(Cc, H), c;
+ } finally {
+ Lc = false;
+ }
+ }
+ }
+ __name(Rc, "Rc");
+ var Sc = ca.ReactCurrentBatchConfig;
+ function Tc(a, b) {
+ return a === b && (0 !== a || 1 / a === 1 / b) || a !== a && b !== b;
+ }
+ __name(Tc, "Tc");
+ var I = "function" === typeof Object.is ? Object.is : Tc, Uc = Object.prototype.hasOwnProperty;
+ function Vc(a, b) {
+ if (I(a, b))
+ return true;
+ if ("object" !== typeof a || null === a || "object" !== typeof b || null === b)
+ return false;
+ var c = Object.keys(a), d = Object.keys(b);
+ if (c.length !== d.length)
+ return false;
+ for (d = 0; d < c.length; d++)
+ if (!Uc.call(b, c[d]) || !I(a[c[d]], b[c[d]]))
+ return false;
+ return true;
+ }
+ __name(Vc, "Vc");
+ function Wc(a) {
+ switch (a.tag) {
+ case 5:
+ return Rb(a.type);
+ case 16:
+ return Rb("Lazy");
+ case 13:
+ return Rb("Suspense");
+ case 19:
+ return Rb("SuspenseList");
+ case 0:
+ case 2:
+ case 15:
+ return a = Tb(a.type, false), a;
+ case 11:
+ return a = Tb(a.type.render, false), a;
+ case 22:
+ return a = Tb(a.type._render, false), a;
+ case 1:
+ return a = Tb(a.type, true), a;
+ default:
+ return "";
+ }
+ }
+ __name(Wc, "Wc");
+ function Xc(a, b) {
+ if (a && a.defaultProps) {
+ b = aa({}, b);
+ a = a.defaultProps;
+ for (var c in a)
+ void 0 === b[c] && (b[c] = a[c]);
+ return b;
+ }
+ return b;
+ }
+ __name(Xc, "Xc");
+ var Yc = Wb(null), Zc = null, $c = null, ad = null;
+ function bd() {
+ ad = $c = Zc = null;
+ }
+ __name(bd, "bd");
+ function cd(a, b) {
+ a = a.type._context;
+ Sa ? (A(Yc, a._currentValue), a._currentValue = b) : (A(Yc, a._currentValue2), a._currentValue2 = b);
+ }
+ __name(cd, "cd");
+ function dd(a) {
+ var b = Yc.current;
+ z(Yc);
+ a = a.type._context;
+ Sa ? a._currentValue = b : a._currentValue2 = b;
+ }
+ __name(dd, "dd");
+ function ed(a, b) {
+ for (; null !== a; ) {
+ var c = a.alternate;
+ if ((a.childLanes & b) === b)
+ if (null === c || (c.childLanes & b) === b)
+ break;
+ else
+ c.childLanes |= b;
+ else
+ a.childLanes |= b, null !== c && (c.childLanes |= b);
+ a = a.return;
+ }
+ }
+ __name(ed, "ed");
+ function fd(a, b) {
+ Zc = a;
+ ad = $c = null;
+ a = a.dependencies;
+ null !== a && null !== a.firstContext && (0 !== (a.lanes & b) && (gd2 = true), a.firstContext = null);
+ }
+ __name(fd, "fd");
+ function J(a, b) {
+ if (ad !== a && false !== b && 0 !== b) {
+ if ("number" !== typeof b || 1073741823 === b)
+ ad = a, b = 1073741823;
+ b = { context: a, observedBits: b, next: null };
+ if (null === $c) {
+ if (null === Zc)
+ throw Error(q(308));
+ $c = b;
+ Zc.dependencies = { lanes: 0, firstContext: b, responders: null };
+ } else
+ $c = $c.next = b;
+ }
+ return Sa ? a._currentValue : a._currentValue2;
+ }
+ __name(J, "J");
+ var hd = false;
+ function id(a) {
+ a.updateQueue = { baseState: a.memoizedState, firstBaseUpdate: null, lastBaseUpdate: null, shared: { pending: null }, effects: null };
+ }
+ __name(id, "id");
+ function jd(a, b) {
+ a = a.updateQueue;
+ b.updateQueue === a && (b.updateQueue = { baseState: a.baseState, firstBaseUpdate: a.firstBaseUpdate, lastBaseUpdate: a.lastBaseUpdate, shared: a.shared, effects: a.effects });
+ }
+ __name(jd, "jd");
+ function kd(a, b) {
+ return { eventTime: a, lane: b, tag: 0, payload: null, callback: null, next: null };
+ }
+ __name(kd, "kd");
+ function md(a, b) {
+ a = a.updateQueue;
+ if (null !== a) {
+ a = a.shared;
+ var c = a.pending;
+ null === c ? b.next = b : (b.next = c.next, c.next = b);
+ a.pending = b;
+ }
+ }
+ __name(md, "md");
+ function nd(a, b) {
+ var c = a.updateQueue, d = a.alternate;
+ if (null !== d && (d = d.updateQueue, c === d)) {
+ var e2 = null, f = null;
+ c = c.firstBaseUpdate;
+ if (null !== c) {
+ do {
+ var g = { eventTime: c.eventTime, lane: c.lane, tag: c.tag, payload: c.payload, callback: c.callback, next: null };
+ null === f ? e2 = f = g : f = f.next = g;
+ c = c.next;
+ } while (null !== c);
+ null === f ? e2 = f = b : f = f.next = b;
+ } else
+ e2 = f = b;
+ c = { baseState: d.baseState, firstBaseUpdate: e2, lastBaseUpdate: f, shared: d.shared, effects: d.effects };
+ a.updateQueue = c;
+ return;
+ }
+ a = c.lastBaseUpdate;
+ null === a ? c.firstBaseUpdate = b : a.next = b;
+ c.lastBaseUpdate = b;
+ }
+ __name(nd, "nd");
+ function od(a, b, c, d) {
+ var e2 = a.updateQueue;
+ hd = false;
+ var f = e2.firstBaseUpdate, g = e2.lastBaseUpdate, h = e2.shared.pending;
+ if (null !== h) {
+ e2.shared.pending = null;
+ var k = h, l = k.next;
+ k.next = null;
+ null === g ? f = l : g.next = l;
+ g = k;
+ var n = a.alternate;
+ if (null !== n) {
+ n = n.updateQueue;
+ var t2 = n.lastBaseUpdate;
+ t2 !== g && (null === t2 ? n.firstBaseUpdate = l : t2.next = l, n.lastBaseUpdate = k);
+ }
+ }
+ if (null !== f) {
+ t2 = e2.baseState;
+ g = 0;
+ n = l = k = null;
+ do {
+ h = f.lane;
+ var p = f.eventTime;
+ if ((d & h) === h) {
+ null !== n && (n = n.next = {
+ eventTime: p,
+ lane: 0,
+ tag: f.tag,
+ payload: f.payload,
+ callback: f.callback,
+ next: null
+ });
+ a: {
+ var y = a, x = f;
+ h = b;
+ p = c;
+ switch (x.tag) {
+ case 1:
+ y = x.payload;
+ if ("function" === typeof y) {
+ t2 = y.call(p, t2, h);
+ break a;
+ }
+ t2 = y;
+ break a;
+ case 3:
+ y.flags = y.flags & -4097 | 64;
+ case 0:
+ y = x.payload;
+ h = "function" === typeof y ? y.call(p, t2, h) : y;
+ if (null === h || void 0 === h)
+ break a;
+ t2 = aa({}, t2, h);
+ break a;
+ case 2:
+ hd = true;
+ }
+ }
+ null !== f.callback && (a.flags |= 32, h = e2.effects, null === h ? e2.effects = [f] : h.push(f));
+ } else
+ p = { eventTime: p, lane: h, tag: f.tag, payload: f.payload, callback: f.callback, next: null }, null === n ? (l = n = p, k = t2) : n = n.next = p, g |= h;
+ f = f.next;
+ if (null === f)
+ if (h = e2.shared.pending, null === h)
+ break;
+ else
+ f = h.next, h.next = null, e2.lastBaseUpdate = h, e2.shared.pending = null;
+ } while (1);
+ null === n && (k = t2);
+ e2.baseState = k;
+ e2.firstBaseUpdate = l;
+ e2.lastBaseUpdate = n;
+ pd |= g;
+ a.lanes = g;
+ a.memoizedState = t2;
+ }
+ }
+ __name(od, "od");
+ function qd(a, b, c) {
+ a = b.effects;
+ b.effects = null;
+ if (null !== a)
+ for (b = 0; b < a.length; b++) {
+ var d = a[b], e2 = d.callback;
+ if (null !== e2) {
+ d.callback = null;
+ d = c;
+ if ("function" !== typeof e2)
+ throw Error(q(191, e2));
+ e2.call(d);
+ }
+ }
+ }
+ __name(qd, "qd");
+ var rd = new ba.Component().refs;
+ function sd(a, b, c, d) {
+ b = a.memoizedState;
+ c = c(d, b);
+ c = null === c || void 0 === c ? b : aa({}, b, c);
+ a.memoizedState = c;
+ 0 === a.lanes && (a.updateQueue.baseState = c);
+ }
+ __name(sd, "sd");
+ var vd = { isMounted: function(a) {
+ return (a = a._reactInternals) ? xa(a) === a : false;
+ }, enqueueSetState: function(a, b, c) {
+ a = a._reactInternals;
+ var d = K(), e2 = td(a), f = kd(d, e2);
+ f.payload = b;
+ void 0 !== c && null !== c && (f.callback = c);
+ md(a, f);
+ ud(a, e2, d);
+ }, enqueueReplaceState: function(a, b, c) {
+ a = a._reactInternals;
+ var d = K(), e2 = td(a), f = kd(d, e2);
+ f.tag = 1;
+ f.payload = b;
+ void 0 !== c && null !== c && (f.callback = c);
+ md(a, f);
+ ud(a, e2, d);
+ }, enqueueForceUpdate: function(a, b) {
+ a = a._reactInternals;
+ var c = K(), d = td(a), e2 = kd(c, d);
+ e2.tag = 2;
+ void 0 !== b && null !== b && (e2.callback = b);
+ md(a, e2);
+ ud(a, d, c);
+ } };
+ function wd(a, b, c, d, e2, f, g) {
+ a = a.stateNode;
+ return "function" === typeof a.shouldComponentUpdate ? a.shouldComponentUpdate(d, f, g) : b.prototype && b.prototype.isPureReactComponent ? !Vc(c, d) || !Vc(e2, f) : true;
+ }
+ __name(wd, "wd");
+ function xd(a, b, c) {
+ var d = false, e2 = Xb;
+ var f = b.contextType;
+ "object" === typeof f && null !== f ? f = J(f) : (e2 = E(b) ? Yb : B.current, d = b.contextTypes, f = (d = null !== d && void 0 !== d) ? Zb(a, e2) : Xb);
+ b = new b(c, f);
+ a.memoizedState = null !== b.state && void 0 !== b.state ? b.state : null;
+ b.updater = vd;
+ a.stateNode = b;
+ b._reactInternals = a;
+ d && (a = a.stateNode, a.__reactInternalMemoizedUnmaskedChildContext = e2, a.__reactInternalMemoizedMaskedChildContext = f);
+ return b;
+ }
+ __name(xd, "xd");
+ function yd(a, b, c, d) {
+ a = b.state;
+ "function" === typeof b.componentWillReceiveProps && b.componentWillReceiveProps(c, d);
+ "function" === typeof b.UNSAFE_componentWillReceiveProps && b.UNSAFE_componentWillReceiveProps(c, d);
+ b.state !== a && vd.enqueueReplaceState(b, b.state, null);
+ }
+ __name(yd, "yd");
+ function zd(a, b, c, d) {
+ var e2 = a.stateNode;
+ e2.props = c;
+ e2.state = a.memoizedState;
+ e2.refs = rd;
+ id(a);
+ var f = b.contextType;
+ "object" === typeof f && null !== f ? e2.context = J(f) : (f = E(b) ? Yb : B.current, e2.context = Zb(a, f));
+ od(a, c, e2, d);
+ e2.state = a.memoizedState;
+ f = b.getDerivedStateFromProps;
+ "function" === typeof f && (sd(a, b, f, c), e2.state = a.memoizedState);
+ "function" === typeof b.getDerivedStateFromProps || "function" === typeof e2.getSnapshotBeforeUpdate || "function" !== typeof e2.UNSAFE_componentWillMount && "function" !== typeof e2.componentWillMount || (b = e2.state, "function" === typeof e2.componentWillMount && e2.componentWillMount(), "function" === typeof e2.UNSAFE_componentWillMount && e2.UNSAFE_componentWillMount(), b !== e2.state && vd.enqueueReplaceState(e2, e2.state, null), od(a, c, e2, d), e2.state = a.memoizedState);
+ "function" === typeof e2.componentDidMount && (a.flags |= 4);
+ }
+ __name(zd, "zd");
+ var Ad = Array.isArray;
+ function Bd(a, b, c) {
+ a = c.ref;
+ if (null !== a && "function" !== typeof a && "object" !== typeof a) {
+ if (c._owner) {
+ c = c._owner;
+ if (c) {
+ if (1 !== c.tag)
+ throw Error(q(309));
+ var d = c.stateNode;
+ }
+ if (!d)
+ throw Error(q(147, a));
+ var e2 = "" + a;
+ if (null !== b && null !== b.ref && "function" === typeof b.ref && b.ref._stringRef === e2)
+ return b.ref;
+ b = /* @__PURE__ */ __name(function(a2) {
+ var b2 = d.refs;
+ b2 === rd && (b2 = d.refs = {});
+ null === a2 ? delete b2[e2] : b2[e2] = a2;
+ }, "b");
+ b._stringRef = e2;
+ return b;
+ }
+ if ("string" !== typeof a)
+ throw Error(q(284));
+ if (!c._owner)
+ throw Error(q(290, a));
+ }
+ return a;
+ }
+ __name(Bd, "Bd");
+ function Cd(a, b) {
+ if ("textarea" !== a.type)
+ throw Error(q(31, "[object Object]" === Object.prototype.toString.call(b) ? "object with keys {" + Object.keys(b).join(", ") + "}" : b));
+ }
+ __name(Cd, "Cd");
+ function Dd(a) {
+ function b(b2, c2) {
+ if (a) {
+ var d2 = b2.lastEffect;
+ null !== d2 ? (d2.nextEffect = c2, b2.lastEffect = c2) : b2.firstEffect = b2.lastEffect = c2;
+ c2.nextEffect = null;
+ c2.flags = 8;
+ }
+ }
+ __name(b, "b");
+ function c(c2, d2) {
+ if (!a)
+ return null;
+ for (; null !== d2; )
+ b(c2, d2), d2 = d2.sibling;
+ return null;
+ }
+ __name(c, "c");
+ function d(a2, b2) {
+ for (a2 = /* @__PURE__ */ new Map(); null !== b2; )
+ null !== b2.key ? a2.set(b2.key, b2) : a2.set(b2.index, b2), b2 = b2.sibling;
+ return a2;
+ }
+ __name(d, "d");
+ function e2(a2, b2) {
+ a2 = Ed(a2, b2);
+ a2.index = 0;
+ a2.sibling = null;
+ return a2;
+ }
+ __name(e2, "e");
+ function f(b2, c2, d2) {
+ b2.index = d2;
+ if (!a)
+ return c2;
+ d2 = b2.alternate;
+ if (null !== d2)
+ return d2 = d2.index, d2 < c2 ? (b2.flags = 2, c2) : d2;
+ b2.flags = 2;
+ return c2;
+ }
+ __name(f, "f");
+ function g(b2) {
+ a && null === b2.alternate && (b2.flags = 2);
+ return b2;
+ }
+ __name(g, "g");
+ function h(a2, b2, c2, d2) {
+ if (null === b2 || 6 !== b2.tag)
+ return b2 = Fd(c2, a2.mode, d2), b2.return = a2, b2;
+ b2 = e2(b2, c2);
+ b2.return = a2;
+ return b2;
+ }
+ __name(h, "h");
+ function k(a2, b2, c2, d2) {
+ if (null !== b2 && b2.elementType === c2.type)
+ return d2 = e2(b2, c2.props), d2.ref = Bd(a2, b2, c2), d2.return = a2, d2;
+ d2 = Gd(c2.type, c2.key, c2.props, null, a2.mode, d2);
+ d2.ref = Bd(a2, b2, c2);
+ d2.return = a2;
+ return d2;
+ }
+ __name(k, "k");
+ function l(a2, b2, c2, d2) {
+ if (null === b2 || 4 !== b2.tag || b2.stateNode.containerInfo !== c2.containerInfo || b2.stateNode.implementation !== c2.implementation)
+ return b2 = Hd(c2, a2.mode, d2), b2.return = a2, b2;
+ b2 = e2(b2, c2.children || []);
+ b2.return = a2;
+ return b2;
+ }
+ __name(l, "l");
+ function n(a2, b2, c2, d2, f2) {
+ if (null === b2 || 7 !== b2.tag)
+ return b2 = Id(c2, a2.mode, d2, f2), b2.return = a2, b2;
+ b2 = e2(b2, c2);
+ b2.return = a2;
+ return b2;
+ }
+ __name(n, "n");
+ function t2(a2, b2, c2) {
+ if ("string" === typeof b2 || "number" === typeof b2)
+ return b2 = Fd("" + b2, a2.mode, c2), b2.return = a2, b2;
+ if ("object" === typeof b2 && null !== b2) {
+ switch (b2.$$typeof) {
+ case da2:
+ return c2 = Gd(b2.type, b2.key, b2.props, null, a2.mode, c2), c2.ref = Bd(a2, null, b2), c2.return = a2, c2;
+ case ea:
+ return b2 = Hd(b2, a2.mode, c2), b2.return = a2, b2;
+ }
+ if (Ad(b2) || va(b2))
+ return b2 = Id(
+ b2,
+ a2.mode,
+ c2,
+ null
+ ), b2.return = a2, b2;
+ Cd(a2, b2);
+ }
+ return null;
+ }
+ __name(t2, "t");
+ function p(a2, b2, c2, d2) {
+ var e3 = null !== b2 ? b2.key : null;
+ if ("string" === typeof c2 || "number" === typeof c2)
+ return null !== e3 ? null : h(a2, b2, "" + c2, d2);
+ if ("object" === typeof c2 && null !== c2) {
+ switch (c2.$$typeof) {
+ case da2:
+ return c2.key === e3 ? c2.type === fa ? n(a2, b2, c2.props.children, d2, e3) : k(a2, b2, c2, d2) : null;
+ case ea:
+ return c2.key === e3 ? l(a2, b2, c2, d2) : null;
+ }
+ if (Ad(c2) || va(c2))
+ return null !== e3 ? null : n(a2, b2, c2, d2, null);
+ Cd(a2, c2);
+ }
+ return null;
+ }
+ __name(p, "p");
+ function y(a2, b2, c2, d2, e3) {
+ if ("string" === typeof d2 || "number" === typeof d2)
+ return a2 = a2.get(c2) || null, h(b2, a2, "" + d2, e3);
+ if ("object" === typeof d2 && null !== d2) {
+ switch (d2.$$typeof) {
+ case da2:
+ return a2 = a2.get(null === d2.key ? c2 : d2.key) || null, d2.type === fa ? n(b2, a2, d2.props.children, e3, d2.key) : k(b2, a2, d2, e3);
+ case ea:
+ return a2 = a2.get(null === d2.key ? c2 : d2.key) || null, l(b2, a2, d2, e3);
+ }
+ if (Ad(d2) || va(d2))
+ return a2 = a2.get(c2) || null, n(b2, a2, d2, e3, null);
+ Cd(b2, d2);
+ }
+ return null;
+ }
+ __name(y, "y");
+ function x(e3, g2, h2, k2) {
+ for (var l2 = null, v = null, u = g2, C = g2 = 0, n2 = null; null !== u && C < h2.length; C++) {
+ u.index > C ? (n2 = u, u = null) : n2 = u.sibling;
+ var w = p(e3, u, h2[C], k2);
+ if (null === w) {
+ null === u && (u = n2);
+ break;
+ }
+ a && u && null === w.alternate && b(e3, u);
+ g2 = f(w, g2, C);
+ null === v ? l2 = w : v.sibling = w;
+ v = w;
+ u = n2;
+ }
+ if (C === h2.length)
+ return c(e3, u), l2;
+ if (null === u) {
+ for (; C < h2.length; C++)
+ u = t2(e3, h2[C], k2), null !== u && (g2 = f(u, g2, C), null === v ? l2 = u : v.sibling = u, v = u);
+ return l2;
+ }
+ for (u = d(e3, u); C < h2.length; C++)
+ n2 = y(u, e3, C, h2[C], k2), null !== n2 && (a && null !== n2.alternate && u.delete(null === n2.key ? C : n2.key), g2 = f(n2, g2, C), null === v ? l2 = n2 : v.sibling = n2, v = n2);
+ a && u.forEach(function(a2) {
+ return b(e3, a2);
+ });
+ return l2;
+ }
+ __name(x, "x");
+ function Y(e3, g2, h2, k2) {
+ var l2 = va(h2);
+ if ("function" !== typeof l2)
+ throw Error(q(150));
+ h2 = l2.call(h2);
+ if (null == h2)
+ throw Error(q(151));
+ for (var u = l2 = null, v = g2, n2 = g2 = 0, C = null, w = h2.next(); null !== v && !w.done; n2++, w = h2.next()) {
+ v.index > n2 ? (C = v, v = null) : C = v.sibling;
+ var x2 = p(e3, v, w.value, k2);
+ if (null === x2) {
+ null === v && (v = C);
+ break;
+ }
+ a && v && null === x2.alternate && b(e3, v);
+ g2 = f(x2, g2, n2);
+ null === u ? l2 = x2 : u.sibling = x2;
+ u = x2;
+ v = C;
+ }
+ if (w.done)
+ return c(e3, v), l2;
+ if (null === v) {
+ for (; !w.done; n2++, w = h2.next())
+ w = t2(e3, w.value, k2), null !== w && (g2 = f(w, g2, n2), null === u ? l2 = w : u.sibling = w, u = w);
+ return l2;
+ }
+ for (v = d(e3, v); !w.done; n2++, w = h2.next())
+ w = y(v, e3, n2, w.value, k2), null !== w && (a && null !== w.alternate && v.delete(null === w.key ? n2 : w.key), g2 = f(w, g2, n2), null === u ? l2 = w : u.sibling = w, u = w);
+ a && v.forEach(function(a2) {
+ return b(e3, a2);
+ });
+ return l2;
+ }
+ __name(Y, "Y");
+ return function(a2, d2, f2, h2) {
+ var k2 = "object" === typeof f2 && null !== f2 && f2.type === fa && null === f2.key;
+ k2 && (f2 = f2.props.children);
+ var l2 = "object" === typeof f2 && null !== f2;
+ if (l2)
+ switch (f2.$$typeof) {
+ case da2:
+ a: {
+ l2 = f2.key;
+ for (k2 = d2; null !== k2; ) {
+ if (k2.key === l2) {
+ switch (k2.tag) {
+ case 7:
+ if (f2.type === fa) {
+ c(a2, k2.sibling);
+ d2 = e2(k2, f2.props.children);
+ d2.return = a2;
+ a2 = d2;
+ break a;
+ }
+ break;
+ default:
+ if (k2.elementType === f2.type) {
+ c(a2, k2.sibling);
+ d2 = e2(k2, f2.props);
+ d2.ref = Bd(a2, k2, f2);
+ d2.return = a2;
+ a2 = d2;
+ break a;
+ }
+ }
+ c(a2, k2);
+ break;
+ } else
+ b(a2, k2);
+ k2 = k2.sibling;
+ }
+ f2.type === fa ? (d2 = Id(f2.props.children, a2.mode, h2, f2.key), d2.return = a2, a2 = d2) : (h2 = Gd(f2.type, f2.key, f2.props, null, a2.mode, h2), h2.ref = Bd(a2, d2, f2), h2.return = a2, a2 = h2);
+ }
+ return g(a2);
+ case ea:
+ a: {
+ for (k2 = f2.key; null !== d2; ) {
+ if (d2.key === k2)
+ if (4 === d2.tag && d2.stateNode.containerInfo === f2.containerInfo && d2.stateNode.implementation === f2.implementation) {
+ c(a2, d2.sibling);
+ d2 = e2(d2, f2.children || []);
+ d2.return = a2;
+ a2 = d2;
+ break a;
+ } else {
+ c(a2, d2);
+ break;
+ }
+ else
+ b(a2, d2);
+ d2 = d2.sibling;
+ }
+ d2 = Hd(f2, a2.mode, h2);
+ d2.return = a2;
+ a2 = d2;
+ }
+ return g(a2);
+ }
+ if ("string" === typeof f2 || "number" === typeof f2)
+ return f2 = "" + f2, null !== d2 && 6 === d2.tag ? (c(a2, d2.sibling), d2 = e2(d2, f2), d2.return = a2, a2 = d2) : (c(a2, d2), d2 = Fd(f2, a2.mode, h2), d2.return = a2, a2 = d2), g(a2);
+ if (Ad(f2))
+ return x(a2, d2, f2, h2);
+ if (va(f2))
+ return Y(a2, d2, f2, h2);
+ l2 && Cd(a2, f2);
+ if ("undefined" === typeof f2 && !k2)
+ switch (a2.tag) {
+ case 1:
+ case 22:
+ case 0:
+ case 11:
+ case 15:
+ throw Error(q(152, wa(a2.type) || "Component"));
+ }
+ return c(a2, d2);
+ };
+ }
+ __name(Dd, "Dd");
+ var Jd = Dd(true), Kd = Dd(false), Ld = {}, L = Wb(Ld), Md = Wb(Ld), Nd = Wb(Ld);
+ function Od(a) {
+ if (a === Ld)
+ throw Error(q(174));
+ return a;
+ }
+ __name(Od, "Od");
+ function Pd(a, b) {
+ A(Nd, b);
+ A(Md, a);
+ A(L, Ld);
+ a = Ea(b);
+ z(L);
+ A(L, a);
+ }
+ __name(Pd, "Pd");
+ function Qd() {
+ z(L);
+ z(Md);
+ z(Nd);
+ }
+ __name(Qd, "Qd");
+ function Rd(a) {
+ var b = Od(Nd.current), c = Od(L.current);
+ b = Fa(c, a.type, b);
+ c !== b && (A(Md, a), A(L, b));
+ }
+ __name(Rd, "Rd");
+ function Sd(a) {
+ Md.current === a && (z(L), z(Md));
+ }
+ __name(Sd, "Sd");
+ var M = Wb(0);
+ function Td(a) {
+ for (var b = a; null !== b; ) {
+ if (13 === b.tag) {
+ var c = b.memoizedState;
+ if (null !== c && (c = c.dehydrated, null === c || Hb(c) || Ib(c)))
+ return b;
+ } else if (19 === b.tag && void 0 !== b.memoizedProps.revealOrder) {
+ if (0 !== (b.flags & 64))
+ return b;
+ } else if (null !== b.child) {
+ b.child.return = b;
+ b = b.child;
+ continue;
+ }
+ if (b === a)
+ break;
+ for (; null === b.sibling; ) {
+ if (null === b.return || b.return === a)
+ return null;
+ b = b.return;
+ }
+ b.sibling.return = b.return;
+ b = b.sibling;
+ }
+ return null;
+ }
+ __name(Td, "Td");
+ var Ud = null, Vd = null, Wd = false;
+ function Xd(a, b) {
+ var c = Yd(5, null, null, 0);
+ c.elementType = "DELETED";
+ c.type = "DELETED";
+ c.stateNode = b;
+ c.return = a;
+ c.flags = 8;
+ null !== a.lastEffect ? (a.lastEffect.nextEffect = c, a.lastEffect = c) : a.firstEffect = a.lastEffect = c;
+ }
+ __name(Xd, "Xd");
+ function Zd(a, b) {
+ switch (a.tag) {
+ case 5:
+ return b = Fb(b, a.type, a.pendingProps), null !== b ? (a.stateNode = b, true) : false;
+ case 6:
+ return b = Gb(b, a.pendingProps), null !== b ? (a.stateNode = b, true) : false;
+ case 13:
+ return false;
+ default:
+ return false;
+ }
+ }
+ __name(Zd, "Zd");
+ function $d(a) {
+ if (Wd) {
+ var b = Vd;
+ if (b) {
+ var c = b;
+ if (!Zd(a, b)) {
+ b = Jb(c);
+ if (!b || !Zd(a, b)) {
+ a.flags = a.flags & -1025 | 2;
+ Wd = false;
+ Ud = a;
+ return;
+ }
+ Xd(Ud, c);
+ }
+ Ud = a;
+ Vd = Kb(b);
+ } else
+ a.flags = a.flags & -1025 | 2, Wd = false, Ud = a;
+ }
+ }
+ __name($d, "$d");
+ function ae(a) {
+ for (a = a.return; null !== a && 5 !== a.tag && 3 !== a.tag && 13 !== a.tag; )
+ a = a.return;
+ Ud = a;
+ }
+ __name(ae, "ae");
+ function be2(a) {
+ if (!Va || a !== Ud)
+ return false;
+ if (!Wd)
+ return ae(a), Wd = true, false;
+ var b = a.type;
+ if (5 !== a.tag || "head" !== b && "body" !== b && !Ma(b, a.memoizedProps))
+ for (b = Vd; b; )
+ Xd(a, b), b = Jb(b);
+ ae(a);
+ if (13 === a.tag) {
+ if (!Va)
+ throw Error(q(316));
+ a = a.memoizedState;
+ a = null !== a ? a.dehydrated : null;
+ if (!a)
+ throw Error(q(317));
+ Vd = Nb(a);
+ } else
+ Vd = Ud ? Jb(a.stateNode) : null;
+ return true;
+ }
+ __name(be2, "be");
+ function ce() {
+ Va && (Vd = Ud = null, Wd = false);
+ }
+ __name(ce, "ce");
+ var de = [];
+ function ee() {
+ for (var a = 0; a < de.length; a++) {
+ var b = de[a];
+ Sa ? b._workInProgressVersionPrimary = null : b._workInProgressVersionSecondary = null;
+ }
+ de.length = 0;
+ }
+ __name(ee, "ee");
+ var fe = ca.ReactCurrentDispatcher, ge = ca.ReactCurrentBatchConfig, he2 = 0, N = null, O = null, P = null, ie = false, je = false;
+ function Q() {
+ throw Error(q(321));
+ }
+ __name(Q, "Q");
+ function ke(a, b) {
+ if (null === b)
+ return false;
+ for (var c = 0; c < b.length && c < a.length; c++)
+ if (!I(a[c], b[c]))
+ return false;
+ return true;
+ }
+ __name(ke, "ke");
+ function le(a, b, c, d, e2, f) {
+ he2 = f;
+ N = b;
+ b.memoizedState = null;
+ b.updateQueue = null;
+ b.lanes = 0;
+ fe.current = null === a || null === a.memoizedState ? me : ne;
+ a = c(d, e2);
+ if (je) {
+ f = 0;
+ do {
+ je = false;
+ if (!(25 > f))
+ throw Error(q(301));
+ f += 1;
+ P = O = null;
+ b.updateQueue = null;
+ fe.current = oe;
+ a = c(d, e2);
+ } while (je);
+ }
+ fe.current = pe;
+ b = null !== O && null !== O.next;
+ he2 = 0;
+ P = O = N = null;
+ ie = false;
+ if (b)
+ throw Error(q(300));
+ return a;
+ }
+ __name(le, "le");
+ function qe() {
+ var a = { memoizedState: null, baseState: null, baseQueue: null, queue: null, next: null };
+ null === P ? N.memoizedState = P = a : P = P.next = a;
+ return P;
+ }
+ __name(qe, "qe");
+ function re() {
+ if (null === O) {
+ var a = N.alternate;
+ a = null !== a ? a.memoizedState : null;
+ } else
+ a = O.next;
+ var b = null === P ? N.memoizedState : P.next;
+ if (null !== b)
+ P = b, O = a;
+ else {
+ if (null === a)
+ throw Error(q(310));
+ O = a;
+ a = { memoizedState: O.memoizedState, baseState: O.baseState, baseQueue: O.baseQueue, queue: O.queue, next: null };
+ null === P ? N.memoizedState = P = a : P = P.next = a;
+ }
+ return P;
+ }
+ __name(re, "re");
+ function se2(a, b) {
+ return "function" === typeof b ? b(a) : b;
+ }
+ __name(se2, "se");
+ function te(a) {
+ var b = re(), c = b.queue;
+ if (null === c)
+ throw Error(q(311));
+ c.lastRenderedReducer = a;
+ var d = O, e2 = d.baseQueue, f = c.pending;
+ if (null !== f) {
+ if (null !== e2) {
+ var g = e2.next;
+ e2.next = f.next;
+ f.next = g;
+ }
+ d.baseQueue = e2 = f;
+ c.pending = null;
+ }
+ if (null !== e2) {
+ e2 = e2.next;
+ d = d.baseState;
+ var h = g = f = null, k = e2;
+ do {
+ var l = k.lane;
+ if ((he2 & l) === l)
+ null !== h && (h = h.next = { lane: 0, action: k.action, eagerReducer: k.eagerReducer, eagerState: k.eagerState, next: null }), d = k.eagerReducer === a ? k.eagerState : a(d, k.action);
+ else {
+ var n = {
+ lane: l,
+ action: k.action,
+ eagerReducer: k.eagerReducer,
+ eagerState: k.eagerState,
+ next: null
+ };
+ null === h ? (g = h = n, f = d) : h = h.next = n;
+ N.lanes |= l;
+ pd |= l;
+ }
+ k = k.next;
+ } while (null !== k && k !== e2);
+ null === h ? f = d : h.next = g;
+ I(d, b.memoizedState) || (gd2 = true);
+ b.memoizedState = d;
+ b.baseState = f;
+ b.baseQueue = h;
+ c.lastRenderedState = d;
+ }
+ return [b.memoizedState, c.dispatch];
+ }
+ __name(te, "te");
+ function ue(a) {
+ var b = re(), c = b.queue;
+ if (null === c)
+ throw Error(q(311));
+ c.lastRenderedReducer = a;
+ var d = c.dispatch, e2 = c.pending, f = b.memoizedState;
+ if (null !== e2) {
+ c.pending = null;
+ var g = e2 = e2.next;
+ do
+ f = a(f, g.action), g = g.next;
+ while (g !== e2);
+ I(f, b.memoizedState) || (gd2 = true);
+ b.memoizedState = f;
+ null === b.baseQueue && (b.baseState = f);
+ c.lastRenderedState = f;
+ }
+ return [f, d];
+ }
+ __name(ue, "ue");
+ function ve(a, b, c) {
+ var d = b._getVersion;
+ d = d(b._source);
+ var e2 = Sa ? b._workInProgressVersionPrimary : b._workInProgressVersionSecondary;
+ if (null !== e2)
+ a = e2 === d;
+ else if (a = a.mutableReadLanes, a = (he2 & a) === a)
+ Sa ? b._workInProgressVersionPrimary = d : b._workInProgressVersionSecondary = d, de.push(b);
+ if (a)
+ return c(b._source);
+ de.push(b);
+ throw Error(q(350));
+ }
+ __name(ve, "ve");
+ function we(a, b, c, d) {
+ var e2 = R;
+ if (null === e2)
+ throw Error(q(349));
+ var f = b._getVersion, g = f(b._source), h = fe.current, k = h.useState(function() {
+ return ve(e2, b, c);
+ }), l = k[1], n = k[0];
+ k = P;
+ var t2 = a.memoizedState, p = t2.refs, y = p.getSnapshot, x = t2.source;
+ t2 = t2.subscribe;
+ var Y = N;
+ a.memoizedState = { refs: p, source: b, subscribe: d };
+ h.useEffect(function() {
+ p.getSnapshot = c;
+ p.setSnapshot = l;
+ var a2 = f(b._source);
+ if (!I(g, a2)) {
+ a2 = c(b._source);
+ I(n, a2) || (l(a2), a2 = td(Y), e2.mutableReadLanes |= a2 & e2.pendingLanes);
+ a2 = e2.mutableReadLanes;
+ e2.entangledLanes |= a2;
+ for (var d2 = e2.entanglements, h2 = a2; 0 < h2; ) {
+ var k2 = 31 - mc(h2), t3 = 1 << k2;
+ d2[k2] |= a2;
+ h2 &= ~t3;
+ }
+ }
+ }, [c, b, d]);
+ h.useEffect(function() {
+ return d(b._source, function() {
+ var a2 = p.getSnapshot, c2 = p.setSnapshot;
+ try {
+ c2(a2(b._source));
+ var d2 = td(Y);
+ e2.mutableReadLanes |= d2 & e2.pendingLanes;
+ } catch (Oa) {
+ c2(function() {
+ throw Oa;
+ });
+ }
+ });
+ }, [b, d]);
+ I(y, c) && I(x, b) && I(t2, d) || (a = { pending: null, dispatch: null, lastRenderedReducer: se2, lastRenderedState: n }, a.dispatch = l = xe.bind(null, N, a), k.queue = a, k.baseQueue = null, n = ve(e2, b, c), k.memoizedState = k.baseState = n);
+ return n;
+ }
+ __name(we, "we");
+ function ye(a, b, c) {
+ var d = re();
+ return we(d, a, b, c);
+ }
+ __name(ye, "ye");
+ function ze(a) {
+ var b = qe();
+ "function" === typeof a && (a = a());
+ b.memoizedState = b.baseState = a;
+ a = b.queue = { pending: null, dispatch: null, lastRenderedReducer: se2, lastRenderedState: a };
+ a = a.dispatch = xe.bind(null, N, a);
+ return [b.memoizedState, a];
+ }
+ __name(ze, "ze");
+ function Ae(a, b, c, d) {
+ a = { tag: a, create: b, destroy: c, deps: d, next: null };
+ b = N.updateQueue;
+ null === b ? (b = { lastEffect: null }, N.updateQueue = b, b.lastEffect = a.next = a) : (c = b.lastEffect, null === c ? b.lastEffect = a.next = a : (d = c.next, c.next = a, a.next = d, b.lastEffect = a));
+ return a;
+ }
+ __name(Ae, "Ae");
+ function Be(a) {
+ var b = qe();
+ a = { current: a };
+ return b.memoizedState = a;
+ }
+ __name(Be, "Be");
+ function Ce() {
+ return re().memoizedState;
+ }
+ __name(Ce, "Ce");
+ function De(a, b, c, d) {
+ var e2 = qe();
+ N.flags |= a;
+ e2.memoizedState = Ae(1 | b, c, void 0, void 0 === d ? null : d);
+ }
+ __name(De, "De");
+ function Ee(a, b, c, d) {
+ var e2 = re();
+ d = void 0 === d ? null : d;
+ var f = void 0;
+ if (null !== O) {
+ var g = O.memoizedState;
+ f = g.destroy;
+ if (null !== d && ke(d, g.deps)) {
+ Ae(b, c, f, d);
+ return;
+ }
+ }
+ N.flags |= a;
+ e2.memoizedState = Ae(1 | b, c, f, d);
+ }
+ __name(Ee, "Ee");
+ function Fe(a, b) {
+ return De(516, 4, a, b);
+ }
+ __name(Fe, "Fe");
+ function Ge(a, b) {
+ return Ee(516, 4, a, b);
+ }
+ __name(Ge, "Ge");
+ function He(a, b) {
+ return Ee(4, 2, a, b);
+ }
+ __name(He, "He");
+ function Ie(a, b) {
+ if ("function" === typeof b)
+ return a = a(), b(a), function() {
+ b(null);
+ };
+ if (null !== b && void 0 !== b)
+ return a = a(), b.current = a, function() {
+ b.current = null;
+ };
+ }
+ __name(Ie, "Ie");
+ function Je(a, b, c) {
+ c = null !== c && void 0 !== c ? c.concat([a]) : null;
+ return Ee(4, 2, Ie.bind(null, b, a), c);
+ }
+ __name(Je, "Je");
+ function Ke() {
+ }
+ __name(Ke, "Ke");
+ function Le(a, b) {
+ var c = re();
+ b = void 0 === b ? null : b;
+ var d = c.memoizedState;
+ if (null !== d && null !== b && ke(b, d[1]))
+ return d[0];
+ c.memoizedState = [a, b];
+ return a;
+ }
+ __name(Le, "Le");
+ function Me(a, b) {
+ var c = re();
+ b = void 0 === b ? null : b;
+ var d = c.memoizedState;
+ if (null !== d && null !== b && ke(b, d[1]))
+ return d[0];
+ a = a();
+ c.memoizedState = [a, b];
+ return a;
+ }
+ __name(Me, "Me");
+ function Ne(a, b) {
+ var c = Nc();
+ Pc(98 > c ? 98 : c, function() {
+ a(true);
+ });
+ Pc(97 < c ? 97 : c, function() {
+ var c2 = ge.transition;
+ ge.transition = 1;
+ try {
+ a(false), b();
+ } finally {
+ ge.transition = c2;
+ }
+ });
+ }
+ __name(Ne, "Ne");
+ function xe(a, b, c) {
+ var d = K(), e2 = td(a), f = { lane: e2, action: c, eagerReducer: null, eagerState: null, next: null }, g = b.pending;
+ null === g ? f.next = f : (f.next = g.next, g.next = f);
+ b.pending = f;
+ g = a.alternate;
+ if (a === N || null !== g && g === N)
+ je = ie = true;
+ else {
+ if (0 === a.lanes && (null === g || 0 === g.lanes) && (g = b.lastRenderedReducer, null !== g))
+ try {
+ var h = b.lastRenderedState, k = g(h, c);
+ f.eagerReducer = g;
+ f.eagerState = k;
+ if (I(k, h))
+ return;
+ } catch (l) {
+ } finally {
+ }
+ ud(a, e2, d);
+ }
+ }
+ __name(xe, "xe");
+ var pe = { readContext: J, useCallback: Q, useContext: Q, useEffect: Q, useImperativeHandle: Q, useLayoutEffect: Q, useMemo: Q, useReducer: Q, useRef: Q, useState: Q, useDebugValue: Q, useDeferredValue: Q, useTransition: Q, useMutableSource: Q, useOpaqueIdentifier: Q, unstable_isNewReconciler: false }, me = { readContext: J, useCallback: function(a, b) {
+ qe().memoizedState = [a, void 0 === b ? null : b];
+ return a;
+ }, useContext: J, useEffect: Fe, useImperativeHandle: function(a, b, c) {
+ c = null !== c && void 0 !== c ? c.concat([a]) : null;
+ return De(4, 2, Ie.bind(null, b, a), c);
+ }, useLayoutEffect: function(a, b) {
+ return De(4, 2, a, b);
+ }, useMemo: function(a, b) {
+ var c = qe();
+ b = void 0 === b ? null : b;
+ a = a();
+ c.memoizedState = [a, b];
+ return a;
+ }, useReducer: function(a, b, c) {
+ var d = qe();
+ b = void 0 !== c ? c(b) : b;
+ d.memoizedState = d.baseState = b;
+ a = d.queue = { pending: null, dispatch: null, lastRenderedReducer: a, lastRenderedState: b };
+ a = a.dispatch = xe.bind(null, N, a);
+ return [d.memoizedState, a];
+ }, useRef: Be, useState: ze, useDebugValue: Ke, useDeferredValue: function(a) {
+ var b = ze(a), c = b[0], d = b[1];
+ Fe(function() {
+ var b2 = ge.transition;
+ ge.transition = 1;
+ try {
+ d(a);
+ } finally {
+ ge.transition = b2;
+ }
+ }, [a]);
+ return c;
+ }, useTransition: function() {
+ var a = ze(false), b = a[0];
+ a = Ne.bind(null, a[1]);
+ Be(a);
+ return [a, b];
+ }, useMutableSource: function(a, b, c) {
+ var d = qe();
+ d.memoizedState = { refs: { getSnapshot: b, setSnapshot: null }, source: a, subscribe: c };
+ return we(d, a, b, c);
+ }, useOpaqueIdentifier: function() {
+ if (Wd) {
+ var a = false, b = Xa(function() {
+ a || (a = true, c(Ya()));
+ throw Error(q(355));
+ }), c = ze(b)[1];
+ 0 === (N.mode & 2) && (N.flags |= 516, Ae(5, function() {
+ c(Ya());
+ }, void 0, null));
+ return b;
+ }
+ b = Ya();
+ ze(b);
+ return b;
+ }, unstable_isNewReconciler: false }, ne = {
+ readContext: J,
+ useCallback: Le,
+ useContext: J,
+ useEffect: Ge,
+ useImperativeHandle: Je,
+ useLayoutEffect: He,
+ useMemo: Me,
+ useReducer: te,
+ useRef: Ce,
+ useState: function() {
+ return te(se2);
+ },
+ useDebugValue: Ke,
+ useDeferredValue: function(a) {
+ var b = te(se2), c = b[0], d = b[1];
+ Ge(function() {
+ var b2 = ge.transition;
+ ge.transition = 1;
+ try {
+ d(a);
+ } finally {
+ ge.transition = b2;
+ }
+ }, [a]);
+ return c;
+ },
+ useTransition: function() {
+ var a = te(se2)[0];
+ return [Ce().current, a];
+ },
+ useMutableSource: ye,
+ useOpaqueIdentifier: function() {
+ return te(se2)[0];
+ },
+ unstable_isNewReconciler: false
+ }, oe = {
+ readContext: J,
+ useCallback: Le,
+ useContext: J,
+ useEffect: Ge,
+ useImperativeHandle: Je,
+ useLayoutEffect: He,
+ useMemo: Me,
+ useReducer: ue,
+ useRef: Ce,
+ useState: function() {
+ return ue(se2);
+ },
+ useDebugValue: Ke,
+ useDeferredValue: function(a) {
+ var b = ue(se2), c = b[0], d = b[1];
+ Ge(function() {
+ var b2 = ge.transition;
+ ge.transition = 1;
+ try {
+ d(a);
+ } finally {
+ ge.transition = b2;
+ }
+ }, [a]);
+ return c;
+ },
+ useTransition: function() {
+ var a = ue(se2)[0];
+ return [Ce().current, a];
+ },
+ useMutableSource: ye,
+ useOpaqueIdentifier: function() {
+ return ue(se2)[0];
+ },
+ unstable_isNewReconciler: false
+ }, Oe = ca.ReactCurrentOwner, gd2 = false;
+ function S(a, b, c, d) {
+ b.child = null === a ? Kd(b, null, c, d) : Jd(b, a.child, c, d);
+ }
+ __name(S, "S");
+ function Pe(a, b, c, d, e2) {
+ c = c.render;
+ var f = b.ref;
+ fd(b, e2);
+ d = le(a, b, c, d, f, e2);
+ if (null !== a && !gd2)
+ return b.updateQueue = a.updateQueue, b.flags &= -517, a.lanes &= ~e2, Re(a, b, e2);
+ b.flags |= 1;
+ S(a, b, d, e2);
+ return b.child;
+ }
+ __name(Pe, "Pe");
+ function Se(a, b, c, d, e2, f) {
+ if (null === a) {
+ var g = c.type;
+ if ("function" === typeof g && !Te(g) && void 0 === g.defaultProps && null === c.compare && void 0 === c.defaultProps)
+ return b.tag = 15, b.type = g, Ue(a, b, g, d, e2, f);
+ a = Gd(c.type, null, d, b, b.mode, f);
+ a.ref = b.ref;
+ a.return = b;
+ return b.child = a;
+ }
+ g = a.child;
+ if (0 === (e2 & f) && (e2 = g.memoizedProps, c = c.compare, c = null !== c ? c : Vc, c(e2, d) && a.ref === b.ref))
+ return Re(a, b, f);
+ b.flags |= 1;
+ a = Ed(g, d);
+ a.ref = b.ref;
+ a.return = b;
+ return b.child = a;
+ }
+ __name(Se, "Se");
+ function Ue(a, b, c, d, e2, f) {
+ if (null !== a && Vc(a.memoizedProps, d) && a.ref === b.ref)
+ if (gd2 = false, 0 !== (f & e2))
+ 0 !== (a.flags & 16384) && (gd2 = true);
+ else
+ return b.lanes = a.lanes, Re(a, b, f);
+ return Ve(a, b, c, d, f);
+ }
+ __name(Ue, "Ue");
+ function We(a, b, c) {
+ var d = b.pendingProps, e2 = d.children, f = null !== a ? a.memoizedState : null;
+ if ("hidden" === d.mode || "unstable-defer-without-hiding" === d.mode)
+ if (0 === (b.mode & 4))
+ b.memoizedState = { baseLanes: 0 }, Xe(b, c);
+ else if (0 !== (c & 1073741824))
+ b.memoizedState = { baseLanes: 0 }, Xe(b, null !== f ? f.baseLanes : c);
+ else
+ return a = null !== f ? f.baseLanes | c : c, b.lanes = b.childLanes = 1073741824, b.memoizedState = { baseLanes: a }, Xe(b, a), null;
+ else
+ null !== f ? (d = f.baseLanes | c, b.memoizedState = null) : d = c, Xe(b, d);
+ S(a, b, e2, c);
+ return b.child;
+ }
+ __name(We, "We");
+ function Ye(a, b) {
+ var c = b.ref;
+ if (null === a && null !== c || null !== a && a.ref !== c)
+ b.flags |= 128;
+ }
+ __name(Ye, "Ye");
+ function Ve(a, b, c, d, e2) {
+ var f = E(c) ? Yb : B.current;
+ f = Zb(b, f);
+ fd(b, e2);
+ c = le(a, b, c, d, f, e2);
+ if (null !== a && !gd2)
+ return b.updateQueue = a.updateQueue, b.flags &= -517, a.lanes &= ~e2, Re(a, b, e2);
+ b.flags |= 1;
+ S(a, b, c, e2);
+ return b.child;
+ }
+ __name(Ve, "Ve");
+ function Ze(a, b, c, d, e2) {
+ if (E(c)) {
+ var f = true;
+ cc(b);
+ } else
+ f = false;
+ fd(b, e2);
+ if (null === b.stateNode)
+ null !== a && (a.alternate = null, b.alternate = null, b.flags |= 2), xd(b, c, d), zd(b, c, d, e2), d = true;
+ else if (null === a) {
+ var g = b.stateNode, h = b.memoizedProps;
+ g.props = h;
+ var k = g.context, l = c.contextType;
+ "object" === typeof l && null !== l ? l = J(l) : (l = E(c) ? Yb : B.current, l = Zb(b, l));
+ var n = c.getDerivedStateFromProps, t2 = "function" === typeof n || "function" === typeof g.getSnapshotBeforeUpdate;
+ t2 || "function" !== typeof g.UNSAFE_componentWillReceiveProps && "function" !== typeof g.componentWillReceiveProps || (h !== d || k !== l) && yd(b, g, d, l);
+ hd = false;
+ var p = b.memoizedState;
+ g.state = p;
+ od(b, d, g, e2);
+ k = b.memoizedState;
+ h !== d || p !== k || D.current || hd ? ("function" === typeof n && (sd(b, c, n, d), k = b.memoizedState), (h = hd || wd(b, c, h, d, p, k, l)) ? (t2 || "function" !== typeof g.UNSAFE_componentWillMount && "function" !== typeof g.componentWillMount || ("function" === typeof g.componentWillMount && g.componentWillMount(), "function" === typeof g.UNSAFE_componentWillMount && g.UNSAFE_componentWillMount()), "function" === typeof g.componentDidMount && (b.flags |= 4)) : ("function" === typeof g.componentDidMount && (b.flags |= 4), b.memoizedProps = d, b.memoizedState = k), g.props = d, g.state = k, g.context = l, d = h) : ("function" === typeof g.componentDidMount && (b.flags |= 4), d = false);
+ } else {
+ g = b.stateNode;
+ jd(a, b);
+ h = b.memoizedProps;
+ l = b.type === b.elementType ? h : Xc(b.type, h);
+ g.props = l;
+ t2 = b.pendingProps;
+ p = g.context;
+ k = c.contextType;
+ "object" === typeof k && null !== k ? k = J(k) : (k = E(c) ? Yb : B.current, k = Zb(b, k));
+ var y = c.getDerivedStateFromProps;
+ (n = "function" === typeof y || "function" === typeof g.getSnapshotBeforeUpdate) || "function" !== typeof g.UNSAFE_componentWillReceiveProps && "function" !== typeof g.componentWillReceiveProps || (h !== t2 || p !== k) && yd(b, g, d, k);
+ hd = false;
+ p = b.memoizedState;
+ g.state = p;
+ od(b, d, g, e2);
+ var x = b.memoizedState;
+ h !== t2 || p !== x || D.current || hd ? ("function" === typeof y && (sd(b, c, y, d), x = b.memoizedState), (l = hd || wd(b, c, l, d, p, x, k)) ? (n || "function" !== typeof g.UNSAFE_componentWillUpdate && "function" !== typeof g.componentWillUpdate || ("function" === typeof g.componentWillUpdate && g.componentWillUpdate(d, x, k), "function" === typeof g.UNSAFE_componentWillUpdate && g.UNSAFE_componentWillUpdate(d, x, k)), "function" === typeof g.componentDidUpdate && (b.flags |= 4), "function" === typeof g.getSnapshotBeforeUpdate && (b.flags |= 256)) : ("function" !== typeof g.componentDidUpdate || h === a.memoizedProps && p === a.memoizedState || (b.flags |= 4), "function" !== typeof g.getSnapshotBeforeUpdate || h === a.memoizedProps && p === a.memoizedState || (b.flags |= 256), b.memoizedProps = d, b.memoizedState = x), g.props = d, g.state = x, g.context = k, d = l) : ("function" !== typeof g.componentDidUpdate || h === a.memoizedProps && p === a.memoizedState || (b.flags |= 4), "function" !== typeof g.getSnapshotBeforeUpdate || h === a.memoizedProps && p === a.memoizedState || (b.flags |= 256), d = false);
+ }
+ return $e(a, b, c, d, f, e2);
+ }
+ __name(Ze, "Ze");
+ function $e(a, b, c, d, e2, f) {
+ Ye(a, b);
+ var g = 0 !== (b.flags & 64);
+ if (!d && !g)
+ return e2 && dc(b, c, false), Re(a, b, f);
+ d = b.stateNode;
+ Oe.current = b;
+ var h = g && "function" !== typeof c.getDerivedStateFromError ? null : d.render();
+ b.flags |= 1;
+ null !== a && g ? (b.child = Jd(b, a.child, null, f), b.child = Jd(b, null, h, f)) : S(a, b, h, f);
+ b.memoizedState = d.state;
+ e2 && dc(b, c, true);
+ return b.child;
+ }
+ __name($e, "$e");
+ function af2(a) {
+ var b = a.stateNode;
+ b.pendingContext ? ac(a, b.pendingContext, b.pendingContext !== b.context) : b.context && ac(a, b.context, false);
+ Pd(a, b.containerInfo);
+ }
+ __name(af2, "af");
+ var bf = { dehydrated: null, retryLane: 0 };
+ function cf(a, b, c) {
+ var d = b.pendingProps, e2 = M.current, f = false, g;
+ (g = 0 !== (b.flags & 64)) || (g = null !== a && null === a.memoizedState ? false : 0 !== (e2 & 2));
+ g ? (f = true, b.flags &= -65) : null !== a && null === a.memoizedState || void 0 === d.fallback || true === d.unstable_avoidThisFallback || (e2 |= 1);
+ A(M, e2 & 1);
+ if (null === a) {
+ void 0 !== d.fallback && $d(b);
+ a = d.children;
+ e2 = d.fallback;
+ if (f)
+ return a = df(b, a, e2, c), b.child.memoizedState = { baseLanes: c }, b.memoizedState = bf, a;
+ if ("number" === typeof d.unstable_expectedLoadTime)
+ return a = df(b, a, e2, c), b.child.memoizedState = { baseLanes: c }, b.memoizedState = bf, b.lanes = 33554432, a;
+ c = ef({ mode: "visible", children: a }, b.mode, c, null);
+ c.return = b;
+ return b.child = c;
+ }
+ if (null !== a.memoizedState) {
+ if (f)
+ return d = ff2(a, b, d.children, d.fallback, c), f = b.child, e2 = a.child.memoizedState, f.memoizedState = null === e2 ? { baseLanes: c } : { baseLanes: e2.baseLanes | c }, f.childLanes = a.childLanes & ~c, b.memoizedState = bf, d;
+ c = gf(a, b, d.children, c);
+ b.memoizedState = null;
+ return c;
+ }
+ if (f)
+ return d = ff2(a, b, d.children, d.fallback, c), f = b.child, e2 = a.child.memoizedState, f.memoizedState = null === e2 ? { baseLanes: c } : { baseLanes: e2.baseLanes | c }, f.childLanes = a.childLanes & ~c, b.memoizedState = bf, d;
+ c = gf(a, b, d.children, c);
+ b.memoizedState = null;
+ return c;
+ }
+ __name(cf, "cf");
+ function df(a, b, c, d) {
+ var e2 = a.mode, f = a.child;
+ b = { mode: "hidden", children: b };
+ 0 === (e2 & 2) && null !== f ? (f.childLanes = 0, f.pendingProps = b) : f = ef(b, e2, 0, null);
+ c = Id(c, e2, d, null);
+ f.return = a;
+ c.return = a;
+ f.sibling = c;
+ a.child = f;
+ return c;
+ }
+ __name(df, "df");
+ function gf(a, b, c, d) {
+ var e2 = a.child;
+ a = e2.sibling;
+ c = Ed(e2, { mode: "visible", children: c });
+ 0 === (b.mode & 2) && (c.lanes = d);
+ c.return = b;
+ c.sibling = null;
+ null !== a && (a.nextEffect = null, a.flags = 8, b.firstEffect = b.lastEffect = a);
+ return b.child = c;
+ }
+ __name(gf, "gf");
+ function ff2(a, b, c, d, e2) {
+ var f = b.mode, g = a.child;
+ a = g.sibling;
+ var h = { mode: "hidden", children: c };
+ 0 === (f & 2) && b.child !== g ? (c = b.child, c.childLanes = 0, c.pendingProps = h, g = c.lastEffect, null !== g ? (b.firstEffect = c.firstEffect, b.lastEffect = g, g.nextEffect = null) : b.firstEffect = b.lastEffect = null) : c = Ed(g, h);
+ null !== a ? d = Ed(a, d) : (d = Id(d, f, e2, null), d.flags |= 2);
+ d.return = b;
+ c.return = b;
+ c.sibling = d;
+ b.child = c;
+ return d;
+ }
+ __name(ff2, "ff");
+ function hf(a, b) {
+ a.lanes |= b;
+ var c = a.alternate;
+ null !== c && (c.lanes |= b);
+ ed(a.return, b);
+ }
+ __name(hf, "hf");
+ function jf(a, b, c, d, e2, f) {
+ var g = a.memoizedState;
+ null === g ? a.memoizedState = { isBackwards: b, rendering: null, renderingStartTime: 0, last: d, tail: c, tailMode: e2, lastEffect: f } : (g.isBackwards = b, g.rendering = null, g.renderingStartTime = 0, g.last = d, g.tail = c, g.tailMode = e2, g.lastEffect = f);
+ }
+ __name(jf, "jf");
+ function kf(a, b, c) {
+ var d = b.pendingProps, e2 = d.revealOrder, f = d.tail;
+ S(a, b, d.children, c);
+ d = M.current;
+ if (0 !== (d & 2))
+ d = d & 1 | 2, b.flags |= 64;
+ else {
+ if (null !== a && 0 !== (a.flags & 64))
+ a:
+ for (a = b.child; null !== a; ) {
+ if (13 === a.tag)
+ null !== a.memoizedState && hf(a, c);
+ else if (19 === a.tag)
+ hf(a, c);
+ else if (null !== a.child) {
+ a.child.return = a;
+ a = a.child;
+ continue;
+ }
+ if (a === b)
+ break a;
+ for (; null === a.sibling; ) {
+ if (null === a.return || a.return === b)
+ break a;
+ a = a.return;
+ }
+ a.sibling.return = a.return;
+ a = a.sibling;
+ }
+ d &= 1;
+ }
+ A(M, d);
+ if (0 === (b.mode & 2))
+ b.memoizedState = null;
+ else
+ switch (e2) {
+ case "forwards":
+ c = b.child;
+ for (e2 = null; null !== c; )
+ a = c.alternate, null !== a && null === Td(a) && (e2 = c), c = c.sibling;
+ c = e2;
+ null === c ? (e2 = b.child, b.child = null) : (e2 = c.sibling, c.sibling = null);
+ jf(b, false, e2, c, f, b.lastEffect);
+ break;
+ case "backwards":
+ c = null;
+ e2 = b.child;
+ for (b.child = null; null !== e2; ) {
+ a = e2.alternate;
+ if (null !== a && null === Td(a)) {
+ b.child = e2;
+ break;
+ }
+ a = e2.sibling;
+ e2.sibling = c;
+ c = e2;
+ e2 = a;
+ }
+ jf(b, true, c, null, f, b.lastEffect);
+ break;
+ case "together":
+ jf(b, false, null, null, void 0, b.lastEffect);
+ break;
+ default:
+ b.memoizedState = null;
+ }
+ return b.child;
+ }
+ __name(kf, "kf");
+ function Re(a, b, c) {
+ null !== a && (b.dependencies = a.dependencies);
+ pd |= b.lanes;
+ if (0 !== (c & b.childLanes)) {
+ if (null !== a && b.child !== a.child)
+ throw Error(q(153));
+ if (null !== b.child) {
+ a = b.child;
+ c = Ed(a, a.pendingProps);
+ b.child = c;
+ for (c.return = b; null !== a.sibling; )
+ a = a.sibling, c = c.sibling = Ed(a, a.pendingProps), c.return = b;
+ c.sibling = null;
+ }
+ return b.child;
+ }
+ return null;
+ }
+ __name(Re, "Re");
+ function lf(a) {
+ a.flags |= 4;
+ }
+ __name(lf, "lf");
+ var mf, nf, of, pf;
+ if (Ta)
+ mf = /* @__PURE__ */ __name(function(a, b) {
+ for (var c = b.child; null !== c; ) {
+ if (5 === c.tag || 6 === c.tag)
+ Ja(a, c.stateNode);
+ else if (4 !== c.tag && null !== c.child) {
+ c.child.return = c;
+ c = c.child;
+ continue;
+ }
+ if (c === b)
+ break;
+ for (; null === c.sibling; ) {
+ if (null === c.return || c.return === b)
+ return;
+ c = c.return;
+ }
+ c.sibling.return = c.return;
+ c = c.sibling;
+ }
+ }, "mf"), nf = /* @__PURE__ */ __name(function() {
+ }, "nf"), of = /* @__PURE__ */ __name(function(a, b, c, d, e2) {
+ a = a.memoizedProps;
+ if (a !== d) {
+ var f = b.stateNode, g = Od(L.current);
+ c = La(f, c, a, d, e2, g);
+ (b.updateQueue = c) && lf(b);
+ }
+ }, "of"), pf = /* @__PURE__ */ __name(function(a, b, c, d) {
+ c !== d && lf(b);
+ }, "pf");
+ else if (Ua) {
+ mf = /* @__PURE__ */ __name(function(a, b, c, d) {
+ for (var e2 = b.child; null !== e2; ) {
+ if (5 === e2.tag) {
+ var f = e2.stateNode;
+ c && d && (f = Db(f, e2.type, e2.memoizedProps, e2));
+ Ja(a, f);
+ } else if (6 === e2.tag)
+ f = e2.stateNode, c && d && (f = Eb(f, e2.memoizedProps, e2)), Ja(a, f);
+ else if (4 !== e2.tag) {
+ if (13 === e2.tag && 0 !== (e2.flags & 4) && (f = null !== e2.memoizedState)) {
+ var g = e2.child;
+ if (null !== g && (null !== g.child && (g.child.return = g, mf(a, g, true, f)), f = g.sibling, null !== f)) {
+ f.return = e2;
+ e2 = f;
+ continue;
+ }
+ }
+ if (null !== e2.child) {
+ e2.child.return = e2;
+ e2 = e2.child;
+ continue;
+ }
+ }
+ if (e2 === b)
+ break;
+ for (; null === e2.sibling; ) {
+ if (null === e2.return || e2.return === b)
+ return;
+ e2 = e2.return;
+ }
+ e2.sibling.return = e2.return;
+ e2 = e2.sibling;
+ }
+ }, "mf");
+ var qf = /* @__PURE__ */ __name(function(a, b, c, d) {
+ for (var e2 = b.child; null !== e2; ) {
+ if (5 === e2.tag) {
+ var f = e2.stateNode;
+ c && d && (f = Db(f, e2.type, e2.memoizedProps, e2));
+ Ab(a, f);
+ } else if (6 === e2.tag)
+ f = e2.stateNode, c && d && (f = Eb(f, e2.memoizedProps, e2)), Ab(a, f);
+ else if (4 !== e2.tag) {
+ if (13 === e2.tag && 0 !== (e2.flags & 4) && (f = null !== e2.memoizedState)) {
+ var g = e2.child;
+ if (null !== g && (null !== g.child && (g.child.return = g, qf(a, g, true, f)), f = g.sibling, null !== f)) {
+ f.return = e2;
+ e2 = f;
+ continue;
+ }
+ }
+ if (null !== e2.child) {
+ e2.child.return = e2;
+ e2 = e2.child;
+ continue;
+ }
+ }
+ if (e2 === b)
+ break;
+ for (; null === e2.sibling; ) {
+ if (null === e2.return || e2.return === b)
+ return;
+ e2 = e2.return;
+ }
+ e2.sibling.return = e2.return;
+ e2 = e2.sibling;
+ }
+ }, "qf");
+ nf = /* @__PURE__ */ __name(function(a) {
+ var b = a.stateNode;
+ if (null !== a.firstEffect) {
+ var c = b.containerInfo, d = zb(c);
+ qf(d, a, false, false);
+ b.pendingChildren = d;
+ lf(a);
+ Bb(c, d);
+ }
+ }, "nf");
+ of = /* @__PURE__ */ __name(function(a, b, c, d, e2) {
+ var f = a.stateNode, g = a.memoizedProps;
+ if ((a = null === b.firstEffect) && g === d)
+ b.stateNode = f;
+ else {
+ var h = b.stateNode, k = Od(L.current), l = null;
+ g !== d && (l = La(h, c, g, d, e2, k));
+ a && null === l ? b.stateNode = f : (f = yb(
+ f,
+ l,
+ c,
+ g,
+ d,
+ b,
+ a,
+ h
+ ), Ka(f, c, d, e2, k) && lf(b), b.stateNode = f, a ? lf(b) : mf(f, b, false, false));
+ }
+ }, "of");
+ pf = /* @__PURE__ */ __name(function(a, b, c, d) {
+ c !== d ? (a = Od(Nd.current), c = Od(L.current), b.stateNode = Na(d, a, c, b), lf(b)) : b.stateNode = a.stateNode;
+ }, "pf");
+ } else
+ nf = /* @__PURE__ */ __name(function() {
+ }, "nf"), of = /* @__PURE__ */ __name(function() {
+ }, "of"), pf = /* @__PURE__ */ __name(function() {
+ }, "pf");
+ function rf(a, b) {
+ if (!Wd)
+ switch (a.tailMode) {
+ case "hidden":
+ b = a.tail;
+ for (var c = null; null !== b; )
+ null !== b.alternate && (c = b), b = b.sibling;
+ null === c ? a.tail = null : c.sibling = null;
+ break;
+ case "collapsed":
+ c = a.tail;
+ for (var d = null; null !== c; )
+ null !== c.alternate && (d = c), c = c.sibling;
+ null === d ? b || null === a.tail ? a.tail = null : a.tail.sibling = null : d.sibling = null;
+ }
+ }
+ __name(rf, "rf");
+ function sf(a, b, c) {
+ var d = b.pendingProps;
+ switch (b.tag) {
+ case 2:
+ case 16:
+ case 15:
+ case 0:
+ case 11:
+ case 7:
+ case 8:
+ case 12:
+ case 9:
+ case 14:
+ return null;
+ case 1:
+ return E(b.type) && $b(), null;
+ case 3:
+ Qd();
+ z(D);
+ z(B);
+ ee();
+ d = b.stateNode;
+ d.pendingContext && (d.context = d.pendingContext, d.pendingContext = null);
+ if (null === a || null === a.child)
+ be2(b) ? lf(b) : d.hydrate || (b.flags |= 256);
+ nf(b);
+ return null;
+ case 5:
+ Sd(b);
+ var e2 = Od(Nd.current);
+ c = b.type;
+ if (null !== a && null != b.stateNode)
+ of(a, b, c, d, e2), a.ref !== b.ref && (b.flags |= 128);
+ else {
+ if (!d) {
+ if (null === b.stateNode)
+ throw Error(q(166));
+ return null;
+ }
+ a = Od(L.current);
+ if (be2(b)) {
+ if (!Va)
+ throw Error(q(175));
+ a = Lb(b.stateNode, b.type, b.memoizedProps, e2, a, b);
+ b.updateQueue = a;
+ null !== a && lf(b);
+ } else {
+ var f = Ia(c, d, e2, a, b);
+ mf(f, b, false, false);
+ b.stateNode = f;
+ Ka(f, c, d, e2, a) && lf(b);
+ }
+ null !== b.ref && (b.flags |= 128);
+ }
+ return null;
+ case 6:
+ if (a && null != b.stateNode)
+ pf(a, b, a.memoizedProps, d);
+ else {
+ if ("string" !== typeof d && null === b.stateNode)
+ throw Error(q(166));
+ a = Od(Nd.current);
+ e2 = Od(L.current);
+ if (be2(b)) {
+ if (!Va)
+ throw Error(q(176));
+ Mb(
+ b.stateNode,
+ b.memoizedProps,
+ b
+ ) && lf(b);
+ } else
+ b.stateNode = Na(d, a, e2, b);
+ }
+ return null;
+ case 13:
+ z(M);
+ d = b.memoizedState;
+ if (0 !== (b.flags & 64))
+ return b.lanes = c, b;
+ d = null !== d;
+ e2 = false;
+ null === a ? void 0 !== b.memoizedProps.fallback && be2(b) : e2 = null !== a.memoizedState;
+ if (d && !e2 && 0 !== (b.mode & 2))
+ if (null === a && true !== b.memoizedProps.unstable_avoidThisFallback || 0 !== (M.current & 1))
+ 0 === T && (T = 3);
+ else {
+ if (0 === T || 3 === T)
+ T = 4;
+ null === R || 0 === (pd & 134217727) && 0 === (tf & 134217727) || uf(R, U);
+ }
+ Ua && d && (b.flags |= 4);
+ Ta && (d || e2) && (b.flags |= 4);
+ return null;
+ case 4:
+ return Qd(), nf(b), null === a && ab(b.stateNode.containerInfo), null;
+ case 10:
+ return dd(b), null;
+ case 17:
+ return E(b.type) && $b(), null;
+ case 19:
+ z(M);
+ d = b.memoizedState;
+ if (null === d)
+ return null;
+ e2 = 0 !== (b.flags & 64);
+ f = d.rendering;
+ if (null === f)
+ if (e2)
+ rf(d, false);
+ else {
+ if (0 !== T || null !== a && 0 !== (a.flags & 64))
+ for (a = b.child; null !== a; ) {
+ f = Td(a);
+ if (null !== f) {
+ b.flags |= 64;
+ rf(d, false);
+ a = f.updateQueue;
+ null !== a && (b.updateQueue = a, b.flags |= 4);
+ null === d.lastEffect && (b.firstEffect = null);
+ b.lastEffect = d.lastEffect;
+ a = c;
+ for (d = b.child; null !== d; )
+ e2 = d, c = a, e2.flags &= 2, e2.nextEffect = null, e2.firstEffect = null, e2.lastEffect = null, f = e2.alternate, null === f ? (e2.childLanes = 0, e2.lanes = c, e2.child = null, e2.memoizedProps = null, e2.memoizedState = null, e2.updateQueue = null, e2.dependencies = null, e2.stateNode = null) : (e2.childLanes = f.childLanes, e2.lanes = f.lanes, e2.child = f.child, e2.memoizedProps = f.memoizedProps, e2.memoizedState = f.memoizedState, e2.updateQueue = f.updateQueue, e2.type = f.type, c = f.dependencies, e2.dependencies = null === c ? null : { lanes: c.lanes, firstContext: c.firstContext }), d = d.sibling;
+ A(M, M.current & 1 | 2);
+ return b.child;
+ }
+ a = a.sibling;
+ }
+ null !== d.tail && G() > vf && (b.flags |= 64, e2 = true, rf(d, false), b.lanes = 33554432);
+ }
+ else {
+ if (!e2)
+ if (a = Td(f), null !== a) {
+ if (b.flags |= 64, e2 = true, a = a.updateQueue, null !== a && (b.updateQueue = a, b.flags |= 4), rf(d, true), null === d.tail && "hidden" === d.tailMode && !f.alternate && !Wd)
+ return b = b.lastEffect = d.lastEffect, null !== b && (b.nextEffect = null), null;
+ } else
+ 2 * G() - d.renderingStartTime > vf && 1073741824 !== c && (b.flags |= 64, e2 = true, rf(d, false), b.lanes = 33554432);
+ d.isBackwards ? (f.sibling = b.child, b.child = f) : (a = d.last, null !== a ? a.sibling = f : b.child = f, d.last = f);
+ }
+ return null !== d.tail ? (a = d.tail, d.rendering = a, d.tail = a.sibling, d.lastEffect = b.lastEffect, d.renderingStartTime = G(), a.sibling = null, b = M.current, A(M, e2 ? b & 1 | 2 : b & 1), a) : null;
+ case 23:
+ case 24:
+ return wf(), null !== a && null !== a.memoizedState !== (null !== b.memoizedState) && "unstable-defer-without-hiding" !== d.mode && (b.flags |= 4), null;
+ }
+ throw Error(q(156, b.tag));
+ }
+ __name(sf, "sf");
+ function xf(a) {
+ switch (a.tag) {
+ case 1:
+ E(a.type) && $b();
+ var b = a.flags;
+ return b & 4096 ? (a.flags = b & -4097 | 64, a) : null;
+ case 3:
+ Qd();
+ z(D);
+ z(B);
+ ee();
+ b = a.flags;
+ if (0 !== (b & 64))
+ throw Error(q(285));
+ a.flags = b & -4097 | 64;
+ return a;
+ case 5:
+ return Sd(a), null;
+ case 13:
+ return z(M), b = a.flags, b & 4096 ? (a.flags = b & -4097 | 64, a) : null;
+ case 19:
+ return z(M), null;
+ case 4:
+ return Qd(), null;
+ case 10:
+ return dd(a), null;
+ case 23:
+ case 24:
+ return wf(), null;
+ default:
+ return null;
+ }
+ }
+ __name(xf, "xf");
+ function yf(a, b) {
+ try {
+ var c = "", d = b;
+ do
+ c += Wc(d), d = d.return;
+ while (d);
+ var e2 = c;
+ } catch (f) {
+ e2 = "\nError generating stack: " + f.message + "\n" + f.stack;
+ }
+ return { value: a, source: b, stack: e2 };
+ }
+ __name(yf, "yf");
+ function zf(a, b) {
+ try {
+ console.error(b.value);
+ } catch (c) {
+ setTimeout(function() {
+ throw c;
+ });
+ }
+ }
+ __name(zf, "zf");
+ var Af = "function" === typeof WeakMap ? WeakMap : Map;
+ function Bf(a, b, c) {
+ c = kd(-1, c);
+ c.tag = 3;
+ c.payload = { element: null };
+ var d = b.value;
+ c.callback = function() {
+ Cf || (Cf = true, Df = d);
+ zf(a, b);
+ };
+ return c;
+ }
+ __name(Bf, "Bf");
+ function Ef(a, b, c) {
+ c = kd(-1, c);
+ c.tag = 3;
+ var d = a.type.getDerivedStateFromError;
+ if ("function" === typeof d) {
+ var e2 = b.value;
+ c.payload = function() {
+ zf(a, b);
+ return d(e2);
+ };
+ }
+ var f = a.stateNode;
+ null !== f && "function" === typeof f.componentDidCatch && (c.callback = function() {
+ "function" !== typeof d && (null === Ff ? Ff = /* @__PURE__ */ new Set([this]) : Ff.add(this), zf(a, b));
+ var c2 = b.stack;
+ this.componentDidCatch(b.value, { componentStack: null !== c2 ? c2 : "" });
+ });
+ return c;
+ }
+ __name(Ef, "Ef");
+ var Gf = "function" === typeof WeakSet ? WeakSet : Set;
+ function Hf(a) {
+ var b = a.ref;
+ if (null !== b)
+ if ("function" === typeof b)
+ try {
+ b(null);
+ } catch (c) {
+ If(a, c);
+ }
+ else
+ b.current = null;
+ }
+ __name(Hf, "Hf");
+ function Jf(a, b) {
+ switch (b.tag) {
+ case 0:
+ case 11:
+ case 15:
+ case 22:
+ return;
+ case 1:
+ if (b.flags & 256 && null !== a) {
+ var c = a.memoizedProps, d = a.memoizedState;
+ a = b.stateNode;
+ b = a.getSnapshotBeforeUpdate(b.elementType === b.type ? c : Xc(b.type, c), d);
+ a.__reactInternalSnapshotBeforeUpdate = b;
+ }
+ return;
+ case 3:
+ Ta && b.flags & 256 && xb(b.stateNode.containerInfo);
+ return;
+ case 5:
+ case 6:
+ case 4:
+ case 17:
+ return;
+ }
+ throw Error(q(163));
+ }
+ __name(Jf, "Jf");
+ function Kf(a, b) {
+ b = b.updateQueue;
+ b = null !== b ? b.lastEffect : null;
+ if (null !== b) {
+ var c = b = b.next;
+ do {
+ if ((c.tag & a) === a) {
+ var d = c.destroy;
+ c.destroy = void 0;
+ void 0 !== d && d();
+ }
+ c = c.next;
+ } while (c !== b);
+ }
+ }
+ __name(Kf, "Kf");
+ function Lf(a, b, c) {
+ switch (c.tag) {
+ case 0:
+ case 11:
+ case 15:
+ case 22:
+ b = c.updateQueue;
+ b = null !== b ? b.lastEffect : null;
+ if (null !== b) {
+ a = b = b.next;
+ do {
+ if (3 === (a.tag & 3)) {
+ var d = a.create;
+ a.destroy = d();
+ }
+ a = a.next;
+ } while (a !== b);
+ }
+ b = c.updateQueue;
+ b = null !== b ? b.lastEffect : null;
+ if (null !== b) {
+ a = b = b.next;
+ do {
+ var e2 = a;
+ d = e2.next;
+ e2 = e2.tag;
+ 0 !== (e2 & 4) && 0 !== (e2 & 1) && (Mf(c, a), Nf(c, a));
+ a = d;
+ } while (a !== b);
+ }
+ return;
+ case 1:
+ a = c.stateNode;
+ c.flags & 4 && (null === b ? a.componentDidMount() : (d = c.elementType === c.type ? b.memoizedProps : Xc(c.type, b.memoizedProps), a.componentDidUpdate(
+ d,
+ b.memoizedState,
+ a.__reactInternalSnapshotBeforeUpdate
+ )));
+ b = c.updateQueue;
+ null !== b && qd(c, b, a);
+ return;
+ case 3:
+ b = c.updateQueue;
+ if (null !== b) {
+ a = null;
+ if (null !== c.child)
+ switch (c.child.tag) {
+ case 5:
+ a = Da(c.child.stateNode);
+ break;
+ case 1:
+ a = c.child.stateNode;
+ }
+ qd(c, b, a);
+ }
+ return;
+ case 5:
+ a = c.stateNode;
+ null === b && c.flags & 4 && mb(a, c.type, c.memoizedProps, c);
+ return;
+ case 6:
+ return;
+ case 4:
+ return;
+ case 12:
+ return;
+ case 13:
+ Va && null === c.memoizedState && (c = c.alternate, null !== c && (c = c.memoizedState, null !== c && (c = c.dehydrated, null !== c && Pb(c))));
+ return;
+ case 19:
+ case 17:
+ case 20:
+ case 21:
+ case 23:
+ case 24:
+ return;
+ }
+ throw Error(q(163));
+ }
+ __name(Lf, "Lf");
+ function Of(a, b) {
+ if (Ta)
+ for (var c = a; ; ) {
+ if (5 === c.tag) {
+ var d = c.stateNode;
+ b ? tb(d) : vb(c.stateNode, c.memoizedProps);
+ } else if (6 === c.tag)
+ d = c.stateNode, b ? ub(d) : wb(d, c.memoizedProps);
+ else if ((23 !== c.tag && 24 !== c.tag || null === c.memoizedState || c === a) && null !== c.child) {
+ c.child.return = c;
+ c = c.child;
+ continue;
+ }
+ if (c === a)
+ break;
+ for (; null === c.sibling; ) {
+ if (null === c.return || c.return === a)
+ return;
+ c = c.return;
+ }
+ c.sibling.return = c.return;
+ c = c.sibling;
+ }
+ }
+ __name(Of, "Of");
+ function Pf(a, b) {
+ if (fc && "function" === typeof fc.onCommitFiberUnmount)
+ try {
+ fc.onCommitFiberUnmount(ec, b);
+ } catch (f) {
+ }
+ switch (b.tag) {
+ case 0:
+ case 11:
+ case 14:
+ case 15:
+ case 22:
+ a = b.updateQueue;
+ if (null !== a && (a = a.lastEffect, null !== a)) {
+ var c = a = a.next;
+ do {
+ var d = c, e2 = d.destroy;
+ d = d.tag;
+ if (void 0 !== e2)
+ if (0 !== (d & 4))
+ Mf(b, c);
+ else {
+ d = b;
+ try {
+ e2();
+ } catch (f) {
+ If(d, f);
+ }
+ }
+ c = c.next;
+ } while (c !== a);
+ }
+ break;
+ case 1:
+ Hf(b);
+ a = b.stateNode;
+ if ("function" === typeof a.componentWillUnmount)
+ try {
+ a.props = b.memoizedProps, a.state = b.memoizedState, a.componentWillUnmount();
+ } catch (f) {
+ If(
+ b,
+ f
+ );
+ }
+ break;
+ case 5:
+ Hf(b);
+ break;
+ case 4:
+ Ta ? Qf(a, b) : Ua && Ua && (b = b.stateNode.containerInfo, a = zb(b), Cb(b, a));
+ }
+ }
+ __name(Pf, "Pf");
+ function Rf(a, b) {
+ for (var c = b; ; )
+ if (Pf(a, c), null === c.child || Ta && 4 === c.tag) {
+ if (c === b)
+ break;
+ for (; null === c.sibling; ) {
+ if (null === c.return || c.return === b)
+ return;
+ c = c.return;
+ }
+ c.sibling.return = c.return;
+ c = c.sibling;
+ } else
+ c.child.return = c, c = c.child;
+ }
+ __name(Rf, "Rf");
+ function Sf(a) {
+ a.alternate = null;
+ a.child = null;
+ a.dependencies = null;
+ a.firstEffect = null;
+ a.lastEffect = null;
+ a.memoizedProps = null;
+ a.memoizedState = null;
+ a.pendingProps = null;
+ a.return = null;
+ a.updateQueue = null;
+ }
+ __name(Sf, "Sf");
+ function Tf(a) {
+ return 5 === a.tag || 3 === a.tag || 4 === a.tag;
+ }
+ __name(Tf, "Tf");
+ function Uf(a) {
+ if (Ta) {
+ a: {
+ for (var b = a.return; null !== b; ) {
+ if (Tf(b))
+ break a;
+ b = b.return;
+ }
+ throw Error(q(160));
+ }
+ var c = b;
+ b = c.stateNode;
+ switch (c.tag) {
+ case 5:
+ var d = false;
+ break;
+ case 3:
+ b = b.containerInfo;
+ d = true;
+ break;
+ case 4:
+ b = b.containerInfo;
+ d = true;
+ break;
+ default:
+ throw Error(q(161));
+ }
+ c.flags & 16 && (sb(b), c.flags &= -17);
+ a:
+ b:
+ for (c = a; ; ) {
+ for (; null === c.sibling; ) {
+ if (null === c.return || Tf(c.return)) {
+ c = null;
+ break a;
+ }
+ c = c.return;
+ }
+ c.sibling.return = c.return;
+ for (c = c.sibling; 5 !== c.tag && 6 !== c.tag && 18 !== c.tag; ) {
+ if (c.flags & 2)
+ continue b;
+ if (null === c.child || 4 === c.tag)
+ continue b;
+ else
+ c.child.return = c, c = c.child;
+ }
+ if (!(c.flags & 2)) {
+ c = c.stateNode;
+ break a;
+ }
+ }
+ d ? Vf(a, c, b) : Wf(a, c, b);
+ }
+ }
+ __name(Uf, "Uf");
+ function Vf(a, b, c) {
+ var d = a.tag, e2 = 5 === d || 6 === d;
+ if (e2)
+ a = e2 ? a.stateNode : a.stateNode.instance, b ? pb(c, a, b) : kb(c, a);
+ else if (4 !== d && (a = a.child, null !== a))
+ for (Vf(a, b, c), a = a.sibling; null !== a; )
+ Vf(a, b, c), a = a.sibling;
+ }
+ __name(Vf, "Vf");
+ function Wf(a, b, c) {
+ var d = a.tag, e2 = 5 === d || 6 === d;
+ if (e2)
+ a = e2 ? a.stateNode : a.stateNode.instance, b ? ob(c, a, b) : jb(c, a);
+ else if (4 !== d && (a = a.child, null !== a))
+ for (Wf(a, b, c), a = a.sibling; null !== a; )
+ Wf(a, b, c), a = a.sibling;
+ }
+ __name(Wf, "Wf");
+ function Qf(a, b) {
+ for (var c = b, d = false, e2, f; ; ) {
+ if (!d) {
+ d = c.return;
+ a:
+ for (; ; ) {
+ if (null === d)
+ throw Error(q(160));
+ e2 = d.stateNode;
+ switch (d.tag) {
+ case 5:
+ f = false;
+ break a;
+ case 3:
+ e2 = e2.containerInfo;
+ f = true;
+ break a;
+ case 4:
+ e2 = e2.containerInfo;
+ f = true;
+ break a;
+ }
+ d = d.return;
+ }
+ d = true;
+ }
+ if (5 === c.tag || 6 === c.tag)
+ Rf(a, c), f ? rb(e2, c.stateNode) : qb(e2, c.stateNode);
+ else if (4 === c.tag) {
+ if (null !== c.child) {
+ e2 = c.stateNode.containerInfo;
+ f = true;
+ c.child.return = c;
+ c = c.child;
+ continue;
+ }
+ } else if (Pf(a, c), null !== c.child) {
+ c.child.return = c;
+ c = c.child;
+ continue;
+ }
+ if (c === b)
+ break;
+ for (; null === c.sibling; ) {
+ if (null === c.return || c.return === b)
+ return;
+ c = c.return;
+ 4 === c.tag && (d = false);
+ }
+ c.sibling.return = c.return;
+ c = c.sibling;
+ }
+ }
+ __name(Qf, "Qf");
+ function Xf(a, b) {
+ if (Ta) {
+ switch (b.tag) {
+ case 0:
+ case 11:
+ case 14:
+ case 15:
+ case 22:
+ Kf(3, b);
+ return;
+ case 1:
+ return;
+ case 5:
+ var c = b.stateNode;
+ if (null != c) {
+ var d = b.memoizedProps;
+ a = null !== a ? a.memoizedProps : d;
+ var e2 = b.type, f = b.updateQueue;
+ b.updateQueue = null;
+ null !== f && nb(c, f, e2, a, d, b);
+ }
+ return;
+ case 6:
+ if (null === b.stateNode)
+ throw Error(q(162));
+ c = b.memoizedProps;
+ lb(b.stateNode, null !== a ? a.memoizedProps : c, c);
+ return;
+ case 3:
+ Va && (b = b.stateNode, b.hydrate && (b.hydrate = false, Ob(b.containerInfo)));
+ return;
+ case 12:
+ return;
+ case 13:
+ Yf(b);
+ Zf(b);
+ return;
+ case 19:
+ Zf(b);
+ return;
+ case 17:
+ return;
+ case 23:
+ case 24:
+ Of(b, null !== b.memoizedState);
+ return;
+ }
+ throw Error(q(163));
+ }
+ switch (b.tag) {
+ case 0:
+ case 11:
+ case 14:
+ case 15:
+ case 22:
+ Kf(3, b);
+ return;
+ case 12:
+ return;
+ case 13:
+ Yf(b);
+ Zf(b);
+ return;
+ case 19:
+ Zf(b);
+ return;
+ case 3:
+ Va && (c = b.stateNode, c.hydrate && (c.hydrate = false, Ob(c.containerInfo)));
+ break;
+ case 23:
+ case 24:
+ return;
+ }
+ a:
+ if (Ua) {
+ switch (b.tag) {
+ case 1:
+ case 5:
+ case 6:
+ case 20:
+ break a;
+ case 3:
+ case 4:
+ b = b.stateNode;
+ Cb(b.containerInfo, b.pendingChildren);
+ break a;
+ }
+ throw Error(q(163));
+ }
+ }
+ __name(Xf, "Xf");
+ function Yf(a) {
+ null !== a.memoizedState && ($f = G(), Ta && Of(a.child, true));
+ }
+ __name(Yf, "Yf");
+ function Zf(a) {
+ var b = a.updateQueue;
+ if (null !== b) {
+ a.updateQueue = null;
+ var c = a.stateNode;
+ null === c && (c = a.stateNode = new Gf());
+ b.forEach(function(b2) {
+ var d = ag.bind(null, a, b2);
+ c.has(b2) || (c.add(b2), b2.then(d, d));
+ });
+ }
+ }
+ __name(Zf, "Zf");
+ function bg(a, b) {
+ return null !== a && (a = a.memoizedState, null === a || null !== a.dehydrated) ? (b = b.memoizedState, null !== b && null === b.dehydrated) : false;
+ }
+ __name(bg, "bg");
+ var cg = 0, dg = 1, eg = 2, fg = 3, gg = 4;
+ if ("function" === typeof Symbol && Symbol.for) {
+ var hg = Symbol.for;
+ cg = hg("selector.component");
+ dg = hg("selector.has_pseudo_class");
+ eg = hg("selector.role");
+ fg = hg("selector.test_id");
+ gg = hg("selector.text");
+ }
+ function ig(a) {
+ var b = Wa(a);
+ if (null != b) {
+ if ("string" !== typeof b.memoizedProps["data-testname"])
+ throw Error(q(364));
+ return b;
+ }
+ a = cb(a);
+ if (null === a)
+ throw Error(q(362));
+ return a.stateNode.current;
+ }
+ __name(ig, "ig");
+ function jg(a, b) {
+ switch (b.$$typeof) {
+ case cg:
+ if (a.type === b.value)
+ return true;
+ break;
+ case dg:
+ a: {
+ b = b.value;
+ a = [a, 0];
+ for (var c = 0; c < a.length; ) {
+ var d = a[c++], e2 = a[c++], f = b[e2];
+ if (5 !== d.tag || !fb(d)) {
+ for (; null != f && jg(d, f); )
+ e2++, f = b[e2];
+ if (e2 === b.length) {
+ b = true;
+ break a;
+ } else
+ for (d = d.child; null !== d; )
+ a.push(d, e2), d = d.sibling;
+ }
+ }
+ b = false;
+ }
+ return b;
+ case eg:
+ if (5 === a.tag && gb(a.stateNode, b.value))
+ return true;
+ break;
+ case gg:
+ if (5 === a.tag || 6 === a.tag) {
+ if (a = eb(a), null !== a && 0 <= a.indexOf(b.value))
+ return true;
+ }
+ break;
+ case fg:
+ if (5 === a.tag && (a = a.memoizedProps["data-testname"], "string" === typeof a && a.toLowerCase() === b.value.toLowerCase()))
+ return true;
+ break;
+ default:
+ throw Error(q(365, b));
+ }
+ return false;
+ }
+ __name(jg, "jg");
+ function kg(a) {
+ switch (a.$$typeof) {
+ case cg:
+ return "<" + (wa(a.value) || "Unknown") + ">";
+ case dg:
+ return ":has(" + (kg(a) || "") + ")";
+ case eg:
+ return '[role="' + a.value + '"]';
+ case gg:
+ return '"' + a.value + '"';
+ case fg:
+ return '[data-testname="' + a.value + '"]';
+ default:
+ throw Error(q(365, a));
+ }
+ }
+ __name(kg, "kg");
+ function lg(a, b) {
+ var c = [];
+ a = [a, 0];
+ for (var d = 0; d < a.length; ) {
+ var e2 = a[d++], f = a[d++], g = b[f];
+ if (5 !== e2.tag || !fb(e2)) {
+ for (; null != g && jg(e2, g); )
+ f++, g = b[f];
+ if (f === b.length)
+ c.push(e2);
+ else
+ for (e2 = e2.child; null !== e2; )
+ a.push(e2, f), e2 = e2.sibling;
+ }
+ }
+ return c;
+ }
+ __name(lg, "lg");
+ function mg(a, b) {
+ if (!bb)
+ throw Error(q(363));
+ a = ig(a);
+ a = lg(a, b);
+ b = [];
+ a = Array.from(a);
+ for (var c = 0; c < a.length; ) {
+ var d = a[c++];
+ if (5 === d.tag)
+ fb(d) || b.push(d.stateNode);
+ else
+ for (d = d.child; null !== d; )
+ a.push(d), d = d.sibling;
+ }
+ return b;
+ }
+ __name(mg, "mg");
+ var ng = null;
+ function og(a) {
+ if (null === ng)
+ try {
+ var b = ("require" + Math.random()).slice(0, 7);
+ ng = (module2 && module2[b]).call(module2, "timers").setImmediate;
+ } catch (c) {
+ ng = /* @__PURE__ */ __name(function(a2) {
+ var b2 = new MessageChannel();
+ b2.port1.onmessage = a2;
+ b2.port2.postMessage(void 0);
+ }, "ng");
+ }
+ return ng(a);
+ }
+ __name(og, "og");
+ var pg = Math.ceil, qg = ca.ReactCurrentDispatcher, rg = ca.ReactCurrentOwner, sg = ca.IsSomeRendererActing, V = 0, R = null, W = null, U = 0, tg = 0, ug = Wb(0), T = 0, vg = null, wg = 0, pd = 0, tf = 0, xg = 0, yg = null, $f = 0, vf = Infinity;
+ function zg() {
+ vf = G() + 500;
+ }
+ __name(zg, "zg");
+ var X = null, Cf = false, Df = null, Ff = null, Ag = false, Bg = null, Cg = 90, Dg = [], Eg = [], Fg = null, Gg = 0, Hg = null, Ig = -1, Jg = 0, Kg = 0, Lg = null, Mg = false;
+ function K() {
+ return 0 !== (V & 48) ? G() : -1 !== Ig ? Ig : Ig = G();
+ }
+ __name(K, "K");
+ function td(a) {
+ a = a.mode;
+ if (0 === (a & 2))
+ return 1;
+ if (0 === (a & 4))
+ return 99 === Nc() ? 1 : 2;
+ 0 === Jg && (Jg = wg);
+ if (0 !== Sc.transition) {
+ 0 !== Kg && (Kg = null !== yg ? yg.pendingLanes : 0);
+ a = Jg;
+ var b = 4186112 & ~Kg;
+ b &= -b;
+ 0 === b && (a = 4186112 & ~a, b = a & -a, 0 === b && (b = 8192));
+ return b;
+ }
+ a = Nc();
+ 0 !== (V & 4) && 98 === a ? a = oc(12, Jg) : (a = jc(a), a = oc(a, Jg));
+ return a;
+ }
+ __name(td, "td");
+ function ud(a, b, c) {
+ if (50 < Gg)
+ throw Gg = 0, Hg = null, Error(q(185));
+ a = Ng(a, b);
+ if (null === a)
+ return null;
+ rc(a, b, c);
+ a === R && (tf |= b, 4 === T && uf(a, U));
+ var d = Nc();
+ 1 === b ? 0 !== (V & 8) && 0 === (V & 48) ? Og(a) : (Z(a, c), 0 === V && (zg(), H())) : (0 === (V & 4) || 98 !== d && 99 !== d || (null === Fg ? Fg = /* @__PURE__ */ new Set([a]) : Fg.add(a)), Z(a, c));
+ yg = a;
+ }
+ __name(ud, "ud");
+ function Ng(a, b) {
+ a.lanes |= b;
+ var c = a.alternate;
+ null !== c && (c.lanes |= b);
+ c = a;
+ for (a = a.return; null !== a; )
+ a.childLanes |= b, c = a.alternate, null !== c && (c.childLanes |= b), c = a, a = a.return;
+ return 3 === c.tag ? c.stateNode : null;
+ }
+ __name(Ng, "Ng");
+ function Z(a, b) {
+ for (var c = a.callbackNode, d = a.suspendedLanes, e2 = a.pingedLanes, f = a.expirationTimes, g = a.pendingLanes; 0 < g; ) {
+ var h = 31 - mc(g), k = 1 << h, l = f[h];
+ if (-1 === l) {
+ if (0 === (k & d) || 0 !== (k & e2)) {
+ l = b;
+ ic(k);
+ var n = F;
+ f[h] = 10 <= n ? l + 250 : 6 <= n ? l + 5e3 : -1;
+ }
+ } else
+ l <= b && (a.expiredLanes |= k);
+ g &= ~k;
+ }
+ d = lc(a, a === R ? U : 0);
+ b = F;
+ if (0 === d)
+ null !== c && (c !== Hc && xc(c), a.callbackNode = null, a.callbackPriority = 0);
+ else {
+ if (null !== c) {
+ if (a.callbackPriority === b)
+ return;
+ c !== Hc && xc(c);
+ }
+ 15 === b ? (c = Og.bind(null, a), null === Jc ? (Jc = [c], Kc = wc(Cc, Rc)) : Jc.push(c), c = Hc) : 14 === b ? c = Qc(99, Og.bind(null, a)) : (c = kc(b), c = Qc(c, Pg.bind(null, a)));
+ a.callbackPriority = b;
+ a.callbackNode = c;
+ }
+ }
+ __name(Z, "Z");
+ function Pg(a) {
+ Ig = -1;
+ Kg = Jg = 0;
+ if (0 !== (V & 48))
+ throw Error(q(327));
+ var b = a.callbackNode;
+ if (Qg() && a.callbackNode !== b)
+ return null;
+ var c = lc(a, a === R ? U : 0);
+ if (0 === c)
+ return null;
+ var d = c;
+ var e2 = V;
+ V |= 16;
+ var f = Rg();
+ if (R !== a || U !== d)
+ zg(), Sg(a, d);
+ do
+ try {
+ Tg();
+ break;
+ } catch (h) {
+ Ug(a, h);
+ }
+ while (1);
+ bd();
+ qg.current = f;
+ V = e2;
+ null !== W ? d = 0 : (R = null, U = 0, d = T);
+ if (0 !== (wg & tf))
+ Sg(a, 0);
+ else if (0 !== d) {
+ 2 === d && (V |= 64, a.hydrate && (a.hydrate = false, xb(a.containerInfo)), c = nc(a), 0 !== c && (d = Vg(a, c)));
+ if (1 === d)
+ throw b = vg, Sg(a, 0), uf(a, c), Z(a, G()), b;
+ a.finishedWork = a.current.alternate;
+ a.finishedLanes = c;
+ switch (d) {
+ case 0:
+ case 1:
+ throw Error(q(345));
+ case 2:
+ Zg(a);
+ break;
+ case 3:
+ uf(a, c);
+ if ((c & 62914560) === c && (d = $f + 500 - G(), 10 < d)) {
+ if (0 !== lc(a, 0))
+ break;
+ e2 = a.suspendedLanes;
+ if ((e2 & c) !== c) {
+ K();
+ a.pingedLanes |= a.suspendedLanes & e2;
+ break;
+ }
+ a.timeoutHandle = Pa(Zg.bind(null, a), d);
+ break;
+ }
+ Zg(a);
+ break;
+ case 4:
+ uf(a, c);
+ if ((c & 4186112) === c)
+ break;
+ d = a.eventTimes;
+ for (e2 = -1; 0 < c; ) {
+ var g = 31 - mc(c);
+ f = 1 << g;
+ g = d[g];
+ g > e2 && (e2 = g);
+ c &= ~f;
+ }
+ c = e2;
+ c = G() - c;
+ c = (120 > c ? 120 : 480 > c ? 480 : 1080 > c ? 1080 : 1920 > c ? 1920 : 3e3 > c ? 3e3 : 4320 > c ? 4320 : 1960 * pg(c / 1960)) - c;
+ if (10 < c) {
+ a.timeoutHandle = Pa(Zg.bind(null, a), c);
+ break;
+ }
+ Zg(a);
+ break;
+ case 5:
+ Zg(a);
+ break;
+ default:
+ throw Error(q(329));
+ }
+ }
+ Z(a, G());
+ return a.callbackNode === b ? Pg.bind(null, a) : null;
+ }
+ __name(Pg, "Pg");
+ function uf(a, b) {
+ b &= ~xg;
+ b &= ~tf;
+ a.suspendedLanes |= b;
+ a.pingedLanes &= ~b;
+ for (a = a.expirationTimes; 0 < b; ) {
+ var c = 31 - mc(b), d = 1 << c;
+ a[c] = -1;
+ b &= ~d;
+ }
+ }
+ __name(uf, "uf");
+ function Og(a) {
+ if (0 !== (V & 48))
+ throw Error(q(327));
+ Qg();
+ if (a === R && 0 !== (a.expiredLanes & U)) {
+ var b = U;
+ var c = Vg(a, b);
+ 0 !== (wg & tf) && (b = lc(a, b), c = Vg(a, b));
+ } else
+ b = lc(a, 0), c = Vg(a, b);
+ 0 !== a.tag && 2 === c && (V |= 64, a.hydrate && (a.hydrate = false, xb(a.containerInfo)), b = nc(a), 0 !== b && (c = Vg(a, b)));
+ if (1 === c)
+ throw c = vg, Sg(a, 0), uf(a, b), Z(a, G()), c;
+ a.finishedWork = a.current.alternate;
+ a.finishedLanes = b;
+ Zg(a);
+ Z(a, G());
+ return null;
+ }
+ __name(Og, "Og");
+ function $g() {
+ if (null !== Fg) {
+ var a = Fg;
+ Fg = null;
+ a.forEach(function(a2) {
+ a2.expiredLanes |= 24 & a2.pendingLanes;
+ Z(a2, G());
+ });
+ }
+ H();
+ }
+ __name($g, "$g");
+ function ah(a, b) {
+ var c = V;
+ V |= 1;
+ try {
+ return a(b);
+ } finally {
+ V = c, 0 === V && (zg(), H());
+ }
+ }
+ __name(ah, "ah");
+ function bh(a, b) {
+ var c = V;
+ if (0 !== (c & 48))
+ return a(b);
+ V |= 1;
+ try {
+ if (a)
+ return Pc(99, a.bind(null, b));
+ } finally {
+ V = c, H();
+ }
+ }
+ __name(bh, "bh");
+ function Xe(a, b) {
+ A(ug, tg);
+ tg |= b;
+ wg |= b;
+ }
+ __name(Xe, "Xe");
+ function wf() {
+ tg = ug.current;
+ z(ug);
+ }
+ __name(wf, "wf");
+ function Sg(a, b) {
+ a.finishedWork = null;
+ a.finishedLanes = 0;
+ var c = a.timeoutHandle;
+ c !== Ra && (a.timeoutHandle = Ra, Qa(c));
+ if (null !== W)
+ for (c = W.return; null !== c; ) {
+ var d = c;
+ switch (d.tag) {
+ case 1:
+ d = d.type.childContextTypes;
+ null !== d && void 0 !== d && $b();
+ break;
+ case 3:
+ Qd();
+ z(D);
+ z(B);
+ ee();
+ break;
+ case 5:
+ Sd(d);
+ break;
+ case 4:
+ Qd();
+ break;
+ case 13:
+ z(M);
+ break;
+ case 19:
+ z(M);
+ break;
+ case 10:
+ dd(d);
+ break;
+ case 23:
+ case 24:
+ wf();
+ }
+ c = c.return;
+ }
+ R = a;
+ W = Ed(a.current, null);
+ U = tg = wg = b;
+ T = 0;
+ vg = null;
+ xg = tf = pd = 0;
+ }
+ __name(Sg, "Sg");
+ function Ug(a, b) {
+ do {
+ var c = W;
+ try {
+ bd();
+ fe.current = pe;
+ if (ie) {
+ for (var d = N.memoizedState; null !== d; ) {
+ var e2 = d.queue;
+ null !== e2 && (e2.pending = null);
+ d = d.next;
+ }
+ ie = false;
+ }
+ he2 = 0;
+ P = O = N = null;
+ je = false;
+ rg.current = null;
+ if (null === c || null === c.return) {
+ T = 1;
+ vg = b;
+ W = null;
+ break;
+ }
+ a: {
+ var f = a, g = c.return, h = c, k = b;
+ b = U;
+ h.flags |= 2048;
+ h.firstEffect = h.lastEffect = null;
+ if (null !== k && "object" === typeof k && "function" === typeof k.then) {
+ var l = k;
+ if (0 === (h.mode & 2)) {
+ var n = h.alternate;
+ n ? (h.updateQueue = n.updateQueue, h.memoizedState = n.memoizedState, h.lanes = n.lanes) : (h.updateQueue = null, h.memoizedState = null);
+ }
+ var t2 = 0 !== (M.current & 1), p = g;
+ do {
+ var y;
+ if (y = 13 === p.tag) {
+ var x = p.memoizedState;
+ if (null !== x)
+ y = null !== x.dehydrated ? true : false;
+ else {
+ var Y = p.memoizedProps;
+ y = void 0 === Y.fallback ? false : true !== Y.unstable_avoidThisFallback ? true : t2 ? false : true;
+ }
+ }
+ if (y) {
+ var u = p.updateQueue;
+ if (null === u) {
+ var v = /* @__PURE__ */ new Set();
+ v.add(l);
+ p.updateQueue = v;
+ } else
+ u.add(l);
+ if (0 === (p.mode & 2)) {
+ p.flags |= 64;
+ h.flags |= 16384;
+ h.flags &= -2981;
+ if (1 === h.tag)
+ if (null === h.alternate)
+ h.tag = 17;
+ else {
+ var C = kd(-1, 1);
+ C.tag = 2;
+ md(h, C);
+ }
+ h.lanes |= 1;
+ break a;
+ }
+ k = void 0;
+ h = b;
+ var Oa = f.pingCache;
+ null === Oa ? (Oa = f.pingCache = new Af(), k = /* @__PURE__ */ new Set(), Oa.set(l, k)) : (k = Oa.get(l), void 0 === k && (k = /* @__PURE__ */ new Set(), Oa.set(l, k)));
+ if (!k.has(h)) {
+ k.add(h);
+ var Qe = ch.bind(null, f, l, h);
+ l.then(Qe, Qe);
+ }
+ p.flags |= 4096;
+ p.lanes = b;
+ break a;
+ }
+ p = p.return;
+ } while (null !== p);
+ k = Error((wa(h.type) || "A React component") + " suspended while rendering, but no fallback UI was specified.\n\nAdd a component higher in the tree to provide a loading indicator or placeholder to display.");
+ }
+ 5 !== T && (T = 2);
+ k = yf(k, h);
+ p = g;
+ do {
+ switch (p.tag) {
+ case 3:
+ f = k;
+ p.flags |= 4096;
+ b &= -b;
+ p.lanes |= b;
+ var Wg = Bf(p, f, b);
+ nd(p, Wg);
+ break a;
+ case 1:
+ f = k;
+ var Xg = p.type, ld = p.stateNode;
+ if (0 === (p.flags & 64) && ("function" === typeof Xg.getDerivedStateFromError || null !== ld && "function" === typeof ld.componentDidCatch && (null === Ff || !Ff.has(ld)))) {
+ p.flags |= 4096;
+ b &= -b;
+ p.lanes |= b;
+ var Yg = Ef(p, f, b);
+ nd(p, Yg);
+ break a;
+ }
+ }
+ p = p.return;
+ } while (null !== p);
+ }
+ dh(c);
+ } catch (w) {
+ b = w;
+ W === c && null !== c && (W = c = c.return);
+ continue;
+ }
+ break;
+ } while (1);
+ }
+ __name(Ug, "Ug");
+ function Rg() {
+ var a = qg.current;
+ qg.current = pe;
+ return null === a ? pe : a;
+ }
+ __name(Rg, "Rg");
+ function Vg(a, b) {
+ var c = V;
+ V |= 16;
+ var d = Rg();
+ R === a && U === b || Sg(a, b);
+ do
+ try {
+ eh();
+ break;
+ } catch (e2) {
+ Ug(a, e2);
+ }
+ while (1);
+ bd();
+ V = c;
+ qg.current = d;
+ if (null !== W)
+ throw Error(q(261));
+ R = null;
+ U = 0;
+ return T;
+ }
+ __name(Vg, "Vg");
+ function eh() {
+ for (; null !== W; )
+ fh(W);
+ }
+ __name(eh, "eh");
+ function Tg() {
+ for (; null !== W && !yc(); )
+ fh(W);
+ }
+ __name(Tg, "Tg");
+ function fh(a) {
+ var b = gh(a.alternate, a, tg);
+ a.memoizedProps = a.pendingProps;
+ null === b ? dh(a) : W = b;
+ rg.current = null;
+ }
+ __name(fh, "fh");
+ function dh(a) {
+ var b = a;
+ do {
+ var c = b.alternate;
+ a = b.return;
+ if (0 === (b.flags & 2048)) {
+ c = sf(c, b, tg);
+ if (null !== c) {
+ W = c;
+ return;
+ }
+ c = b;
+ if (24 !== c.tag && 23 !== c.tag || null === c.memoizedState || 0 !== (tg & 1073741824) || 0 === (c.mode & 4)) {
+ for (var d = 0, e2 = c.child; null !== e2; )
+ d |= e2.lanes | e2.childLanes, e2 = e2.sibling;
+ c.childLanes = d;
+ }
+ null !== a && 0 === (a.flags & 2048) && (null === a.firstEffect && (a.firstEffect = b.firstEffect), null !== b.lastEffect && (null !== a.lastEffect && (a.lastEffect.nextEffect = b.firstEffect), a.lastEffect = b.lastEffect), 1 < b.flags && (null !== a.lastEffect ? a.lastEffect.nextEffect = b : a.firstEffect = b, a.lastEffect = b));
+ } else {
+ c = xf(b);
+ if (null !== c) {
+ c.flags &= 2047;
+ W = c;
+ return;
+ }
+ null !== a && (a.firstEffect = a.lastEffect = null, a.flags |= 2048);
+ }
+ b = b.sibling;
+ if (null !== b) {
+ W = b;
+ return;
+ }
+ W = b = a;
+ } while (null !== b);
+ 0 === T && (T = 5);
+ }
+ __name(dh, "dh");
+ function Zg(a) {
+ var b = Nc();
+ Pc(99, hh.bind(null, a, b));
+ return null;
+ }
+ __name(Zg, "Zg");
+ function hh(a, b) {
+ do
+ Qg();
+ while (null !== Bg);
+ if (0 !== (V & 48))
+ throw Error(q(327));
+ var c = a.finishedWork;
+ if (null === c)
+ return null;
+ a.finishedWork = null;
+ a.finishedLanes = 0;
+ if (c === a.current)
+ throw Error(q(177));
+ a.callbackNode = null;
+ var d = c.lanes | c.childLanes, e2 = d, f = a.pendingLanes & ~e2;
+ a.pendingLanes = e2;
+ a.suspendedLanes = 0;
+ a.pingedLanes = 0;
+ a.expiredLanes &= e2;
+ a.mutableReadLanes &= e2;
+ a.entangledLanes &= e2;
+ e2 = a.entanglements;
+ for (var g = a.eventTimes, h = a.expirationTimes; 0 < f; ) {
+ var k = 31 - mc(f), l = 1 << k;
+ e2[k] = 0;
+ g[k] = -1;
+ h[k] = -1;
+ f &= ~l;
+ }
+ null !== Fg && 0 === (d & 24) && Fg.has(a) && Fg.delete(a);
+ a === R && (W = R = null, U = 0);
+ 1 < c.flags ? null !== c.lastEffect ? (c.lastEffect.nextEffect = c, d = c.firstEffect) : d = c : d = c.firstEffect;
+ if (null !== d) {
+ e2 = V;
+ V |= 32;
+ rg.current = null;
+ Lg = Ga(a.containerInfo);
+ Mg = false;
+ X = d;
+ do
+ try {
+ ih();
+ } catch (v) {
+ if (null === X)
+ throw Error(q(330));
+ If(X, v);
+ X = X.nextEffect;
+ }
+ while (null !== X);
+ Lg = null;
+ X = d;
+ do
+ try {
+ for (g = a; null !== X; ) {
+ var n = X.flags;
+ n & 16 && Ta && sb(X.stateNode);
+ if (n & 128) {
+ var t2 = X.alternate;
+ if (null !== t2) {
+ var p = t2.ref;
+ null !== p && ("function" === typeof p ? p(null) : p.current = null);
+ }
+ }
+ switch (n & 1038) {
+ case 2:
+ Uf(X);
+ X.flags &= -3;
+ break;
+ case 6:
+ Uf(X);
+ X.flags &= -3;
+ Xf(X.alternate, X);
+ break;
+ case 1024:
+ X.flags &= -1025;
+ break;
+ case 1028:
+ X.flags &= -1025;
+ Xf(X.alternate, X);
+ break;
+ case 4:
+ Xf(X.alternate, X);
+ break;
+ case 8:
+ h = g;
+ f = X;
+ Ta ? Qf(h, f) : Rf(h, f);
+ var y = f.alternate;
+ Sf(f);
+ null !== y && Sf(y);
+ }
+ X = X.nextEffect;
+ }
+ } catch (v) {
+ if (null === X)
+ throw Error(q(330));
+ If(X, v);
+ X = X.nextEffect;
+ }
+ while (null !== X);
+ Mg && $a();
+ Ha(a.containerInfo);
+ a.current = c;
+ X = d;
+ do
+ try {
+ for (n = a; null !== X; ) {
+ var x = X.flags;
+ x & 36 && Lf(n, X.alternate, X);
+ if (x & 128) {
+ t2 = void 0;
+ var Y = X.ref;
+ if (null !== Y) {
+ var u = X.stateNode;
+ switch (X.tag) {
+ case 5:
+ t2 = Da(u);
+ break;
+ default:
+ t2 = u;
+ }
+ "function" === typeof Y ? Y(t2) : Y.current = t2;
+ }
+ }
+ X = X.nextEffect;
+ }
+ } catch (v) {
+ if (null === X)
+ throw Error(q(330));
+ If(X, v);
+ X = X.nextEffect;
+ }
+ while (null !== X);
+ X = null;
+ Ic();
+ V = e2;
+ } else
+ a.current = c;
+ if (Ag)
+ Ag = false, Bg = a, Cg = b;
+ else
+ for (X = d; null !== X; )
+ b = X.nextEffect, X.nextEffect = null, X.flags & 8 && (x = X, x.sibling = null, x.stateNode = null), X = b;
+ d = a.pendingLanes;
+ 0 === d && (Ff = null);
+ 1 === d ? a === Hg ? Gg++ : (Gg = 0, Hg = a) : Gg = 0;
+ c = c.stateNode;
+ if (fc && "function" === typeof fc.onCommitFiberRoot)
+ try {
+ fc.onCommitFiberRoot(
+ ec,
+ c,
+ void 0,
+ 64 === (c.current.flags & 64)
+ );
+ } catch (v) {
+ }
+ Z(a, G());
+ if (Cf)
+ throw Cf = false, a = Df, Df = null, a;
+ if (0 !== (V & 8))
+ return null;
+ H();
+ return null;
+ }
+ __name(hh, "hh");
+ function ih() {
+ for (; null !== X; ) {
+ var a = X.alternate;
+ Mg || null === Lg || (0 !== (X.flags & 8) ? Ca(X, Lg) && (Mg = true, Za()) : 13 === X.tag && bg(a, X) && Ca(X, Lg) && (Mg = true, Za()));
+ var b = X.flags;
+ 0 !== (b & 256) && Jf(a, X);
+ 0 === (b & 512) || Ag || (Ag = true, Qc(97, function() {
+ Qg();
+ return null;
+ }));
+ X = X.nextEffect;
+ }
+ }
+ __name(ih, "ih");
+ function Qg() {
+ if (90 !== Cg) {
+ var a = 97 < Cg ? 97 : Cg;
+ Cg = 90;
+ return Pc(a, jh);
+ }
+ return false;
+ }
+ __name(Qg, "Qg");
+ function Nf(a, b) {
+ Dg.push(b, a);
+ Ag || (Ag = true, Qc(97, function() {
+ Qg();
+ return null;
+ }));
+ }
+ __name(Nf, "Nf");
+ function Mf(a, b) {
+ Eg.push(b, a);
+ Ag || (Ag = true, Qc(97, function() {
+ Qg();
+ return null;
+ }));
+ }
+ __name(Mf, "Mf");
+ function jh() {
+ if (null === Bg)
+ return false;
+ var a = Bg;
+ Bg = null;
+ if (0 !== (V & 48))
+ throw Error(q(331));
+ var b = V;
+ V |= 32;
+ var c = Eg;
+ Eg = [];
+ for (var d = 0; d < c.length; d += 2) {
+ var e2 = c[d], f = c[d + 1], g = e2.destroy;
+ e2.destroy = void 0;
+ if ("function" === typeof g)
+ try {
+ g();
+ } catch (k) {
+ if (null === f)
+ throw Error(q(330));
+ If(f, k);
+ }
+ }
+ c = Dg;
+ Dg = [];
+ for (d = 0; d < c.length; d += 2) {
+ e2 = c[d];
+ f = c[d + 1];
+ try {
+ var h = e2.create;
+ e2.destroy = h();
+ } catch (k) {
+ if (null === f)
+ throw Error(q(330));
+ If(f, k);
+ }
+ }
+ for (h = a.current.firstEffect; null !== h; )
+ a = h.nextEffect, h.nextEffect = null, h.flags & 8 && (h.sibling = null, h.stateNode = null), h = a;
+ V = b;
+ H();
+ return true;
+ }
+ __name(jh, "jh");
+ function kh(a, b, c) {
+ b = yf(c, b);
+ b = Bf(a, b, 1);
+ md(a, b);
+ b = K();
+ a = Ng(a, 1);
+ null !== a && (rc(a, 1, b), Z(a, b));
+ }
+ __name(kh, "kh");
+ function If(a, b) {
+ if (3 === a.tag)
+ kh(a, a, b);
+ else
+ for (var c = a.return; null !== c; ) {
+ if (3 === c.tag) {
+ kh(c, a, b);
+ break;
+ } else if (1 === c.tag) {
+ var d = c.stateNode;
+ if ("function" === typeof c.type.getDerivedStateFromError || "function" === typeof d.componentDidCatch && (null === Ff || !Ff.has(d))) {
+ a = yf(b, a);
+ var e2 = Ef(c, a, 1);
+ md(c, e2);
+ e2 = K();
+ c = Ng(c, 1);
+ if (null !== c)
+ rc(c, 1, e2), Z(c, e2);
+ else if ("function" === typeof d.componentDidCatch && (null === Ff || !Ff.has(d)))
+ try {
+ d.componentDidCatch(b, a);
+ } catch (f) {
+ }
+ break;
+ }
+ }
+ c = c.return;
+ }
+ }
+ __name(If, "If");
+ function ch(a, b, c) {
+ var d = a.pingCache;
+ null !== d && d.delete(b);
+ b = K();
+ a.pingedLanes |= a.suspendedLanes & c;
+ R === a && (U & c) === c && (4 === T || 3 === T && (U & 62914560) === U && 500 > G() - $f ? Sg(a, 0) : xg |= c);
+ Z(a, b);
+ }
+ __name(ch, "ch");
+ function ag(a, b) {
+ var c = a.stateNode;
+ null !== c && c.delete(b);
+ b = 0;
+ 0 === b && (b = a.mode, 0 === (b & 2) ? b = 1 : 0 === (b & 4) ? b = 99 === Nc() ? 1 : 2 : (0 === Jg && (Jg = wg), b = pc(62914560 & ~Jg), 0 === b && (b = 4194304)));
+ c = K();
+ a = Ng(a, b);
+ null !== a && (rc(a, b, c), Z(a, c));
+ }
+ __name(ag, "ag");
+ var gh;
+ gh = /* @__PURE__ */ __name(function(a, b, c) {
+ var d = b.lanes;
+ if (null !== a)
+ if (a.memoizedProps !== b.pendingProps || D.current)
+ gd2 = true;
+ else if (0 !== (c & d))
+ gd2 = 0 !== (a.flags & 16384) ? true : false;
+ else {
+ gd2 = false;
+ switch (b.tag) {
+ case 3:
+ af2(b);
+ ce();
+ break;
+ case 5:
+ Rd(b);
+ break;
+ case 1:
+ E(b.type) && cc(b);
+ break;
+ case 4:
+ Pd(b, b.stateNode.containerInfo);
+ break;
+ case 10:
+ cd(b, b.memoizedProps.value);
+ break;
+ case 13:
+ if (null !== b.memoizedState) {
+ if (0 !== (c & b.child.childLanes))
+ return cf(a, b, c);
+ A(M, M.current & 1);
+ b = Re(a, b, c);
+ return null !== b ? b.sibling : null;
+ }
+ A(M, M.current & 1);
+ break;
+ case 19:
+ d = 0 !== (c & b.childLanes);
+ if (0 !== (a.flags & 64)) {
+ if (d)
+ return kf(a, b, c);
+ b.flags |= 64;
+ }
+ var e2 = b.memoizedState;
+ null !== e2 && (e2.rendering = null, e2.tail = null, e2.lastEffect = null);
+ A(M, M.current);
+ if (d)
+ break;
+ else
+ return null;
+ case 23:
+ case 24:
+ return b.lanes = 0, We(a, b, c);
+ }
+ return Re(a, b, c);
+ }
+ else
+ gd2 = false;
+ b.lanes = 0;
+ switch (b.tag) {
+ case 2:
+ d = b.type;
+ null !== a && (a.alternate = null, b.alternate = null, b.flags |= 2);
+ a = b.pendingProps;
+ e2 = Zb(b, B.current);
+ fd(b, c);
+ e2 = le(null, b, d, a, e2, c);
+ b.flags |= 1;
+ if ("object" === typeof e2 && null !== e2 && "function" === typeof e2.render && void 0 === e2.$$typeof) {
+ b.tag = 1;
+ b.memoizedState = null;
+ b.updateQueue = null;
+ if (E(d)) {
+ var f = true;
+ cc(b);
+ } else
+ f = false;
+ b.memoizedState = null !== e2.state && void 0 !== e2.state ? e2.state : null;
+ id(b);
+ var g = d.getDerivedStateFromProps;
+ "function" === typeof g && sd(b, d, g, a);
+ e2.updater = vd;
+ b.stateNode = e2;
+ e2._reactInternals = b;
+ zd(b, d, a, c);
+ b = $e(null, b, d, true, f, c);
+ } else
+ b.tag = 0, S(null, b, e2, c), b = b.child;
+ return b;
+ case 16:
+ e2 = b.elementType;
+ a: {
+ null !== a && (a.alternate = null, b.alternate = null, b.flags |= 2);
+ a = b.pendingProps;
+ f = e2._init;
+ e2 = f(e2._payload);
+ b.type = e2;
+ f = b.tag = lh(e2);
+ a = Xc(e2, a);
+ switch (f) {
+ case 0:
+ b = Ve(null, b, e2, a, c);
+ break a;
+ case 1:
+ b = Ze(null, b, e2, a, c);
+ break a;
+ case 11:
+ b = Pe(null, b, e2, a, c);
+ break a;
+ case 14:
+ b = Se(null, b, e2, Xc(e2.type, a), d, c);
+ break a;
+ }
+ throw Error(q(306, e2, ""));
+ }
+ return b;
+ case 0:
+ return d = b.type, e2 = b.pendingProps, e2 = b.elementType === d ? e2 : Xc(d, e2), Ve(a, b, d, e2, c);
+ case 1:
+ return d = b.type, e2 = b.pendingProps, e2 = b.elementType === d ? e2 : Xc(d, e2), Ze(a, b, d, e2, c);
+ case 3:
+ af2(b);
+ d = b.updateQueue;
+ if (null === a || null === d)
+ throw Error(q(282));
+ d = b.pendingProps;
+ e2 = b.memoizedState;
+ e2 = null !== e2 ? e2.element : null;
+ jd(a, b);
+ od(b, d, null, c);
+ d = b.memoizedState.element;
+ if (d === e2)
+ ce(), b = Re(a, b, c);
+ else {
+ e2 = b.stateNode;
+ if (f = e2.hydrate)
+ Va ? (Vd = Kb(b.stateNode.containerInfo), Ud = b, f = Wd = true) : f = false;
+ if (f) {
+ if (Va && (a = e2.mutableSourceEagerHydrationData, null != a))
+ for (e2 = 0; e2 < a.length; e2 += 2)
+ f = a[e2], g = a[e2 + 1], Sa ? f._workInProgressVersionPrimary = g : f._workInProgressVersionSecondary = g, de.push(f);
+ c = Kd(b, null, d, c);
+ for (b.child = c; c; )
+ c.flags = c.flags & -3 | 1024, c = c.sibling;
+ } else
+ S(a, b, d, c), ce();
+ b = b.child;
+ }
+ return b;
+ case 5:
+ return Rd(b), null === a && $d(b), d = b.type, e2 = b.pendingProps, f = null !== a ? a.memoizedProps : null, g = e2.children, Ma(d, e2) ? g = null : null !== f && Ma(d, f) && (b.flags |= 16), Ye(a, b), S(a, b, g, c), b.child;
+ case 6:
+ return null === a && $d(b), null;
+ case 13:
+ return cf(a, b, c);
+ case 4:
+ return Pd(b, b.stateNode.containerInfo), d = b.pendingProps, null === a ? b.child = Jd(b, null, d, c) : S(a, b, d, c), b.child;
+ case 11:
+ return d = b.type, e2 = b.pendingProps, e2 = b.elementType === d ? e2 : Xc(d, e2), Pe(a, b, d, e2, c);
+ case 7:
+ return S(a, b, b.pendingProps, c), b.child;
+ case 8:
+ return S(
+ a,
+ b,
+ b.pendingProps.children,
+ c
+ ), b.child;
+ case 12:
+ return S(a, b, b.pendingProps.children, c), b.child;
+ case 10:
+ a: {
+ d = b.type._context;
+ e2 = b.pendingProps;
+ g = b.memoizedProps;
+ f = e2.value;
+ cd(b, f);
+ if (null !== g) {
+ var h = g.value;
+ f = I(h, f) ? 0 : ("function" === typeof d._calculateChangedBits ? d._calculateChangedBits(h, f) : 1073741823) | 0;
+ if (0 === f) {
+ if (g.children === e2.children && !D.current) {
+ b = Re(a, b, c);
+ break a;
+ }
+ } else
+ for (h = b.child, null !== h && (h.return = b); null !== h; ) {
+ var k = h.dependencies;
+ if (null !== k) {
+ g = h.child;
+ for (var l = k.firstContext; null !== l; ) {
+ if (l.context === d && 0 !== (l.observedBits & f)) {
+ 1 === h.tag && (l = kd(-1, c & -c), l.tag = 2, md(h, l));
+ h.lanes |= c;
+ l = h.alternate;
+ null !== l && (l.lanes |= c);
+ ed(h.return, c);
+ k.lanes |= c;
+ break;
+ }
+ l = l.next;
+ }
+ } else
+ g = 10 === h.tag ? h.type === b.type ? null : h.child : h.child;
+ if (null !== g)
+ g.return = h;
+ else
+ for (g = h; null !== g; ) {
+ if (g === b) {
+ g = null;
+ break;
+ }
+ h = g.sibling;
+ if (null !== h) {
+ h.return = g.return;
+ g = h;
+ break;
+ }
+ g = g.return;
+ }
+ h = g;
+ }
+ }
+ S(a, b, e2.children, c);
+ b = b.child;
+ }
+ return b;
+ case 9:
+ return e2 = b.type, f = b.pendingProps, d = f.children, fd(b, c), e2 = J(e2, f.unstable_observedBits), d = d(e2), b.flags |= 1, S(
+ a,
+ b,
+ d,
+ c
+ ), b.child;
+ case 14:
+ return e2 = b.type, f = Xc(e2, b.pendingProps), f = Xc(e2.type, f), Se(a, b, e2, f, d, c);
+ case 15:
+ return Ue(a, b, b.type, b.pendingProps, d, c);
+ case 17:
+ return d = b.type, e2 = b.pendingProps, e2 = b.elementType === d ? e2 : Xc(d, e2), null !== a && (a.alternate = null, b.alternate = null, b.flags |= 2), b.tag = 1, E(d) ? (a = true, cc(b)) : a = false, fd(b, c), xd(b, d, e2), zd(b, d, e2, c), $e(null, b, d, true, a, c);
+ case 19:
+ return kf(a, b, c);
+ case 23:
+ return We(a, b, c);
+ case 24:
+ return We(a, b, c);
+ }
+ throw Error(q(156, b.tag));
+ }, "gh");
+ var mh = { current: false }, nh = m.unstable_flushAllWithoutAsserting, oh = "function" === typeof nh;
+ function ph() {
+ if (void 0 !== nh)
+ return nh();
+ for (var a = false; Qg(); )
+ a = true;
+ return a;
+ }
+ __name(ph, "ph");
+ function qh(a) {
+ try {
+ ph(), og(function() {
+ ph() ? qh(a) : a();
+ });
+ } catch (b) {
+ a(b);
+ }
+ }
+ __name(qh, "qh");
+ var rh = 0, sh = false;
+ function th(a, b, c, d) {
+ this.tag = a;
+ this.key = c;
+ this.sibling = this.child = this.return = this.stateNode = this.type = this.elementType = null;
+ this.index = 0;
+ this.ref = null;
+ this.pendingProps = b;
+ this.dependencies = this.memoizedState = this.updateQueue = this.memoizedProps = null;
+ this.mode = d;
+ this.flags = 0;
+ this.lastEffect = this.firstEffect = this.nextEffect = null;
+ this.childLanes = this.lanes = 0;
+ this.alternate = null;
+ }
+ __name(th, "th");
+ function Yd(a, b, c, d) {
+ return new th(a, b, c, d);
+ }
+ __name(Yd, "Yd");
+ function Te(a) {
+ a = a.prototype;
+ return !(!a || !a.isReactComponent);
+ }
+ __name(Te, "Te");
+ function lh(a) {
+ if ("function" === typeof a)
+ return Te(a) ? 1 : 0;
+ if (void 0 !== a && null !== a) {
+ a = a.$$typeof;
+ if (a === la)
+ return 11;
+ if (a === oa)
+ return 14;
+ }
+ return 2;
+ }
+ __name(lh, "lh");
+ function Ed(a, b) {
+ var c = a.alternate;
+ null === c ? (c = Yd(a.tag, b, a.key, a.mode), c.elementType = a.elementType, c.type = a.type, c.stateNode = a.stateNode, c.alternate = a, a.alternate = c) : (c.pendingProps = b, c.type = a.type, c.flags = 0, c.nextEffect = null, c.firstEffect = null, c.lastEffect = null);
+ c.childLanes = a.childLanes;
+ c.lanes = a.lanes;
+ c.child = a.child;
+ c.memoizedProps = a.memoizedProps;
+ c.memoizedState = a.memoizedState;
+ c.updateQueue = a.updateQueue;
+ b = a.dependencies;
+ c.dependencies = null === b ? null : { lanes: b.lanes, firstContext: b.firstContext };
+ c.sibling = a.sibling;
+ c.index = a.index;
+ c.ref = a.ref;
+ return c;
+ }
+ __name(Ed, "Ed");
+ function Gd(a, b, c, d, e2, f) {
+ var g = 2;
+ d = a;
+ if ("function" === typeof a)
+ Te(a) && (g = 1);
+ else if ("string" === typeof a)
+ g = 5;
+ else
+ a:
+ switch (a) {
+ case fa:
+ return Id(c.children, e2, f, b);
+ case ra:
+ g = 8;
+ e2 |= 16;
+ break;
+ case ha:
+ g = 8;
+ e2 |= 1;
+ break;
+ case ia:
+ return a = Yd(12, c, b, e2 | 8), a.elementType = ia, a.type = ia, a.lanes = f, a;
+ case ma:
+ return a = Yd(13, c, b, e2), a.type = ma, a.elementType = ma, a.lanes = f, a;
+ case na:
+ return a = Yd(19, c, b, e2), a.elementType = na, a.lanes = f, a;
+ case sa:
+ return ef(c, e2, f, b);
+ case ta:
+ return a = Yd(24, c, b, e2), a.elementType = ta, a.lanes = f, a;
+ default:
+ if ("object" === typeof a && null !== a)
+ switch (a.$$typeof) {
+ case ja:
+ g = 10;
+ break a;
+ case ka:
+ g = 9;
+ break a;
+ case la:
+ g = 11;
+ break a;
+ case oa:
+ g = 14;
+ break a;
+ case pa2:
+ g = 16;
+ d = null;
+ break a;
+ case qa:
+ g = 22;
+ break a;
+ }
+ throw Error(q(130, null == a ? a : typeof a, ""));
+ }
+ b = Yd(g, c, b, e2);
+ b.elementType = a;
+ b.type = d;
+ b.lanes = f;
+ return b;
+ }
+ __name(Gd, "Gd");
+ function Id(a, b, c, d) {
+ a = Yd(7, a, d, b);
+ a.lanes = c;
+ return a;
+ }
+ __name(Id, "Id");
+ function ef(a, b, c, d) {
+ a = Yd(23, a, d, b);
+ a.elementType = sa;
+ a.lanes = c;
+ return a;
+ }
+ __name(ef, "ef");
+ function Fd(a, b, c) {
+ a = Yd(6, a, null, b);
+ a.lanes = c;
+ return a;
+ }
+ __name(Fd, "Fd");
+ function Hd(a, b, c) {
+ b = Yd(4, null !== a.children ? a.children : [], a.key, b);
+ b.lanes = c;
+ b.stateNode = { containerInfo: a.containerInfo, pendingChildren: null, implementation: a.implementation };
+ return b;
+ }
+ __name(Hd, "Hd");
+ function uh(a, b, c) {
+ this.tag = b;
+ this.containerInfo = a;
+ this.finishedWork = this.pingCache = this.current = this.pendingChildren = null;
+ this.timeoutHandle = Ra;
+ this.pendingContext = this.context = null;
+ this.hydrate = c;
+ this.callbackNode = null;
+ this.callbackPriority = 0;
+ this.eventTimes = qc(0);
+ this.expirationTimes = qc(-1);
+ this.entangledLanes = this.finishedLanes = this.mutableReadLanes = this.expiredLanes = this.pingedLanes = this.suspendedLanes = this.pendingLanes = 0;
+ this.entanglements = qc(0);
+ Va && (this.mutableSourceEagerHydrationData = null);
+ }
+ __name(uh, "uh");
+ function vh(a) {
+ var b = a._reactInternals;
+ if (void 0 === b) {
+ if ("function" === typeof a.render)
+ throw Error(q(188));
+ throw Error(q(268, Object.keys(a)));
+ }
+ a = Aa(b);
+ return null === a ? null : a.stateNode;
+ }
+ __name(vh, "vh");
+ function wh(a, b) {
+ a = a.memoizedState;
+ if (null !== a && null !== a.dehydrated) {
+ var c = a.retryLane;
+ a.retryLane = 0 !== c && c < b ? c : b;
+ }
+ }
+ __name(wh, "wh");
+ function xh(a, b) {
+ wh(a, b);
+ (a = a.alternate) && wh(a, b);
+ }
+ __name(xh, "xh");
+ function yh(a) {
+ a = Aa(a);
+ return null === a ? null : a.stateNode;
+ }
+ __name(yh, "yh");
+ function zh() {
+ return null;
+ }
+ __name(zh, "zh");
+ exports3.IsThisRendererActing = mh;
+ exports3.act = function(a) {
+ function b() {
+ rh--;
+ sg.current = c;
+ mh.current = d;
+ }
+ __name(b, "b");
+ false === sh && (sh = true, console.error("act(...) is not supported in production builds of React, and might not behave as expected."));
+ rh++;
+ var c = sg.current, d = mh.current;
+ sg.current = true;
+ mh.current = true;
+ try {
+ var e2 = ah(a);
+ } catch (f) {
+ throw b(), f;
+ }
+ if (null !== e2 && "object" === typeof e2 && "function" === typeof e2.then)
+ return { then: function(a2, d2) {
+ e2.then(function() {
+ 1 < rh || true === oh && true === c ? (b(), a2()) : qh(function(c2) {
+ b();
+ c2 ? d2(c2) : a2();
+ });
+ }, function(a3) {
+ b();
+ d2(a3);
+ });
+ } };
+ try {
+ 1 !== rh || false !== oh && false !== c || ph(), b();
+ } catch (f) {
+ throw b(), f;
+ }
+ return { then: function(a2) {
+ a2();
+ } };
+ };
+ exports3.attemptContinuousHydration = function(a) {
+ if (13 === a.tag) {
+ var b = K();
+ ud(a, 67108864, b);
+ xh(a, 67108864);
+ }
+ };
+ exports3.attemptHydrationAtCurrentPriority = function(a) {
+ if (13 === a.tag) {
+ var b = K(), c = td(a);
+ ud(a, c, b);
+ xh(a, c);
+ }
+ };
+ exports3.attemptSynchronousHydration = function(a) {
+ switch (a.tag) {
+ case 3:
+ var b = a.stateNode;
+ if (b.hydrate) {
+ var c = ic(b.pendingLanes);
+ b.expiredLanes |= c & b.pendingLanes;
+ Z(b, G());
+ 0 === (V & 48) && (zg(), H());
+ }
+ break;
+ case 13:
+ var d = K();
+ bh(function() {
+ return ud(a, 1, d);
+ });
+ xh(a, 4);
+ }
+ };
+ exports3.attemptUserBlockingHydration = function(a) {
+ if (13 === a.tag) {
+ var b = K();
+ ud(a, 4, b);
+ xh(a, 4);
+ }
+ };
+ exports3.batchedEventUpdates = function(a, b) {
+ var c = V;
+ V |= 2;
+ try {
+ return a(b);
+ } finally {
+ V = c, 0 === V && (zg(), H());
+ }
+ };
+ exports3.batchedUpdates = ah;
+ exports3.createComponentSelector = function(a) {
+ return { $$typeof: cg, value: a };
+ };
+ exports3.createContainer = function(a, b, c) {
+ a = new uh(a, b, c);
+ b = Yd(3, null, null, 2 === b ? 7 : 1 === b ? 3 : 0);
+ a.current = b;
+ b.stateNode = a;
+ id(b);
+ return a;
+ };
+ exports3.createHasPsuedoClassSelector = function(a) {
+ return { $$typeof: dg, value: a };
+ };
+ exports3.createPortal = function(a, b, c) {
+ var d = 3 < arguments.length && void 0 !== arguments[3] ? arguments[3] : null;
+ return { $$typeof: ea, key: null == d ? null : "" + d, children: a, containerInfo: b, implementation: c };
+ };
+ exports3.createRoleSelector = function(a) {
+ return { $$typeof: eg, value: a };
+ };
+ exports3.createTestNameSelector = function(a) {
+ return { $$typeof: fg, value: a };
+ };
+ exports3.createTextSelector = function(a) {
+ return { $$typeof: gg, value: a };
+ };
+ exports3.deferredUpdates = function(a) {
+ return Pc(97, a);
+ };
+ exports3.discreteUpdates = function(a, b, c, d, e2) {
+ var f = V;
+ V |= 4;
+ try {
+ return Pc(98, a.bind(null, b, c, d, e2));
+ } finally {
+ V = f, 0 === V && (zg(), H());
+ }
+ };
+ exports3.findAllNodes = mg;
+ exports3.findBoundingRects = function(a, b) {
+ if (!bb)
+ throw Error(q(363));
+ b = mg(a, b);
+ a = [];
+ for (var c = 0; c < b.length; c++)
+ a.push(db(b[c]));
+ for (b = a.length - 1; 0 < b; b--) {
+ c = a[b];
+ for (var d = c.x, e2 = d + c.width, f = c.y, g = f + c.height, h = b - 1; 0 <= h; h--)
+ if (b !== h) {
+ var k = a[h], l = k.x, n = l + k.width, t2 = k.y, p = t2 + k.height;
+ if (d >= l && f >= t2 && e2 <= n && g <= p) {
+ a.splice(b, 1);
+ break;
+ } else if (!(d !== l || c.width !== k.width || p < f || t2 > g)) {
+ t2 > f && (k.height += t2 - f, k.y = f);
+ p < g && (k.height = g - t2);
+ a.splice(b, 1);
+ break;
+ } else if (!(f !== t2 || c.height !== k.height || n < d || l > e2)) {
+ l > d && (k.width += l - d, k.x = d);
+ n < e2 && (k.width = e2 - l);
+ a.splice(b, 1);
+ break;
+ }
+ }
+ }
+ return a;
+ };
+ exports3.findHostInstance = vh;
+ exports3.findHostInstanceWithNoPortals = function(a) {
+ a = Ba(a);
+ return null === a ? null : 20 === a.tag ? a.stateNode.instance : a.stateNode;
+ };
+ exports3.findHostInstanceWithWarning = function(a) {
+ return vh(a);
+ };
+ exports3.flushControlled = function(a) {
+ var b = V;
+ V |= 1;
+ try {
+ Pc(99, a);
+ } finally {
+ V = b, 0 === V && (zg(), H());
+ }
+ };
+ exports3.flushDiscreteUpdates = function() {
+ 0 === (V & 49) && ($g(), Qg());
+ };
+ exports3.flushPassiveEffects = Qg;
+ exports3.flushSync = bh;
+ exports3.focusWithin = function(a, b) {
+ if (!bb)
+ throw Error(q(363));
+ a = ig(a);
+ b = lg(a, b);
+ b = Array.from(b);
+ for (a = 0; a < b.length; ) {
+ var c = b[a++];
+ if (!fb(c)) {
+ if (5 === c.tag && hb(c.stateNode))
+ return true;
+ for (c = c.child; null !== c; )
+ b.push(c), c = c.sibling;
+ }
+ }
+ return false;
+ };
+ exports3.getCurrentUpdateLanePriority = function() {
+ return hc;
+ };
+ exports3.getFindAllNodesFailureDescription = function(a, b) {
+ if (!bb)
+ throw Error(q(363));
+ var c = 0, d = [];
+ a = [ig(a), 0];
+ for (var e2 = 0; e2 < a.length; ) {
+ var f = a[e2++], g = a[e2++], h = b[g];
+ if (5 !== f.tag || !fb(f)) {
+ if (jg(f, h) && (d.push(kg(h)), g++, g > c && (c = g)), g < b.length)
+ for (f = f.child; null !== f; )
+ a.push(f, g), f = f.sibling;
+ }
+ }
+ if (c < b.length) {
+ for (a = []; c < b.length; c++)
+ a.push(kg(b[c]));
+ return "findAllNodes was able to match part of the selector:\n " + (d.join(" > ") + "\n\nNo matching component was found for:\n ") + a.join(" > ");
+ }
+ return null;
+ };
+ exports3.getPublicRootInstance = function(a) {
+ a = a.current;
+ if (!a.child)
+ return null;
+ switch (a.child.tag) {
+ case 5:
+ return Da(a.child.stateNode);
+ default:
+ return a.child.stateNode;
+ }
+ };
+ exports3.injectIntoDevTools = function(a) {
+ a = {
+ bundleType: a.bundleType,
+ version: a.version,
+ rendererPackageName: a.rendererPackageName,
+ rendererConfig: a.rendererConfig,
+ overrideHookState: null,
+ overrideHookStateDeletePath: null,
+ overrideHookStateRenamePath: null,
+ overrideProps: null,
+ overridePropsDeletePath: null,
+ overridePropsRenamePath: null,
+ setSuspenseHandler: null,
+ scheduleUpdate: null,
+ currentDispatcherRef: ca.ReactCurrentDispatcher,
+ findHostInstanceByFiber: yh,
+ findFiberByHostInstance: a.findFiberByHostInstance || zh,
+ findHostInstancesForRefresh: null,
+ scheduleRefresh: null,
+ scheduleRoot: null,
+ setRefreshHandler: null,
+ getCurrentFiber: null
+ };
+ if ("undefined" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__)
+ a = false;
+ else {
+ var b = __REACT_DEVTOOLS_GLOBAL_HOOK__;
+ if (!b.isDisabled && b.supportsFiber)
+ try {
+ ec = b.inject(a), fc = b;
+ } catch (c) {
+ }
+ a = true;
+ }
+ return a;
+ };
+ exports3.observeVisibleRects = function(a, b, c, d) {
+ if (!bb)
+ throw Error(q(363));
+ a = mg(a, b);
+ var e2 = ib(a, c, d).disconnect;
+ return { disconnect: function() {
+ e2();
+ } };
+ };
+ exports3.registerMutableSourceForHydration = function(a, b) {
+ var c = b._getVersion;
+ c = c(b._source);
+ null == a.mutableSourceEagerHydrationData ? a.mutableSourceEagerHydrationData = [b, c] : a.mutableSourceEagerHydrationData.push(b, c);
+ };
+ exports3.runWithPriority = function(a, b) {
+ var c = hc;
+ try {
+ return hc = a, b();
+ } finally {
+ hc = c;
+ }
+ };
+ exports3.shouldSuspend = function() {
+ return false;
+ };
+ exports3.unbatchedUpdates = function(a, b) {
+ var c = V;
+ V &= -2;
+ V |= 8;
+ try {
+ return a(b);
+ } finally {
+ V = c, 0 === V && (zg(), H());
+ }
+ };
+ exports3.updateContainer = function(a, b, c, d) {
+ var e2 = b.current, f = K(), g = td(e2);
+ a:
+ if (c) {
+ c = c._reactInternals;
+ b: {
+ if (xa(c) !== c || 1 !== c.tag)
+ throw Error(q(170));
+ var h = c;
+ do {
+ switch (h.tag) {
+ case 3:
+ h = h.stateNode.context;
+ break b;
+ case 1:
+ if (E(h.type)) {
+ h = h.stateNode.__reactInternalMemoizedMergedChildContext;
+ break b;
+ }
+ }
+ h = h.return;
+ } while (null !== h);
+ throw Error(q(171));
+ }
+ if (1 === c.tag) {
+ var k = c.type;
+ if (E(k)) {
+ c = bc(c, k, h);
+ break a;
+ }
+ }
+ c = h;
+ } else
+ c = Xb;
+ null === b.context ? b.context = c : b.pendingContext = c;
+ b = kd(f, g);
+ b.payload = { element: a };
+ d = void 0 === d ? null : d;
+ null !== d && (b.callback = d);
+ md(e2, b);
+ ud(e2, g, f);
+ return g;
+ };
+ return exports3;
+ }, "$$$reconciler");
+ }
+});
+
+// ../../node_modules/.pnpm/react-reconciler@0.26.2_react@17.0.2/node_modules/react-reconciler/index.js
+var require_react_reconciler = __commonJS({
+ "../../node_modules/.pnpm/react-reconciler@0.26.2_react@17.0.2/node_modules/react-reconciler/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ if (true) {
+ module2.exports = require_react_reconciler_production_min();
+ } else {
+ module2.exports = null;
+ }
+ }
+});
+
+// ../../node_modules/.pnpm/file+vendor+yoga-layout-2.0.0-beta.1.tgz/node_modules/yoga-layout/dist/build/wasm-sync.js
+var require_wasm_sync = __commonJS({
+ "../../node_modules/.pnpm/file+vendor+yoga-layout-2.0.0-beta.1.tgz/node_modules/yoga-layout/dist/build/wasm-sync.js"(exports2, module2) {
+ init_import_meta_url();
+ var loadYoga = (() => {
+ var _scriptDir = typeof document !== "undefined" && document.currentScript ? document.currentScript.src : void 0;
+ if (typeof __filename !== "undefined")
+ _scriptDir = _scriptDir || __filename;
+ return function(loadYoga2) {
+ loadYoga2 = loadYoga2 || {};
+ var l;
+ l || (l = typeof loadYoga2 !== "undefined" ? loadYoga2 : {});
+ var aa, ba;
+ l.ready = new Promise(function(a, b) {
+ aa = a;
+ ba = b;
+ });
+ var ca = Object.assign({}, l), da2 = "object" == typeof window, ea = "function" == typeof importScripts, q = "", fa, ha;
+ if ("object" == typeof process && "object" == typeof process.versions && "string" == typeof process.versions.node) {
+ var fs20 = require("fs"), ia = require("path");
+ q = ea ? ia.dirname(q) + "/" : __dirname + "/";
+ fa = /* @__PURE__ */ __name((a, b) => {
+ a = a.startsWith("file://") ? new URL(a) : ia.normalize(a);
+ return fs20.readFileSync(a, b ? void 0 : "utf8");
+ }, "fa");
+ ha = /* @__PURE__ */ __name((a) => {
+ a = fa(a, true);
+ a.buffer || (a = new Uint8Array(a));
+ return a;
+ }, "ha");
+ 1 < process.argv.length && process.argv[1].replace(/\\/g, "/");
+ process.argv.slice(2);
+ process.on("uncaughtException", function(a) {
+ throw a;
+ });
+ process.on(
+ "unhandledRejection",
+ function(a) {
+ throw a;
+ }
+ );
+ l.inspect = function() {
+ return "[Emscripten Module object]";
+ };
+ } else if (da2 || ea)
+ ea ? q = self.location.href : "undefined" != typeof document && document.currentScript && (q = document.currentScript.src), _scriptDir && (q = _scriptDir), 0 !== q.indexOf("blob:") ? q = q.substr(0, q.replace(/[?#].*/, "").lastIndexOf("/") + 1) : q = "", fa = /* @__PURE__ */ __name((a) => {
+ var b = new XMLHttpRequest();
+ b.open("GET", a, false);
+ b.send(null);
+ return b.responseText;
+ }, "fa"), ea && (ha = /* @__PURE__ */ __name((a) => {
+ var b = new XMLHttpRequest();
+ b.open("GET", a, false);
+ b.responseType = "arraybuffer";
+ b.send(null);
+ return new Uint8Array(b.response);
+ }, "ha"));
+ var ja = l.print || console.log.bind(console), v = l.printErr || console.warn.bind(console);
+ Object.assign(l, ca);
+ ca = null;
+ var ka;
+ l.wasmBinary && (ka = l.wasmBinary);
+ var noExitRuntime = l.noExitRuntime || true;
+ "object" != typeof WebAssembly && la("no native wasm support detected");
+ var ma, na = false;
+ function oa(a, b, c) {
+ c = b + c;
+ for (var d = ""; !(b >= c); ) {
+ var e2 = a[b++];
+ if (!e2)
+ break;
+ if (e2 & 128) {
+ var f = a[b++] & 63;
+ if (192 == (e2 & 224))
+ d += String.fromCharCode((e2 & 31) << 6 | f);
+ else {
+ var g = a[b++] & 63;
+ e2 = 224 == (e2 & 240) ? (e2 & 15) << 12 | f << 6 | g : (e2 & 7) << 18 | f << 12 | g << 6 | a[b++] & 63;
+ 65536 > e2 ? d += String.fromCharCode(e2) : (e2 -= 65536, d += String.fromCharCode(55296 | e2 >> 10, 56320 | e2 & 1023));
+ }
+ } else
+ d += String.fromCharCode(e2);
+ }
+ return d;
+ }
+ __name(oa, "oa");
+ var pa2, qa, w, x, ra, z, A, sa, ta;
+ function ua() {
+ var a = ma.buffer;
+ pa2 = a;
+ l.HEAP8 = qa = new Int8Array(a);
+ l.HEAP16 = x = new Int16Array(a);
+ l.HEAP32 = z = new Int32Array(a);
+ l.HEAPU8 = w = new Uint8Array(a);
+ l.HEAPU16 = ra = new Uint16Array(a);
+ l.HEAPU32 = A = new Uint32Array(a);
+ l.HEAPF32 = sa = new Float32Array(a);
+ l.HEAPF64 = ta = new Float64Array(a);
+ }
+ __name(ua, "ua");
+ var va, wa = [], xa = [], ya = [];
+ function za() {
+ var a = l.preRun.shift();
+ wa.unshift(a);
+ }
+ __name(za, "za");
+ var B = 0, Aa = null, D = null;
+ function la(a) {
+ if (l.onAbort)
+ l.onAbort(a);
+ a = "Aborted(" + a + ")";
+ v(a);
+ na = true;
+ a = new WebAssembly.RuntimeError(a + ". Build with -sASSERTIONS for more info.");
+ ba(a);
+ throw a;
+ }
+ __name(la, "la");
+ var E;
+ E = "wasm-sync.wasm";
+ if (!E.startsWith("data:application/octet-stream;base64,")) {
+ var Ba = E;
+ E = l.locateFile ? l.locateFile(Ba, q) : q + Ba;
+ }
+ function Ca(a) {
+ var b = E;
+ try {
+ a: {
+ try {
+ if (b == E && ka) {
+ var c = new Uint8Array(ka);
+ break a;
+ }
+ if (ha) {
+ c = ha(b);
+ break a;
+ }
+ throw "sync fetching of the wasm failed: you can preload it to Module['wasmBinary'] manually, or emcc.py will do that for you when generating HTML (but not JS)";
+ } catch (f) {
+ la(f);
+ }
+ c = void 0;
+ }
+ var d = new WebAssembly.Module(c);
+ var e2 = new WebAssembly.Instance(d, a);
+ } catch (f) {
+ throw a = f.toString(), v("failed to compile wasm module: " + a), (a.includes("imported Memory") || a.includes("memory import")) && v("Memory size incompatibility issues may be due to changing INITIAL_MEMORY at runtime to something too large. Use ALLOW_MEMORY_GROWTH to allow any size memory (and also make sure not to set INITIAL_MEMORY at runtime to something smaller than it was at compile time)."), f;
+ }
+ return [e2, d];
+ }
+ __name(Ca, "Ca");
+ function Da(a) {
+ for (; 0 < a.length; )
+ a.shift()(l);
+ }
+ __name(Da, "Da");
+ function Ea(a) {
+ if (void 0 === a)
+ return "_unknown";
+ a = a.replace(/[^a-zA-Z0-9_]/g, "$");
+ var b = a.charCodeAt(0);
+ return 48 <= b && 57 >= b ? "_" + a : a;
+ }
+ __name(Ea, "Ea");
+ function Fa(a, b) {
+ a = Ea(a);
+ return function() {
+ return b.apply(this, arguments);
+ };
+ }
+ __name(Fa, "Fa");
+ var F = [{}, { value: void 0 }, { value: null }, { value: true }, { value: false }], Ga = [];
+ function Ha(a) {
+ var b = Error, c = Fa(a, function(d) {
+ this.name = a;
+ this.message = d;
+ d = Error(d).stack;
+ void 0 !== d && (this.stack = this.toString() + "\n" + d.replace(/^Error(:[^\n]*)?\n/, ""));
+ });
+ c.prototype = Object.create(b.prototype);
+ c.prototype.constructor = c;
+ c.prototype.toString = function() {
+ return void 0 === this.message ? this.name : this.name + ": " + this.message;
+ };
+ return c;
+ }
+ __name(Ha, "Ha");
+ var H = void 0;
+ function I(a) {
+ throw new H(a);
+ }
+ __name(I, "I");
+ var J = /* @__PURE__ */ __name((a) => {
+ a || I("Cannot use deleted val. handle = " + a);
+ return F[a].value;
+ }, "J"), Ia = /* @__PURE__ */ __name((a) => {
+ switch (a) {
+ case void 0:
+ return 1;
+ case null:
+ return 2;
+ case true:
+ return 3;
+ case false:
+ return 4;
+ default:
+ var b = Ga.length ? Ga.pop() : F.length;
+ F[b] = { ga: 1, value: a };
+ return b;
+ }
+ }, "Ia"), Ja = void 0, Ka = void 0;
+ function K(a) {
+ for (var b = ""; w[a]; )
+ b += Ka[w[a++]];
+ return b;
+ }
+ __name(K, "K");
+ var L = [];
+ function La() {
+ for (; L.length; ) {
+ var a = L.pop();
+ a.L.Z = false;
+ a["delete"]();
+ }
+ }
+ __name(La, "La");
+ var M = void 0, N = {};
+ function Ma(a, b) {
+ for (void 0 === b && I("ptr should not be undefined"); a.P; )
+ b = a.aa(b), a = a.P;
+ return b;
+ }
+ __name(Ma, "Ma");
+ var O = {};
+ function Na(a) {
+ a = Oa(a);
+ var b = K(a);
+ P(a);
+ return b;
+ }
+ __name(Na, "Na");
+ function Pa(a, b) {
+ var c = O[a];
+ void 0 === c && I(b + " has unknown type " + Na(a));
+ return c;
+ }
+ __name(Pa, "Pa");
+ function Qa() {
+ }
+ __name(Qa, "Qa");
+ var Ra = false;
+ function Sa(a) {
+ --a.count.value;
+ 0 === a.count.value && (a.S ? a.T.V(a.S) : a.O.M.V(a.N));
+ }
+ __name(Sa, "Sa");
+ function Ta(a, b, c) {
+ if (b === c)
+ return a;
+ if (void 0 === c.P)
+ return null;
+ a = Ta(a, b, c.P);
+ return null === a ? null : c.na(a);
+ }
+ __name(Ta, "Ta");
+ var Ua = {};
+ function Va(a, b) {
+ b = Ma(a, b);
+ return N[b];
+ }
+ __name(Va, "Va");
+ var Wa = void 0;
+ function Xa(a) {
+ throw new Wa(a);
+ }
+ __name(Xa, "Xa");
+ function Ya(a, b) {
+ b.O && b.N || Xa("makeClassHandle requires ptr and ptrType");
+ !!b.T !== !!b.S && Xa("Both smartPtrType and smartPtr must be specified");
+ b.count = { value: 1 };
+ return Q(Object.create(a, { L: { value: b } }));
+ }
+ __name(Ya, "Ya");
+ function Q(a) {
+ if ("undefined" === typeof FinalizationRegistry)
+ return Q = /* @__PURE__ */ __name((b) => b, "Q"), a;
+ Ra = new FinalizationRegistry((b) => {
+ Sa(b.L);
+ });
+ Q = /* @__PURE__ */ __name((b) => {
+ var c = b.L;
+ c.S && Ra.register(b, { L: c }, b);
+ return b;
+ }, "Q");
+ Qa = /* @__PURE__ */ __name((b) => {
+ Ra.unregister(b);
+ }, "Qa");
+ return Q(a);
+ }
+ __name(Q, "Q");
+ var Za = {};
+ function $a(a) {
+ for (; a.length; ) {
+ var b = a.pop();
+ a.pop()(b);
+ }
+ }
+ __name($a, "$a");
+ function R(a) {
+ return this.fromWireType(z[a >> 2]);
+ }
+ __name(R, "R");
+ var S = {}, ab = {};
+ function T(a, b, c) {
+ function d(h) {
+ h = c(h);
+ h.length !== a.length && Xa("Mismatched type converter count");
+ for (var m = 0; m < a.length; ++m)
+ U(a[m], h[m]);
+ }
+ __name(d, "d");
+ a.forEach(function(h) {
+ ab[h] = b;
+ });
+ var e2 = Array(b.length), f = [], g = 0;
+ b.forEach((h, m) => {
+ O.hasOwnProperty(h) ? e2[m] = O[h] : (f.push(h), S.hasOwnProperty(h) || (S[h] = []), S[h].push(() => {
+ e2[m] = O[h];
+ ++g;
+ g === f.length && d(e2);
+ }));
+ });
+ 0 === f.length && d(e2);
+ }
+ __name(T, "T");
+ function bb(a) {
+ switch (a) {
+ case 1:
+ return 0;
+ case 2:
+ return 1;
+ case 4:
+ return 2;
+ case 8:
+ return 3;
+ default:
+ throw new TypeError("Unknown type size: " + a);
+ }
+ }
+ __name(bb, "bb");
+ function U(a, b, c = {}) {
+ if (!("argPackAdvance" in b))
+ throw new TypeError("registerType registeredInstance requires argPackAdvance");
+ var d = b.name;
+ a || I('type "' + d + '" must have a positive integer typeid pointer');
+ if (O.hasOwnProperty(a)) {
+ if (c.ua)
+ return;
+ I("Cannot register type '" + d + "' twice");
+ }
+ O[a] = b;
+ delete ab[a];
+ S.hasOwnProperty(a) && (b = S[a], delete S[a], b.forEach((e2) => e2()));
+ }
+ __name(U, "U");
+ function cb(a) {
+ I(a.L.O.M.name + " instance already deleted");
+ }
+ __name(cb, "cb");
+ function V() {
+ }
+ __name(V, "V");
+ function db(a, b, c) {
+ if (void 0 === a[b].R) {
+ var d = a[b];
+ a[b] = function() {
+ a[b].R.hasOwnProperty(arguments.length) || I("Function '" + c + "' called with an invalid number of arguments (" + arguments.length + ") - expects one of (" + a[b].R + ")!");
+ return a[b].R[arguments.length].apply(this, arguments);
+ };
+ a[b].R = [];
+ a[b].R[d.Y] = d;
+ }
+ }
+ __name(db, "db");
+ function eb(a, b) {
+ l.hasOwnProperty(a) ? (I("Cannot register public name '" + a + "' twice"), db(l, a, a), l.hasOwnProperty(void 0) && I("Cannot register multiple overloads of a function with the same number of arguments (undefined)!"), l[a].R[void 0] = b) : l[a] = b;
+ }
+ __name(eb, "eb");
+ function fb(a, b, c, d, e2, f, g, h) {
+ this.name = a;
+ this.constructor = b;
+ this.W = c;
+ this.V = d;
+ this.P = e2;
+ this.pa = f;
+ this.aa = g;
+ this.na = h;
+ this.ja = [];
+ }
+ __name(fb, "fb");
+ function gb(a, b, c) {
+ for (; b !== c; )
+ b.aa || I("Expected null or instance of " + c.name + ", got an instance of " + b.name), a = b.aa(a), b = b.P;
+ return a;
+ }
+ __name(gb, "gb");
+ function hb(a, b) {
+ if (null === b)
+ return this.ea && I("null is not a valid " + this.name), 0;
+ b.L || I('Cannot pass "' + ib(b) + '" as a ' + this.name);
+ b.L.N || I("Cannot pass deleted object as a pointer of type " + this.name);
+ return gb(b.L.N, b.L.O.M, this.M);
+ }
+ __name(hb, "hb");
+ function jb(a, b) {
+ if (null === b) {
+ this.ea && I("null is not a valid " + this.name);
+ if (this.da) {
+ var c = this.fa();
+ null !== a && a.push(this.V, c);
+ return c;
+ }
+ return 0;
+ }
+ b.L || I('Cannot pass "' + ib(b) + '" as a ' + this.name);
+ b.L.N || I("Cannot pass deleted object as a pointer of type " + this.name);
+ !this.ba && b.L.O.ba && I("Cannot convert argument of type " + (b.L.T ? b.L.T.name : b.L.O.name) + " to parameter type " + this.name);
+ c = gb(b.L.N, b.L.O.M, this.M);
+ if (this.da)
+ switch (void 0 === b.L.S && I("Passing raw pointer to smart pointer is illegal"), this.Ba) {
+ case 0:
+ b.L.T === this ? c = b.L.S : I("Cannot convert argument of type " + (b.L.T ? b.L.T.name : b.L.O.name) + " to parameter type " + this.name);
+ break;
+ case 1:
+ c = b.L.S;
+ break;
+ case 2:
+ if (b.L.T === this)
+ c = b.L.S;
+ else {
+ var d = b.clone();
+ c = this.xa(c, Ia(function() {
+ d["delete"]();
+ }));
+ null !== a && a.push(this.V, c);
+ }
+ break;
+ default:
+ I("Unsupporting sharing policy");
+ }
+ return c;
+ }
+ __name(jb, "jb");
+ function kb(a, b) {
+ if (null === b)
+ return this.ea && I("null is not a valid " + this.name), 0;
+ b.L || I('Cannot pass "' + ib(b) + '" as a ' + this.name);
+ b.L.N || I("Cannot pass deleted object as a pointer of type " + this.name);
+ b.L.O.ba && I("Cannot convert argument of type " + b.L.O.name + " to parameter type " + this.name);
+ return gb(b.L.N, b.L.O.M, this.M);
+ }
+ __name(kb, "kb");
+ function W(a, b, c, d) {
+ this.name = a;
+ this.M = b;
+ this.ea = c;
+ this.ba = d;
+ this.da = false;
+ this.V = this.xa = this.fa = this.ka = this.Ba = this.wa = void 0;
+ void 0 !== b.P ? this.toWireType = jb : (this.toWireType = d ? hb : kb, this.U = null);
+ }
+ __name(W, "W");
+ function nb(a, b) {
+ l.hasOwnProperty(a) || Xa("Replacing nonexistant public symbol");
+ l[a] = b;
+ l[a].Y = void 0;
+ }
+ __name(nb, "nb");
+ function ob(a, b) {
+ var c = [];
+ return function() {
+ c.length = 0;
+ Object.assign(c, arguments);
+ if (a.includes("j")) {
+ var d = l["dynCall_" + a];
+ d = c && c.length ? d.apply(null, [b].concat(c)) : d.call(null, b);
+ } else
+ d = va.get(b).apply(null, c);
+ return d;
+ };
+ }
+ __name(ob, "ob");
+ function X(a, b) {
+ a = K(a);
+ var c = a.includes("j") ? ob(a, b) : va.get(b);
+ "function" != typeof c && I("unknown function pointer with signature " + a + ": " + b);
+ return c;
+ }
+ __name(X, "X");
+ var pb = void 0;
+ function qb(a, b) {
+ function c(f) {
+ e2[f] || O[f] || (ab[f] ? ab[f].forEach(c) : (d.push(f), e2[f] = true));
+ }
+ __name(c, "c");
+ var d = [], e2 = {};
+ b.forEach(c);
+ throw new pb(a + ": " + d.map(Na).join([", "]));
+ }
+ __name(qb, "qb");
+ function rb(a, b, c, d, e2) {
+ var f = b.length;
+ 2 > f && I("argTypes array size mismatch! Must at least get return value and 'this' types!");
+ var g = null !== b[1] && null !== c, h = false;
+ for (c = 1; c < b.length; ++c)
+ if (null !== b[c] && void 0 === b[c].U) {
+ h = true;
+ break;
+ }
+ var m = "void" !== b[0].name, k = f - 2, n = Array(k), p = [], r = [];
+ return function() {
+ arguments.length !== k && I("function " + a + " called with " + arguments.length + " arguments, expected " + k + " args!");
+ r.length = 0;
+ p.length = g ? 2 : 1;
+ p[0] = e2;
+ if (g) {
+ var u = b[1].toWireType(r, this);
+ p[1] = u;
+ }
+ for (var t2 = 0; t2 < k; ++t2)
+ n[t2] = b[t2 + 2].toWireType(r, arguments[t2]), p.push(n[t2]);
+ t2 = d.apply(null, p);
+ if (h)
+ $a(r);
+ else
+ for (var y = g ? 1 : 2; y < b.length; y++) {
+ var C = 1 === y ? u : n[y - 2];
+ null !== b[y].U && b[y].U(C);
+ }
+ u = m ? b[0].fromWireType(t2) : void 0;
+ return u;
+ };
+ }
+ __name(rb, "rb");
+ function sb(a, b) {
+ for (var c = [], d = 0; d < a; d++)
+ c.push(A[b + 4 * d >> 2]);
+ return c;
+ }
+ __name(sb, "sb");
+ function tb(a) {
+ 4 < a && 0 === --F[a].ga && (F[a] = void 0, Ga.push(a));
+ }
+ __name(tb, "tb");
+ function ib(a) {
+ if (null === a)
+ return "null";
+ var b = typeof a;
+ return "object" === b || "array" === b || "function" === b ? a.toString() : "" + a;
+ }
+ __name(ib, "ib");
+ function ub(a, b) {
+ switch (b) {
+ case 2:
+ return function(c) {
+ return this.fromWireType(sa[c >> 2]);
+ };
+ case 3:
+ return function(c) {
+ return this.fromWireType(ta[c >> 3]);
+ };
+ default:
+ throw new TypeError("Unknown float type: " + a);
+ }
+ }
+ __name(ub, "ub");
+ function vb(a, b, c) {
+ switch (b) {
+ case 0:
+ return c ? function(d) {
+ return qa[d];
+ } : function(d) {
+ return w[d];
+ };
+ case 1:
+ return c ? function(d) {
+ return x[d >> 1];
+ } : function(d) {
+ return ra[d >> 1];
+ };
+ case 2:
+ return c ? function(d) {
+ return z[d >> 2];
+ } : function(d) {
+ return A[d >> 2];
+ };
+ default:
+ throw new TypeError("Unknown integer type: " + a);
+ }
+ }
+ __name(vb, "vb");
+ function wb(a, b) {
+ for (var c = "", d = 0; !(d >= b / 2); ++d) {
+ var e2 = x[a + 2 * d >> 1];
+ if (0 == e2)
+ break;
+ c += String.fromCharCode(e2);
+ }
+ return c;
+ }
+ __name(wb, "wb");
+ function xb(a, b, c) {
+ void 0 === c && (c = 2147483647);
+ if (2 > c)
+ return 0;
+ c -= 2;
+ var d = b;
+ c = c < 2 * a.length ? c / 2 : a.length;
+ for (var e2 = 0; e2 < c; ++e2)
+ x[b >> 1] = a.charCodeAt(e2), b += 2;
+ x[b >> 1] = 0;
+ return b - d;
+ }
+ __name(xb, "xb");
+ function yb(a) {
+ return 2 * a.length;
+ }
+ __name(yb, "yb");
+ function zb(a, b) {
+ for (var c = 0, d = ""; !(c >= b / 4); ) {
+ var e2 = z[a + 4 * c >> 2];
+ if (0 == e2)
+ break;
+ ++c;
+ 65536 <= e2 ? (e2 -= 65536, d += String.fromCharCode(55296 | e2 >> 10, 56320 | e2 & 1023)) : d += String.fromCharCode(e2);
+ }
+ return d;
+ }
+ __name(zb, "zb");
+ function Ab(a, b, c) {
+ void 0 === c && (c = 2147483647);
+ if (4 > c)
+ return 0;
+ var d = b;
+ c = d + c - 4;
+ for (var e2 = 0; e2 < a.length; ++e2) {
+ var f = a.charCodeAt(e2);
+ if (55296 <= f && 57343 >= f) {
+ var g = a.charCodeAt(++e2);
+ f = 65536 + ((f & 1023) << 10) | g & 1023;
+ }
+ z[b >> 2] = f;
+ b += 4;
+ if (b + 4 > c)
+ break;
+ }
+ z[b >> 2] = 0;
+ return b - d;
+ }
+ __name(Ab, "Ab");
+ function Bb(a) {
+ for (var b = 0, c = 0; c < a.length; ++c) {
+ var d = a.charCodeAt(c);
+ 55296 <= d && 57343 >= d && ++c;
+ b += 4;
+ }
+ return b;
+ }
+ __name(Bb, "Bb");
+ var Cb = {};
+ function Db(a) {
+ var b = Cb[a];
+ return void 0 === b ? K(a) : b;
+ }
+ __name(Db, "Db");
+ var Eb = [];
+ function Fb(a) {
+ var b = Eb.length;
+ Eb.push(a);
+ return b;
+ }
+ __name(Fb, "Fb");
+ function Gb(a, b) {
+ for (var c = Array(a), d = 0; d < a; ++d)
+ c[d] = Pa(A[b + 4 * d >> 2], "parameter " + d);
+ return c;
+ }
+ __name(Gb, "Gb");
+ var Hb = [], Ib = [null, [], []];
+ H = l.BindingError = Ha("BindingError");
+ l.count_emval_handles = function() {
+ for (var a = 0, b = 5; b < F.length; ++b)
+ void 0 !== F[b] && ++a;
+ return a;
+ };
+ l.get_first_emval = function() {
+ for (var a = 5; a < F.length; ++a)
+ if (void 0 !== F[a])
+ return F[a];
+ return null;
+ };
+ Ja = l.PureVirtualError = Ha("PureVirtualError");
+ for (var Jb = Array(256), Kb = 0; 256 > Kb; ++Kb)
+ Jb[Kb] = String.fromCharCode(Kb);
+ Ka = Jb;
+ l.getInheritedInstanceCount = function() {
+ return Object.keys(N).length;
+ };
+ l.getLiveInheritedInstances = function() {
+ var a = [], b;
+ for (b in N)
+ N.hasOwnProperty(b) && a.push(N[b]);
+ return a;
+ };
+ l.flushPendingDeletes = La;
+ l.setDelayFunction = function(a) {
+ M = a;
+ L.length && M && M(La);
+ };
+ Wa = l.InternalError = Ha("InternalError");
+ V.prototype.isAliasOf = function(a) {
+ if (!(this instanceof V && a instanceof V))
+ return false;
+ var b = this.L.O.M, c = this.L.N, d = a.L.O.M;
+ for (a = a.L.N; b.P; )
+ c = b.aa(c), b = b.P;
+ for (; d.P; )
+ a = d.aa(a), d = d.P;
+ return b === d && c === a;
+ };
+ V.prototype.clone = function() {
+ this.L.N || cb(this);
+ if (this.L.$)
+ return this.L.count.value += 1, this;
+ var a = Q, b = Object, c = b.create, d = Object.getPrototypeOf(this), e2 = this.L;
+ a = a(c.call(b, d, { L: { value: { count: e2.count, Z: e2.Z, $: e2.$, N: e2.N, O: e2.O, S: e2.S, T: e2.T } } }));
+ a.L.count.value += 1;
+ a.L.Z = false;
+ return a;
+ };
+ V.prototype["delete"] = function() {
+ this.L.N || cb(this);
+ this.L.Z && !this.L.$ && I("Object already scheduled for deletion");
+ Qa(this);
+ Sa(this.L);
+ this.L.$ || (this.L.S = void 0, this.L.N = void 0);
+ };
+ V.prototype.isDeleted = function() {
+ return !this.L.N;
+ };
+ V.prototype.deleteLater = function() {
+ this.L.N || cb(this);
+ this.L.Z && !this.L.$ && I("Object already scheduled for deletion");
+ L.push(this);
+ 1 === L.length && M && M(La);
+ this.L.Z = true;
+ return this;
+ };
+ W.prototype.qa = function(a) {
+ this.ka && (a = this.ka(a));
+ return a;
+ };
+ W.prototype.ha = function(a) {
+ this.V && this.V(a);
+ };
+ W.prototype.argPackAdvance = 8;
+ W.prototype.readValueFromPointer = R;
+ W.prototype.deleteObject = function(a) {
+ if (null !== a)
+ a["delete"]();
+ };
+ W.prototype.fromWireType = function(a) {
+ function b() {
+ return this.da ? Ya(this.M.W, { O: this.wa, N: c, T: this, S: a }) : Ya(this.M.W, { O: this, N: a });
+ }
+ __name(b, "b");
+ var c = this.qa(a);
+ if (!c)
+ return this.ha(a), null;
+ var d = Va(this.M, c);
+ if (void 0 !== d) {
+ if (0 === d.L.count.value)
+ return d.L.N = c, d.L.S = a, d.clone();
+ d = d.clone();
+ this.ha(a);
+ return d;
+ }
+ d = this.M.pa(c);
+ d = Ua[d];
+ if (!d)
+ return b.call(this);
+ d = this.ba ? d.la : d.pointerType;
+ var e2 = Ta(c, this.M, d.M);
+ return null === e2 ? b.call(this) : this.da ? Ya(d.M.W, { O: d, N: e2, T: this, S: a }) : Ya(d.M.W, { O: d, N: e2 });
+ };
+ pb = l.UnboundTypeError = Ha("UnboundTypeError");
+ var Mb = { p: function(a, b, c) {
+ a = K(a);
+ b = Pa(b, "wrapper");
+ c = J(c);
+ var d = [].slice, e2 = b.M, f = e2.W, g = e2.P.W, h = e2.P.constructor;
+ a = Fa(a, function() {
+ e2.P.ja.forEach(function(k) {
+ if (this[k] === g[k])
+ throw new Ja("Pure virtual function " + k + " must be implemented in JavaScript");
+ }.bind(this));
+ Object.defineProperty(this, "__parent", { value: f });
+ this.__construct.apply(this, d.call(arguments));
+ });
+ f.__construct = function() {
+ this === f && I("Pass correct 'this' to __construct");
+ var k = h.implement.apply(void 0, [this].concat(d.call(arguments)));
+ Qa(k);
+ var n = k.L;
+ k.notifyOnDestruction();
+ n.$ = true;
+ Object.defineProperties(this, { L: { value: n } });
+ Q(this);
+ k = n.N;
+ k = Ma(e2, k);
+ N.hasOwnProperty(k) ? I("Tried to register registered instance: " + k) : N[k] = this;
+ };
+ f.__destruct = function() {
+ this === f && I("Pass correct 'this' to __destruct");
+ Qa(this);
+ var k = this.L.N;
+ k = Ma(e2, k);
+ N.hasOwnProperty(k) ? delete N[k] : I("Tried to unregister unregistered instance: " + k);
+ };
+ a.prototype = Object.create(f);
+ for (var m in c)
+ a.prototype[m] = c[m];
+ return Ia(a);
+ }, j: function(a) {
+ var b = Za[a];
+ delete Za[a];
+ var c = b.fa, d = b.V, e2 = b.ia, f = e2.map((g) => g.ta).concat(e2.map((g) => g.za));
+ T([a], f, (g) => {
+ var h = {};
+ e2.forEach((m, k) => {
+ var n = g[k], p = m.ra, r = m.sa, u = g[k + e2.length], t2 = m.ya, y = m.Aa;
+ h[m.oa] = { read: (C) => n.fromWireType(p(r, C)), write: (C, Z) => {
+ var G = [];
+ t2(y, C, u.toWireType(G, Z));
+ $a(G);
+ } };
+ });
+ return [{ name: b.name, fromWireType: function(m) {
+ var k = {}, n;
+ for (n in h)
+ k[n] = h[n].read(m);
+ d(m);
+ return k;
+ }, toWireType: function(m, k) {
+ for (var n in h)
+ if (!(n in k))
+ throw new TypeError('Missing field: "' + n + '"');
+ var p = c();
+ for (n in h)
+ h[n].write(p, k[n]);
+ null !== m && m.push(d, p);
+ return p;
+ }, argPackAdvance: 8, readValueFromPointer: R, U: d }];
+ });
+ }, v: function() {
+ }, B: function(a, b, c, d, e2) {
+ var f = bb(c);
+ b = K(b);
+ U(a, { name: b, fromWireType: function(g) {
+ return !!g;
+ }, toWireType: function(g, h) {
+ return h ? d : e2;
+ }, argPackAdvance: 8, readValueFromPointer: function(g) {
+ if (1 === c)
+ var h = qa;
+ else if (2 === c)
+ h = x;
+ else if (4 === c)
+ h = z;
+ else
+ throw new TypeError("Unknown boolean type size: " + b);
+ return this.fromWireType(h[g >> f]);
+ }, U: null });
+ }, f: function(a, b, c, d, e2, f, g, h, m, k, n, p, r) {
+ n = K(n);
+ f = X(e2, f);
+ h && (h = X(g, h));
+ k && (k = X(
+ m,
+ k
+ ));
+ r = X(p, r);
+ var u = Ea(n);
+ eb(u, function() {
+ qb("Cannot construct " + n + " due to unbound types", [d]);
+ });
+ T([a, b, c], d ? [d] : [], function(t2) {
+ t2 = t2[0];
+ if (d) {
+ var y = t2.M;
+ var C = y.W;
+ } else
+ C = V.prototype;
+ t2 = Fa(u, function() {
+ if (Object.getPrototypeOf(this) !== Z)
+ throw new H("Use 'new' to construct " + n);
+ if (void 0 === G.X)
+ throw new H(n + " has no accessible constructor");
+ var lb = G.X[arguments.length];
+ if (void 0 === lb)
+ throw new H("Tried to invoke ctor of " + n + " with invalid number of parameters (" + arguments.length + ") - expected (" + Object.keys(G.X).toString() + ") parameters instead!");
+ return lb.apply(this, arguments);
+ });
+ var Z = Object.create(C, { constructor: { value: t2 } });
+ t2.prototype = Z;
+ var G = new fb(n, t2, Z, r, y, f, h, k);
+ y = new W(n, G, true, false);
+ C = new W(n + "*", G, false, false);
+ var mb = new W(n + " const*", G, false, true);
+ Ua[a] = { pointerType: C, la: mb };
+ nb(u, t2);
+ return [y, C, mb];
+ });
+ }, c: function(a, b, c, d, e2, f, g) {
+ var h = sb(c, d);
+ b = K(b);
+ f = X(e2, f);
+ T([], [a], function(m) {
+ function k() {
+ qb("Cannot call " + n + " due to unbound types", h);
+ }
+ __name(k, "k");
+ m = m[0];
+ var n = m.name + "." + b;
+ b.startsWith("@@") && (b = Symbol[b.substring(2)]);
+ var p = m.M.constructor;
+ void 0 === p[b] ? (k.Y = c - 1, p[b] = k) : (db(p, b, n), p[b].R[c - 1] = k);
+ T([], h, function(r) {
+ r = [r[0], null].concat(r.slice(1));
+ r = rb(n, r, null, f, g);
+ void 0 === p[b].R ? (r.Y = c - 1, p[b] = r) : p[b].R[c - 1] = r;
+ return [];
+ });
+ return [];
+ });
+ }, o: function(a, b, c, d, e2, f) {
+ 0 < b || la();
+ var g = sb(b, c);
+ e2 = X(d, e2);
+ T([], [a], function(h) {
+ h = h[0];
+ var m = "constructor " + h.name;
+ void 0 === h.M.X && (h.M.X = []);
+ if (void 0 !== h.M.X[b - 1])
+ throw new H("Cannot register multiple constructors with identical number of parameters (" + (b - 1) + ") for class '" + h.name + "'! Overload resolution is currently only performed using the parameter count, not actual type info!");
+ h.M.X[b - 1] = () => {
+ qb("Cannot construct " + h.name + " due to unbound types", g);
+ };
+ T([], g, function(k) {
+ k.splice(1, 0, null);
+ h.M.X[b - 1] = rb(m, k, null, e2, f);
+ return [];
+ });
+ return [];
+ });
+ }, a: function(a, b, c, d, e2, f, g, h) {
+ var m = sb(c, d);
+ b = K(b);
+ f = X(e2, f);
+ T([], [a], function(k) {
+ function n() {
+ qb("Cannot call " + p + " due to unbound types", m);
+ }
+ __name(n, "n");
+ k = k[0];
+ var p = k.name + "." + b;
+ b.startsWith("@@") && (b = Symbol[b.substring(2)]);
+ h && k.M.ja.push(b);
+ var r = k.M.W, u = r[b];
+ void 0 === u || void 0 === u.R && u.className !== k.name && u.Y === c - 2 ? (n.Y = c - 2, n.className = k.name, r[b] = n) : (db(r, b, p), r[b].R[c - 2] = n);
+ T([], m, function(t2) {
+ t2 = rb(p, t2, k, f, g);
+ void 0 === r[b].R ? (t2.Y = c - 2, r[b] = t2) : r[b].R[c - 2] = t2;
+ return [];
+ });
+ return [];
+ });
+ }, A: function(a, b) {
+ b = K(b);
+ U(a, { name: b, fromWireType: function(c) {
+ var d = J(c);
+ tb(c);
+ return d;
+ }, toWireType: function(c, d) {
+ return Ia(d);
+ }, argPackAdvance: 8, readValueFromPointer: R, U: null });
+ }, m: function(a, b, c) {
+ c = bb(c);
+ b = K(b);
+ U(a, { name: b, fromWireType: function(d) {
+ return d;
+ }, toWireType: function(d, e2) {
+ return e2;
+ }, argPackAdvance: 8, readValueFromPointer: ub(b, c), U: null });
+ }, d: function(a, b, c, d, e2) {
+ b = K(b);
+ -1 === e2 && (e2 = 4294967295);
+ e2 = bb(c);
+ var f = /* @__PURE__ */ __name((h) => h, "f");
+ if (0 === d) {
+ var g = 32 - 8 * c;
+ f = /* @__PURE__ */ __name((h) => h << g >>> g, "f");
+ }
+ c = b.includes("unsigned") ? function(h, m) {
+ return m >>> 0;
+ } : function(h, m) {
+ return m;
+ };
+ U(a, { name: b, fromWireType: f, toWireType: c, argPackAdvance: 8, readValueFromPointer: vb(b, e2, 0 !== d), U: null });
+ }, b: function(a, b, c) {
+ function d(f) {
+ f >>= 2;
+ var g = A;
+ return new e2(pa2, g[f + 1], g[f]);
+ }
+ __name(d, "d");
+ var e2 = [Int8Array, Uint8Array, Int16Array, Uint16Array, Int32Array, Uint32Array, Float32Array, Float64Array][b];
+ c = K(c);
+ U(
+ a,
+ { name: c, fromWireType: d, argPackAdvance: 8, readValueFromPointer: d },
+ { ua: true }
+ );
+ }, n: function(a, b) {
+ b = K(b);
+ var c = "std::string" === b;
+ U(a, { name: b, fromWireType: function(d) {
+ var e2 = A[d >> 2], f = d + 4;
+ if (c)
+ for (var g = f, h = 0; h <= e2; ++h) {
+ var m = f + h;
+ if (h == e2 || 0 == w[m]) {
+ g = g ? oa(w, g, m - g) : "";
+ if (void 0 === k)
+ var k = g;
+ else
+ k += String.fromCharCode(0), k += g;
+ g = m + 1;
+ }
+ }
+ else {
+ k = Array(e2);
+ for (h = 0; h < e2; ++h)
+ k[h] = String.fromCharCode(w[f + h]);
+ k = k.join("");
+ }
+ P(d);
+ return k;
+ }, toWireType: function(d, e2) {
+ e2 instanceof ArrayBuffer && (e2 = new Uint8Array(e2));
+ var f, g = "string" == typeof e2;
+ g || e2 instanceof Uint8Array || e2 instanceof Uint8ClampedArray || e2 instanceof Int8Array || I("Cannot pass non-string to std::string");
+ if (c && g) {
+ var h = 0;
+ for (f = 0; f < e2.length; ++f) {
+ var m = e2.charCodeAt(f);
+ 127 >= m ? h++ : 2047 >= m ? h += 2 : 55296 <= m && 57343 >= m ? (h += 4, ++f) : h += 3;
+ }
+ f = h;
+ } else
+ f = e2.length;
+ h = Lb(4 + f + 1);
+ m = h + 4;
+ A[h >> 2] = f;
+ if (c && g) {
+ if (g = m, m = f + 1, f = w, 0 < m) {
+ m = g + m - 1;
+ for (var k = 0; k < e2.length; ++k) {
+ var n = e2.charCodeAt(k);
+ if (55296 <= n && 57343 >= n) {
+ var p = e2.charCodeAt(++k);
+ n = 65536 + ((n & 1023) << 10) | p & 1023;
+ }
+ if (127 >= n) {
+ if (g >= m)
+ break;
+ f[g++] = n;
+ } else {
+ if (2047 >= n) {
+ if (g + 1 >= m)
+ break;
+ f[g++] = 192 | n >> 6;
+ } else {
+ if (65535 >= n) {
+ if (g + 2 >= m)
+ break;
+ f[g++] = 224 | n >> 12;
+ } else {
+ if (g + 3 >= m)
+ break;
+ f[g++] = 240 | n >> 18;
+ f[g++] = 128 | n >> 12 & 63;
+ }
+ f[g++] = 128 | n >> 6 & 63;
+ }
+ f[g++] = 128 | n & 63;
+ }
+ }
+ f[g] = 0;
+ }
+ } else if (g)
+ for (g = 0; g < f; ++g)
+ k = e2.charCodeAt(g), 255 < k && (P(m), I("String has UTF-16 code units that do not fit in 8 bits")), w[m + g] = k;
+ else
+ for (g = 0; g < f; ++g)
+ w[m + g] = e2[g];
+ null !== d && d.push(P, h);
+ return h;
+ }, argPackAdvance: 8, readValueFromPointer: R, U: function(d) {
+ P(d);
+ } });
+ }, i: function(a, b, c) {
+ c = K(c);
+ if (2 === b) {
+ var d = wb;
+ var e2 = xb;
+ var f = yb;
+ var g = /* @__PURE__ */ __name(() => ra, "g");
+ var h = 1;
+ } else
+ 4 === b && (d = zb, e2 = Ab, f = Bb, g = /* @__PURE__ */ __name(() => A, "g"), h = 2);
+ U(a, { name: c, fromWireType: function(m) {
+ for (var k = A[m >> 2], n = g(), p, r = m + 4, u = 0; u <= k; ++u) {
+ var t2 = m + 4 + u * b;
+ if (u == k || 0 == n[t2 >> h])
+ r = d(r, t2 - r), void 0 === p ? p = r : (p += String.fromCharCode(0), p += r), r = t2 + b;
+ }
+ P(m);
+ return p;
+ }, toWireType: function(m, k) {
+ "string" != typeof k && I("Cannot pass non-string to C++ string type " + c);
+ var n = f(k), p = Lb(4 + n + b);
+ A[p >> 2] = n >> h;
+ e2(k, p + 4, n + b);
+ null !== m && m.push(P, p);
+ return p;
+ }, argPackAdvance: 8, readValueFromPointer: R, U: function(m) {
+ P(m);
+ } });
+ }, k: function(a, b, c, d, e2, f) {
+ Za[a] = {
+ name: K(b),
+ fa: X(c, d),
+ V: X(e2, f),
+ ia: []
+ };
+ }, h: function(a, b, c, d, e2, f, g, h, m, k) {
+ Za[a].ia.push({ oa: K(b), ta: c, ra: X(d, e2), sa: f, za: g, ya: X(h, m), Aa: k });
+ }, C: function(a, b) {
+ b = K(b);
+ U(a, { va: true, name: b, argPackAdvance: 0, fromWireType: function() {
+ }, toWireType: function() {
+ } });
+ }, s: function(a, b, c, d, e2) {
+ a = Eb[a];
+ b = J(b);
+ c = Db(c);
+ var f = [];
+ A[d >> 2] = Ia(f);
+ return a(b, c, f, e2);
+ }, t: function(a, b, c, d) {
+ a = Eb[a];
+ b = J(b);
+ c = Db(c);
+ a(b, c, null, d);
+ }, g: tb, l: function(a, b) {
+ var c = Gb(a, b), d = c[0];
+ b = d.name + "_$" + c.slice(1).map(function(g) {
+ return g.name;
+ }).join("_") + "$";
+ var e2 = Hb[b];
+ if (void 0 !== e2)
+ return e2;
+ var f = Array(a - 1);
+ e2 = Fb((g, h, m, k) => {
+ for (var n = 0, p = 0; p < a - 1; ++p)
+ f[p] = c[p + 1].readValueFromPointer(k + n), n += c[p + 1].argPackAdvance;
+ g = g[h].apply(g, f);
+ for (p = 0; p < a - 1; ++p)
+ c[p + 1].ma && c[p + 1].ma(f[p]);
+ if (!d.va)
+ return d.toWireType(m, g);
+ });
+ return Hb[b] = e2;
+ }, q: function(a) {
+ 4 < a && (F[a].ga += 1);
+ }, r: function(a) {
+ var b = J(a);
+ $a(b);
+ tb(a);
+ }, e: function() {
+ la("");
+ }, x: function(a, b, c) {
+ w.copyWithin(a, b, b + c);
+ }, w: function(a) {
+ var b = w.length;
+ a >>>= 0;
+ if (2147483648 < a)
+ return false;
+ for (var c = 1; 4 >= c; c *= 2) {
+ var d = b * (1 + 0.2 / c);
+ d = Math.min(d, a + 100663296);
+ var e2 = Math;
+ d = Math.max(a, d);
+ e2 = e2.min.call(e2, 2147483648, d + (65536 - d % 65536) % 65536);
+ a: {
+ try {
+ ma.grow(e2 - pa2.byteLength + 65535 >>> 16);
+ ua();
+ var f = 1;
+ break a;
+ } catch (g) {
+ }
+ f = void 0;
+ }
+ if (f)
+ return true;
+ }
+ return false;
+ }, z: function() {
+ return 52;
+ }, u: function() {
+ return 70;
+ }, y: function(a, b, c, d) {
+ for (var e2 = 0, f = 0; f < c; f++) {
+ var g = A[b >> 2], h = A[b + 4 >> 2];
+ b += 8;
+ for (var m = 0; m < h; m++) {
+ var k = w[g + m], n = Ib[a];
+ 0 === k || 10 === k ? ((1 === a ? ja : v)(oa(n, 0)), n.length = 0) : n.push(k);
+ }
+ e2 += h;
+ }
+ A[d >> 2] = e2;
+ return 0;
+ } }, Y = function() {
+ function a(c) {
+ l.asm = c.exports;
+ ma = l.asm.D;
+ ua();
+ va = l.asm.I;
+ xa.unshift(l.asm.E);
+ B--;
+ l.monitorRunDependencies && l.monitorRunDependencies(B);
+ 0 == B && (null !== Aa && (clearInterval(Aa), Aa = null), D && (c = D, D = null, c()));
+ }
+ __name(a, "a");
+ var b = { a: Mb };
+ B++;
+ l.monitorRunDependencies && l.monitorRunDependencies(B);
+ if (l.instantiateWasm)
+ try {
+ return l.instantiateWasm(b, a);
+ } catch (c) {
+ v("Module.instantiateWasm callback failed with error: " + c), ba(c);
+ }
+ b = Ca(b);
+ a(b[0]);
+ return l.asm;
+ }();
+ l.___wasm_call_ctors = Y.E;
+ var Oa = l.___getTypeName = Y.F;
+ l.__embind_initialize_bindings = Y.G;
+ var Lb = l._malloc = Y.H, P = l._free = Y.J;
+ l.dynCall_jiji = Y.K;
+ var Nb;
+ D = /* @__PURE__ */ __name(function Ob() {
+ Nb || Pb();
+ Nb || (D = Ob);
+ }, "Ob");
+ function Pb() {
+ function a() {
+ if (!Nb && (Nb = true, l.calledRun = true, !na)) {
+ Da(xa);
+ aa(l);
+ if (l.onRuntimeInitialized)
+ l.onRuntimeInitialized();
+ if (l.postRun)
+ for ("function" == typeof l.postRun && (l.postRun = [l.postRun]); l.postRun.length; ) {
+ var b = l.postRun.shift();
+ ya.unshift(b);
+ }
+ Da(ya);
+ }
+ }
+ __name(a, "a");
+ if (!(0 < B)) {
+ if (l.preRun)
+ for ("function" == typeof l.preRun && (l.preRun = [l.preRun]); l.preRun.length; )
+ za();
+ Da(wa);
+ 0 < B || (l.setStatus ? (l.setStatus("Running..."), setTimeout(function() {
+ setTimeout(function() {
+ l.setStatus("");
+ }, 1);
+ a();
+ }, 1)) : a());
+ }
+ }
+ __name(Pb, "Pb");
+ if (l.preInit)
+ for ("function" == typeof l.preInit && (l.preInit = [l.preInit]); 0 < l.preInit.length; )
+ l.preInit.pop()();
+ Pb();
+ return loadYoga2;
+ };
+ })();
+ if (typeof exports2 === "object" && typeof module2 === "object")
+ module2.exports = loadYoga;
+ else if (typeof define === "function" && define["amd"])
+ define([], function() {
+ return loadYoga;
+ });
+ else if (typeof exports2 === "object")
+ exports2["loadYoga"] = loadYoga;
+ }
+});
+
+// ../../node_modules/.pnpm/file+vendor+yoga-layout-2.0.0-beta.1.tgz/node_modules/yoga-layout/dist/generated/YGEnums.js
+var require_YGEnums = __commonJS({
+ "../../node_modules/.pnpm/file+vendor+yoga-layout-2.0.0-beta.1.tgz/node_modules/yoga-layout/dist/generated/YGEnums.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ module2.exports = {
+ ALIGN_AUTO: 0,
+ ALIGN_FLEX_START: 1,
+ ALIGN_CENTER: 2,
+ ALIGN_FLEX_END: 3,
+ ALIGN_STRETCH: 4,
+ ALIGN_BASELINE: 5,
+ ALIGN_SPACE_BETWEEN: 6,
+ ALIGN_SPACE_AROUND: 7,
+ DIMENSION_WIDTH: 0,
+ DIMENSION_HEIGHT: 1,
+ DIRECTION_INHERIT: 0,
+ DIRECTION_LTR: 1,
+ DIRECTION_RTL: 2,
+ DISPLAY_FLEX: 0,
+ DISPLAY_NONE: 1,
+ EDGE_LEFT: 0,
+ EDGE_TOP: 1,
+ EDGE_RIGHT: 2,
+ EDGE_BOTTOM: 3,
+ EDGE_START: 4,
+ EDGE_END: 5,
+ EDGE_HORIZONTAL: 6,
+ EDGE_VERTICAL: 7,
+ EDGE_ALL: 8,
+ EXPERIMENTAL_FEATURE_WEB_FLEX_BASIS: 0,
+ FLEX_DIRECTION_COLUMN: 0,
+ FLEX_DIRECTION_COLUMN_REVERSE: 1,
+ FLEX_DIRECTION_ROW: 2,
+ FLEX_DIRECTION_ROW_REVERSE: 3,
+ GUTTER_COLUMN: 0,
+ GUTTER_ROW: 1,
+ GUTTER_ALL: 2,
+ JUSTIFY_FLEX_START: 0,
+ JUSTIFY_CENTER: 1,
+ JUSTIFY_FLEX_END: 2,
+ JUSTIFY_SPACE_BETWEEN: 3,
+ JUSTIFY_SPACE_AROUND: 4,
+ JUSTIFY_SPACE_EVENLY: 5,
+ LOG_LEVEL_ERROR: 0,
+ LOG_LEVEL_WARN: 1,
+ LOG_LEVEL_INFO: 2,
+ LOG_LEVEL_DEBUG: 3,
+ LOG_LEVEL_VERBOSE: 4,
+ LOG_LEVEL_FATAL: 5,
+ MEASURE_MODE_UNDEFINED: 0,
+ MEASURE_MODE_EXACTLY: 1,
+ MEASURE_MODE_AT_MOST: 2,
+ NODE_TYPE_DEFAULT: 0,
+ NODE_TYPE_TEXT: 1,
+ OVERFLOW_VISIBLE: 0,
+ OVERFLOW_HIDDEN: 1,
+ OVERFLOW_SCROLL: 2,
+ POSITION_TYPE_STATIC: 0,
+ POSITION_TYPE_RELATIVE: 1,
+ POSITION_TYPE_ABSOLUTE: 2,
+ PRINT_OPTIONS_LAYOUT: 1,
+ PRINT_OPTIONS_STYLE: 2,
+ PRINT_OPTIONS_CHILDREN: 4,
+ UNIT_UNDEFINED: 0,
+ UNIT_POINT: 1,
+ UNIT_PERCENT: 2,
+ UNIT_AUTO: 3,
+ WRAP_NO_WRAP: 0,
+ WRAP_WRAP: 1,
+ WRAP_WRAP_REVERSE: 2
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/file+vendor+yoga-layout-2.0.0-beta.1.tgz/node_modules/yoga-layout/dist/wrapAsm.js
+var require_wrapAsm = __commonJS({
+ "../../node_modules/.pnpm/file+vendor+yoga-layout-2.0.0-beta.1.tgz/node_modules/yoga-layout/dist/wrapAsm.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var CONSTANTS = require_YGEnums();
+ module2.exports = (lib) => {
+ function patch(prototype, name, fn2) {
+ const original = prototype[name];
+ prototype[name] = function() {
+ for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+ args[_key] = arguments[_key];
+ }
+ return fn2.call(this, original, ...args);
+ };
+ }
+ __name(patch, "patch");
+ for (const fnName of ["setPosition", "setMargin", "setFlexBasis", "setWidth", "setHeight", "setMinWidth", "setMinHeight", "setMaxWidth", "setMaxHeight", "setPadding"]) {
+ const methods = {
+ [CONSTANTS.UNIT_POINT]: lib.Node.prototype[fnName],
+ [CONSTANTS.UNIT_PERCENT]: lib.Node.prototype[`${fnName}Percent`],
+ [CONSTANTS.UNIT_AUTO]: lib.Node.prototype[`${fnName}Auto`]
+ };
+ patch(lib.Node.prototype, fnName, function(original) {
+ for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+ args[_key2 - 1] = arguments[_key2];
+ }
+ const value = args.pop();
+ let unit, asNumber;
+ if (value === "auto") {
+ unit = CONSTANTS.UNIT_AUTO;
+ asNumber = void 0;
+ } else if (typeof value === "object") {
+ unit = value.unit;
+ asNumber = value.valueOf();
+ } else {
+ unit = typeof value === "string" && value.endsWith("%") ? CONSTANTS.UNIT_PERCENT : CONSTANTS.UNIT_POINT;
+ asNumber = parseFloat(value);
+ if (!Number.isNaN(value) && Number.isNaN(asNumber)) {
+ throw new Error(`Invalid value ${value} for ${fnName}`);
+ }
+ }
+ if (!methods[unit])
+ throw new Error(`Failed to execute "${fnName}": Unsupported unit '${value}'`);
+ if (asNumber !== void 0) {
+ return methods[unit].call(this, ...args, asNumber);
+ } else {
+ return methods[unit].call(this, ...args);
+ }
+ });
+ }
+ function wrapMeasureFunction(measureFunction) {
+ return lib.MeasureCallback.implement({
+ measure: measureFunction
+ });
+ }
+ __name(wrapMeasureFunction, "wrapMeasureFunction");
+ patch(lib.Node.prototype, "setMeasureFunc", function(original, measureFunc) {
+ original.call(this, wrapMeasureFunction(measureFunc));
+ });
+ function wrapDirtiedFunc(dirtiedFunction) {
+ return lib.DirtiedCallback.implement({
+ dirtied: dirtiedFunction
+ });
+ }
+ __name(wrapDirtiedFunc, "wrapDirtiedFunc");
+ patch(lib.Node.prototype, "setDirtiedFunc", function(original, dirtiedFunc) {
+ original.call(this, wrapDirtiedFunc(dirtiedFunc));
+ });
+ patch(lib.Config.prototype, "free", function() {
+ lib.Config.destroy(this);
+ });
+ patch(lib.Node, "create", (_2, config) => {
+ return config ? lib.Node.createWithConfig(config) : lib.Node.createDefault();
+ });
+ patch(lib.Node.prototype, "free", function() {
+ lib.Node.destroy(this);
+ });
+ patch(lib.Node.prototype, "freeRecursive", function() {
+ for (let t2 = 0, T = this.getChildCount(); t2 < T; ++t2) {
+ this.getChild(0).freeRecursive();
+ }
+ this.free();
+ });
+ patch(lib.Node.prototype, "setMeasureFunc", function(original, measureFunc) {
+ if (measureFunc) {
+ return original.call(this, function() {
+ return measureFunc(...arguments);
+ });
+ } else {
+ return this.unsetMeasureFunc();
+ }
+ });
+ patch(lib.Node.prototype, "calculateLayout", function(original) {
+ let width = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : NaN;
+ let height = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : NaN;
+ let direction = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : CONSTANTS.DIRECTION_LTR;
+ return original.call(this, width, height, direction);
+ });
+ return {
+ Config: lib.Config,
+ Node: lib.Node,
+ ...CONSTANTS
+ };
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/file+vendor+yoga-layout-2.0.0-beta.1.tgz/node_modules/yoga-layout/dist/entrypoint/_entrySync.js
+var require_entrySync = __commonJS({
+ "../../node_modules/.pnpm/file+vendor+yoga-layout-2.0.0-beta.1.tgz/node_modules/yoga-layout/dist/entrypoint/_entrySync.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var wrapAsm = require_wrapAsm();
+ module2.exports = (asm) => wrapAsm(asm());
+ }
+});
+
+// ../../node_modules/.pnpm/file+vendor+yoga-layout-2.0.0-beta.1.tgz/node_modules/yoga-layout/dist/entrypoint/wasm-sync.js
+var require_wasm_sync2 = __commonJS({
+ "../../node_modules/.pnpm/file+vendor+yoga-layout-2.0.0-beta.1.tgz/node_modules/yoga-layout/dist/entrypoint/wasm-sync.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var asm = require_wasm_sync();
+ module2.exports = require_entrySync()(asm);
+ }
+});
+
+// ../../node_modules/.pnpm/ansi-regex@5.0.1/node_modules/ansi-regex/index.js
+var require_ansi_regex = __commonJS({
+ "../../node_modules/.pnpm/ansi-regex@5.0.1/node_modules/ansi-regex/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ module2.exports = ({ onlyFirst = false } = {}) => {
+ const pattern = [
+ "[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)",
+ "(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~]))"
+ ].join("|");
+ return new RegExp(pattern, onlyFirst ? void 0 : "g");
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/strip-ansi@6.0.1/node_modules/strip-ansi/index.js
+var require_strip_ansi = __commonJS({
+ "../../node_modules/.pnpm/strip-ansi@6.0.1/node_modules/strip-ansi/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var ansiRegex = require_ansi_regex();
+ module2.exports = (string) => typeof string === "string" ? string.replace(ansiRegex(), "") : string;
+ }
+});
+
+// ../../node_modules/.pnpm/is-fullwidth-code-point@3.0.0/node_modules/is-fullwidth-code-point/index.js
+var require_is_fullwidth_code_point = __commonJS({
+ "../../node_modules/.pnpm/is-fullwidth-code-point@3.0.0/node_modules/is-fullwidth-code-point/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var isFullwidthCodePoint = /* @__PURE__ */ __name((codePoint) => {
+ if (Number.isNaN(codePoint)) {
+ return false;
+ }
+ if (codePoint >= 4352 && (codePoint <= 4447 || // Hangul Jamo
+ codePoint === 9001 || // LEFT-POINTING ANGLE BRACKET
+ codePoint === 9002 || // RIGHT-POINTING ANGLE BRACKET
+ // CJK Radicals Supplement .. Enclosed CJK Letters and Months
+ 11904 <= codePoint && codePoint <= 12871 && codePoint !== 12351 || // Enclosed CJK Letters and Months .. CJK Unified Ideographs Extension A
+ 12880 <= codePoint && codePoint <= 19903 || // CJK Unified Ideographs .. Yi Radicals
+ 19968 <= codePoint && codePoint <= 42182 || // Hangul Jamo Extended-A
+ 43360 <= codePoint && codePoint <= 43388 || // Hangul Syllables
+ 44032 <= codePoint && codePoint <= 55203 || // CJK Compatibility Ideographs
+ 63744 <= codePoint && codePoint <= 64255 || // Vertical Forms
+ 65040 <= codePoint && codePoint <= 65049 || // CJK Compatibility Forms .. Small Form Variants
+ 65072 <= codePoint && codePoint <= 65131 || // Halfwidth and Fullwidth Forms
+ 65281 <= codePoint && codePoint <= 65376 || 65504 <= codePoint && codePoint <= 65510 || // Kana Supplement
+ 110592 <= codePoint && codePoint <= 110593 || // Enclosed Ideographic Supplement
+ 127488 <= codePoint && codePoint <= 127569 || // CJK Unified Ideographs Extension B .. Tertiary Ideographic Plane
+ 131072 <= codePoint && codePoint <= 262141)) {
+ return true;
+ }
+ return false;
+ }, "isFullwidthCodePoint");
+ module2.exports = isFullwidthCodePoint;
+ module2.exports.default = isFullwidthCodePoint;
+ }
+});
+
+// ../../node_modules/.pnpm/emoji-regex@8.0.0/node_modules/emoji-regex/index.js
+var require_emoji_regex = __commonJS({
+ "../../node_modules/.pnpm/emoji-regex@8.0.0/node_modules/emoji-regex/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ module2.exports = function() {
+ return /\uD83C\uDFF4\uDB40\uDC67\uDB40\uDC62(?:\uDB40\uDC65\uDB40\uDC6E\uDB40\uDC67|\uDB40\uDC73\uDB40\uDC63\uDB40\uDC74|\uDB40\uDC77\uDB40\uDC6C\uDB40\uDC73)\uDB40\uDC7F|\uD83D\uDC68(?:\uD83C\uDFFC\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68\uD83C\uDFFB|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFF\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFB-\uDFFE])|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFE\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFB-\uDFFD])|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFD\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFB\uDFFC])|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\u200D(?:\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D)?\uD83D\uDC68|(?:\uD83D[\uDC68\uDC69])\u200D(?:\uD83D\uDC66\u200D\uD83D\uDC66|\uD83D\uDC67\u200D(?:\uD83D[\uDC66\uDC67]))|\uD83D\uDC66\u200D\uD83D\uDC66|\uD83D\uDC67\u200D(?:\uD83D[\uDC66\uDC67])|(?:\uD83D[\uDC68\uDC69])\u200D(?:\uD83D[\uDC66\uDC67])|[\u2695\u2696\u2708]\uFE0F|\uD83D[\uDC66\uDC67]|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|(?:\uD83C\uDFFB\u200D[\u2695\u2696\u2708]|\uD83C\uDFFF\u200D[\u2695\u2696\u2708]|\uD83C\uDFFE\u200D[\u2695\u2696\u2708]|\uD83C\uDFFD\u200D[\u2695\u2696\u2708]|\uD83C\uDFFC\u200D[\u2695\u2696\u2708])\uFE0F|\uD83C\uDFFB\u200D(?:\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C[\uDFFB-\uDFFF])|(?:\uD83E\uDDD1\uD83C\uDFFB\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1|\uD83D\uDC69\uD83C\uDFFC\u200D\uD83E\uDD1D\u200D\uD83D\uDC69)\uD83C\uDFFB|\uD83E\uDDD1(?:\uD83C\uDFFF\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1(?:\uD83C[\uDFFB-\uDFFF])|\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1)|(?:\uD83E\uDDD1\uD83C\uDFFE\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1|\uD83D\uDC69\uD83C\uDFFF\u200D\uD83E\uDD1D\u200D(?:\uD83D[\uDC68\uDC69]))(?:\uD83C[\uDFFB-\uDFFE])|(?:\uD83E\uDDD1\uD83C\uDFFC\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1|\uD83D\uDC69\uD83C\uDFFD\u200D\uD83E\uDD1D\u200D\uD83D\uDC69)(?:\uD83C[\uDFFB\uDFFC])|\uD83D\uDC69(?:\uD83C\uDFFE\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFB-\uDFFD\uDFFF])|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFC\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFB\uDFFD-\uDFFF])|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFB\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFC-\uDFFF])|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFD\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\u200D(?:\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D(?:\uD83D[\uDC68\uDC69])|\uD83D[\uDC68\uDC69])|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFF\u200D(?:\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD]))|\uD83D\uDC69\u200D\uD83D\uDC69\u200D(?:\uD83D\uDC66\u200D\uD83D\uDC66|\uD83D\uDC67\u200D(?:\uD83D[\uDC66\uDC67]))|(?:\uD83E\uDDD1\uD83C\uDFFD\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1|\uD83D\uDC69\uD83C\uDFFE\u200D\uD83E\uDD1D\u200D\uD83D\uDC69)(?:\uD83C[\uDFFB-\uDFFD])|\uD83D\uDC69\u200D\uD83D\uDC66\u200D\uD83D\uDC66|\uD83D\uDC69\u200D\uD83D\uDC69\u200D(?:\uD83D[\uDC66\uDC67])|(?:\uD83D\uDC41\uFE0F\u200D\uD83D\uDDE8|\uD83D\uDC69(?:\uD83C\uDFFF\u200D[\u2695\u2696\u2708]|\uD83C\uDFFE\u200D[\u2695\u2696\u2708]|\uD83C\uDFFC\u200D[\u2695\u2696\u2708]|\uD83C\uDFFB\u200D[\u2695\u2696\u2708]|\uD83C\uDFFD\u200D[\u2695\u2696\u2708]|\u200D[\u2695\u2696\u2708])|(?:(?:\u26F9|\uD83C[\uDFCB\uDFCC]|\uD83D\uDD75)\uFE0F|\uD83D\uDC6F|\uD83E[\uDD3C\uDDDE\uDDDF])\u200D[\u2640\u2642]|(?:\u26F9|\uD83C[\uDFCB\uDFCC]|\uD83D\uDD75)(?:\uD83C[\uDFFB-\uDFFF])\u200D[\u2640\u2642]|(?:\uD83C[\uDFC3\uDFC4\uDFCA]|\uD83D[\uDC6E\uDC71\uDC73\uDC77\uDC81\uDC82\uDC86\uDC87\uDE45-\uDE47\uDE4B\uDE4D\uDE4E\uDEA3\uDEB4-\uDEB6]|\uD83E[\uDD26\uDD37-\uDD39\uDD3D\uDD3E\uDDB8\uDDB9\uDDCD-\uDDCF\uDDD6-\uDDDD])(?:(?:\uD83C[\uDFFB-\uDFFF])\u200D[\u2640\u2642]|\u200D[\u2640\u2642])|\uD83C\uDFF4\u200D\u2620)\uFE0F|\uD83D\uDC69\u200D\uD83D\uDC67\u200D(?:\uD83D[\uDC66\uDC67])|\uD83C\uDFF3\uFE0F\u200D\uD83C\uDF08|\uD83D\uDC15\u200D\uD83E\uDDBA|\uD83D\uDC69\u200D\uD83D\uDC66|\uD83D\uDC69\u200D\uD83D\uDC67|\uD83C\uDDFD\uD83C\uDDF0|\uD83C\uDDF4\uD83C\uDDF2|\uD83C\uDDF6\uD83C\uDDE6|[#\*0-9]\uFE0F\u20E3|\uD83C\uDDE7(?:\uD83C[\uDDE6\uDDE7\uDDE9-\uDDEF\uDDF1-\uDDF4\uDDF6-\uDDF9\uDDFB\uDDFC\uDDFE\uDDFF])|\uD83C\uDDF9(?:\uD83C[\uDDE6\uDDE8\uDDE9\uDDEB-\uDDED\uDDEF-\uDDF4\uDDF7\uDDF9\uDDFB\uDDFC\uDDFF])|\uD83C\uDDEA(?:\uD83C[\uDDE6\uDDE8\uDDEA\uDDEC\uDDED\uDDF7-\uDDFA])|\uD83E\uDDD1(?:\uD83C[\uDFFB-\uDFFF])|\uD83C\uDDF7(?:\uD83C[\uDDEA\uDDF4\uDDF8\uDDFA\uDDFC])|\uD83D\uDC69(?:\uD83C[\uDFFB-\uDFFF])|\uD83C\uDDF2(?:\uD83C[\uDDE6\uDDE8-\uDDED\uDDF0-\uDDFF])|\uD83C\uDDE6(?:\uD83C[\uDDE8-\uDDEC\uDDEE\uDDF1\uDDF2\uDDF4\uDDF6-\uDDFA\uDDFC\uDDFD\uDDFF])|\uD83C\uDDF0(?:\uD83C[\uDDEA\uDDEC-\uDDEE\uDDF2\uDDF3\uDDF5\uDDF7\uDDFC\uDDFE\uDDFF])|\uD83C\uDDED(?:\uD83C[\uDDF0\uDDF2\uDDF3\uDDF7\uDDF9\uDDFA])|\uD83C\uDDE9(?:\uD83C[\uDDEA\uDDEC\uDDEF\uDDF0\uDDF2\uDDF4\uDDFF])|\uD83C\uDDFE(?:\uD83C[\uDDEA\uDDF9])|\uD83C\uDDEC(?:\uD83C[\uDDE6\uDDE7\uDDE9-\uDDEE\uDDF1-\uDDF3\uDDF5-\uDDFA\uDDFC\uDDFE])|\uD83C\uDDF8(?:\uD83C[\uDDE6-\uDDEA\uDDEC-\uDDF4\uDDF7-\uDDF9\uDDFB\uDDFD-\uDDFF])|\uD83C\uDDEB(?:\uD83C[\uDDEE-\uDDF0\uDDF2\uDDF4\uDDF7])|\uD83C\uDDF5(?:\uD83C[\uDDE6\uDDEA-\uDDED\uDDF0-\uDDF3\uDDF7-\uDDF9\uDDFC\uDDFE])|\uD83C\uDDFB(?:\uD83C[\uDDE6\uDDE8\uDDEA\uDDEC\uDDEE\uDDF3\uDDFA])|\uD83C\uDDF3(?:\uD83C[\uDDE6\uDDE8\uDDEA-\uDDEC\uDDEE\uDDF1\uDDF4\uDDF5\uDDF7\uDDFA\uDDFF])|\uD83C\uDDE8(?:\uD83C[\uDDE6\uDDE8\uDDE9\uDDEB-\uDDEE\uDDF0-\uDDF5\uDDF7\uDDFA-\uDDFF])|\uD83C\uDDF1(?:\uD83C[\uDDE6-\uDDE8\uDDEE\uDDF0\uDDF7-\uDDFB\uDDFE])|\uD83C\uDDFF(?:\uD83C[\uDDE6\uDDF2\uDDFC])|\uD83C\uDDFC(?:\uD83C[\uDDEB\uDDF8])|\uD83C\uDDFA(?:\uD83C[\uDDE6\uDDEC\uDDF2\uDDF3\uDDF8\uDDFE\uDDFF])|\uD83C\uDDEE(?:\uD83C[\uDDE8-\uDDEA\uDDF1-\uDDF4\uDDF6-\uDDF9])|\uD83C\uDDEF(?:\uD83C[\uDDEA\uDDF2\uDDF4\uDDF5])|(?:\uD83C[\uDFC3\uDFC4\uDFCA]|\uD83D[\uDC6E\uDC71\uDC73\uDC77\uDC81\uDC82\uDC86\uDC87\uDE45-\uDE47\uDE4B\uDE4D\uDE4E\uDEA3\uDEB4-\uDEB6]|\uD83E[\uDD26\uDD37-\uDD39\uDD3D\uDD3E\uDDB8\uDDB9\uDDCD-\uDDCF\uDDD6-\uDDDD])(?:\uD83C[\uDFFB-\uDFFF])|(?:\u26F9|\uD83C[\uDFCB\uDFCC]|\uD83D\uDD75)(?:\uD83C[\uDFFB-\uDFFF])|(?:[\u261D\u270A-\u270D]|\uD83C[\uDF85\uDFC2\uDFC7]|\uD83D[\uDC42\uDC43\uDC46-\uDC50\uDC66\uDC67\uDC6B-\uDC6D\uDC70\uDC72\uDC74-\uDC76\uDC78\uDC7C\uDC83\uDC85\uDCAA\uDD74\uDD7A\uDD90\uDD95\uDD96\uDE4C\uDE4F\uDEC0\uDECC]|\uD83E[\uDD0F\uDD18-\uDD1C\uDD1E\uDD1F\uDD30-\uDD36\uDDB5\uDDB6\uDDBB\uDDD2-\uDDD5])(?:\uD83C[\uDFFB-\uDFFF])|(?:[\u231A\u231B\u23E9-\u23EC\u23F0\u23F3\u25FD\u25FE\u2614\u2615\u2648-\u2653\u267F\u2693\u26A1\u26AA\u26AB\u26BD\u26BE\u26C4\u26C5\u26CE\u26D4\u26EA\u26F2\u26F3\u26F5\u26FA\u26FD\u2705\u270A\u270B\u2728\u274C\u274E\u2753-\u2755\u2757\u2795-\u2797\u27B0\u27BF\u2B1B\u2B1C\u2B50\u2B55]|\uD83C[\uDC04\uDCCF\uDD8E\uDD91-\uDD9A\uDDE6-\uDDFF\uDE01\uDE1A\uDE2F\uDE32-\uDE36\uDE38-\uDE3A\uDE50\uDE51\uDF00-\uDF20\uDF2D-\uDF35\uDF37-\uDF7C\uDF7E-\uDF93\uDFA0-\uDFCA\uDFCF-\uDFD3\uDFE0-\uDFF0\uDFF4\uDFF8-\uDFFF]|\uD83D[\uDC00-\uDC3E\uDC40\uDC42-\uDCFC\uDCFF-\uDD3D\uDD4B-\uDD4E\uDD50-\uDD67\uDD7A\uDD95\uDD96\uDDA4\uDDFB-\uDE4F\uDE80-\uDEC5\uDECC\uDED0-\uDED2\uDED5\uDEEB\uDEEC\uDEF4-\uDEFA\uDFE0-\uDFEB]|\uD83E[\uDD0D-\uDD3A\uDD3C-\uDD45\uDD47-\uDD71\uDD73-\uDD76\uDD7A-\uDDA2\uDDA5-\uDDAA\uDDAE-\uDDCA\uDDCD-\uDDFF\uDE70-\uDE73\uDE78-\uDE7A\uDE80-\uDE82\uDE90-\uDE95])|(?:[#\*0-9\xA9\xAE\u203C\u2049\u2122\u2139\u2194-\u2199\u21A9\u21AA\u231A\u231B\u2328\u23CF\u23E9-\u23F3\u23F8-\u23FA\u24C2\u25AA\u25AB\u25B6\u25C0\u25FB-\u25FE\u2600-\u2604\u260E\u2611\u2614\u2615\u2618\u261D\u2620\u2622\u2623\u2626\u262A\u262E\u262F\u2638-\u263A\u2640\u2642\u2648-\u2653\u265F\u2660\u2663\u2665\u2666\u2668\u267B\u267E\u267F\u2692-\u2697\u2699\u269B\u269C\u26A0\u26A1\u26AA\u26AB\u26B0\u26B1\u26BD\u26BE\u26C4\u26C5\u26C8\u26CE\u26CF\u26D1\u26D3\u26D4\u26E9\u26EA\u26F0-\u26F5\u26F7-\u26FA\u26FD\u2702\u2705\u2708-\u270D\u270F\u2712\u2714\u2716\u271D\u2721\u2728\u2733\u2734\u2744\u2747\u274C\u274E\u2753-\u2755\u2757\u2763\u2764\u2795-\u2797\u27A1\u27B0\u27BF\u2934\u2935\u2B05-\u2B07\u2B1B\u2B1C\u2B50\u2B55\u3030\u303D\u3297\u3299]|\uD83C[\uDC04\uDCCF\uDD70\uDD71\uDD7E\uDD7F\uDD8E\uDD91-\uDD9A\uDDE6-\uDDFF\uDE01\uDE02\uDE1A\uDE2F\uDE32-\uDE3A\uDE50\uDE51\uDF00-\uDF21\uDF24-\uDF93\uDF96\uDF97\uDF99-\uDF9B\uDF9E-\uDFF0\uDFF3-\uDFF5\uDFF7-\uDFFF]|\uD83D[\uDC00-\uDCFD\uDCFF-\uDD3D\uDD49-\uDD4E\uDD50-\uDD67\uDD6F\uDD70\uDD73-\uDD7A\uDD87\uDD8A-\uDD8D\uDD90\uDD95\uDD96\uDDA4\uDDA5\uDDA8\uDDB1\uDDB2\uDDBC\uDDC2-\uDDC4\uDDD1-\uDDD3\uDDDC-\uDDDE\uDDE1\uDDE3\uDDE8\uDDEF\uDDF3\uDDFA-\uDE4F\uDE80-\uDEC5\uDECB-\uDED2\uDED5\uDEE0-\uDEE5\uDEE9\uDEEB\uDEEC\uDEF0\uDEF3-\uDEFA\uDFE0-\uDFEB]|\uD83E[\uDD0D-\uDD3A\uDD3C-\uDD45\uDD47-\uDD71\uDD73-\uDD76\uDD7A-\uDDA2\uDDA5-\uDDAA\uDDAE-\uDDCA\uDDCD-\uDDFF\uDE70-\uDE73\uDE78-\uDE7A\uDE80-\uDE82\uDE90-\uDE95])\uFE0F|(?:[\u261D\u26F9\u270A-\u270D]|\uD83C[\uDF85\uDFC2-\uDFC4\uDFC7\uDFCA-\uDFCC]|\uD83D[\uDC42\uDC43\uDC46-\uDC50\uDC66-\uDC78\uDC7C\uDC81-\uDC83\uDC85-\uDC87\uDC8F\uDC91\uDCAA\uDD74\uDD75\uDD7A\uDD90\uDD95\uDD96\uDE45-\uDE47\uDE4B-\uDE4F\uDEA3\uDEB4-\uDEB6\uDEC0\uDECC]|\uD83E[\uDD0F\uDD18-\uDD1F\uDD26\uDD30-\uDD39\uDD3C-\uDD3E\uDDB5\uDDB6\uDDB8\uDDB9\uDDBB\uDDCD-\uDDCF\uDDD1-\uDDDD])/g;
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/string-width@4.2.3/node_modules/string-width/index.js
+var require_string_width = __commonJS({
+ "../../node_modules/.pnpm/string-width@4.2.3/node_modules/string-width/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var stripAnsi2 = require_strip_ansi();
+ var isFullwidthCodePoint = require_is_fullwidth_code_point();
+ var emojiRegex = require_emoji_regex();
+ var stringWidth = /* @__PURE__ */ __name((string) => {
+ if (typeof string !== "string" || string.length === 0) {
+ return 0;
+ }
+ string = stripAnsi2(string);
+ if (string.length === 0) {
+ return 0;
+ }
+ string = string.replace(emojiRegex(), " ");
+ let width = 0;
+ for (let i = 0; i < string.length; i++) {
+ const code = string.codePointAt(i);
+ if (code <= 31 || code >= 127 && code <= 159) {
+ continue;
+ }
+ if (code >= 768 && code <= 879) {
+ continue;
+ }
+ if (code > 65535) {
+ i++;
+ }
+ width += isFullwidthCodePoint(code) ? 2 : 1;
+ }
+ return width;
+ }, "stringWidth");
+ module2.exports = stringWidth;
+ module2.exports.default = stringWidth;
+ }
+});
+
+// ../../node_modules/.pnpm/widest-line@3.1.0/node_modules/widest-line/index.js
+var require_widest_line = __commonJS({
+ "../../node_modules/.pnpm/widest-line@3.1.0/node_modules/widest-line/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var stringWidth = require_string_width();
+ var widestLine = /* @__PURE__ */ __name((input) => {
+ let max = 0;
+ for (const line of input.split("\n")) {
+ max = Math.max(max, stringWidth(line));
+ }
+ return max;
+ }, "widestLine");
+ module2.exports = widestLine;
+ module2.exports.default = widestLine;
+ }
+});
+
+// ../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/measure-text.js
+var require_measure_text = __commonJS({
+ "../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/measure-text.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ var __importDefault = exports2 && exports2.__importDefault || function(mod) {
+ return mod && mod.__esModule ? mod : { "default": mod };
+ };
+ Object.defineProperty(exports2, "__esModule", { value: true });
+ var widest_line_1 = __importDefault(require_widest_line());
+ var cache2 = {};
+ exports2.default = (text) => {
+ if (text.length === 0) {
+ return {
+ width: 0,
+ height: 0
+ };
+ }
+ if (cache2[text]) {
+ return cache2[text];
+ }
+ const width = widest_line_1.default(text);
+ const height = text.split("\n").length;
+ cache2[text] = { width, height };
+ return { width, height };
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/styles.js
+var require_styles = __commonJS({
+ "../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/styles.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ var __importDefault = exports2 && exports2.__importDefault || function(mod) {
+ return mod && mod.__esModule ? mod : { "default": mod };
+ };
+ Object.defineProperty(exports2, "__esModule", { value: true });
+ var yoga_layout_prebuilt_1 = __importDefault(require_wasm_sync2());
+ var applyPositionStyles = /* @__PURE__ */ __name((node, style) => {
+ if ("position" in style) {
+ node.setPositionType(style.position === "absolute" ? yoga_layout_prebuilt_1.default.POSITION_TYPE_ABSOLUTE : yoga_layout_prebuilt_1.default.POSITION_TYPE_RELATIVE);
+ }
+ }, "applyPositionStyles");
+ var applyMarginStyles = /* @__PURE__ */ __name((node, style) => {
+ if ("marginLeft" in style) {
+ node.setMargin(yoga_layout_prebuilt_1.default.EDGE_START, style.marginLeft || 0);
+ }
+ if ("marginRight" in style) {
+ node.setMargin(yoga_layout_prebuilt_1.default.EDGE_END, style.marginRight || 0);
+ }
+ if ("marginTop" in style) {
+ node.setMargin(yoga_layout_prebuilt_1.default.EDGE_TOP, style.marginTop || 0);
+ }
+ if ("marginBottom" in style) {
+ node.setMargin(yoga_layout_prebuilt_1.default.EDGE_BOTTOM, style.marginBottom || 0);
+ }
+ }, "applyMarginStyles");
+ var applyPaddingStyles = /* @__PURE__ */ __name((node, style) => {
+ if ("paddingLeft" in style) {
+ node.setPadding(yoga_layout_prebuilt_1.default.EDGE_LEFT, style.paddingLeft || 0);
+ }
+ if ("paddingRight" in style) {
+ node.setPadding(yoga_layout_prebuilt_1.default.EDGE_RIGHT, style.paddingRight || 0);
+ }
+ if ("paddingTop" in style) {
+ node.setPadding(yoga_layout_prebuilt_1.default.EDGE_TOP, style.paddingTop || 0);
+ }
+ if ("paddingBottom" in style) {
+ node.setPadding(yoga_layout_prebuilt_1.default.EDGE_BOTTOM, style.paddingBottom || 0);
+ }
+ }, "applyPaddingStyles");
+ var applyFlexStyles = /* @__PURE__ */ __name((node, style) => {
+ var _a2;
+ if ("flexGrow" in style) {
+ node.setFlexGrow((_a2 = style.flexGrow) !== null && _a2 !== void 0 ? _a2 : 0);
+ }
+ if ("flexShrink" in style) {
+ node.setFlexShrink(typeof style.flexShrink === "number" ? style.flexShrink : 1);
+ }
+ if ("flexDirection" in style) {
+ if (style.flexDirection === "row") {
+ node.setFlexDirection(yoga_layout_prebuilt_1.default.FLEX_DIRECTION_ROW);
+ }
+ if (style.flexDirection === "row-reverse") {
+ node.setFlexDirection(yoga_layout_prebuilt_1.default.FLEX_DIRECTION_ROW_REVERSE);
+ }
+ if (style.flexDirection === "column") {
+ node.setFlexDirection(yoga_layout_prebuilt_1.default.FLEX_DIRECTION_COLUMN);
+ }
+ if (style.flexDirection === "column-reverse") {
+ node.setFlexDirection(yoga_layout_prebuilt_1.default.FLEX_DIRECTION_COLUMN_REVERSE);
+ }
+ }
+ if ("flexBasis" in style) {
+ if (typeof style.flexBasis === "number") {
+ node.setFlexBasis(style.flexBasis);
+ } else if (typeof style.flexBasis === "string") {
+ node.setFlexBasisPercent(Number.parseInt(style.flexBasis, 10));
+ } else {
+ node.setFlexBasis(NaN);
+ }
+ }
+ if ("alignItems" in style) {
+ if (style.alignItems === "stretch" || !style.alignItems) {
+ node.setAlignItems(yoga_layout_prebuilt_1.default.ALIGN_STRETCH);
+ }
+ if (style.alignItems === "flex-start") {
+ node.setAlignItems(yoga_layout_prebuilt_1.default.ALIGN_FLEX_START);
+ }
+ if (style.alignItems === "center") {
+ node.setAlignItems(yoga_layout_prebuilt_1.default.ALIGN_CENTER);
+ }
+ if (style.alignItems === "flex-end") {
+ node.setAlignItems(yoga_layout_prebuilt_1.default.ALIGN_FLEX_END);
+ }
+ }
+ if ("alignSelf" in style) {
+ if (style.alignSelf === "auto" || !style.alignSelf) {
+ node.setAlignSelf(yoga_layout_prebuilt_1.default.ALIGN_AUTO);
+ }
+ if (style.alignSelf === "flex-start") {
+ node.setAlignSelf(yoga_layout_prebuilt_1.default.ALIGN_FLEX_START);
+ }
+ if (style.alignSelf === "center") {
+ node.setAlignSelf(yoga_layout_prebuilt_1.default.ALIGN_CENTER);
+ }
+ if (style.alignSelf === "flex-end") {
+ node.setAlignSelf(yoga_layout_prebuilt_1.default.ALIGN_FLEX_END);
+ }
+ }
+ if ("justifyContent" in style) {
+ if (style.justifyContent === "flex-start" || !style.justifyContent) {
+ node.setJustifyContent(yoga_layout_prebuilt_1.default.JUSTIFY_FLEX_START);
+ }
+ if (style.justifyContent === "center") {
+ node.setJustifyContent(yoga_layout_prebuilt_1.default.JUSTIFY_CENTER);
+ }
+ if (style.justifyContent === "flex-end") {
+ node.setJustifyContent(yoga_layout_prebuilt_1.default.JUSTIFY_FLEX_END);
+ }
+ if (style.justifyContent === "space-between") {
+ node.setJustifyContent(yoga_layout_prebuilt_1.default.JUSTIFY_SPACE_BETWEEN);
+ }
+ if (style.justifyContent === "space-around") {
+ node.setJustifyContent(yoga_layout_prebuilt_1.default.JUSTIFY_SPACE_AROUND);
+ }
+ }
+ }, "applyFlexStyles");
+ var applyDimensionStyles = /* @__PURE__ */ __name((node, style) => {
+ var _a2, _b2;
+ if ("width" in style) {
+ if (typeof style.width === "number") {
+ node.setWidth(style.width);
+ } else if (typeof style.width === "string") {
+ node.setWidthPercent(Number.parseInt(style.width, 10));
+ } else {
+ node.setWidthAuto();
+ }
+ }
+ if ("height" in style) {
+ if (typeof style.height === "number") {
+ node.setHeight(style.height);
+ } else if (typeof style.height === "string") {
+ node.setHeightPercent(Number.parseInt(style.height, 10));
+ } else {
+ node.setHeightAuto();
+ }
+ }
+ if ("minWidth" in style) {
+ if (typeof style.minWidth === "string") {
+ node.setMinWidthPercent(Number.parseInt(style.minWidth, 10));
+ } else {
+ node.setMinWidth((_a2 = style.minWidth) !== null && _a2 !== void 0 ? _a2 : 0);
+ }
+ }
+ if ("minHeight" in style) {
+ if (typeof style.minHeight === "string") {
+ node.setMinHeightPercent(Number.parseInt(style.minHeight, 10));
+ } else {
+ node.setMinHeight((_b2 = style.minHeight) !== null && _b2 !== void 0 ? _b2 : 0);
+ }
+ }
+ }, "applyDimensionStyles");
+ var applyDisplayStyles = /* @__PURE__ */ __name((node, style) => {
+ if ("display" in style) {
+ node.setDisplay(style.display === "flex" ? yoga_layout_prebuilt_1.default.DISPLAY_FLEX : yoga_layout_prebuilt_1.default.DISPLAY_NONE);
+ }
+ }, "applyDisplayStyles");
+ var applyBorderStyles = /* @__PURE__ */ __name((node, style) => {
+ if ("borderStyle" in style) {
+ const borderWidth = typeof style.borderStyle === "string" ? 1 : 0;
+ node.setBorder(yoga_layout_prebuilt_1.default.EDGE_TOP, borderWidth);
+ node.setBorder(yoga_layout_prebuilt_1.default.EDGE_BOTTOM, borderWidth);
+ node.setBorder(yoga_layout_prebuilt_1.default.EDGE_LEFT, borderWidth);
+ node.setBorder(yoga_layout_prebuilt_1.default.EDGE_RIGHT, borderWidth);
+ }
+ }, "applyBorderStyles");
+ exports2.default = (node, style = {}) => {
+ applyPositionStyles(node, style);
+ applyMarginStyles(node, style);
+ applyPaddingStyles(node, style);
+ applyFlexStyles(node, style);
+ applyDimensionStyles(node, style);
+ applyDisplayStyles(node, style);
+ applyBorderStyles(node, style);
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/color-name@1.1.4/node_modules/color-name/index.js
+var require_color_name2 = __commonJS({
+ "../../node_modules/.pnpm/color-name@1.1.4/node_modules/color-name/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ 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]
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/color-convert@2.0.1/node_modules/color-convert/conversions.js
+var require_conversions2 = __commonJS({
+ "../../node_modules/.pnpm/color-convert@2.0.1/node_modules/color-convert/conversions.js"(exports2, module2) {
+ init_import_meta_url();
+ var cssKeywords = require_color_name2();
+ 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 = /* @__PURE__ */ __name(function(c) {
+ return (v - c) / 6 / diff + 1 / 2;
+ }, "diffc");
+ 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;
+ }
+ __name(comparativeDistance, "comparativeDistance");
+ 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 z = r * 0.0193 + g * 0.1192 + b * 0.9505;
+ return [x * 100, y * 100, z * 100];
+ };
+ convert.rgb.lab = function(rgb) {
+ const xyz = convert.rgb.xyz(rgb);
+ let x = xyz[0];
+ let y = xyz[1];
+ let z = xyz[2];
+ x /= 95.047;
+ y /= 100;
+ z /= 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;
+ z = z > 8856e-6 ? z ** (1 / 3) : 7.787 * z + 16 / 116;
+ const l = 116 * y - 16;
+ const a = 500 * (x - y);
+ const b = 200 * (y - z);
+ 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 t2 = 255 * v * (1 - s * (1 - f));
+ v *= 255;
+ switch (hi) {
+ case 0:
+ return [v, t2, p];
+ case 1:
+ return [q, v, p];
+ case 2:
+ return [p, v, t2];
+ case 3:
+ return [p, q, v];
+ case 4:
+ return [t2, 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 sl2;
+ let l;
+ l = (2 - s) * v;
+ const lmin = (2 - s) * vmin;
+ sl2 = s * vmin;
+ sl2 /= lmin <= 1 ? lmin : 2 - lmin;
+ sl2 = sl2 || 0;
+ l /= 2;
+ return [h, sl2 * 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 z = xyz[2] / 100;
+ let r;
+ let g;
+ let b;
+ r = x * 3.2406 + y * -1.5372 + z * -0.4986;
+ g = x * -0.9689 + y * 1.8758 + z * 0.0415;
+ b = x * 0.0557 + y * -0.204 + z * 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 z = xyz[2];
+ x /= 95.047;
+ y /= 100;
+ z /= 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;
+ z = z > 8856e-6 ? z ** (1 / 3) : 7.787 * z + 16 / 116;
+ const l = 116 * y - 16;
+ const a = 500 * (x - y);
+ const b = 200 * (y - z);
+ 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 z;
+ y = (l + 16) / 116;
+ x = a / 500 + y;
+ z = y - b / 200;
+ const y2 = y ** 3;
+ const x2 = x ** 3;
+ const z2 = z ** 3;
+ y = y2 > 8856e-6 ? y2 : (y - 16 / 116) / 7.787;
+ x = x2 > 8856e-6 ? x2 : (x - 16 / 116) / 7.787;
+ z = z2 > 8856e-6 ? z2 : (z - 16 / 116) / 7.787;
+ x *= 95.047;
+ y *= 100;
+ z *= 108.883;
+ return [x, y, z];
+ };
+ 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 ansi2 = 30 + (Math.round(b / 255) << 2 | Math.round(g / 255) << 1 | Math.round(r / 255));
+ if (value === 2) {
+ ansi2 += 60;
+ }
+ return ansi2;
+ };
+ 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 ansi2 = 16 + 36 * Math.round(r / 255 * 5) + 6 * Math.round(g / 255 * 5) + Math.round(b / 255 * 5);
+ return ansi2;
+ };
+ 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];
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/color-convert@2.0.1/node_modules/color-convert/route.js
+var require_route2 = __commonJS({
+ "../../node_modules/.pnpm/color-convert@2.0.1/node_modules/color-convert/route.js"(exports2, module2) {
+ init_import_meta_url();
+ var conversions = require_conversions2();
+ 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;
+ }
+ __name(buildGraph, "buildGraph");
+ 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;
+ }
+ __name(deriveBFS, "deriveBFS");
+ function link(from, to) {
+ return function(args) {
+ return to(from(args));
+ };
+ }
+ __name(link, "link");
+ function wrapConversion(toModel, graph) {
+ const path45 = [graph[toModel].parent, toModel];
+ let fn2 = conversions[graph[toModel].parent][toModel];
+ let cur = graph[toModel].parent;
+ while (graph[cur].parent) {
+ path45.unshift(graph[cur].parent);
+ fn2 = link(conversions[graph[cur].parent][cur], fn2);
+ cur = graph[cur].parent;
+ }
+ fn2.conversion = path45;
+ return fn2;
+ }
+ __name(wrapConversion, "wrapConversion");
+ 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;
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/color-convert@2.0.1/node_modules/color-convert/index.js
+var require_color_convert2 = __commonJS({
+ "../../node_modules/.pnpm/color-convert@2.0.1/node_modules/color-convert/index.js"(exports2, module2) {
+ init_import_meta_url();
+ var conversions = require_conversions2();
+ var route2 = require_route2();
+ var convert = {};
+ var models = Object.keys(conversions);
+ function wrapRaw(fn2) {
+ const wrappedFn = /* @__PURE__ */ __name(function(...args) {
+ const arg0 = args[0];
+ if (arg0 === void 0 || arg0 === null) {
+ return arg0;
+ }
+ if (arg0.length > 1) {
+ args = arg0;
+ }
+ return fn2(args);
+ }, "wrappedFn");
+ if ("conversion" in fn2) {
+ wrappedFn.conversion = fn2.conversion;
+ }
+ return wrappedFn;
+ }
+ __name(wrapRaw, "wrapRaw");
+ function wrapRounded(fn2) {
+ const wrappedFn = /* @__PURE__ */ __name(function(...args) {
+ const arg0 = args[0];
+ if (arg0 === void 0 || arg0 === null) {
+ return arg0;
+ }
+ if (arg0.length > 1) {
+ args = arg0;
+ }
+ const result = fn2(args);
+ if (typeof result === "object") {
+ for (let len = result.length, i = 0; i < len; i++) {
+ result[i] = Math.round(result[i]);
+ }
+ }
+ return result;
+ }, "wrappedFn");
+ if ("conversion" in fn2) {
+ wrappedFn.conversion = fn2.conversion;
+ }
+ return wrappedFn;
+ }
+ __name(wrapRounded, "wrapRounded");
+ 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 = route2(fromModel);
+ const routeModels = Object.keys(routes);
+ routeModels.forEach((toModel) => {
+ const fn2 = routes[toModel];
+ convert[fromModel][toModel] = wrapRounded(fn2);
+ convert[fromModel][toModel].raw = wrapRaw(fn2);
+ });
+ });
+ module2.exports = convert;
+ }
+});
+
+// ../../node_modules/.pnpm/ansi-styles@4.3.0/node_modules/ansi-styles/index.js
+var require_ansi_styles2 = __commonJS({
+ "../../node_modules/.pnpm/ansi-styles@4.3.0/node_modules/ansi-styles/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var wrapAnsi16 = /* @__PURE__ */ __name((fn2, offset) => (...args) => {
+ const code = fn2(...args);
+ return `\x1B[${code + offset}m`;
+ }, "wrapAnsi16");
+ var wrapAnsi256 = /* @__PURE__ */ __name((fn2, offset) => (...args) => {
+ const code = fn2(...args);
+ return `\x1B[${38 + offset};5;${code}m`;
+ }, "wrapAnsi256");
+ var wrapAnsi16m = /* @__PURE__ */ __name((fn2, offset) => (...args) => {
+ const rgb = fn2(...args);
+ return `\x1B[${38 + offset};2;${rgb[0]};${rgb[1]};${rgb[2]}m`;
+ }, "wrapAnsi16m");
+ var ansi2ansi = /* @__PURE__ */ __name((n) => n, "ansi2ansi");
+ var rgb2rgb = /* @__PURE__ */ __name((r, g, b) => [r, g, b], "rgb2rgb");
+ var setLazyProperty = /* @__PURE__ */ __name((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
+ });
+ }, "setLazyProperty");
+ var colorConvert;
+ var makeDynamicStyles = /* @__PURE__ */ __name((wrap2, targetSpace, identity, isBackground) => {
+ if (colorConvert === void 0) {
+ colorConvert = require_color_convert2();
+ }
+ const offset = isBackground ? 10 : 0;
+ const styles = {};
+ for (const [sourceSpace, suite] of Object.entries(colorConvert)) {
+ const name = sourceSpace === "ansi16" ? "ansi" : sourceSpace;
+ if (sourceSpace === targetSpace) {
+ styles[name] = wrap2(identity, offset);
+ } else if (typeof suite === "object") {
+ styles[name] = wrap2(suite[targetSpace], offset);
+ }
+ }
+ return styles;
+ }, "makeDynamicStyles");
+ function assembleStyles() {
+ const codes = /* @__PURE__ */ new Map();
+ const 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],
+ 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]
+ }
+ };
+ styles.color.gray = styles.color.blackBright;
+ styles.bgColor.bgGray = styles.bgColor.bgBlackBright;
+ styles.color.grey = styles.color.blackBright;
+ styles.bgColor.bgGrey = styles.bgColor.bgBlackBright;
+ 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";
+ setLazyProperty(styles.color, "ansi", () => makeDynamicStyles(wrapAnsi16, "ansi16", ansi2ansi, false));
+ setLazyProperty(styles.color, "ansi256", () => makeDynamicStyles(wrapAnsi256, "ansi256", ansi2ansi, false));
+ setLazyProperty(styles.color, "ansi16m", () => makeDynamicStyles(wrapAnsi16m, "rgb", rgb2rgb, false));
+ setLazyProperty(styles.bgColor, "ansi", () => makeDynamicStyles(wrapAnsi16, "ansi16", ansi2ansi, true));
+ setLazyProperty(styles.bgColor, "ansi256", () => makeDynamicStyles(wrapAnsi256, "ansi256", ansi2ansi, true));
+ setLazyProperty(styles.bgColor, "ansi16m", () => makeDynamicStyles(wrapAnsi16m, "rgb", rgb2rgb, true));
+ return styles;
+ }
+ __name(assembleStyles, "assembleStyles");
+ Object.defineProperty(module2, "exports", {
+ enumerable: true,
+ get: assembleStyles
+ });
+ }
+});
+
+// ../../node_modules/.pnpm/wrap-ansi@6.2.0/node_modules/wrap-ansi/index.js
+var require_wrap_ansi = __commonJS({
+ "../../node_modules/.pnpm/wrap-ansi@6.2.0/node_modules/wrap-ansi/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var stringWidth = require_string_width();
+ var stripAnsi2 = require_strip_ansi();
+ var ansiStyles = require_ansi_styles2();
+ var ESCAPES = /* @__PURE__ */ new Set([
+ "\x1B",
+ "\x9B"
+ ]);
+ var END_CODE = 39;
+ var wrapAnsi = /* @__PURE__ */ __name((code) => `${ESCAPES.values().next().value}[${code}m`, "wrapAnsi");
+ var wordLengths = /* @__PURE__ */ __name((string) => string.split(" ").map((character) => stringWidth(character)), "wordLengths");
+ var wrapWord = /* @__PURE__ */ __name((rows, word, columns) => {
+ const characters = [...word];
+ let isInsideEscape = false;
+ let visible = stringWidth(stripAnsi2(rows[rows.length - 1]));
+ for (const [index, character] of characters.entries()) {
+ const characterLength = stringWidth(character);
+ if (visible + characterLength <= columns) {
+ rows[rows.length - 1] += character;
+ } else {
+ rows.push(character);
+ visible = 0;
+ }
+ if (ESCAPES.has(character)) {
+ isInsideEscape = true;
+ } else if (isInsideEscape && character === "m") {
+ isInsideEscape = false;
+ continue;
+ }
+ if (isInsideEscape) {
+ continue;
+ }
+ visible += characterLength;
+ if (visible === columns && index < characters.length - 1) {
+ rows.push("");
+ visible = 0;
+ }
+ }
+ if (!visible && rows[rows.length - 1].length > 0 && rows.length > 1) {
+ rows[rows.length - 2] += rows.pop();
+ }
+ }, "wrapWord");
+ var stringVisibleTrimSpacesRight = /* @__PURE__ */ __name((str) => {
+ const words = str.split(" ");
+ let last = words.length;
+ while (last > 0) {
+ if (stringWidth(words[last - 1]) > 0) {
+ break;
+ }
+ last--;
+ }
+ if (last === words.length) {
+ return str;
+ }
+ return words.slice(0, last).join(" ") + words.slice(last).join("");
+ }, "stringVisibleTrimSpacesRight");
+ var exec = /* @__PURE__ */ __name((string, columns, options14 = {}) => {
+ if (options14.trim !== false && string.trim() === "") {
+ return "";
+ }
+ let pre = "";
+ let ret = "";
+ let escapeCode;
+ const lengths = wordLengths(string);
+ let rows = [""];
+ for (const [index, word] of string.split(" ").entries()) {
+ if (options14.trim !== false) {
+ rows[rows.length - 1] = rows[rows.length - 1].trimLeft();
+ }
+ let rowLength = stringWidth(rows[rows.length - 1]);
+ if (index !== 0) {
+ if (rowLength >= columns && (options14.wordWrap === false || options14.trim === false)) {
+ rows.push("");
+ rowLength = 0;
+ }
+ if (rowLength > 0 || options14.trim === false) {
+ rows[rows.length - 1] += " ";
+ rowLength++;
+ }
+ }
+ if (options14.hard && lengths[index] > columns) {
+ const remainingColumns = columns - rowLength;
+ const breaksStartingThisLine = 1 + Math.floor((lengths[index] - remainingColumns - 1) / columns);
+ const breaksStartingNextLine = Math.floor((lengths[index] - 1) / columns);
+ if (breaksStartingNextLine < breaksStartingThisLine) {
+ rows.push("");
+ }
+ wrapWord(rows, word, columns);
+ continue;
+ }
+ if (rowLength + lengths[index] > columns && rowLength > 0 && lengths[index] > 0) {
+ if (options14.wordWrap === false && rowLength < columns) {
+ wrapWord(rows, word, columns);
+ continue;
+ }
+ rows.push("");
+ }
+ if (rowLength + lengths[index] > columns && options14.wordWrap === false) {
+ wrapWord(rows, word, columns);
+ continue;
+ }
+ rows[rows.length - 1] += word;
+ }
+ if (options14.trim !== false) {
+ rows = rows.map(stringVisibleTrimSpacesRight);
+ }
+ pre = rows.join("\n");
+ for (const [index, character] of [...pre].entries()) {
+ ret += character;
+ if (ESCAPES.has(character)) {
+ const code2 = parseFloat(/\d[^m]*/.exec(pre.slice(index, index + 4)));
+ escapeCode = code2 === END_CODE ? null : code2;
+ }
+ const code = ansiStyles.codes.get(Number(escapeCode));
+ if (escapeCode && code) {
+ if (pre[index + 1] === "\n") {
+ ret += wrapAnsi(code);
+ } else if (character === "\n") {
+ ret += wrapAnsi(escapeCode);
+ }
+ }
+ }
+ return ret;
+ }, "exec");
+ module2.exports = (string, columns, options14) => {
+ return String(string).normalize().replace(/\r\n/g, "\n").split("\n").map((line) => exec(line, columns, options14)).join("\n");
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/astral-regex@2.0.0/node_modules/astral-regex/index.js
+var require_astral_regex = __commonJS({
+ "../../node_modules/.pnpm/astral-regex@2.0.0/node_modules/astral-regex/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var regex = "[\uD800-\uDBFF][\uDC00-\uDFFF]";
+ var astralRegex = /* @__PURE__ */ __name((options14) => options14 && options14.exact ? new RegExp(`^${regex}$`) : new RegExp(regex, "g"), "astralRegex");
+ module2.exports = astralRegex;
+ }
+});
+
+// ../../node_modules/.pnpm/slice-ansi@3.0.0/node_modules/slice-ansi/index.js
+var require_slice_ansi = __commonJS({
+ "../../node_modules/.pnpm/slice-ansi@3.0.0/node_modules/slice-ansi/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var isFullwidthCodePoint = require_is_fullwidth_code_point();
+ var astralRegex = require_astral_regex();
+ var ansiStyles = require_ansi_styles2();
+ var ESCAPES = [
+ "\x1B",
+ "\x9B"
+ ];
+ var wrapAnsi = /* @__PURE__ */ __name((code) => `${ESCAPES[0]}[${code}m`, "wrapAnsi");
+ var checkAnsi = /* @__PURE__ */ __name((ansiCodes, isEscapes, endAnsiCode) => {
+ let output = [];
+ ansiCodes = [...ansiCodes];
+ for (let ansiCode of ansiCodes) {
+ const ansiCodeOrigin = ansiCode;
+ if (ansiCode.match(";")) {
+ ansiCode = ansiCode.split(";")[0][0] + "0";
+ }
+ const item = ansiStyles.codes.get(parseInt(ansiCode, 10));
+ if (item) {
+ const indexEscape = ansiCodes.indexOf(item.toString());
+ if (indexEscape >= 0) {
+ ansiCodes.splice(indexEscape, 1);
+ } else {
+ output.push(wrapAnsi(isEscapes ? item : ansiCodeOrigin));
+ }
+ } else if (isEscapes) {
+ output.push(wrapAnsi(0));
+ break;
+ } else {
+ output.push(wrapAnsi(ansiCodeOrigin));
+ }
+ }
+ if (isEscapes) {
+ output = output.filter((element, index) => output.indexOf(element) === index);
+ if (endAnsiCode !== void 0) {
+ const fistEscapeCode = wrapAnsi(ansiStyles.codes.get(parseInt(endAnsiCode, 10)));
+ output = output.reduce((current, next) => next === fistEscapeCode ? [next, ...current] : [...current, next], []);
+ }
+ }
+ return output.join("");
+ }, "checkAnsi");
+ module2.exports = (string, begin, end) => {
+ const characters = [...string.normalize()];
+ const ansiCodes = [];
+ end = typeof end === "number" ? end : characters.length;
+ let isInsideEscape = false;
+ let ansiCode;
+ let visible = 0;
+ let output = "";
+ for (const [index, character] of characters.entries()) {
+ let leftEscape = false;
+ if (ESCAPES.includes(character)) {
+ const code = /\d[^m]*/.exec(string.slice(index, index + 18));
+ ansiCode = code && code.length > 0 ? code[0] : void 0;
+ if (visible < end) {
+ isInsideEscape = true;
+ if (ansiCode !== void 0) {
+ ansiCodes.push(ansiCode);
+ }
+ }
+ } else if (isInsideEscape && character === "m") {
+ isInsideEscape = false;
+ leftEscape = true;
+ }
+ if (!isInsideEscape && !leftEscape) {
+ ++visible;
+ }
+ if (!astralRegex({ exact: true }).test(character) && isFullwidthCodePoint(character.codePointAt())) {
+ ++visible;
+ }
+ if (visible > begin && visible <= end) {
+ output += character;
+ } else if (visible === begin && !isInsideEscape && ansiCode !== void 0) {
+ output = checkAnsi(ansiCodes);
+ } else if (visible >= end) {
+ output += checkAnsi(ansiCodes, true, ansiCode);
+ break;
+ }
+ }
+ return output;
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/cli-truncate@2.1.0/node_modules/cli-truncate/index.js
+var require_cli_truncate = __commonJS({
+ "../../node_modules/.pnpm/cli-truncate@2.1.0/node_modules/cli-truncate/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var sliceAnsi = require_slice_ansi();
+ var stringWidth = require_string_width();
+ function getIndexOfNearestSpace(string, index, shouldSearchRight) {
+ if (string.charAt(index) === " ") {
+ return index;
+ }
+ for (let i = 1; i <= 3; i++) {
+ if (shouldSearchRight) {
+ if (string.charAt(index + i) === " ") {
+ return index + i;
+ }
+ } else if (string.charAt(index - i) === " ") {
+ return index - i;
+ }
+ }
+ return index;
+ }
+ __name(getIndexOfNearestSpace, "getIndexOfNearestSpace");
+ module2.exports = (text, columns, options14) => {
+ options14 = {
+ position: "end",
+ preferTruncationOnSpace: false,
+ ...options14
+ };
+ const { position, space, preferTruncationOnSpace } = options14;
+ let ellipsis = "\u2026";
+ let ellipsisWidth = 1;
+ if (typeof text !== "string") {
+ throw new TypeError(`Expected \`input\` to be a string, got ${typeof text}`);
+ }
+ if (typeof columns !== "number") {
+ throw new TypeError(`Expected \`columns\` to be a number, got ${typeof columns}`);
+ }
+ if (columns < 1) {
+ return "";
+ }
+ if (columns === 1) {
+ return ellipsis;
+ }
+ const length = stringWidth(text);
+ if (length <= columns) {
+ return text;
+ }
+ if (position === "start") {
+ if (preferTruncationOnSpace) {
+ const nearestSpace = getIndexOfNearestSpace(text, length - columns + 1, true);
+ return ellipsis + sliceAnsi(text, nearestSpace, length).trim();
+ }
+ if (space === true) {
+ ellipsis += " ";
+ ellipsisWidth = 2;
+ }
+ return ellipsis + sliceAnsi(text, length - columns + ellipsisWidth, length);
+ }
+ if (position === "middle") {
+ if (space === true) {
+ ellipsis = " " + ellipsis + " ";
+ ellipsisWidth = 3;
+ }
+ const half = Math.floor(columns / 2);
+ if (preferTruncationOnSpace) {
+ const spaceNearFirstBreakPoint = getIndexOfNearestSpace(text, half);
+ const spaceNearSecondBreakPoint = getIndexOfNearestSpace(text, length - (columns - half) + 1, true);
+ return sliceAnsi(text, 0, spaceNearFirstBreakPoint) + ellipsis + sliceAnsi(text, spaceNearSecondBreakPoint, length).trim();
+ }
+ return sliceAnsi(text, 0, half) + ellipsis + sliceAnsi(text, length - (columns - half) + ellipsisWidth, length);
+ }
+ if (position === "end") {
+ if (preferTruncationOnSpace) {
+ const nearestSpace = getIndexOfNearestSpace(text, columns - 1);
+ return sliceAnsi(text, 0, nearestSpace) + ellipsis;
+ }
+ if (space === true) {
+ ellipsis = " " + ellipsis;
+ ellipsisWidth = 2;
+ }
+ return sliceAnsi(text, 0, columns - ellipsisWidth) + ellipsis;
+ }
+ throw new Error(`Expected \`options.position\` to be either \`start\`, \`middle\` or \`end\`, got ${position}`);
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/wrap-text.js
+var require_wrap_text = __commonJS({
+ "../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/wrap-text.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ var __importDefault = exports2 && exports2.__importDefault || function(mod) {
+ return mod && mod.__esModule ? mod : { "default": mod };
+ };
+ Object.defineProperty(exports2, "__esModule", { value: true });
+ var wrap_ansi_1 = __importDefault(require_wrap_ansi());
+ var cli_truncate_1 = __importDefault(require_cli_truncate());
+ var cache2 = {};
+ exports2.default = (text, maxWidth, wrapType) => {
+ const cacheKey = text + String(maxWidth) + String(wrapType);
+ if (cache2[cacheKey]) {
+ return cache2[cacheKey];
+ }
+ let wrappedText = text;
+ if (wrapType === "wrap") {
+ wrappedText = wrap_ansi_1.default(text, maxWidth, {
+ trim: false,
+ hard: true
+ });
+ }
+ if (wrapType.startsWith("truncate")) {
+ let position = "end";
+ if (wrapType === "truncate-middle") {
+ position = "middle";
+ }
+ if (wrapType === "truncate-start") {
+ position = "start";
+ }
+ wrappedText = cli_truncate_1.default(text, maxWidth, { position });
+ }
+ cache2[cacheKey] = wrappedText;
+ return wrappedText;
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/squash-text-nodes.js
+var require_squash_text_nodes = __commonJS({
+ "../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/squash-text-nodes.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ Object.defineProperty(exports2, "__esModule", { value: true });
+ var squashTextNodes = /* @__PURE__ */ __name((node) => {
+ let text = "";
+ if (node.childNodes.length > 0) {
+ for (const childNode of node.childNodes) {
+ let nodeText = "";
+ if (childNode.nodeName === "#text") {
+ nodeText = childNode.nodeValue;
+ } else {
+ if (childNode.nodeName === "ink-text" || childNode.nodeName === "ink-virtual-text") {
+ nodeText = squashTextNodes(childNode);
+ }
+ if (nodeText.length > 0 && typeof childNode.internal_transform === "function") {
+ nodeText = childNode.internal_transform(nodeText);
+ }
+ }
+ text += nodeText;
+ }
+ }
+ return text;
+ }, "squashTextNodes");
+ exports2.default = squashTextNodes;
+ }
+});
+
+// ../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/dom.js
+var require_dom = __commonJS({
+ "../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/dom.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ var __importDefault = exports2 && exports2.__importDefault || function(mod) {
+ return mod && mod.__esModule ? mod : { "default": mod };
+ };
+ Object.defineProperty(exports2, "__esModule", { value: true });
+ exports2.setTextNodeValue = exports2.createTextNode = exports2.setStyle = exports2.setAttribute = exports2.removeChildNode = exports2.insertBeforeNode = exports2.appendChildNode = exports2.createNode = exports2.TEXT_NAME = void 0;
+ var yoga_layout_prebuilt_1 = __importDefault(require_wasm_sync2());
+ var measure_text_1 = __importDefault(require_measure_text());
+ var styles_1 = __importDefault(require_styles());
+ var wrap_text_1 = __importDefault(require_wrap_text());
+ var squash_text_nodes_1 = __importDefault(require_squash_text_nodes());
+ exports2.TEXT_NAME = "#text";
+ exports2.createNode = (nodeName) => {
+ var _a2;
+ const node = {
+ nodeName,
+ style: {},
+ attributes: {},
+ childNodes: [],
+ parentNode: null,
+ yogaNode: nodeName === "ink-virtual-text" ? void 0 : yoga_layout_prebuilt_1.default.Node.create()
+ };
+ if (nodeName === "ink-text") {
+ (_a2 = node.yogaNode) === null || _a2 === void 0 ? void 0 : _a2.setMeasureFunc(measureTextNode.bind(null, node));
+ }
+ return node;
+ };
+ exports2.appendChildNode = (node, childNode) => {
+ var _a2;
+ if (childNode.parentNode) {
+ exports2.removeChildNode(childNode.parentNode, childNode);
+ }
+ childNode.parentNode = node;
+ node.childNodes.push(childNode);
+ if (childNode.yogaNode) {
+ (_a2 = node.yogaNode) === null || _a2 === void 0 ? void 0 : _a2.insertChild(childNode.yogaNode, node.yogaNode.getChildCount());
+ }
+ if (node.nodeName === "ink-text" || node.nodeName === "ink-virtual-text") {
+ markNodeAsDirty(node);
+ }
+ };
+ exports2.insertBeforeNode = (node, newChildNode, beforeChildNode) => {
+ var _a2, _b2;
+ if (newChildNode.parentNode) {
+ exports2.removeChildNode(newChildNode.parentNode, newChildNode);
+ }
+ newChildNode.parentNode = node;
+ const index = node.childNodes.indexOf(beforeChildNode);
+ if (index >= 0) {
+ node.childNodes.splice(index, 0, newChildNode);
+ if (newChildNode.yogaNode) {
+ (_a2 = node.yogaNode) === null || _a2 === void 0 ? void 0 : _a2.insertChild(newChildNode.yogaNode, index);
+ }
+ return;
+ }
+ node.childNodes.push(newChildNode);
+ if (newChildNode.yogaNode) {
+ (_b2 = node.yogaNode) === null || _b2 === void 0 ? void 0 : _b2.insertChild(newChildNode.yogaNode, node.yogaNode.getChildCount());
+ }
+ if (node.nodeName === "ink-text" || node.nodeName === "ink-virtual-text") {
+ markNodeAsDirty(node);
+ }
+ };
+ exports2.removeChildNode = (node, removeNode) => {
+ var _a2, _b2;
+ if (removeNode.yogaNode) {
+ (_b2 = (_a2 = removeNode.parentNode) === null || _a2 === void 0 ? void 0 : _a2.yogaNode) === null || _b2 === void 0 ? void 0 : _b2.removeChild(removeNode.yogaNode);
+ }
+ removeNode.parentNode = null;
+ const index = node.childNodes.indexOf(removeNode);
+ if (index >= 0) {
+ node.childNodes.splice(index, 1);
+ }
+ if (node.nodeName === "ink-text" || node.nodeName === "ink-virtual-text") {
+ markNodeAsDirty(node);
+ }
+ };
+ exports2.setAttribute = (node, key, value) => {
+ node.attributes[key] = value;
+ };
+ exports2.setStyle = (node, style) => {
+ node.style = style;
+ if (node.yogaNode) {
+ styles_1.default(node.yogaNode, style);
+ }
+ };
+ exports2.createTextNode = (text) => {
+ const node = {
+ nodeName: "#text",
+ nodeValue: text,
+ yogaNode: void 0,
+ parentNode: null,
+ style: {}
+ };
+ exports2.setTextNodeValue(node, text);
+ return node;
+ };
+ var measureTextNode = /* @__PURE__ */ __name(function(node, width) {
+ var _a2, _b2;
+ const text = node.nodeName === "#text" ? node.nodeValue : squash_text_nodes_1.default(node);
+ const dimensions = measure_text_1.default(text);
+ if (dimensions.width <= width) {
+ return dimensions;
+ }
+ if (dimensions.width >= 1 && width > 0 && width < 1) {
+ return dimensions;
+ }
+ const textWrap = (_b2 = (_a2 = node.style) === null || _a2 === void 0 ? void 0 : _a2.textWrap) !== null && _b2 !== void 0 ? _b2 : "wrap";
+ const wrappedText = wrap_text_1.default(text, width, textWrap);
+ return measure_text_1.default(wrappedText);
+ }, "measureTextNode");
+ var findClosestYogaNode = /* @__PURE__ */ __name((node) => {
+ var _a2;
+ if (!node || !node.parentNode) {
+ return void 0;
+ }
+ return (_a2 = node.yogaNode) !== null && _a2 !== void 0 ? _a2 : findClosestYogaNode(node.parentNode);
+ }, "findClosestYogaNode");
+ var markNodeAsDirty = /* @__PURE__ */ __name((node) => {
+ const yogaNode = findClosestYogaNode(node);
+ yogaNode === null || yogaNode === void 0 ? void 0 : yogaNode.markDirty();
+ }, "markNodeAsDirty");
+ exports2.setTextNodeValue = (node, text) => {
+ if (typeof text !== "string") {
+ text = String(text);
+ }
+ node.nodeValue = text;
+ markNodeAsDirty(node);
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/ws@7.5.6/node_modules/ws/lib/constants.js
+var require_constants5 = __commonJS({
+ "../../node_modules/.pnpm/ws@7.5.6/node_modules/ws/lib/constants.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ module2.exports = {
+ BINARY_TYPES: ["nodebuffer", "arraybuffer", "fragments"],
+ GUID: "258EAFA5-E914-47DA-95CA-C5AB0DC85B11",
+ kStatusCode: Symbol("status-code"),
+ kWebSocket: Symbol("websocket"),
+ EMPTY_BUFFER: Buffer.alloc(0),
+ NOOP: () => {
+ }
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/ws@7.5.6/node_modules/ws/lib/buffer-util.js
+var require_buffer_util = __commonJS({
+ "../../node_modules/.pnpm/ws@7.5.6/node_modules/ws/lib/buffer-util.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var { EMPTY_BUFFER } = require_constants5();
+ function concat(list, totalLength) {
+ if (list.length === 0)
+ return EMPTY_BUFFER;
+ if (list.length === 1)
+ return list[0];
+ const target = Buffer.allocUnsafe(totalLength);
+ let offset = 0;
+ for (let i = 0; i < list.length; i++) {
+ const buf = list[i];
+ target.set(buf, offset);
+ offset += buf.length;
+ }
+ if (offset < totalLength)
+ return target.slice(0, offset);
+ return target;
+ }
+ __name(concat, "concat");
+ function _mask(source, mask, output, offset, length) {
+ for (let i = 0; i < length; i++) {
+ output[offset + i] = source[i] ^ mask[i & 3];
+ }
+ }
+ __name(_mask, "_mask");
+ function _unmask(buffer, mask) {
+ const length = buffer.length;
+ for (let i = 0; i < length; i++) {
+ buffer[i] ^= mask[i & 3];
+ }
+ }
+ __name(_unmask, "_unmask");
+ function toArrayBuffer(buf) {
+ if (buf.byteLength === buf.buffer.byteLength) {
+ return buf.buffer;
+ }
+ return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
+ }
+ __name(toArrayBuffer, "toArrayBuffer");
+ function toBuffer(data) {
+ toBuffer.readOnly = true;
+ if (Buffer.isBuffer(data))
+ return data;
+ let buf;
+ if (data instanceof ArrayBuffer) {
+ buf = Buffer.from(data);
+ } else if (ArrayBuffer.isView(data)) {
+ buf = Buffer.from(data.buffer, data.byteOffset, data.byteLength);
+ } else {
+ buf = Buffer.from(data);
+ toBuffer.readOnly = false;
+ }
+ return buf;
+ }
+ __name(toBuffer, "toBuffer");
+ try {
+ const bufferUtil = require("bufferutil");
+ const bu = bufferUtil.BufferUtil || bufferUtil;
+ module2.exports = {
+ concat,
+ mask(source, mask, output, offset, length) {
+ if (length < 48)
+ _mask(source, mask, output, offset, length);
+ else
+ bu.mask(source, mask, output, offset, length);
+ },
+ toArrayBuffer,
+ toBuffer,
+ unmask(buffer, mask) {
+ if (buffer.length < 32)
+ _unmask(buffer, mask);
+ else
+ bu.unmask(buffer, mask);
+ }
+ };
+ } catch (e2) {
+ module2.exports = {
+ concat,
+ mask: _mask,
+ toArrayBuffer,
+ toBuffer,
+ unmask: _unmask
+ };
+ }
+ }
+});
+
+// ../../node_modules/.pnpm/ws@7.5.6/node_modules/ws/lib/limiter.js
+var require_limiter = __commonJS({
+ "../../node_modules/.pnpm/ws@7.5.6/node_modules/ws/lib/limiter.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var kDone = Symbol("kDone");
+ var kRun = Symbol("kRun");
+ var Limiter = class {
+ /**
+ * Creates a new `Limiter`.
+ *
+ * @param {Number} [concurrency=Infinity] The maximum number of jobs allowed
+ * to run concurrently
+ */
+ constructor(concurrency) {
+ this[kDone] = () => {
+ this.pending--;
+ this[kRun]();
+ };
+ this.concurrency = concurrency || Infinity;
+ this.jobs = [];
+ this.pending = 0;
+ }
+ /**
+ * Adds a job to the queue.
+ *
+ * @param {Function} job The job to run
+ * @public
+ */
+ add(job) {
+ this.jobs.push(job);
+ this[kRun]();
+ }
+ /**
+ * Removes a job from the queue and runs it if possible.
+ *
+ * @private
+ */
+ [kRun]() {
+ if (this.pending === this.concurrency)
+ return;
+ if (this.jobs.length) {
+ const job = this.jobs.shift();
+ this.pending++;
+ job(this[kDone]);
+ }
+ }
+ };
+ __name(Limiter, "Limiter");
+ module2.exports = Limiter;
+ }
+});
+
+// ../../node_modules/.pnpm/ws@7.5.6/node_modules/ws/lib/permessage-deflate.js
+var require_permessage_deflate = __commonJS({
+ "../../node_modules/.pnpm/ws@7.5.6/node_modules/ws/lib/permessage-deflate.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var zlib = require("zlib");
+ var bufferUtil = require_buffer_util();
+ var Limiter = require_limiter();
+ var { kStatusCode, NOOP } = require_constants5();
+ var TRAILER = Buffer.from([0, 0, 255, 255]);
+ var kPerMessageDeflate = Symbol("permessage-deflate");
+ var kTotalLength = Symbol("total-length");
+ var kCallback = Symbol("callback");
+ var kBuffers = Symbol("buffers");
+ var kError = Symbol("error");
+ var zlibLimiter;
+ var PerMessageDeflate = class {
+ /**
+ * Creates a PerMessageDeflate instance.
+ *
+ * @param {Object} [options] Configuration options
+ * @param {Boolean} [options.serverNoContextTakeover=false] Request/accept
+ * disabling of server context takeover
+ * @param {Boolean} [options.clientNoContextTakeover=false] Advertise/
+ * acknowledge disabling of client context takeover
+ * @param {(Boolean|Number)} [options.serverMaxWindowBits] Request/confirm the
+ * use of a custom server window size
+ * @param {(Boolean|Number)} [options.clientMaxWindowBits] Advertise support
+ * for, or request, a custom client window size
+ * @param {Object} [options.zlibDeflateOptions] Options to pass to zlib on
+ * deflate
+ * @param {Object} [options.zlibInflateOptions] Options to pass to zlib on
+ * inflate
+ * @param {Number} [options.threshold=1024] Size (in bytes) below which
+ * messages should not be compressed
+ * @param {Number} [options.concurrencyLimit=10] The number of concurrent
+ * calls to zlib
+ * @param {Boolean} [isServer=false] Create the instance in either server or
+ * client mode
+ * @param {Number} [maxPayload=0] The maximum allowed message length
+ */
+ constructor(options14, isServer, maxPayload) {
+ this._maxPayload = maxPayload | 0;
+ this._options = options14 || {};
+ this._threshold = this._options.threshold !== void 0 ? this._options.threshold : 1024;
+ this._isServer = !!isServer;
+ this._deflate = null;
+ this._inflate = null;
+ this.params = null;
+ if (!zlibLimiter) {
+ const concurrency = this._options.concurrencyLimit !== void 0 ? this._options.concurrencyLimit : 10;
+ zlibLimiter = new Limiter(concurrency);
+ }
+ }
+ /**
+ * @type {String}
+ */
+ static get extensionName() {
+ return "permessage-deflate";
+ }
+ /**
+ * Create an extension negotiation offer.
+ *
+ * @return {Object} Extension parameters
+ * @public
+ */
+ offer() {
+ const params = {};
+ if (this._options.serverNoContextTakeover) {
+ params.server_no_context_takeover = true;
+ }
+ if (this._options.clientNoContextTakeover) {
+ params.client_no_context_takeover = true;
+ }
+ if (this._options.serverMaxWindowBits) {
+ params.server_max_window_bits = this._options.serverMaxWindowBits;
+ }
+ if (this._options.clientMaxWindowBits) {
+ params.client_max_window_bits = this._options.clientMaxWindowBits;
+ } else if (this._options.clientMaxWindowBits == null) {
+ params.client_max_window_bits = true;
+ }
+ return params;
+ }
+ /**
+ * Accept an extension negotiation offer/response.
+ *
+ * @param {Array} configurations The extension negotiation offers/reponse
+ * @return {Object} Accepted configuration
+ * @public
+ */
+ accept(configurations) {
+ configurations = this.normalizeParams(configurations);
+ this.params = this._isServer ? this.acceptAsServer(configurations) : this.acceptAsClient(configurations);
+ return this.params;
+ }
+ /**
+ * Releases all resources used by the extension.
+ *
+ * @public
+ */
+ cleanup() {
+ if (this._inflate) {
+ this._inflate.close();
+ this._inflate = null;
+ }
+ if (this._deflate) {
+ const callback = this._deflate[kCallback];
+ this._deflate.close();
+ this._deflate = null;
+ if (callback) {
+ callback(
+ new Error(
+ "The deflate stream was closed while data was being processed"
+ )
+ );
+ }
+ }
+ }
+ /**
+ * Accept an extension negotiation offer.
+ *
+ * @param {Array} offers The extension negotiation offers
+ * @return {Object} Accepted configuration
+ * @private
+ */
+ acceptAsServer(offers) {
+ const opts = this._options;
+ const accepted = offers.find((params) => {
+ if (opts.serverNoContextTakeover === false && params.server_no_context_takeover || params.server_max_window_bits && (opts.serverMaxWindowBits === false || typeof opts.serverMaxWindowBits === "number" && opts.serverMaxWindowBits > params.server_max_window_bits) || typeof opts.clientMaxWindowBits === "number" && !params.client_max_window_bits) {
+ return false;
+ }
+ return true;
+ });
+ if (!accepted) {
+ throw new Error("None of the extension offers can be accepted");
+ }
+ if (opts.serverNoContextTakeover) {
+ accepted.server_no_context_takeover = true;
+ }
+ if (opts.clientNoContextTakeover) {
+ accepted.client_no_context_takeover = true;
+ }
+ if (typeof opts.serverMaxWindowBits === "number") {
+ accepted.server_max_window_bits = opts.serverMaxWindowBits;
+ }
+ if (typeof opts.clientMaxWindowBits === "number") {
+ accepted.client_max_window_bits = opts.clientMaxWindowBits;
+ } else if (accepted.client_max_window_bits === true || opts.clientMaxWindowBits === false) {
+ delete accepted.client_max_window_bits;
+ }
+ return accepted;
+ }
+ /**
+ * Accept the extension negotiation response.
+ *
+ * @param {Array} response The extension negotiation response
+ * @return {Object} Accepted configuration
+ * @private
+ */
+ acceptAsClient(response) {
+ const params = response[0];
+ if (this._options.clientNoContextTakeover === false && params.client_no_context_takeover) {
+ throw new Error('Unexpected parameter "client_no_context_takeover"');
+ }
+ if (!params.client_max_window_bits) {
+ if (typeof this._options.clientMaxWindowBits === "number") {
+ params.client_max_window_bits = this._options.clientMaxWindowBits;
+ }
+ } else if (this._options.clientMaxWindowBits === false || typeof this._options.clientMaxWindowBits === "number" && params.client_max_window_bits > this._options.clientMaxWindowBits) {
+ throw new Error(
+ 'Unexpected or invalid parameter "client_max_window_bits"'
+ );
+ }
+ return params;
+ }
+ /**
+ * Normalize parameters.
+ *
+ * @param {Array} configurations The extension negotiation offers/reponse
+ * @return {Array} The offers/response with normalized parameters
+ * @private
+ */
+ normalizeParams(configurations) {
+ configurations.forEach((params) => {
+ Object.keys(params).forEach((key) => {
+ let value = params[key];
+ if (value.length > 1) {
+ throw new Error(`Parameter "${key}" must have only a single value`);
+ }
+ value = value[0];
+ if (key === "client_max_window_bits") {
+ if (value !== true) {
+ const num = +value;
+ if (!Number.isInteger(num) || num < 8 || num > 15) {
+ throw new TypeError(
+ `Invalid value for parameter "${key}": ${value}`
+ );
+ }
+ value = num;
+ } else if (!this._isServer) {
+ throw new TypeError(
+ `Invalid value for parameter "${key}": ${value}`
+ );
+ }
+ } else if (key === "server_max_window_bits") {
+ const num = +value;
+ if (!Number.isInteger(num) || num < 8 || num > 15) {
+ throw new TypeError(
+ `Invalid value for parameter "${key}": ${value}`
+ );
+ }
+ value = num;
+ } else if (key === "client_no_context_takeover" || key === "server_no_context_takeover") {
+ if (value !== true) {
+ throw new TypeError(
+ `Invalid value for parameter "${key}": ${value}`
+ );
+ }
+ } else {
+ throw new Error(`Unknown parameter "${key}"`);
+ }
+ params[key] = value;
+ });
+ });
+ return configurations;
+ }
+ /**
+ * Decompress data. Concurrency limited.
+ *
+ * @param {Buffer} data Compressed data
+ * @param {Boolean} fin Specifies whether or not this is the last fragment
+ * @param {Function} callback Callback
+ * @public
+ */
+ decompress(data, fin, callback) {
+ zlibLimiter.add((done) => {
+ this._decompress(data, fin, (err, result) => {
+ done();
+ callback(err, result);
+ });
+ });
+ }
+ /**
+ * Compress data. Concurrency limited.
+ *
+ * @param {Buffer} data Data to compress
+ * @param {Boolean} fin Specifies whether or not this is the last fragment
+ * @param {Function} callback Callback
+ * @public
+ */
+ compress(data, fin, callback) {
+ zlibLimiter.add((done) => {
+ this._compress(data, fin, (err, result) => {
+ done();
+ callback(err, result);
+ });
+ });
+ }
+ /**
+ * Decompress data.
+ *
+ * @param {Buffer} data Compressed data
+ * @param {Boolean} fin Specifies whether or not this is the last fragment
+ * @param {Function} callback Callback
+ * @private
+ */
+ _decompress(data, fin, callback) {
+ const endpoint = this._isServer ? "client" : "server";
+ if (!this._inflate) {
+ const key = `${endpoint}_max_window_bits`;
+ const windowBits = typeof this.params[key] !== "number" ? zlib.Z_DEFAULT_WINDOWBITS : this.params[key];
+ this._inflate = zlib.createInflateRaw({
+ ...this._options.zlibInflateOptions,
+ windowBits
+ });
+ this._inflate[kPerMessageDeflate] = this;
+ this._inflate[kTotalLength] = 0;
+ this._inflate[kBuffers] = [];
+ this._inflate.on("error", inflateOnError);
+ this._inflate.on("data", inflateOnData);
+ }
+ this._inflate[kCallback] = callback;
+ this._inflate.write(data);
+ if (fin)
+ this._inflate.write(TRAILER);
+ this._inflate.flush(() => {
+ const err = this._inflate[kError];
+ if (err) {
+ this._inflate.close();
+ this._inflate = null;
+ callback(err);
+ return;
+ }
+ const data2 = bufferUtil.concat(
+ this._inflate[kBuffers],
+ this._inflate[kTotalLength]
+ );
+ if (this._inflate._readableState.endEmitted) {
+ this._inflate.close();
+ this._inflate = null;
+ } else {
+ this._inflate[kTotalLength] = 0;
+ this._inflate[kBuffers] = [];
+ if (fin && this.params[`${endpoint}_no_context_takeover`]) {
+ this._inflate.reset();
+ }
+ }
+ callback(null, data2);
+ });
+ }
+ /**
+ * Compress data.
+ *
+ * @param {Buffer} data Data to compress
+ * @param {Boolean} fin Specifies whether or not this is the last fragment
+ * @param {Function} callback Callback
+ * @private
+ */
+ _compress(data, fin, callback) {
+ const endpoint = this._isServer ? "server" : "client";
+ if (!this._deflate) {
+ const key = `${endpoint}_max_window_bits`;
+ const windowBits = typeof this.params[key] !== "number" ? zlib.Z_DEFAULT_WINDOWBITS : this.params[key];
+ this._deflate = zlib.createDeflateRaw({
+ ...this._options.zlibDeflateOptions,
+ windowBits
+ });
+ this._deflate[kTotalLength] = 0;
+ this._deflate[kBuffers] = [];
+ this._deflate.on("error", NOOP);
+ this._deflate.on("data", deflateOnData);
+ }
+ this._deflate[kCallback] = callback;
+ this._deflate.write(data);
+ this._deflate.flush(zlib.Z_SYNC_FLUSH, () => {
+ if (!this._deflate) {
+ return;
+ }
+ let data2 = bufferUtil.concat(
+ this._deflate[kBuffers],
+ this._deflate[kTotalLength]
+ );
+ if (fin)
+ data2 = data2.slice(0, data2.length - 4);
+ this._deflate[kCallback] = null;
+ this._deflate[kTotalLength] = 0;
+ this._deflate[kBuffers] = [];
+ if (fin && this.params[`${endpoint}_no_context_takeover`]) {
+ this._deflate.reset();
+ }
+ callback(null, data2);
+ });
+ }
+ };
+ __name(PerMessageDeflate, "PerMessageDeflate");
+ module2.exports = PerMessageDeflate;
+ function deflateOnData(chunk) {
+ this[kBuffers].push(chunk);
+ this[kTotalLength] += chunk.length;
+ }
+ __name(deflateOnData, "deflateOnData");
+ function inflateOnData(chunk) {
+ this[kTotalLength] += chunk.length;
+ if (this[kPerMessageDeflate]._maxPayload < 1 || this[kTotalLength] <= this[kPerMessageDeflate]._maxPayload) {
+ this[kBuffers].push(chunk);
+ return;
+ }
+ this[kError] = new RangeError("Max payload size exceeded");
+ this[kError].code = "WS_ERR_UNSUPPORTED_MESSAGE_LENGTH";
+ this[kError][kStatusCode] = 1009;
+ this.removeListener("data", inflateOnData);
+ this.reset();
+ }
+ __name(inflateOnData, "inflateOnData");
+ function inflateOnError(err) {
+ this[kPerMessageDeflate]._inflate = null;
+ err[kStatusCode] = 1007;
+ this[kCallback](err);
+ }
+ __name(inflateOnError, "inflateOnError");
+ }
+});
+
+// ../../node_modules/.pnpm/ws@7.5.6/node_modules/ws/lib/validation.js
+var require_validation = __commonJS({
+ "../../node_modules/.pnpm/ws@7.5.6/node_modules/ws/lib/validation.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ function isValidStatusCode(code) {
+ return code >= 1e3 && code <= 1014 && code !== 1004 && code !== 1005 && code !== 1006 || code >= 3e3 && code <= 4999;
+ }
+ __name(isValidStatusCode, "isValidStatusCode");
+ function _isValidUTF8(buf) {
+ const len = buf.length;
+ let i = 0;
+ while (i < len) {
+ if ((buf[i] & 128) === 0) {
+ i++;
+ } else if ((buf[i] & 224) === 192) {
+ if (i + 1 === len || (buf[i + 1] & 192) !== 128 || (buf[i] & 254) === 192) {
+ return false;
+ }
+ i += 2;
+ } else if ((buf[i] & 240) === 224) {
+ if (i + 2 >= len || (buf[i + 1] & 192) !== 128 || (buf[i + 2] & 192) !== 128 || buf[i] === 224 && (buf[i + 1] & 224) === 128 || // Overlong
+ buf[i] === 237 && (buf[i + 1] & 224) === 160) {
+ return false;
+ }
+ i += 3;
+ } else if ((buf[i] & 248) === 240) {
+ if (i + 3 >= len || (buf[i + 1] & 192) !== 128 || (buf[i + 2] & 192) !== 128 || (buf[i + 3] & 192) !== 128 || buf[i] === 240 && (buf[i + 1] & 240) === 128 || // Overlong
+ buf[i] === 244 && buf[i + 1] > 143 || buf[i] > 244) {
+ return false;
+ }
+ i += 4;
+ } else {
+ return false;
+ }
+ }
+ return true;
+ }
+ __name(_isValidUTF8, "_isValidUTF8");
+ try {
+ let isValidUTF8 = require("utf-8-validate");
+ if (typeof isValidUTF8 === "object") {
+ isValidUTF8 = isValidUTF8.Validation.isValidUTF8;
+ }
+ module2.exports = {
+ isValidStatusCode,
+ isValidUTF8(buf) {
+ return buf.length < 150 ? _isValidUTF8(buf) : isValidUTF8(buf);
+ }
+ };
+ } catch (e2) {
+ module2.exports = {
+ isValidStatusCode,
+ isValidUTF8: _isValidUTF8
+ };
+ }
+ }
+});
+
+// ../../node_modules/.pnpm/ws@7.5.6/node_modules/ws/lib/receiver.js
+var require_receiver2 = __commonJS({
+ "../../node_modules/.pnpm/ws@7.5.6/node_modules/ws/lib/receiver.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var { Writable } = require("stream");
+ var PerMessageDeflate = require_permessage_deflate();
+ var {
+ BINARY_TYPES,
+ EMPTY_BUFFER,
+ kStatusCode,
+ kWebSocket
+ } = require_constants5();
+ var { concat, toArrayBuffer, unmask } = require_buffer_util();
+ var { isValidStatusCode, isValidUTF8 } = require_validation();
+ var GET_INFO = 0;
+ var GET_PAYLOAD_LENGTH_16 = 1;
+ var GET_PAYLOAD_LENGTH_64 = 2;
+ var GET_MASK = 3;
+ var GET_DATA = 4;
+ var INFLATING = 5;
+ var Receiver2 = class extends Writable {
+ /**
+ * Creates a Receiver instance.
+ *
+ * @param {String} [binaryType=nodebuffer] The type for binary data
+ * @param {Object} [extensions] An object containing the negotiated extensions
+ * @param {Boolean} [isServer=false] Specifies whether to operate in client or
+ * server mode
+ * @param {Number} [maxPayload=0] The maximum allowed message length
+ */
+ constructor(binaryType, extensions, isServer, maxPayload) {
+ super();
+ this._binaryType = binaryType || BINARY_TYPES[0];
+ this[kWebSocket] = void 0;
+ this._extensions = extensions || {};
+ this._isServer = !!isServer;
+ this._maxPayload = maxPayload | 0;
+ this._bufferedBytes = 0;
+ this._buffers = [];
+ this._compressed = false;
+ this._payloadLength = 0;
+ this._mask = void 0;
+ this._fragmented = 0;
+ this._masked = false;
+ this._fin = false;
+ this._opcode = 0;
+ this._totalPayloadLength = 0;
+ this._messageLength = 0;
+ this._fragments = [];
+ this._state = GET_INFO;
+ this._loop = false;
+ }
+ /**
+ * Implements `Writable.prototype._write()`.
+ *
+ * @param {Buffer} chunk The chunk of data to write
+ * @param {String} encoding The character encoding of `chunk`
+ * @param {Function} cb Callback
+ * @private
+ */
+ _write(chunk, encoding, cb) {
+ if (this._opcode === 8 && this._state == GET_INFO)
+ return cb();
+ this._bufferedBytes += chunk.length;
+ this._buffers.push(chunk);
+ this.startLoop(cb);
+ }
+ /**
+ * Consumes `n` bytes from the buffered data.
+ *
+ * @param {Number} n The number of bytes to consume
+ * @return {Buffer} The consumed bytes
+ * @private
+ */
+ consume(n) {
+ this._bufferedBytes -= n;
+ if (n === this._buffers[0].length)
+ return this._buffers.shift();
+ if (n < this._buffers[0].length) {
+ const buf = this._buffers[0];
+ this._buffers[0] = buf.slice(n);
+ return buf.slice(0, n);
+ }
+ const dst = Buffer.allocUnsafe(n);
+ do {
+ const buf = this._buffers[0];
+ const offset = dst.length - n;
+ if (n >= buf.length) {
+ dst.set(this._buffers.shift(), offset);
+ } else {
+ dst.set(new Uint8Array(buf.buffer, buf.byteOffset, n), offset);
+ this._buffers[0] = buf.slice(n);
+ }
+ n -= buf.length;
+ } while (n > 0);
+ return dst;
+ }
+ /**
+ * Starts the parsing loop.
+ *
+ * @param {Function} cb Callback
+ * @private
+ */
+ startLoop(cb) {
+ let err;
+ this._loop = true;
+ do {
+ switch (this._state) {
+ case GET_INFO:
+ err = this.getInfo();
+ break;
+ case GET_PAYLOAD_LENGTH_16:
+ err = this.getPayloadLength16();
+ break;
+ case GET_PAYLOAD_LENGTH_64:
+ err = this.getPayloadLength64();
+ break;
+ case GET_MASK:
+ this.getMask();
+ break;
+ case GET_DATA:
+ err = this.getData(cb);
+ break;
+ default:
+ this._loop = false;
+ return;
+ }
+ } while (this._loop);
+ cb(err);
+ }
+ /**
+ * Reads the first two bytes of a frame.
+ *
+ * @return {(RangeError|undefined)} A possible error
+ * @private
+ */
+ getInfo() {
+ if (this._bufferedBytes < 2) {
+ this._loop = false;
+ return;
+ }
+ const buf = this.consume(2);
+ if ((buf[0] & 48) !== 0) {
+ this._loop = false;
+ return error(
+ RangeError,
+ "RSV2 and RSV3 must be clear",
+ true,
+ 1002,
+ "WS_ERR_UNEXPECTED_RSV_2_3"
+ );
+ }
+ const compressed = (buf[0] & 64) === 64;
+ if (compressed && !this._extensions[PerMessageDeflate.extensionName]) {
+ this._loop = false;
+ return error(
+ RangeError,
+ "RSV1 must be clear",
+ true,
+ 1002,
+ "WS_ERR_UNEXPECTED_RSV_1"
+ );
+ }
+ this._fin = (buf[0] & 128) === 128;
+ this._opcode = buf[0] & 15;
+ this._payloadLength = buf[1] & 127;
+ if (this._opcode === 0) {
+ if (compressed) {
+ this._loop = false;
+ return error(
+ RangeError,
+ "RSV1 must be clear",
+ true,
+ 1002,
+ "WS_ERR_UNEXPECTED_RSV_1"
+ );
+ }
+ if (!this._fragmented) {
+ this._loop = false;
+ return error(
+ RangeError,
+ "invalid opcode 0",
+ true,
+ 1002,
+ "WS_ERR_INVALID_OPCODE"
+ );
+ }
+ this._opcode = this._fragmented;
+ } else if (this._opcode === 1 || this._opcode === 2) {
+ if (this._fragmented) {
+ this._loop = false;
+ return error(
+ RangeError,
+ `invalid opcode ${this._opcode}`,
+ true,
+ 1002,
+ "WS_ERR_INVALID_OPCODE"
+ );
+ }
+ this._compressed = compressed;
+ } else if (this._opcode > 7 && this._opcode < 11) {
+ if (!this._fin) {
+ this._loop = false;
+ return error(
+ RangeError,
+ "FIN must be set",
+ true,
+ 1002,
+ "WS_ERR_EXPECTED_FIN"
+ );
+ }
+ if (compressed) {
+ this._loop = false;
+ return error(
+ RangeError,
+ "RSV1 must be clear",
+ true,
+ 1002,
+ "WS_ERR_UNEXPECTED_RSV_1"
+ );
+ }
+ if (this._payloadLength > 125) {
+ this._loop = false;
+ return error(
+ RangeError,
+ `invalid payload length ${this._payloadLength}`,
+ true,
+ 1002,
+ "WS_ERR_INVALID_CONTROL_PAYLOAD_LENGTH"
+ );
+ }
+ } else {
+ this._loop = false;
+ return error(
+ RangeError,
+ `invalid opcode ${this._opcode}`,
+ true,
+ 1002,
+ "WS_ERR_INVALID_OPCODE"
+ );
+ }
+ if (!this._fin && !this._fragmented)
+ this._fragmented = this._opcode;
+ this._masked = (buf[1] & 128) === 128;
+ if (this._isServer) {
+ if (!this._masked) {
+ this._loop = false;
+ return error(
+ RangeError,
+ "MASK must be set",
+ true,
+ 1002,
+ "WS_ERR_EXPECTED_MASK"
+ );
+ }
+ } else if (this._masked) {
+ this._loop = false;
+ return error(
+ RangeError,
+ "MASK must be clear",
+ true,
+ 1002,
+ "WS_ERR_UNEXPECTED_MASK"
+ );
+ }
+ if (this._payloadLength === 126)
+ this._state = GET_PAYLOAD_LENGTH_16;
+ else if (this._payloadLength === 127)
+ this._state = GET_PAYLOAD_LENGTH_64;
+ else
+ return this.haveLength();
+ }
+ /**
+ * Gets extended payload length (7+16).
+ *
+ * @return {(RangeError|undefined)} A possible error
+ * @private
+ */
+ getPayloadLength16() {
+ if (this._bufferedBytes < 2) {
+ this._loop = false;
+ return;
+ }
+ this._payloadLength = this.consume(2).readUInt16BE(0);
+ return this.haveLength();
+ }
+ /**
+ * Gets extended payload length (7+64).
+ *
+ * @return {(RangeError|undefined)} A possible error
+ * @private
+ */
+ getPayloadLength64() {
+ if (this._bufferedBytes < 8) {
+ this._loop = false;
+ return;
+ }
+ const buf = this.consume(8);
+ const num = buf.readUInt32BE(0);
+ if (num > Math.pow(2, 53 - 32) - 1) {
+ this._loop = false;
+ return error(
+ RangeError,
+ "Unsupported WebSocket frame: payload length > 2^53 - 1",
+ false,
+ 1009,
+ "WS_ERR_UNSUPPORTED_DATA_PAYLOAD_LENGTH"
+ );
+ }
+ this._payloadLength = num * Math.pow(2, 32) + buf.readUInt32BE(4);
+ return this.haveLength();
+ }
+ /**
+ * Payload length has been read.
+ *
+ * @return {(RangeError|undefined)} A possible error
+ * @private
+ */
+ haveLength() {
+ if (this._payloadLength && this._opcode < 8) {
+ this._totalPayloadLength += this._payloadLength;
+ if (this._totalPayloadLength > this._maxPayload && this._maxPayload > 0) {
+ this._loop = false;
+ return error(
+ RangeError,
+ "Max payload size exceeded",
+ false,
+ 1009,
+ "WS_ERR_UNSUPPORTED_MESSAGE_LENGTH"
+ );
+ }
+ }
+ if (this._masked)
+ this._state = GET_MASK;
+ else
+ this._state = GET_DATA;
+ }
+ /**
+ * Reads mask bytes.
+ *
+ * @private
+ */
+ getMask() {
+ if (this._bufferedBytes < 4) {
+ this._loop = false;
+ return;
+ }
+ this._mask = this.consume(4);
+ this._state = GET_DATA;
+ }
+ /**
+ * Reads data bytes.
+ *
+ * @param {Function} cb Callback
+ * @return {(Error|RangeError|undefined)} A possible error
+ * @private
+ */
+ getData(cb) {
+ let data = EMPTY_BUFFER;
+ if (this._payloadLength) {
+ if (this._bufferedBytes < this._payloadLength) {
+ this._loop = false;
+ return;
+ }
+ data = this.consume(this._payloadLength);
+ if (this._masked)
+ unmask(data, this._mask);
+ }
+ if (this._opcode > 7)
+ return this.controlMessage(data);
+ if (this._compressed) {
+ this._state = INFLATING;
+ this.decompress(data, cb);
+ return;
+ }
+ if (data.length) {
+ this._messageLength = this._totalPayloadLength;
+ this._fragments.push(data);
+ }
+ return this.dataMessage();
+ }
+ /**
+ * Decompresses data.
+ *
+ * @param {Buffer} data Compressed data
+ * @param {Function} cb Callback
+ * @private
+ */
+ decompress(data, cb) {
+ const perMessageDeflate = this._extensions[PerMessageDeflate.extensionName];
+ perMessageDeflate.decompress(data, this._fin, (err, buf) => {
+ if (err)
+ return cb(err);
+ if (buf.length) {
+ this._messageLength += buf.length;
+ if (this._messageLength > this._maxPayload && this._maxPayload > 0) {
+ return cb(
+ error(
+ RangeError,
+ "Max payload size exceeded",
+ false,
+ 1009,
+ "WS_ERR_UNSUPPORTED_MESSAGE_LENGTH"
+ )
+ );
+ }
+ this._fragments.push(buf);
+ }
+ const er = this.dataMessage();
+ if (er)
+ return cb(er);
+ this.startLoop(cb);
+ });
+ }
+ /**
+ * Handles a data message.
+ *
+ * @return {(Error|undefined)} A possible error
+ * @private
+ */
+ dataMessage() {
+ if (this._fin) {
+ const messageLength = this._messageLength;
+ const fragments = this._fragments;
+ this._totalPayloadLength = 0;
+ this._messageLength = 0;
+ this._fragmented = 0;
+ this._fragments = [];
+ if (this._opcode === 2) {
+ let data;
+ if (this._binaryType === "nodebuffer") {
+ data = concat(fragments, messageLength);
+ } else if (this._binaryType === "arraybuffer") {
+ data = toArrayBuffer(concat(fragments, messageLength));
+ } else {
+ data = fragments;
+ }
+ this.emit("message", data);
+ } else {
+ const buf = concat(fragments, messageLength);
+ if (!isValidUTF8(buf)) {
+ this._loop = false;
+ return error(
+ Error,
+ "invalid UTF-8 sequence",
+ true,
+ 1007,
+ "WS_ERR_INVALID_UTF8"
+ );
+ }
+ this.emit("message", buf.toString());
+ }
+ }
+ this._state = GET_INFO;
+ }
+ /**
+ * Handles a control message.
+ *
+ * @param {Buffer} data Data to handle
+ * @return {(Error|RangeError|undefined)} A possible error
+ * @private
+ */
+ controlMessage(data) {
+ if (this._opcode === 8) {
+ this._loop = false;
+ if (data.length === 0) {
+ this.emit("conclude", 1005, "");
+ this.end();
+ } else if (data.length === 1) {
+ return error(
+ RangeError,
+ "invalid payload length 1",
+ true,
+ 1002,
+ "WS_ERR_INVALID_CONTROL_PAYLOAD_LENGTH"
+ );
+ } else {
+ const code = data.readUInt16BE(0);
+ if (!isValidStatusCode(code)) {
+ return error(
+ RangeError,
+ `invalid status code ${code}`,
+ true,
+ 1002,
+ "WS_ERR_INVALID_CLOSE_CODE"
+ );
+ }
+ const buf = data.slice(2);
+ if (!isValidUTF8(buf)) {
+ return error(
+ Error,
+ "invalid UTF-8 sequence",
+ true,
+ 1007,
+ "WS_ERR_INVALID_UTF8"
+ );
+ }
+ this.emit("conclude", code, buf.toString());
+ this.end();
+ }
+ } else if (this._opcode === 9) {
+ this.emit("ping", data);
+ } else {
+ this.emit("pong", data);
+ }
+ this._state = GET_INFO;
+ }
+ };
+ __name(Receiver2, "Receiver");
+ module2.exports = Receiver2;
+ function error(ErrorCtor, message, prefix, statusCode, errorCode) {
+ const err = new ErrorCtor(
+ prefix ? `Invalid WebSocket frame: ${message}` : message
+ );
+ Error.captureStackTrace(err, error);
+ err.code = errorCode;
+ err[kStatusCode] = statusCode;
+ return err;
+ }
+ __name(error, "error");
+ }
+});
+
+// ../../node_modules/.pnpm/ws@7.5.6/node_modules/ws/lib/sender.js
+var require_sender = __commonJS({
+ "../../node_modules/.pnpm/ws@7.5.6/node_modules/ws/lib/sender.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var net3 = require("net");
+ var tls = require("tls");
+ var { randomFillSync } = require("crypto");
+ var PerMessageDeflate = require_permessage_deflate();
+ var { EMPTY_BUFFER } = require_constants5();
+ var { isValidStatusCode } = require_validation();
+ var { mask: applyMask, toBuffer } = require_buffer_util();
+ var mask = Buffer.alloc(4);
+ var Sender2 = class {
+ /**
+ * Creates a Sender instance.
+ *
+ * @param {(net.Socket|tls.Socket)} socket The connection socket
+ * @param {Object} [extensions] An object containing the negotiated extensions
+ */
+ constructor(socket, extensions) {
+ this._extensions = extensions || {};
+ this._socket = socket;
+ this._firstFragment = true;
+ this._compress = false;
+ this._bufferedBytes = 0;
+ this._deflating = false;
+ this._queue = [];
+ }
+ /**
+ * Frames a piece of data according to the HyBi WebSocket protocol.
+ *
+ * @param {Buffer} data The data to frame
+ * @param {Object} options Options object
+ * @param {Number} options.opcode The opcode
+ * @param {Boolean} [options.readOnly=false] Specifies whether `data` can be
+ * modified
+ * @param {Boolean} [options.fin=false] Specifies whether or not to set the
+ * FIN bit
+ * @param {Boolean} [options.mask=false] Specifies whether or not to mask
+ * `data`
+ * @param {Boolean} [options.rsv1=false] Specifies whether or not to set the
+ * RSV1 bit
+ * @return {Buffer[]} The framed data as a list of `Buffer` instances
+ * @public
+ */
+ static frame(data, options14) {
+ const merge = options14.mask && options14.readOnly;
+ let offset = options14.mask ? 6 : 2;
+ let payloadLength = data.length;
+ if (data.length >= 65536) {
+ offset += 8;
+ payloadLength = 127;
+ } else if (data.length > 125) {
+ offset += 2;
+ payloadLength = 126;
+ }
+ const target = Buffer.allocUnsafe(merge ? data.length + offset : offset);
+ target[0] = options14.fin ? options14.opcode | 128 : options14.opcode;
+ if (options14.rsv1)
+ target[0] |= 64;
+ target[1] = payloadLength;
+ if (payloadLength === 126) {
+ target.writeUInt16BE(data.length, 2);
+ } else if (payloadLength === 127) {
+ target.writeUInt32BE(0, 2);
+ target.writeUInt32BE(data.length, 6);
+ }
+ if (!options14.mask)
+ return [target, data];
+ randomFillSync(mask, 0, 4);
+ target[1] |= 128;
+ target[offset - 4] = mask[0];
+ target[offset - 3] = mask[1];
+ target[offset - 2] = mask[2];
+ target[offset - 1] = mask[3];
+ if (merge) {
+ applyMask(data, mask, target, offset, data.length);
+ return [target];
+ }
+ applyMask(data, mask, data, 0, data.length);
+ return [target, data];
+ }
+ /**
+ * Sends a close message to the other peer.
+ *
+ * @param {Number} [code] The status code component of the body
+ * @param {String} [data] The message component of the body
+ * @param {Boolean} [mask=false] Specifies whether or not to mask the message
+ * @param {Function} [cb] Callback
+ * @public
+ */
+ close(code, data, mask2, cb) {
+ let buf;
+ if (code === void 0) {
+ buf = EMPTY_BUFFER;
+ } else if (typeof code !== "number" || !isValidStatusCode(code)) {
+ throw new TypeError("First argument must be a valid error code number");
+ } else if (data === void 0 || data === "") {
+ buf = Buffer.allocUnsafe(2);
+ buf.writeUInt16BE(code, 0);
+ } else {
+ const length = Buffer.byteLength(data);
+ if (length > 123) {
+ throw new RangeError("The message must not be greater than 123 bytes");
+ }
+ buf = Buffer.allocUnsafe(2 + length);
+ buf.writeUInt16BE(code, 0);
+ buf.write(data, 2);
+ }
+ if (this._deflating) {
+ this.enqueue([this.doClose, buf, mask2, cb]);
+ } else {
+ this.doClose(buf, mask2, cb);
+ }
+ }
+ /**
+ * Frames and sends a close message.
+ *
+ * @param {Buffer} data The message to send
+ * @param {Boolean} [mask=false] Specifies whether or not to mask `data`
+ * @param {Function} [cb] Callback
+ * @private
+ */
+ doClose(data, mask2, cb) {
+ this.sendFrame(
+ Sender2.frame(data, {
+ fin: true,
+ rsv1: false,
+ opcode: 8,
+ mask: mask2,
+ readOnly: false
+ }),
+ cb
+ );
+ }
+ /**
+ * Sends a ping message to the other peer.
+ *
+ * @param {*} data The message to send
+ * @param {Boolean} [mask=false] Specifies whether or not to mask `data`
+ * @param {Function} [cb] Callback
+ * @public
+ */
+ ping(data, mask2, cb) {
+ const buf = toBuffer(data);
+ if (buf.length > 125) {
+ throw new RangeError("The data size must not be greater than 125 bytes");
+ }
+ if (this._deflating) {
+ this.enqueue([this.doPing, buf, mask2, toBuffer.readOnly, cb]);
+ } else {
+ this.doPing(buf, mask2, toBuffer.readOnly, cb);
+ }
+ }
+ /**
+ * Frames and sends a ping message.
+ *
+ * @param {Buffer} data The message to send
+ * @param {Boolean} [mask=false] Specifies whether or not to mask `data`
+ * @param {Boolean} [readOnly=false] Specifies whether `data` can be modified
+ * @param {Function} [cb] Callback
+ * @private
+ */
+ doPing(data, mask2, readOnly, cb) {
+ this.sendFrame(
+ Sender2.frame(data, {
+ fin: true,
+ rsv1: false,
+ opcode: 9,
+ mask: mask2,
+ readOnly
+ }),
+ cb
+ );
+ }
+ /**
+ * Sends a pong message to the other peer.
+ *
+ * @param {*} data The message to send
+ * @param {Boolean} [mask=false] Specifies whether or not to mask `data`
+ * @param {Function} [cb] Callback
+ * @public
+ */
+ pong(data, mask2, cb) {
+ const buf = toBuffer(data);
+ if (buf.length > 125) {
+ throw new RangeError("The data size must not be greater than 125 bytes");
+ }
+ if (this._deflating) {
+ this.enqueue([this.doPong, buf, mask2, toBuffer.readOnly, cb]);
+ } else {
+ this.doPong(buf, mask2, toBuffer.readOnly, cb);
+ }
+ }
+ /**
+ * Frames and sends a pong message.
+ *
+ * @param {Buffer} data The message to send
+ * @param {Boolean} [mask=false] Specifies whether or not to mask `data`
+ * @param {Boolean} [readOnly=false] Specifies whether `data` can be modified
+ * @param {Function} [cb] Callback
+ * @private
+ */
+ doPong(data, mask2, readOnly, cb) {
+ this.sendFrame(
+ Sender2.frame(data, {
+ fin: true,
+ rsv1: false,
+ opcode: 10,
+ mask: mask2,
+ readOnly
+ }),
+ cb
+ );
+ }
+ /**
+ * Sends a data message to the other peer.
+ *
+ * @param {*} data The message to send
+ * @param {Object} options Options object
+ * @param {Boolean} [options.compress=false] Specifies whether or not to
+ * compress `data`
+ * @param {Boolean} [options.binary=false] Specifies whether `data` is binary
+ * or text
+ * @param {Boolean} [options.fin=false] Specifies whether the fragment is the
+ * last one
+ * @param {Boolean} [options.mask=false] Specifies whether or not to mask
+ * `data`
+ * @param {Function} [cb] Callback
+ * @public
+ */
+ send(data, options14, cb) {
+ const buf = toBuffer(data);
+ const perMessageDeflate = this._extensions[PerMessageDeflate.extensionName];
+ let opcode = options14.binary ? 2 : 1;
+ let rsv1 = options14.compress;
+ if (this._firstFragment) {
+ this._firstFragment = false;
+ if (rsv1 && perMessageDeflate) {
+ rsv1 = buf.length >= perMessageDeflate._threshold;
+ }
+ this._compress = rsv1;
+ } else {
+ rsv1 = false;
+ opcode = 0;
+ }
+ if (options14.fin)
+ this._firstFragment = true;
+ if (perMessageDeflate) {
+ const opts = {
+ fin: options14.fin,
+ rsv1,
+ opcode,
+ mask: options14.mask,
+ readOnly: toBuffer.readOnly
+ };
+ if (this._deflating) {
+ this.enqueue([this.dispatch, buf, this._compress, opts, cb]);
+ } else {
+ this.dispatch(buf, this._compress, opts, cb);
+ }
+ } else {
+ this.sendFrame(
+ Sender2.frame(buf, {
+ fin: options14.fin,
+ rsv1: false,
+ opcode,
+ mask: options14.mask,
+ readOnly: toBuffer.readOnly
+ }),
+ cb
+ );
+ }
+ }
+ /**
+ * Dispatches a data message.
+ *
+ * @param {Buffer} data The message to send
+ * @param {Boolean} [compress=false] Specifies whether or not to compress
+ * `data`
+ * @param {Object} options Options object
+ * @param {Number} options.opcode The opcode
+ * @param {Boolean} [options.readOnly=false] Specifies whether `data` can be
+ * modified
+ * @param {Boolean} [options.fin=false] Specifies whether or not to set the
+ * FIN bit
+ * @param {Boolean} [options.mask=false] Specifies whether or not to mask
+ * `data`
+ * @param {Boolean} [options.rsv1=false] Specifies whether or not to set the
+ * RSV1 bit
+ * @param {Function} [cb] Callback
+ * @private
+ */
+ dispatch(data, compress, options14, cb) {
+ if (!compress) {
+ this.sendFrame(Sender2.frame(data, options14), cb);
+ return;
+ }
+ const perMessageDeflate = this._extensions[PerMessageDeflate.extensionName];
+ this._bufferedBytes += data.length;
+ this._deflating = true;
+ perMessageDeflate.compress(data, options14.fin, (_2, buf) => {
+ if (this._socket.destroyed) {
+ const err = new Error(
+ "The socket was closed while data was being compressed"
+ );
+ if (typeof cb === "function")
+ cb(err);
+ for (let i = 0; i < this._queue.length; i++) {
+ const callback = this._queue[i][4];
+ if (typeof callback === "function")
+ callback(err);
+ }
+ return;
+ }
+ this._bufferedBytes -= data.length;
+ this._deflating = false;
+ options14.readOnly = false;
+ this.sendFrame(Sender2.frame(buf, options14), cb);
+ this.dequeue();
+ });
+ }
+ /**
+ * Executes queued send operations.
+ *
+ * @private
+ */
+ dequeue() {
+ while (!this._deflating && this._queue.length) {
+ const params = this._queue.shift();
+ this._bufferedBytes -= params[1].length;
+ Reflect.apply(params[0], this, params.slice(1));
+ }
+ }
+ /**
+ * Enqueues a send operation.
+ *
+ * @param {Array} params Send operation parameters.
+ * @private
+ */
+ enqueue(params) {
+ this._bufferedBytes += params[1].length;
+ this._queue.push(params);
+ }
+ /**
+ * Sends a frame.
+ *
+ * @param {Buffer[]} list The frame to send
+ * @param {Function} [cb] Callback
+ * @private
+ */
+ sendFrame(list, cb) {
+ if (list.length === 2) {
+ this._socket.cork();
+ this._socket.write(list[0]);
+ this._socket.write(list[1], cb);
+ this._socket.uncork();
+ } else {
+ this._socket.write(list[0], cb);
+ }
+ }
+ };
+ __name(Sender2, "Sender");
+ module2.exports = Sender2;
+ }
+});
+
+// ../../node_modules/.pnpm/ws@7.5.6/node_modules/ws/lib/event-target.js
+var require_event_target = __commonJS({
+ "../../node_modules/.pnpm/ws@7.5.6/node_modules/ws/lib/event-target.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var Event2 = class {
+ /**
+ * Create a new `Event`.
+ *
+ * @param {String} type The name of the event
+ * @param {Object} target A reference to the target to which the event was
+ * dispatched
+ */
+ constructor(type, target) {
+ this.target = target;
+ this.type = type;
+ }
+ };
+ __name(Event2, "Event");
+ var MessageEvent = class extends Event2 {
+ /**
+ * Create a new `MessageEvent`.
+ *
+ * @param {(String|Buffer|ArrayBuffer|Buffer[])} data The received data
+ * @param {WebSocket} target A reference to the target to which the event was
+ * dispatched
+ */
+ constructor(data, target) {
+ super("message", target);
+ this.data = data;
+ }
+ };
+ __name(MessageEvent, "MessageEvent");
+ var CloseEvent = class extends Event2 {
+ /**
+ * Create a new `CloseEvent`.
+ *
+ * @param {Number} code The status code explaining why the connection is being
+ * closed
+ * @param {String} reason A human-readable string explaining why the
+ * connection is closing
+ * @param {WebSocket} target A reference to the target to which the event was
+ * dispatched
+ */
+ constructor(code, reason, target) {
+ super("close", target);
+ this.wasClean = target._closeFrameReceived && target._closeFrameSent;
+ this.reason = reason;
+ this.code = code;
+ }
+ };
+ __name(CloseEvent, "CloseEvent");
+ var OpenEvent = class extends Event2 {
+ /**
+ * Create a new `OpenEvent`.
+ *
+ * @param {WebSocket} target A reference to the target to which the event was
+ * dispatched
+ */
+ constructor(target) {
+ super("open", target);
+ }
+ };
+ __name(OpenEvent, "OpenEvent");
+ var ErrorEvent2 = class extends Event2 {
+ /**
+ * Create a new `ErrorEvent`.
+ *
+ * @param {Object} error The error that generated this event
+ * @param {WebSocket} target A reference to the target to which the event was
+ * dispatched
+ */
+ constructor(error, target) {
+ super("error", target);
+ this.message = error.message;
+ this.error = error;
+ }
+ };
+ __name(ErrorEvent2, "ErrorEvent");
+ var EventTarget2 = {
+ /**
+ * Register an event listener.
+ *
+ * @param {String} type A string representing the event type to listen for
+ * @param {Function} listener The listener to add
+ * @param {Object} [options] An options object specifies characteristics about
+ * the event listener
+ * @param {Boolean} [options.once=false] A `Boolean`` indicating that the
+ * listener should be invoked at most once after being added. If `true`,
+ * the listener would be automatically removed when invoked.
+ * @public
+ */
+ addEventListener(type, listener, options14) {
+ if (typeof listener !== "function")
+ return;
+ function onMessage(data) {
+ listener.call(this, new MessageEvent(data, this));
+ }
+ __name(onMessage, "onMessage");
+ function onClose(code, message) {
+ listener.call(this, new CloseEvent(code, message, this));
+ }
+ __name(onClose, "onClose");
+ function onError(error) {
+ listener.call(this, new ErrorEvent2(error, this));
+ }
+ __name(onError, "onError");
+ function onOpen() {
+ listener.call(this, new OpenEvent(this));
+ }
+ __name(onOpen, "onOpen");
+ const method = options14 && options14.once ? "once" : "on";
+ if (type === "message") {
+ onMessage._listener = listener;
+ this[method](type, onMessage);
+ } else if (type === "close") {
+ onClose._listener = listener;
+ this[method](type, onClose);
+ } else if (type === "error") {
+ onError._listener = listener;
+ this[method](type, onError);
+ } else if (type === "open") {
+ onOpen._listener = listener;
+ this[method](type, onOpen);
+ } else {
+ this[method](type, listener);
+ }
+ },
+ /**
+ * Remove an event listener.
+ *
+ * @param {String} type A string representing the event type to remove
+ * @param {Function} listener The listener to remove
+ * @public
+ */
+ removeEventListener(type, listener) {
+ const listeners = this.listeners(type);
+ for (let i = 0; i < listeners.length; i++) {
+ if (listeners[i] === listener || listeners[i]._listener === listener) {
+ this.removeListener(type, listeners[i]);
+ }
+ }
+ }
+ };
+ module2.exports = EventTarget2;
+ }
+});
+
+// ../../node_modules/.pnpm/ws@7.5.6/node_modules/ws/lib/extension.js
+var require_extension = __commonJS({
+ "../../node_modules/.pnpm/ws@7.5.6/node_modules/ws/lib/extension.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var tokenChars = [
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ // 0 - 15
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ // 16 - 31
+ 0,
+ 1,
+ 0,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 0,
+ 0,
+ 1,
+ 1,
+ 0,
+ 1,
+ 1,
+ 0,
+ // 32 - 47
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ // 48 - 63
+ 0,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ // 64 - 79
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 0,
+ 0,
+ 0,
+ 1,
+ 1,
+ // 80 - 95
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ // 96 - 111
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 0,
+ 1,
+ 0,
+ 1,
+ 0
+ // 112 - 127
+ ];
+ function push(dest, name, elem) {
+ if (dest[name] === void 0)
+ dest[name] = [elem];
+ else
+ dest[name].push(elem);
+ }
+ __name(push, "push");
+ function parse4(header) {
+ const offers = /* @__PURE__ */ Object.create(null);
+ if (header === void 0 || header === "")
+ return offers;
+ let params = /* @__PURE__ */ Object.create(null);
+ let mustUnescape = false;
+ let isEscaping = false;
+ let inQuotes = false;
+ let extensionName;
+ let paramName;
+ let start = -1;
+ let end = -1;
+ let i = 0;
+ for (; i < header.length; i++) {
+ const code = header.charCodeAt(i);
+ if (extensionName === void 0) {
+ if (end === -1 && tokenChars[code] === 1) {
+ if (start === -1)
+ start = i;
+ } else if (code === 32 || code === 9) {
+ if (end === -1 && start !== -1)
+ end = i;
+ } else if (code === 59 || code === 44) {
+ if (start === -1) {
+ throw new SyntaxError(`Unexpected character at index ${i}`);
+ }
+ if (end === -1)
+ end = i;
+ const name = header.slice(start, end);
+ if (code === 44) {
+ push(offers, name, params);
+ params = /* @__PURE__ */ Object.create(null);
+ } else {
+ extensionName = name;
+ }
+ start = end = -1;
+ } else {
+ throw new SyntaxError(`Unexpected character at index ${i}`);
+ }
+ } else if (paramName === void 0) {
+ if (end === -1 && tokenChars[code] === 1) {
+ if (start === -1)
+ start = i;
+ } else if (code === 32 || code === 9) {
+ if (end === -1 && start !== -1)
+ end = i;
+ } else if (code === 59 || code === 44) {
+ if (start === -1) {
+ throw new SyntaxError(`Unexpected character at index ${i}`);
+ }
+ if (end === -1)
+ end = i;
+ push(params, header.slice(start, end), true);
+ if (code === 44) {
+ push(offers, extensionName, params);
+ params = /* @__PURE__ */ Object.create(null);
+ extensionName = void 0;
+ }
+ start = end = -1;
+ } else if (code === 61 && start !== -1 && end === -1) {
+ paramName = header.slice(start, i);
+ start = end = -1;
+ } else {
+ throw new SyntaxError(`Unexpected character at index ${i}`);
+ }
+ } else {
+ if (isEscaping) {
+ if (tokenChars[code] !== 1) {
+ throw new SyntaxError(`Unexpected character at index ${i}`);
+ }
+ if (start === -1)
+ start = i;
+ else if (!mustUnescape)
+ mustUnescape = true;
+ isEscaping = false;
+ } else if (inQuotes) {
+ if (tokenChars[code] === 1) {
+ if (start === -1)
+ start = i;
+ } else if (code === 34 && start !== -1) {
+ inQuotes = false;
+ end = i;
+ } else if (code === 92) {
+ isEscaping = true;
+ } else {
+ throw new SyntaxError(`Unexpected character at index ${i}`);
+ }
+ } else if (code === 34 && header.charCodeAt(i - 1) === 61) {
+ inQuotes = true;
+ } else if (end === -1 && tokenChars[code] === 1) {
+ if (start === -1)
+ start = i;
+ } else if (start !== -1 && (code === 32 || code === 9)) {
+ if (end === -1)
+ end = i;
+ } else if (code === 59 || code === 44) {
+ if (start === -1) {
+ throw new SyntaxError(`Unexpected character at index ${i}`);
+ }
+ if (end === -1)
+ end = i;
+ let value = header.slice(start, end);
+ if (mustUnescape) {
+ value = value.replace(/\\/g, "");
+ mustUnescape = false;
+ }
+ push(params, paramName, value);
+ if (code === 44) {
+ push(offers, extensionName, params);
+ params = /* @__PURE__ */ Object.create(null);
+ extensionName = void 0;
+ }
+ paramName = void 0;
+ start = end = -1;
+ } else {
+ throw new SyntaxError(`Unexpected character at index ${i}`);
+ }
+ }
+ }
+ if (start === -1 || inQuotes) {
+ throw new SyntaxError("Unexpected end of input");
+ }
+ if (end === -1)
+ end = i;
+ const token = header.slice(start, end);
+ if (extensionName === void 0) {
+ push(offers, token, params);
+ } else {
+ if (paramName === void 0) {
+ push(params, token, true);
+ } else if (mustUnescape) {
+ push(params, paramName, token.replace(/\\/g, ""));
+ } else {
+ push(params, paramName, token);
+ }
+ push(offers, extensionName, params);
+ }
+ return offers;
+ }
+ __name(parse4, "parse");
+ function format8(extensions) {
+ return Object.keys(extensions).map((extension) => {
+ let configurations = extensions[extension];
+ if (!Array.isArray(configurations))
+ configurations = [configurations];
+ return configurations.map((params) => {
+ return [extension].concat(
+ Object.keys(params).map((k) => {
+ let values = params[k];
+ if (!Array.isArray(values))
+ values = [values];
+ return values.map((v) => v === true ? k : `${k}=${v}`).join("; ");
+ })
+ ).join("; ");
+ }).join(", ");
+ }).join(", ");
+ }
+ __name(format8, "format");
+ module2.exports = { format: format8, parse: parse4 };
+ }
+});
+
+// ../../node_modules/.pnpm/ws@7.5.6/node_modules/ws/lib/websocket.js
+var require_websocket2 = __commonJS({
+ "../../node_modules/.pnpm/ws@7.5.6/node_modules/ws/lib/websocket.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var EventEmitter3 = require("events");
+ var https2 = require("https");
+ var http3 = require("http");
+ var net3 = require("net");
+ var tls = require("tls");
+ var { randomBytes, createHash } = require("crypto");
+ var { Readable } = require("stream");
+ var { URL: URL4 } = require("url");
+ var PerMessageDeflate = require_permessage_deflate();
+ var Receiver2 = require_receiver2();
+ var Sender2 = require_sender();
+ var {
+ BINARY_TYPES,
+ EMPTY_BUFFER,
+ GUID,
+ kStatusCode,
+ kWebSocket,
+ NOOP
+ } = require_constants5();
+ var { addEventListener, removeEventListener } = require_event_target();
+ var { format: format8, parse: parse4 } = require_extension();
+ var { toBuffer } = require_buffer_util();
+ var readyStates = ["CONNECTING", "OPEN", "CLOSING", "CLOSED"];
+ var protocolVersions = [8, 13];
+ var closeTimeout = 30 * 1e3;
+ var WebSocket2 = class extends EventEmitter3 {
+ /**
+ * Create a new `WebSocket`.
+ *
+ * @param {(String|URL)} address The URL to which to connect
+ * @param {(String|String[])} [protocols] The subprotocols
+ * @param {Object} [options] Connection options
+ */
+ constructor(address, protocols, options14) {
+ super();
+ this._binaryType = BINARY_TYPES[0];
+ this._closeCode = 1006;
+ this._closeFrameReceived = false;
+ this._closeFrameSent = false;
+ this._closeMessage = "";
+ this._closeTimer = null;
+ this._extensions = {};
+ this._protocol = "";
+ this._readyState = WebSocket2.CONNECTING;
+ this._receiver = null;
+ this._sender = null;
+ this._socket = null;
+ if (address !== null) {
+ this._bufferedAmount = 0;
+ this._isServer = false;
+ this._redirects = 0;
+ if (Array.isArray(protocols)) {
+ protocols = protocols.join(", ");
+ } else if (typeof protocols === "object" && protocols !== null) {
+ options14 = protocols;
+ protocols = void 0;
+ }
+ initAsClient(this, address, protocols, options14);
+ } else {
+ this._isServer = true;
+ }
+ }
+ /**
+ * This deviates from the WHATWG interface since ws doesn't support the
+ * required default "blob" type (instead we define a custom "nodebuffer"
+ * type).
+ *
+ * @type {String}
+ */
+ get binaryType() {
+ return this._binaryType;
+ }
+ set binaryType(type) {
+ if (!BINARY_TYPES.includes(type))
+ return;
+ this._binaryType = type;
+ if (this._receiver)
+ this._receiver._binaryType = type;
+ }
+ /**
+ * @type {Number}
+ */
+ get bufferedAmount() {
+ if (!this._socket)
+ return this._bufferedAmount;
+ return this._socket._writableState.length + this._sender._bufferedBytes;
+ }
+ /**
+ * @type {String}
+ */
+ get extensions() {
+ return Object.keys(this._extensions).join();
+ }
+ /**
+ * @type {Function}
+ */
+ /* istanbul ignore next */
+ get onclose() {
+ return void 0;
+ }
+ /* istanbul ignore next */
+ set onclose(listener) {
+ }
+ /**
+ * @type {Function}
+ */
+ /* istanbul ignore next */
+ get onerror() {
+ return void 0;
+ }
+ /* istanbul ignore next */
+ set onerror(listener) {
+ }
+ /**
+ * @type {Function}
+ */
+ /* istanbul ignore next */
+ get onopen() {
+ return void 0;
+ }
+ /* istanbul ignore next */
+ set onopen(listener) {
+ }
+ /**
+ * @type {Function}
+ */
+ /* istanbul ignore next */
+ get onmessage() {
+ return void 0;
+ }
+ /* istanbul ignore next */
+ set onmessage(listener) {
+ }
+ /**
+ * @type {String}
+ */
+ get protocol() {
+ return this._protocol;
+ }
+ /**
+ * @type {Number}
+ */
+ get readyState() {
+ return this._readyState;
+ }
+ /**
+ * @type {String}
+ */
+ get url() {
+ return this._url;
+ }
+ /**
+ * Set up the socket and the internal resources.
+ *
+ * @param {(net.Socket|tls.Socket)} socket The network socket between the
+ * server and client
+ * @param {Buffer} head The first packet of the upgraded stream
+ * @param {Number} [maxPayload=0] The maximum allowed message size
+ * @private
+ */
+ setSocket(socket, head, maxPayload) {
+ const receiver = new Receiver2(
+ this.binaryType,
+ this._extensions,
+ this._isServer,
+ maxPayload
+ );
+ this._sender = new Sender2(socket, this._extensions);
+ this._receiver = receiver;
+ this._socket = socket;
+ receiver[kWebSocket] = this;
+ socket[kWebSocket] = this;
+ receiver.on("conclude", receiverOnConclude);
+ receiver.on("drain", receiverOnDrain);
+ receiver.on("error", receiverOnError);
+ receiver.on("message", receiverOnMessage);
+ receiver.on("ping", receiverOnPing);
+ receiver.on("pong", receiverOnPong);
+ socket.setTimeout(0);
+ socket.setNoDelay();
+ if (head.length > 0)
+ socket.unshift(head);
+ socket.on("close", socketOnClose);
+ socket.on("data", socketOnData);
+ socket.on("end", socketOnEnd);
+ socket.on("error", socketOnError);
+ this._readyState = WebSocket2.OPEN;
+ this.emit("open");
+ }
+ /**
+ * Emit the `'close'` event.
+ *
+ * @private
+ */
+ emitClose() {
+ if (!this._socket) {
+ this._readyState = WebSocket2.CLOSED;
+ this.emit("close", this._closeCode, this._closeMessage);
+ return;
+ }
+ if (this._extensions[PerMessageDeflate.extensionName]) {
+ this._extensions[PerMessageDeflate.extensionName].cleanup();
+ }
+ this._receiver.removeAllListeners();
+ this._readyState = WebSocket2.CLOSED;
+ this.emit("close", this._closeCode, this._closeMessage);
+ }
+ /**
+ * Start a closing handshake.
+ *
+ * +----------+ +-----------+ +----------+
+ * - - -|ws.close()|-->|close frame|-->|ws.close()|- - -
+ * | +----------+ +-----------+ +----------+ |
+ * +----------+ +-----------+ |
+ * CLOSING |ws.close()|<--|close frame|<--+-----+ CLOSING
+ * +----------+ +-----------+ |
+ * | | | +---+ |
+ * +------------------------+-->|fin| - - - -
+ * | +---+ | +---+
+ * - - - - -|fin|<---------------------+
+ * +---+
+ *
+ * @param {Number} [code] Status code explaining why the connection is closing
+ * @param {String} [data] A string explaining why the connection is closing
+ * @public
+ */
+ close(code, data) {
+ if (this.readyState === WebSocket2.CLOSED)
+ return;
+ if (this.readyState === WebSocket2.CONNECTING) {
+ const msg = "WebSocket was closed before the connection was established";
+ return abortHandshake(this, this._req, msg);
+ }
+ if (this.readyState === WebSocket2.CLOSING) {
+ if (this._closeFrameSent && (this._closeFrameReceived || this._receiver._writableState.errorEmitted)) {
+ this._socket.end();
+ }
+ return;
+ }
+ this._readyState = WebSocket2.CLOSING;
+ this._sender.close(code, data, !this._isServer, (err) => {
+ if (err)
+ return;
+ this._closeFrameSent = true;
+ if (this._closeFrameReceived || this._receiver._writableState.errorEmitted) {
+ this._socket.end();
+ }
+ });
+ this._closeTimer = setTimeout(
+ this._socket.destroy.bind(this._socket),
+ closeTimeout
+ );
+ }
+ /**
+ * Send a ping.
+ *
+ * @param {*} [data] The data to send
+ * @param {Boolean} [mask] Indicates whether or not to mask `data`
+ * @param {Function} [cb] Callback which is executed when the ping is sent
+ * @public
+ */
+ ping(data, mask, cb) {
+ if (this.readyState === WebSocket2.CONNECTING) {
+ throw new Error("WebSocket is not open: readyState 0 (CONNECTING)");
+ }
+ if (typeof data === "function") {
+ cb = data;
+ data = mask = void 0;
+ } else if (typeof mask === "function") {
+ cb = mask;
+ mask = void 0;
+ }
+ if (typeof data === "number")
+ data = data.toString();
+ if (this.readyState !== WebSocket2.OPEN) {
+ sendAfterClose(this, data, cb);
+ return;
+ }
+ if (mask === void 0)
+ mask = !this._isServer;
+ this._sender.ping(data || EMPTY_BUFFER, mask, cb);
+ }
+ /**
+ * Send a pong.
+ *
+ * @param {*} [data] The data to send
+ * @param {Boolean} [mask] Indicates whether or not to mask `data`
+ * @param {Function} [cb] Callback which is executed when the pong is sent
+ * @public
+ */
+ pong(data, mask, cb) {
+ if (this.readyState === WebSocket2.CONNECTING) {
+ throw new Error("WebSocket is not open: readyState 0 (CONNECTING)");
+ }
+ if (typeof data === "function") {
+ cb = data;
+ data = mask = void 0;
+ } else if (typeof mask === "function") {
+ cb = mask;
+ mask = void 0;
+ }
+ if (typeof data === "number")
+ data = data.toString();
+ if (this.readyState !== WebSocket2.OPEN) {
+ sendAfterClose(this, data, cb);
+ return;
+ }
+ if (mask === void 0)
+ mask = !this._isServer;
+ this._sender.pong(data || EMPTY_BUFFER, mask, cb);
+ }
+ /**
+ * Send a data message.
+ *
+ * @param {*} data The message to send
+ * @param {Object} [options] Options object
+ * @param {Boolean} [options.compress] Specifies whether or not to compress
+ * `data`
+ * @param {Boolean} [options.binary] Specifies whether `data` is binary or
+ * text
+ * @param {Boolean} [options.fin=true] Specifies whether the fragment is the
+ * last one
+ * @param {Boolean} [options.mask] Specifies whether or not to mask `data`
+ * @param {Function} [cb] Callback which is executed when data is written out
+ * @public
+ */
+ send(data, options14, cb) {
+ if (this.readyState === WebSocket2.CONNECTING) {
+ throw new Error("WebSocket is not open: readyState 0 (CONNECTING)");
+ }
+ if (typeof options14 === "function") {
+ cb = options14;
+ options14 = {};
+ }
+ if (typeof data === "number")
+ data = data.toString();
+ if (this.readyState !== WebSocket2.OPEN) {
+ sendAfterClose(this, data, cb);
+ return;
+ }
+ const opts = {
+ binary: typeof data !== "string",
+ mask: !this._isServer,
+ compress: true,
+ fin: true,
+ ...options14
+ };
+ if (!this._extensions[PerMessageDeflate.extensionName]) {
+ opts.compress = false;
+ }
+ this._sender.send(data || EMPTY_BUFFER, opts, cb);
+ }
+ /**
+ * Forcibly close the connection.
+ *
+ * @public
+ */
+ terminate() {
+ if (this.readyState === WebSocket2.CLOSED)
+ return;
+ if (this.readyState === WebSocket2.CONNECTING) {
+ const msg = "WebSocket was closed before the connection was established";
+ return abortHandshake(this, this._req, msg);
+ }
+ if (this._socket) {
+ this._readyState = WebSocket2.CLOSING;
+ this._socket.destroy();
+ }
+ }
+ };
+ __name(WebSocket2, "WebSocket");
+ Object.defineProperty(WebSocket2, "CONNECTING", {
+ enumerable: true,
+ value: readyStates.indexOf("CONNECTING")
+ });
+ Object.defineProperty(WebSocket2.prototype, "CONNECTING", {
+ enumerable: true,
+ value: readyStates.indexOf("CONNECTING")
+ });
+ Object.defineProperty(WebSocket2, "OPEN", {
+ enumerable: true,
+ value: readyStates.indexOf("OPEN")
+ });
+ Object.defineProperty(WebSocket2.prototype, "OPEN", {
+ enumerable: true,
+ value: readyStates.indexOf("OPEN")
+ });
+ Object.defineProperty(WebSocket2, "CLOSING", {
+ enumerable: true,
+ value: readyStates.indexOf("CLOSING")
+ });
+ Object.defineProperty(WebSocket2.prototype, "CLOSING", {
+ enumerable: true,
+ value: readyStates.indexOf("CLOSING")
+ });
+ Object.defineProperty(WebSocket2, "CLOSED", {
+ enumerable: true,
+ value: readyStates.indexOf("CLOSED")
+ });
+ Object.defineProperty(WebSocket2.prototype, "CLOSED", {
+ enumerable: true,
+ value: readyStates.indexOf("CLOSED")
+ });
+ [
+ "binaryType",
+ "bufferedAmount",
+ "extensions",
+ "protocol",
+ "readyState",
+ "url"
+ ].forEach((property) => {
+ Object.defineProperty(WebSocket2.prototype, property, { enumerable: true });
+ });
+ ["open", "error", "close", "message"].forEach((method) => {
+ Object.defineProperty(WebSocket2.prototype, `on${method}`, {
+ enumerable: true,
+ get() {
+ const listeners = this.listeners(method);
+ for (let i = 0; i < listeners.length; i++) {
+ if (listeners[i]._listener)
+ return listeners[i]._listener;
+ }
+ return void 0;
+ },
+ set(listener) {
+ const listeners = this.listeners(method);
+ for (let i = 0; i < listeners.length; i++) {
+ if (listeners[i]._listener)
+ this.removeListener(method, listeners[i]);
+ }
+ this.addEventListener(method, listener);
+ }
+ });
+ });
+ WebSocket2.prototype.addEventListener = addEventListener;
+ WebSocket2.prototype.removeEventListener = removeEventListener;
+ module2.exports = WebSocket2;
+ function initAsClient(websocket, address, protocols, options14) {
+ const opts = {
+ protocolVersion: protocolVersions[1],
+ maxPayload: 100 * 1024 * 1024,
+ perMessageDeflate: true,
+ followRedirects: false,
+ maxRedirects: 10,
+ ...options14,
+ createConnection: void 0,
+ socketPath: void 0,
+ hostname: void 0,
+ protocol: void 0,
+ timeout: void 0,
+ method: void 0,
+ host: void 0,
+ path: void 0,
+ port: void 0
+ };
+ if (!protocolVersions.includes(opts.protocolVersion)) {
+ throw new RangeError(
+ `Unsupported protocol version: ${opts.protocolVersion} (supported versions: ${protocolVersions.join(", ")})`
+ );
+ }
+ let parsedUrl;
+ if (address instanceof URL4) {
+ parsedUrl = address;
+ websocket._url = address.href;
+ } else {
+ parsedUrl = new URL4(address);
+ websocket._url = address;
+ }
+ const isUnixSocket = parsedUrl.protocol === "ws+unix:";
+ if (!parsedUrl.host && (!isUnixSocket || !parsedUrl.pathname)) {
+ const err = new Error(`Invalid URL: ${websocket.url}`);
+ if (websocket._redirects === 0) {
+ throw err;
+ } else {
+ emitErrorAndClose(websocket, err);
+ return;
+ }
+ }
+ const isSecure = parsedUrl.protocol === "wss:" || parsedUrl.protocol === "https:";
+ const defaultPort = isSecure ? 443 : 80;
+ const key = randomBytes(16).toString("base64");
+ const get = isSecure ? https2.get : http3.get;
+ let perMessageDeflate;
+ opts.createConnection = isSecure ? tlsConnect : netConnect;
+ opts.defaultPort = opts.defaultPort || defaultPort;
+ opts.port = parsedUrl.port || defaultPort;
+ opts.host = parsedUrl.hostname.startsWith("[") ? parsedUrl.hostname.slice(1, -1) : parsedUrl.hostname;
+ opts.headers = {
+ "Sec-WebSocket-Version": opts.protocolVersion,
+ "Sec-WebSocket-Key": key,
+ Connection: "Upgrade",
+ Upgrade: "websocket",
+ ...opts.headers
+ };
+ opts.path = parsedUrl.pathname + parsedUrl.search;
+ opts.timeout = opts.handshakeTimeout;
+ if (opts.perMessageDeflate) {
+ perMessageDeflate = new PerMessageDeflate(
+ opts.perMessageDeflate !== true ? opts.perMessageDeflate : {},
+ false,
+ opts.maxPayload
+ );
+ opts.headers["Sec-WebSocket-Extensions"] = format8({
+ [PerMessageDeflate.extensionName]: perMessageDeflate.offer()
+ });
+ }
+ if (protocols) {
+ opts.headers["Sec-WebSocket-Protocol"] = protocols;
+ }
+ if (opts.origin) {
+ if (opts.protocolVersion < 13) {
+ opts.headers["Sec-WebSocket-Origin"] = opts.origin;
+ } else {
+ opts.headers.Origin = opts.origin;
+ }
+ }
+ if (parsedUrl.username || parsedUrl.password) {
+ opts.auth = `${parsedUrl.username}:${parsedUrl.password}`;
+ }
+ if (isUnixSocket) {
+ const parts = opts.path.split(":");
+ opts.socketPath = parts[0];
+ opts.path = parts[1];
+ }
+ let req = websocket._req = get(opts);
+ if (opts.timeout) {
+ req.on("timeout", () => {
+ abortHandshake(websocket, req, "Opening handshake has timed out");
+ });
+ }
+ req.on("error", (err) => {
+ if (req === null || req.aborted)
+ return;
+ req = websocket._req = null;
+ emitErrorAndClose(websocket, err);
+ });
+ req.on("response", (res) => {
+ const location = res.headers.location;
+ const statusCode = res.statusCode;
+ if (location && opts.followRedirects && statusCode >= 300 && statusCode < 400) {
+ if (++websocket._redirects > opts.maxRedirects) {
+ abortHandshake(websocket, req, "Maximum redirects exceeded");
+ return;
+ }
+ req.abort();
+ let addr;
+ try {
+ addr = new URL4(location, address);
+ } catch (err) {
+ emitErrorAndClose(websocket, err);
+ return;
+ }
+ initAsClient(websocket, addr, protocols, options14);
+ } else if (!websocket.emit("unexpected-response", req, res)) {
+ abortHandshake(
+ websocket,
+ req,
+ `Unexpected server response: ${res.statusCode}`
+ );
+ }
+ });
+ req.on("upgrade", (res, socket, head) => {
+ websocket.emit("upgrade", res);
+ if (websocket.readyState !== WebSocket2.CONNECTING)
+ return;
+ req = websocket._req = null;
+ const digest = createHash("sha1").update(key + GUID).digest("base64");
+ if (res.headers["sec-websocket-accept"] !== digest) {
+ abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header");
+ return;
+ }
+ const serverProt = res.headers["sec-websocket-protocol"];
+ const protList = (protocols || "").split(/, */);
+ let protError;
+ if (!protocols && serverProt) {
+ protError = "Server sent a subprotocol but none was requested";
+ } else if (protocols && !serverProt) {
+ protError = "Server sent no subprotocol";
+ } else if (serverProt && !protList.includes(serverProt)) {
+ protError = "Server sent an invalid subprotocol";
+ }
+ if (protError) {
+ abortHandshake(websocket, socket, protError);
+ return;
+ }
+ if (serverProt)
+ websocket._protocol = serverProt;
+ const secWebSocketExtensions = res.headers["sec-websocket-extensions"];
+ if (secWebSocketExtensions !== void 0) {
+ if (!perMessageDeflate) {
+ const message = "Server sent a Sec-WebSocket-Extensions header but no extension was requested";
+ abortHandshake(websocket, socket, message);
+ return;
+ }
+ let extensions;
+ try {
+ extensions = parse4(secWebSocketExtensions);
+ } catch (err) {
+ const message = "Invalid Sec-WebSocket-Extensions header";
+ abortHandshake(websocket, socket, message);
+ return;
+ }
+ const extensionNames = Object.keys(extensions);
+ if (extensionNames.length) {
+ if (extensionNames.length !== 1 || extensionNames[0] !== PerMessageDeflate.extensionName) {
+ const message = "Server indicated an extension that was not requested";
+ abortHandshake(websocket, socket, message);
+ return;
+ }
+ try {
+ perMessageDeflate.accept(extensions[PerMessageDeflate.extensionName]);
+ } catch (err) {
+ const message = "Invalid Sec-WebSocket-Extensions header";
+ abortHandshake(websocket, socket, message);
+ return;
+ }
+ websocket._extensions[PerMessageDeflate.extensionName] = perMessageDeflate;
+ }
+ }
+ websocket.setSocket(socket, head, opts.maxPayload);
+ });
+ }
+ __name(initAsClient, "initAsClient");
+ function emitErrorAndClose(websocket, err) {
+ websocket._readyState = WebSocket2.CLOSING;
+ websocket.emit("error", err);
+ websocket.emitClose();
+ }
+ __name(emitErrorAndClose, "emitErrorAndClose");
+ function netConnect(options14) {
+ options14.path = options14.socketPath;
+ return net3.connect(options14);
+ }
+ __name(netConnect, "netConnect");
+ function tlsConnect(options14) {
+ options14.path = void 0;
+ if (!options14.servername && options14.servername !== "") {
+ options14.servername = net3.isIP(options14.host) ? "" : options14.host;
+ }
+ return tls.connect(options14);
+ }
+ __name(tlsConnect, "tlsConnect");
+ function abortHandshake(websocket, stream2, message) {
+ websocket._readyState = WebSocket2.CLOSING;
+ const err = new Error(message);
+ Error.captureStackTrace(err, abortHandshake);
+ if (stream2.setHeader) {
+ stream2.abort();
+ if (stream2.socket && !stream2.socket.destroyed) {
+ stream2.socket.destroy();
+ }
+ stream2.once("abort", websocket.emitClose.bind(websocket));
+ websocket.emit("error", err);
+ } else {
+ stream2.destroy(err);
+ stream2.once("error", websocket.emit.bind(websocket, "error"));
+ stream2.once("close", websocket.emitClose.bind(websocket));
+ }
+ }
+ __name(abortHandshake, "abortHandshake");
+ function sendAfterClose(websocket, data, cb) {
+ if (data) {
+ const length = toBuffer(data).length;
+ if (websocket._socket)
+ websocket._sender._bufferedBytes += length;
+ else
+ websocket._bufferedAmount += length;
+ }
+ if (cb) {
+ const err = new Error(
+ `WebSocket is not open: readyState ${websocket.readyState} (${readyStates[websocket.readyState]})`
+ );
+ cb(err);
+ }
+ }
+ __name(sendAfterClose, "sendAfterClose");
+ function receiverOnConclude(code, reason) {
+ const websocket = this[kWebSocket];
+ websocket._closeFrameReceived = true;
+ websocket._closeMessage = reason;
+ websocket._closeCode = code;
+ if (websocket._socket[kWebSocket] === void 0)
+ return;
+ websocket._socket.removeListener("data", socketOnData);
+ process.nextTick(resume, websocket._socket);
+ if (code === 1005)
+ websocket.close();
+ else
+ websocket.close(code, reason);
+ }
+ __name(receiverOnConclude, "receiverOnConclude");
+ function receiverOnDrain() {
+ this[kWebSocket]._socket.resume();
+ }
+ __name(receiverOnDrain, "receiverOnDrain");
+ function receiverOnError(err) {
+ const websocket = this[kWebSocket];
+ if (websocket._socket[kWebSocket] !== void 0) {
+ websocket._socket.removeListener("data", socketOnData);
+ process.nextTick(resume, websocket._socket);
+ websocket.close(err[kStatusCode]);
+ }
+ websocket.emit("error", err);
+ }
+ __name(receiverOnError, "receiverOnError");
+ function receiverOnFinish() {
+ this[kWebSocket].emitClose();
+ }
+ __name(receiverOnFinish, "receiverOnFinish");
+ function receiverOnMessage(data) {
+ this[kWebSocket].emit("message", data);
+ }
+ __name(receiverOnMessage, "receiverOnMessage");
+ function receiverOnPing(data) {
+ const websocket = this[kWebSocket];
+ websocket.pong(data, !websocket._isServer, NOOP);
+ websocket.emit("ping", data);
+ }
+ __name(receiverOnPing, "receiverOnPing");
+ function receiverOnPong(data) {
+ this[kWebSocket].emit("pong", data);
+ }
+ __name(receiverOnPong, "receiverOnPong");
+ function resume(stream2) {
+ stream2.resume();
+ }
+ __name(resume, "resume");
+ function socketOnClose() {
+ const websocket = this[kWebSocket];
+ this.removeListener("close", socketOnClose);
+ this.removeListener("data", socketOnData);
+ this.removeListener("end", socketOnEnd);
+ websocket._readyState = WebSocket2.CLOSING;
+ let chunk;
+ if (!this._readableState.endEmitted && !websocket._closeFrameReceived && !websocket._receiver._writableState.errorEmitted && (chunk = websocket._socket.read()) !== null) {
+ websocket._receiver.write(chunk);
+ }
+ websocket._receiver.end();
+ this[kWebSocket] = void 0;
+ clearTimeout(websocket._closeTimer);
+ if (websocket._receiver._writableState.finished || websocket._receiver._writableState.errorEmitted) {
+ websocket.emitClose();
+ } else {
+ websocket._receiver.on("error", receiverOnFinish);
+ websocket._receiver.on("finish", receiverOnFinish);
+ }
+ }
+ __name(socketOnClose, "socketOnClose");
+ function socketOnData(chunk) {
+ if (!this[kWebSocket]._receiver.write(chunk)) {
+ this.pause();
+ }
+ }
+ __name(socketOnData, "socketOnData");
+ function socketOnEnd() {
+ const websocket = this[kWebSocket];
+ websocket._readyState = WebSocket2.CLOSING;
+ websocket._receiver.end();
+ this.end();
+ }
+ __name(socketOnEnd, "socketOnEnd");
+ function socketOnError() {
+ const websocket = this[kWebSocket];
+ this.removeListener("error", socketOnError);
+ this.on("error", NOOP);
+ if (websocket) {
+ websocket._readyState = WebSocket2.CLOSING;
+ this.destroy();
+ }
+ }
+ __name(socketOnError, "socketOnError");
+ }
+});
+
+// ../../node_modules/.pnpm/ws@7.5.6/node_modules/ws/lib/stream.js
+var require_stream = __commonJS({
+ "../../node_modules/.pnpm/ws@7.5.6/node_modules/ws/lib/stream.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var { Duplex } = require("stream");
+ function emitClose(stream2) {
+ stream2.emit("close");
+ }
+ __name(emitClose, "emitClose");
+ function duplexOnEnd() {
+ if (!this.destroyed && this._writableState.finished) {
+ this.destroy();
+ }
+ }
+ __name(duplexOnEnd, "duplexOnEnd");
+ function duplexOnError(err) {
+ this.removeListener("error", duplexOnError);
+ this.destroy();
+ if (this.listenerCount("error") === 0) {
+ this.emit("error", err);
+ }
+ }
+ __name(duplexOnError, "duplexOnError");
+ function createWebSocketStream2(ws, options14) {
+ let resumeOnReceiverDrain = true;
+ let terminateOnDestroy = true;
+ function receiverOnDrain() {
+ if (resumeOnReceiverDrain)
+ ws._socket.resume();
+ }
+ __name(receiverOnDrain, "receiverOnDrain");
+ if (ws.readyState === ws.CONNECTING) {
+ ws.once("open", /* @__PURE__ */ __name(function open3() {
+ ws._receiver.removeAllListeners("drain");
+ ws._receiver.on("drain", receiverOnDrain);
+ }, "open"));
+ } else {
+ ws._receiver.removeAllListeners("drain");
+ ws._receiver.on("drain", receiverOnDrain);
+ }
+ const duplex = new Duplex({
+ ...options14,
+ autoDestroy: false,
+ emitClose: false,
+ objectMode: false,
+ writableObjectMode: false
+ });
+ ws.on("message", /* @__PURE__ */ __name(function message(msg) {
+ if (!duplex.push(msg)) {
+ resumeOnReceiverDrain = false;
+ ws._socket.pause();
+ }
+ }, "message"));
+ ws.once("error", /* @__PURE__ */ __name(function error(err) {
+ if (duplex.destroyed)
+ return;
+ terminateOnDestroy = false;
+ duplex.destroy(err);
+ }, "error"));
+ ws.once("close", /* @__PURE__ */ __name(function close() {
+ if (duplex.destroyed)
+ return;
+ duplex.push(null);
+ }, "close"));
+ duplex._destroy = function(err, callback) {
+ if (ws.readyState === ws.CLOSED) {
+ callback(err);
+ process.nextTick(emitClose, duplex);
+ return;
+ }
+ let called = false;
+ ws.once("error", /* @__PURE__ */ __name(function error(err2) {
+ called = true;
+ callback(err2);
+ }, "error"));
+ ws.once("close", /* @__PURE__ */ __name(function close() {
+ if (!called)
+ callback(err);
+ process.nextTick(emitClose, duplex);
+ }, "close"));
+ if (terminateOnDestroy)
+ ws.terminate();
+ };
+ duplex._final = function(callback) {
+ if (ws.readyState === ws.CONNECTING) {
+ ws.once("open", /* @__PURE__ */ __name(function open3() {
+ duplex._final(callback);
+ }, "open"));
+ return;
+ }
+ if (ws._socket === null)
+ return;
+ if (ws._socket._writableState.finished) {
+ callback();
+ if (duplex._readableState.endEmitted)
+ duplex.destroy();
+ } else {
+ ws._socket.once("finish", /* @__PURE__ */ __name(function finish() {
+ callback();
+ }, "finish"));
+ ws.close();
+ }
+ };
+ duplex._read = function() {
+ if ((ws.readyState === ws.OPEN || ws.readyState === ws.CLOSING) && !resumeOnReceiverDrain) {
+ resumeOnReceiverDrain = true;
+ if (!ws._receiver._writableState.needDrain)
+ ws._socket.resume();
+ }
+ };
+ duplex._write = function(chunk, encoding, callback) {
+ if (ws.readyState === ws.CONNECTING) {
+ ws.once("open", /* @__PURE__ */ __name(function open3() {
+ duplex._write(chunk, encoding, callback);
+ }, "open"));
+ return;
+ }
+ ws.send(chunk, callback);
+ };
+ duplex.on("end", duplexOnEnd);
+ duplex.on("error", duplexOnError);
+ return duplex;
+ }
+ __name(createWebSocketStream2, "createWebSocketStream");
+ module2.exports = createWebSocketStream2;
+ }
+});
+
+// ../../node_modules/.pnpm/ws@7.5.6/node_modules/ws/lib/websocket-server.js
+var require_websocket_server = __commonJS({
+ "../../node_modules/.pnpm/ws@7.5.6/node_modules/ws/lib/websocket-server.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var EventEmitter3 = require("events");
+ var http3 = require("http");
+ var https2 = require("https");
+ var net3 = require("net");
+ var tls = require("tls");
+ var { createHash } = require("crypto");
+ var PerMessageDeflate = require_permessage_deflate();
+ var WebSocket2 = require_websocket2();
+ var { format: format8, parse: parse4 } = require_extension();
+ var { GUID, kWebSocket } = require_constants5();
+ var keyRegex = /^[+/0-9A-Za-z]{22}==$/;
+ var RUNNING = 0;
+ var CLOSING = 1;
+ var CLOSED = 2;
+ var WebSocketServer2 = class extends EventEmitter3 {
+ /**
+ * Create a `WebSocketServer` instance.
+ *
+ * @param {Object} options Configuration options
+ * @param {Number} [options.backlog=511] The maximum length of the queue of
+ * pending connections
+ * @param {Boolean} [options.clientTracking=true] Specifies whether or not to
+ * track clients
+ * @param {Function} [options.handleProtocols] A hook to handle protocols
+ * @param {String} [options.host] The hostname where to bind the server
+ * @param {Number} [options.maxPayload=104857600] The maximum allowed message
+ * size
+ * @param {Boolean} [options.noServer=false] Enable no server mode
+ * @param {String} [options.path] Accept only connections matching this path
+ * @param {(Boolean|Object)} [options.perMessageDeflate=false] Enable/disable
+ * permessage-deflate
+ * @param {Number} [options.port] The port where to bind the server
+ * @param {(http.Server|https.Server)} [options.server] A pre-created HTTP/S
+ * server to use
+ * @param {Function} [options.verifyClient] A hook to reject connections
+ * @param {Function} [callback] A listener for the `listening` event
+ */
+ constructor(options14, callback) {
+ super();
+ options14 = {
+ maxPayload: 100 * 1024 * 1024,
+ perMessageDeflate: false,
+ handleProtocols: null,
+ clientTracking: true,
+ verifyClient: null,
+ noServer: false,
+ backlog: null,
+ // use default (511 as implemented in net.js)
+ server: null,
+ host: null,
+ path: null,
+ port: null,
+ ...options14
+ };
+ if (options14.port == null && !options14.server && !options14.noServer || options14.port != null && (options14.server || options14.noServer) || options14.server && options14.noServer) {
+ throw new TypeError(
+ 'One and only one of the "port", "server", or "noServer" options must be specified'
+ );
+ }
+ if (options14.port != null) {
+ this._server = http3.createServer((req, res) => {
+ const body = http3.STATUS_CODES[426];
+ res.writeHead(426, {
+ "Content-Length": body.length,
+ "Content-Type": "text/plain"
+ });
+ res.end(body);
+ });
+ this._server.listen(
+ options14.port,
+ options14.host,
+ options14.backlog,
+ callback
+ );
+ } else if (options14.server) {
+ this._server = options14.server;
+ }
+ if (this._server) {
+ const emitConnection = this.emit.bind(this, "connection");
+ this._removeListeners = addListeners(this._server, {
+ listening: this.emit.bind(this, "listening"),
+ error: this.emit.bind(this, "error"),
+ upgrade: (req, socket, head) => {
+ this.handleUpgrade(req, socket, head, emitConnection);
+ }
+ });
+ }
+ if (options14.perMessageDeflate === true)
+ options14.perMessageDeflate = {};
+ if (options14.clientTracking)
+ this.clients = /* @__PURE__ */ new Set();
+ this.options = options14;
+ this._state = RUNNING;
+ }
+ /**
+ * Returns the bound address, the address family name, and port of the server
+ * as reported by the operating system if listening on an IP socket.
+ * If the server is listening on a pipe or UNIX domain socket, the name is
+ * returned as a string.
+ *
+ * @return {(Object|String|null)} The address of the server
+ * @public
+ */
+ address() {
+ if (this.options.noServer) {
+ throw new Error('The server is operating in "noServer" mode');
+ }
+ if (!this._server)
+ return null;
+ return this._server.address();
+ }
+ /**
+ * Close the server.
+ *
+ * @param {Function} [cb] Callback
+ * @public
+ */
+ close(cb) {
+ if (cb)
+ this.once("close", cb);
+ if (this._state === CLOSED) {
+ process.nextTick(emitClose, this);
+ return;
+ }
+ if (this._state === CLOSING)
+ return;
+ this._state = CLOSING;
+ if (this.clients) {
+ for (const client of this.clients)
+ client.terminate();
+ }
+ const server2 = this._server;
+ if (server2) {
+ this._removeListeners();
+ this._removeListeners = this._server = null;
+ if (this.options.port != null) {
+ server2.close(emitClose.bind(void 0, this));
+ return;
+ }
+ }
+ process.nextTick(emitClose, this);
+ }
+ /**
+ * See if a given request should be handled by this server instance.
+ *
+ * @param {http.IncomingMessage} req Request object to inspect
+ * @return {Boolean} `true` if the request is valid, else `false`
+ * @public
+ */
+ shouldHandle(req) {
+ if (this.options.path) {
+ const index = req.url.indexOf("?");
+ const pathname = index !== -1 ? req.url.slice(0, index) : req.url;
+ if (pathname !== this.options.path)
+ return false;
+ }
+ return true;
+ }
+ /**
+ * Handle a HTTP Upgrade request.
+ *
+ * @param {http.IncomingMessage} req The request object
+ * @param {(net.Socket|tls.Socket)} socket The network socket between the
+ * server and client
+ * @param {Buffer} head The first packet of the upgraded stream
+ * @param {Function} cb Callback
+ * @public
+ */
+ handleUpgrade(req, socket, head, cb) {
+ socket.on("error", socketOnError);
+ const key = req.headers["sec-websocket-key"] !== void 0 ? req.headers["sec-websocket-key"].trim() : false;
+ const version2 = +req.headers["sec-websocket-version"];
+ const extensions = {};
+ if (req.method !== "GET" || req.headers.upgrade.toLowerCase() !== "websocket" || !key || !keyRegex.test(key) || version2 !== 8 && version2 !== 13 || !this.shouldHandle(req)) {
+ return abortHandshake(socket, 400);
+ }
+ if (this.options.perMessageDeflate) {
+ const perMessageDeflate = new PerMessageDeflate(
+ this.options.perMessageDeflate,
+ true,
+ this.options.maxPayload
+ );
+ try {
+ const offers = parse4(req.headers["sec-websocket-extensions"]);
+ if (offers[PerMessageDeflate.extensionName]) {
+ perMessageDeflate.accept(offers[PerMessageDeflate.extensionName]);
+ extensions[PerMessageDeflate.extensionName] = perMessageDeflate;
+ }
+ } catch (err) {
+ return abortHandshake(socket, 400);
+ }
+ }
+ if (this.options.verifyClient) {
+ const info = {
+ origin: req.headers[`${version2 === 8 ? "sec-websocket-origin" : "origin"}`],
+ secure: !!(req.socket.authorized || req.socket.encrypted),
+ req
+ };
+ if (this.options.verifyClient.length === 2) {
+ this.options.verifyClient(info, (verified, code, message, headers) => {
+ if (!verified) {
+ return abortHandshake(socket, code || 401, message, headers);
+ }
+ this.completeUpgrade(key, extensions, req, socket, head, cb);
+ });
+ return;
+ }
+ if (!this.options.verifyClient(info))
+ return abortHandshake(socket, 401);
+ }
+ this.completeUpgrade(key, extensions, req, socket, head, cb);
+ }
+ /**
+ * Upgrade the connection to WebSocket.
+ *
+ * @param {String} key The value of the `Sec-WebSocket-Key` header
+ * @param {Object} extensions The accepted extensions
+ * @param {http.IncomingMessage} req The request object
+ * @param {(net.Socket|tls.Socket)} socket The network socket between the
+ * server and client
+ * @param {Buffer} head The first packet of the upgraded stream
+ * @param {Function} cb Callback
+ * @throws {Error} If called more than once with the same socket
+ * @private
+ */
+ completeUpgrade(key, extensions, req, socket, head, cb) {
+ if (!socket.readable || !socket.writable)
+ return socket.destroy();
+ if (socket[kWebSocket]) {
+ throw new Error(
+ "server.handleUpgrade() was called more than once with the same socket, possibly due to a misconfiguration"
+ );
+ }
+ if (this._state > RUNNING)
+ return abortHandshake(socket, 503);
+ const digest = createHash("sha1").update(key + GUID).digest("base64");
+ const headers = [
+ "HTTP/1.1 101 Switching Protocols",
+ "Upgrade: websocket",
+ "Connection: Upgrade",
+ `Sec-WebSocket-Accept: ${digest}`
+ ];
+ const ws = new WebSocket2(null);
+ let protocol = req.headers["sec-websocket-protocol"];
+ if (protocol) {
+ protocol = protocol.split(",").map(trim);
+ if (this.options.handleProtocols) {
+ protocol = this.options.handleProtocols(protocol, req);
+ } else {
+ protocol = protocol[0];
+ }
+ if (protocol) {
+ headers.push(`Sec-WebSocket-Protocol: ${protocol}`);
+ ws._protocol = protocol;
+ }
+ }
+ if (extensions[PerMessageDeflate.extensionName]) {
+ const params = extensions[PerMessageDeflate.extensionName].params;
+ const value = format8({
+ [PerMessageDeflate.extensionName]: [params]
+ });
+ headers.push(`Sec-WebSocket-Extensions: ${value}`);
+ ws._extensions = extensions;
+ }
+ this.emit("headers", headers, req);
+ socket.write(headers.concat("\r\n").join("\r\n"));
+ socket.removeListener("error", socketOnError);
+ ws.setSocket(socket, head, this.options.maxPayload);
+ if (this.clients) {
+ this.clients.add(ws);
+ ws.on("close", () => this.clients.delete(ws));
+ }
+ cb(ws, req);
+ }
+ };
+ __name(WebSocketServer2, "WebSocketServer");
+ module2.exports = WebSocketServer2;
+ function addListeners(server2, map) {
+ for (const event of Object.keys(map))
+ server2.on(event, map[event]);
+ return /* @__PURE__ */ __name(function removeListeners() {
+ for (const event of Object.keys(map)) {
+ server2.removeListener(event, map[event]);
+ }
+ }, "removeListeners");
+ }
+ __name(addListeners, "addListeners");
+ function emitClose(server2) {
+ server2._state = CLOSED;
+ server2.emit("close");
+ }
+ __name(emitClose, "emitClose");
+ function socketOnError() {
+ this.destroy();
+ }
+ __name(socketOnError, "socketOnError");
+ function abortHandshake(socket, code, message, headers) {
+ if (socket.writable) {
+ message = message || http3.STATUS_CODES[code];
+ headers = {
+ Connection: "close",
+ "Content-Type": "text/html",
+ "Content-Length": Buffer.byteLength(message),
+ ...headers
+ };
+ socket.write(
+ `HTTP/1.1 ${code} ${http3.STATUS_CODES[code]}\r
+` + Object.keys(headers).map((h) => `${h}: ${headers[h]}`).join("\r\n") + "\r\n\r\n" + message
+ );
+ }
+ socket.removeListener("error", socketOnError);
+ socket.destroy();
+ }
+ __name(abortHandshake, "abortHandshake");
+ function trim(str) {
+ return str.trim();
+ }
+ __name(trim, "trim");
+ }
+});
+
+// ../../node_modules/.pnpm/ws@7.5.6/node_modules/ws/index.js
+var require_ws = __commonJS({
+ "../../node_modules/.pnpm/ws@7.5.6/node_modules/ws/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var WebSocket2 = require_websocket2();
+ WebSocket2.createWebSocketStream = require_stream();
+ WebSocket2.Server = require_websocket_server();
+ WebSocket2.Receiver = require_receiver2();
+ WebSocket2.Sender = require_sender();
+ module2.exports = WebSocket2;
+ }
+});
+
+// ../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/devtools-window-polyfill.js
+var require_devtools_window_polyfill = __commonJS({
+ "../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/devtools-window-polyfill.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ var __importDefault = exports2 && exports2.__importDefault || function(mod) {
+ return mod && mod.__esModule ? mod : { "default": mod };
+ };
+ Object.defineProperty(exports2, "__esModule", { value: true });
+ var ws_1 = __importDefault(require_ws());
+ var customGlobal = global;
+ if (!customGlobal.WebSocket) {
+ customGlobal.WebSocket = ws_1.default;
+ }
+ if (!customGlobal.window) {
+ customGlobal.window = global;
+ }
+ customGlobal.window.__REACT_DEVTOOLS_COMPONENT_FILTERS__ = [
+ {
+ // ComponentFilterElementType
+ type: 1,
+ // ElementTypeHostComponent
+ value: 7,
+ isEnabled: true
+ },
+ {
+ // ComponentFilterDisplayName
+ type: 2,
+ value: "InternalApp",
+ isEnabled: true,
+ isValid: true
+ },
+ {
+ // ComponentFilterDisplayName
+ type: 2,
+ value: "InternalAppContext",
+ isEnabled: true,
+ isValid: true
+ },
+ {
+ // ComponentFilterDisplayName
+ type: 2,
+ value: "InternalStdoutContext",
+ isEnabled: true,
+ isValid: true
+ },
+ {
+ // ComponentFilterDisplayName
+ type: 2,
+ value: "InternalStderrContext",
+ isEnabled: true,
+ isValid: true
+ },
+ {
+ // ComponentFilterDisplayName
+ type: 2,
+ value: "InternalStdinContext",
+ isEnabled: true,
+ isValid: true
+ },
+ {
+ // ComponentFilterDisplayName
+ type: 2,
+ value: "InternalFocusContext",
+ isEnabled: true,
+ isValid: true
+ }
+ ];
+ }
+});
+
+// ../../node_modules/.pnpm/react-devtools-core@4.23.0/node_modules/react-devtools-core/dist/backend.js
+var require_backend = __commonJS({
+ "../../node_modules/.pnpm/react-devtools-core@4.23.0/node_modules/react-devtools-core/dist/backend.js"(exports2, module2) {
+ init_import_meta_url();
+ (/* @__PURE__ */ __name(function webpackUniversalModuleDefinition(root, factory) {
+ if (typeof exports2 === "object" && typeof module2 === "object")
+ module2.exports = factory();
+ else if (typeof define === "function" && define.amd)
+ define([], factory);
+ else if (typeof exports2 === "object")
+ exports2["ReactDevToolsBackend"] = factory();
+ else
+ root["ReactDevToolsBackend"] = factory();
+ }, "webpackUniversalModuleDefinition"))(window, function() {
+ return (
+ /******/
+ function(modules) {
+ var installedModules = {};
+ function __webpack_require__(moduleId) {
+ if (installedModules[moduleId]) {
+ return installedModules[moduleId].exports;
+ }
+ var module3 = installedModules[moduleId] = {
+ /******/
+ i: moduleId,
+ /******/
+ l: false,
+ /******/
+ exports: {}
+ /******/
+ };
+ modules[moduleId].call(module3.exports, module3, module3.exports, __webpack_require__);
+ module3.l = true;
+ return module3.exports;
+ }
+ __name(__webpack_require__, "__webpack_require__");
+ __webpack_require__.m = modules;
+ __webpack_require__.c = installedModules;
+ __webpack_require__.d = function(exports3, name, getter) {
+ if (!__webpack_require__.o(exports3, name)) {
+ Object.defineProperty(exports3, name, { enumerable: true, get: getter });
+ }
+ };
+ __webpack_require__.r = function(exports3) {
+ if (typeof Symbol !== "undefined" && Symbol.toStringTag) {
+ Object.defineProperty(exports3, Symbol.toStringTag, { value: "Module" });
+ }
+ Object.defineProperty(exports3, "__esModule", { value: true });
+ };
+ __webpack_require__.t = function(value, mode) {
+ if (mode & 1)
+ value = __webpack_require__(value);
+ if (mode & 8)
+ return value;
+ if (mode & 4 && typeof value === "object" && value && value.__esModule)
+ return value;
+ var ns = /* @__PURE__ */ Object.create(null);
+ __webpack_require__.r(ns);
+ Object.defineProperty(ns, "default", { enumerable: true, value });
+ if (mode & 2 && typeof value != "string")
+ for (var key in value)
+ __webpack_require__.d(ns, key, function(key2) {
+ return value[key2];
+ }.bind(null, key));
+ return ns;
+ };
+ __webpack_require__.n = function(module3) {
+ var getter = module3 && module3.__esModule ? (
+ /******/
+ /* @__PURE__ */ __name(function getDefault() {
+ return module3["default"];
+ }, "getDefault")
+ ) : (
+ /******/
+ /* @__PURE__ */ __name(function getModuleExports() {
+ return module3;
+ }, "getModuleExports")
+ );
+ __webpack_require__.d(getter, "a", getter);
+ return getter;
+ };
+ __webpack_require__.o = function(object, property) {
+ return Object.prototype.hasOwnProperty.call(object, property);
+ };
+ __webpack_require__.p = "";
+ return __webpack_require__(__webpack_require__.s = 33);
+ }([
+ /* 0 */
+ /***/
+ function(module3, __webpack_exports__, __webpack_require__) {
+ "use strict";
+ __webpack_require__.d(__webpack_exports__, "e", function() {
+ return ElementTypeClass;
+ });
+ __webpack_require__.d(__webpack_exports__, "f", function() {
+ return ElementTypeContext;
+ });
+ __webpack_require__.d(__webpack_exports__, "h", function() {
+ return ElementTypeFunction;
+ });
+ __webpack_require__.d(__webpack_exports__, "g", function() {
+ return ElementTypeForwardRef;
+ });
+ __webpack_require__.d(__webpack_exports__, "i", function() {
+ return ElementTypeHostComponent;
+ });
+ __webpack_require__.d(__webpack_exports__, "j", function() {
+ return ElementTypeMemo;
+ });
+ __webpack_require__.d(__webpack_exports__, "k", function() {
+ return ElementTypeOtherOrUnknown;
+ });
+ __webpack_require__.d(__webpack_exports__, "l", function() {
+ return ElementTypeProfiler;
+ });
+ __webpack_require__.d(__webpack_exports__, "m", function() {
+ return ElementTypeRoot;
+ });
+ __webpack_require__.d(__webpack_exports__, "n", function() {
+ return ElementTypeSuspense;
+ });
+ __webpack_require__.d(__webpack_exports__, "o", function() {
+ return ElementTypeSuspenseList;
+ });
+ __webpack_require__.d(__webpack_exports__, "b", function() {
+ return ComponentFilterElementType;
+ });
+ __webpack_require__.d(__webpack_exports__, "a", function() {
+ return ComponentFilterDisplayName;
+ });
+ __webpack_require__.d(__webpack_exports__, "d", function() {
+ return ComponentFilterLocation;
+ });
+ __webpack_require__.d(__webpack_exports__, "c", function() {
+ return ComponentFilterHOC;
+ });
+ __webpack_require__.d(__webpack_exports__, "p", function() {
+ return StrictMode;
+ });
+ var ElementTypeClass = 1;
+ var ElementTypeContext = 2;
+ var ElementTypeFunction = 5;
+ var ElementTypeForwardRef = 6;
+ var ElementTypeHostComponent = 7;
+ var ElementTypeMemo = 8;
+ var ElementTypeOtherOrUnknown = 9;
+ var ElementTypeProfiler = 10;
+ var ElementTypeRoot = 11;
+ var ElementTypeSuspense = 12;
+ var ElementTypeSuspenseList = 13;
+ var ComponentFilterElementType = 1;
+ var ComponentFilterDisplayName = 2;
+ var ComponentFilterLocation = 3;
+ var ComponentFilterHOC = 4;
+ var StrictMode = 1;
+ },
+ /* 1 */
+ /***/
+ function(module3, __webpack_exports__, __webpack_require__) {
+ "use strict";
+ __webpack_require__.d(__webpack_exports__, "q", function() {
+ return __DEBUG__;
+ });
+ __webpack_require__.d(__webpack_exports__, "j", function() {
+ return TREE_OPERATION_ADD;
+ });
+ __webpack_require__.d(__webpack_exports__, "k", function() {
+ return TREE_OPERATION_REMOVE;
+ });
+ __webpack_require__.d(__webpack_exports__, "m", function() {
+ return TREE_OPERATION_REORDER_CHILDREN;
+ });
+ __webpack_require__.d(__webpack_exports__, "p", function() {
+ return TREE_OPERATION_UPDATE_TREE_BASE_DURATION;
+ });
+ __webpack_require__.d(__webpack_exports__, "o", function() {
+ return TREE_OPERATION_UPDATE_ERRORS_OR_WARNINGS;
+ });
+ __webpack_require__.d(__webpack_exports__, "l", function() {
+ return TREE_OPERATION_REMOVE_ROOT;
+ });
+ __webpack_require__.d(__webpack_exports__, "n", function() {
+ return TREE_OPERATION_SET_SUBTREE_MODE;
+ });
+ __webpack_require__.d(__webpack_exports__, "a", function() {
+ return LOCAL_STORAGE_FILTER_PREFERENCES_KEY;
+ });
+ __webpack_require__.d(__webpack_exports__, "g", function() {
+ return SESSION_STORAGE_LAST_SELECTION_KEY;
+ });
+ __webpack_require__.d(__webpack_exports__, "c", function() {
+ return LOCAL_STORAGE_OPEN_IN_EDITOR_URL;
+ });
+ __webpack_require__.d(__webpack_exports__, "h", function() {
+ return SESSION_STORAGE_RECORD_CHANGE_DESCRIPTIONS_KEY;
+ });
+ __webpack_require__.d(__webpack_exports__, "i", function() {
+ return SESSION_STORAGE_RELOAD_AND_PROFILE_KEY;
+ });
+ __webpack_require__.d(__webpack_exports__, "d", function() {
+ return LOCAL_STORAGE_SHOULD_BREAK_ON_CONSOLE_ERRORS;
+ });
+ __webpack_require__.d(__webpack_exports__, "e", function() {
+ return LOCAL_STORAGE_SHOULD_PATCH_CONSOLE_KEY;
+ });
+ __webpack_require__.d(__webpack_exports__, "f", function() {
+ return LOCAL_STORAGE_SHOW_INLINE_WARNINGS_AND_ERRORS_KEY;
+ });
+ __webpack_require__.d(__webpack_exports__, "b", function() {
+ return LOCAL_STORAGE_HIDE_CONSOLE_LOGS_IN_STRICT_MODE;
+ });
+ var CHROME_WEBSTORE_EXTENSION_ID = "fmkadmapgofadopljbjfkapdkoienihi";
+ var INTERNAL_EXTENSION_ID = "dnjnjgbfilfphmojnmhliehogmojhclc";
+ var LOCAL_EXTENSION_ID = "ikiahnapldjmdmpkmfhjdjilojjhgcbf";
+ var __DEBUG__ = false;
+ var __PERFORMANCE_PROFILE__ = false;
+ var TREE_OPERATION_ADD = 1;
+ var TREE_OPERATION_REMOVE = 2;
+ var TREE_OPERATION_REORDER_CHILDREN = 3;
+ var TREE_OPERATION_UPDATE_TREE_BASE_DURATION = 4;
+ var TREE_OPERATION_UPDATE_ERRORS_OR_WARNINGS = 5;
+ var TREE_OPERATION_REMOVE_ROOT = 6;
+ var TREE_OPERATION_SET_SUBTREE_MODE = 7;
+ var LOCAL_STORAGE_DEFAULT_TAB_KEY = "React::DevTools::defaultTab";
+ var LOCAL_STORAGE_FILTER_PREFERENCES_KEY = "React::DevTools::componentFilters";
+ var SESSION_STORAGE_LAST_SELECTION_KEY = "React::DevTools::lastSelection";
+ var LOCAL_STORAGE_OPEN_IN_EDITOR_URL = "React::DevTools::openInEditorUrl";
+ var LOCAL_STORAGE_PARSE_HOOK_NAMES_KEY = "React::DevTools::parseHookNames";
+ var SESSION_STORAGE_RECORD_CHANGE_DESCRIPTIONS_KEY = "React::DevTools::recordChangeDescriptions";
+ var SESSION_STORAGE_RELOAD_AND_PROFILE_KEY = "React::DevTools::reloadAndProfile";
+ var LOCAL_STORAGE_SHOULD_BREAK_ON_CONSOLE_ERRORS = "React::DevTools::breakOnConsoleErrors";
+ var LOCAL_STORAGE_SHOULD_PATCH_CONSOLE_KEY = "React::DevTools::appendComponentStack";
+ var LOCAL_STORAGE_SHOW_INLINE_WARNINGS_AND_ERRORS_KEY = "React::DevTools::showInlineWarningsAndErrors";
+ var LOCAL_STORAGE_TRACE_UPDATES_ENABLED_KEY = "React::DevTools::traceUpdatesEnabled";
+ var LOCAL_STORAGE_HIDE_CONSOLE_LOGS_IN_STRICT_MODE = "React::DevTools::hideConsoleLogsInStrictMode";
+ var PROFILER_EXPORT_VERSION = 5;
+ var CHANGE_LOG_URL = "https://github.com/facebook/react/blob/main/packages/react-devtools/CHANGELOG.md";
+ var UNSUPPORTED_VERSION_URL = "https://reactjs.org/blog/2019/08/15/new-react-devtools.html#how-do-i-get-the-old-version-back";
+ var REACT_DEVTOOLS_WORKPLACE_URL = "https://fburl.com/react-devtools-workplace-group";
+ var THEME_STYLES = {
+ light: {
+ "--color-attribute-name": "#ef6632",
+ "--color-attribute-name-not-editable": "#23272f",
+ "--color-attribute-name-inverted": "rgba(255, 255, 255, 0.7)",
+ "--color-attribute-value": "#1a1aa6",
+ "--color-attribute-value-inverted": "#ffffff",
+ "--color-attribute-editable-value": "#1a1aa6",
+ "--color-background": "#ffffff",
+ "--color-background-hover": "rgba(0, 136, 250, 0.1)",
+ "--color-background-inactive": "#e5e5e5",
+ "--color-background-invalid": "#fff0f0",
+ "--color-background-selected": "#0088fa",
+ "--color-button-background": "#ffffff",
+ "--color-button-background-focus": "#ededed",
+ "--color-button": "#5f6673",
+ "--color-button-disabled": "#cfd1d5",
+ "--color-button-active": "#0088fa",
+ "--color-button-focus": "#23272f",
+ "--color-button-hover": "#23272f",
+ "--color-border": "#eeeeee",
+ "--color-commit-did-not-render-fill": "#cfd1d5",
+ "--color-commit-did-not-render-fill-text": "#000000",
+ "--color-commit-did-not-render-pattern": "#cfd1d5",
+ "--color-commit-did-not-render-pattern-text": "#333333",
+ "--color-commit-gradient-0": "#37afa9",
+ "--color-commit-gradient-1": "#63b19e",
+ "--color-commit-gradient-2": "#80b393",
+ "--color-commit-gradient-3": "#97b488",
+ "--color-commit-gradient-4": "#abb67d",
+ "--color-commit-gradient-5": "#beb771",
+ "--color-commit-gradient-6": "#cfb965",
+ "--color-commit-gradient-7": "#dfba57",
+ "--color-commit-gradient-8": "#efbb49",
+ "--color-commit-gradient-9": "#febc38",
+ "--color-commit-gradient-text": "#000000",
+ "--color-component-name": "#6a51b2",
+ "--color-component-name-inverted": "#ffffff",
+ "--color-component-badge-background": "rgba(0, 0, 0, 0.1)",
+ "--color-component-badge-background-inverted": "rgba(255, 255, 255, 0.25)",
+ "--color-component-badge-count": "#777d88",
+ "--color-component-badge-count-inverted": "rgba(255, 255, 255, 0.7)",
+ "--color-console-error-badge-text": "#ffffff",
+ "--color-console-error-background": "#fff0f0",
+ "--color-console-error-border": "#ffd6d6",
+ "--color-console-error-icon": "#eb3941",
+ "--color-console-error-text": "#fe2e31",
+ "--color-console-warning-badge-text": "#000000",
+ "--color-console-warning-background": "#fffbe5",
+ "--color-console-warning-border": "#fff5c1",
+ "--color-console-warning-icon": "#f4bd00",
+ "--color-console-warning-text": "#64460c",
+ "--color-context-background": "rgba(0,0,0,.9)",
+ "--color-context-background-hover": "rgba(255, 255, 255, 0.1)",
+ "--color-context-background-selected": "#178fb9",
+ "--color-context-border": "#3d424a",
+ "--color-context-text": "#ffffff",
+ "--color-context-text-selected": "#ffffff",
+ "--color-dim": "#777d88",
+ "--color-dimmer": "#cfd1d5",
+ "--color-dimmest": "#eff0f1",
+ "--color-error-background": "hsl(0, 100%, 97%)",
+ "--color-error-border": "hsl(0, 100%, 92%)",
+ "--color-error-text": "#ff0000",
+ "--color-expand-collapse-toggle": "#777d88",
+ "--color-link": "#0000ff",
+ "--color-modal-background": "rgba(255, 255, 255, 0.75)",
+ "--color-bridge-version-npm-background": "#eff0f1",
+ "--color-bridge-version-npm-text": "#000000",
+ "--color-bridge-version-number": "#0088fa",
+ "--color-primitive-hook-badge-background": "#e5e5e5",
+ "--color-primitive-hook-badge-text": "#5f6673",
+ "--color-record-active": "#fc3a4b",
+ "--color-record-hover": "#3578e5",
+ "--color-record-inactive": "#0088fa",
+ "--color-resize-bar": "#eeeeee",
+ "--color-resize-bar-active": "#dcdcdc",
+ "--color-resize-bar-border": "#d1d1d1",
+ "--color-resize-bar-dot": "#333333",
+ "--color-timeline-internal-module": "#d1d1d1",
+ "--color-timeline-internal-module-hover": "#c9c9c9",
+ "--color-timeline-internal-module-text": "#444",
+ "--color-timeline-native-event": "#ccc",
+ "--color-timeline-native-event-hover": "#aaa",
+ "--color-timeline-network-primary": "#fcf3dc",
+ "--color-timeline-network-primary-hover": "#f0e7d1",
+ "--color-timeline-network-secondary": "#efc457",
+ "--color-timeline-network-secondary-hover": "#e3ba52",
+ "--color-timeline-priority-background": "#f6f6f6",
+ "--color-timeline-priority-border": "#eeeeee",
+ "--color-timeline-user-timing": "#c9cacd",
+ "--color-timeline-user-timing-hover": "#93959a",
+ "--color-timeline-react-idle": "#d3e5f6",
+ "--color-timeline-react-idle-hover": "#c3d9ef",
+ "--color-timeline-react-render": "#9fc3f3",
+ "--color-timeline-react-render-hover": "#83afe9",
+ "--color-timeline-react-render-text": "#11365e",
+ "--color-timeline-react-commit": "#c88ff0",
+ "--color-timeline-react-commit-hover": "#b281d6",
+ "--color-timeline-react-commit-text": "#3e2c4a",
+ "--color-timeline-react-layout-effects": "#b281d6",
+ "--color-timeline-react-layout-effects-hover": "#9d71bd",
+ "--color-timeline-react-layout-effects-text": "#3e2c4a",
+ "--color-timeline-react-passive-effects": "#b281d6",
+ "--color-timeline-react-passive-effects-hover": "#9d71bd",
+ "--color-timeline-react-passive-effects-text": "#3e2c4a",
+ "--color-timeline-react-schedule": "#9fc3f3",
+ "--color-timeline-react-schedule-hover": "#2683E2",
+ "--color-timeline-react-suspense-rejected": "#f1cc14",
+ "--color-timeline-react-suspense-rejected-hover": "#ffdf37",
+ "--color-timeline-react-suspense-resolved": "#a6e59f",
+ "--color-timeline-react-suspense-resolved-hover": "#89d281",
+ "--color-timeline-react-suspense-unresolved": "#c9cacd",
+ "--color-timeline-react-suspense-unresolved-hover": "#93959a",
+ "--color-timeline-thrown-error": "#ee1638",
+ "--color-timeline-thrown-error-hover": "#da1030",
+ "--color-timeline-text-color": "#000000",
+ "--color-timeline-text-dim-color": "#ccc",
+ "--color-timeline-react-work-border": "#eeeeee",
+ "--color-search-match": "yellow",
+ "--color-search-match-current": "#f7923b",
+ "--color-selected-tree-highlight-active": "rgba(0, 136, 250, 0.1)",
+ "--color-selected-tree-highlight-inactive": "rgba(0, 0, 0, 0.05)",
+ "--color-scroll-caret": "rgba(150, 150, 150, 0.5)",
+ "--color-tab-selected-border": "#0088fa",
+ "--color-text": "#000000",
+ "--color-text-invalid": "#ff0000",
+ "--color-text-selected": "#ffffff",
+ "--color-toggle-background-invalid": "#fc3a4b",
+ "--color-toggle-background-on": "#0088fa",
+ "--color-toggle-background-off": "#cfd1d5",
+ "--color-toggle-text": "#ffffff",
+ "--color-warning-background": "#fb3655",
+ "--color-warning-background-hover": "#f82042",
+ "--color-warning-text-color": "#ffffff",
+ "--color-warning-text-color-inverted": "#fd4d69",
+ // The styles below should be kept in sync with 'root.css'
+ // They are repeated there because they're used by e.g. tooltips or context menus
+ // which get rendered outside of the DOM subtree (where normal theme/styles are written).
+ "--color-scroll-thumb": "#c2c2c2",
+ "--color-scroll-track": "#fafafa",
+ "--color-tooltip-background": "rgba(0, 0, 0, 0.9)",
+ "--color-tooltip-text": "#ffffff"
+ },
+ dark: {
+ "--color-attribute-name": "#9d87d2",
+ "--color-attribute-name-not-editable": "#ededed",
+ "--color-attribute-name-inverted": "#282828",
+ "--color-attribute-value": "#cedae0",
+ "--color-attribute-value-inverted": "#ffffff",
+ "--color-attribute-editable-value": "yellow",
+ "--color-background": "#282c34",
+ "--color-background-hover": "rgba(255, 255, 255, 0.1)",
+ "--color-background-inactive": "#3d424a",
+ "--color-background-invalid": "#5c0000",
+ "--color-background-selected": "#178fb9",
+ "--color-button-background": "#282c34",
+ "--color-button-background-focus": "#3d424a",
+ "--color-button": "#afb3b9",
+ "--color-button-active": "#61dafb",
+ "--color-button-disabled": "#4f5766",
+ "--color-button-focus": "#a2e9fc",
+ "--color-button-hover": "#ededed",
+ "--color-border": "#3d424a",
+ "--color-commit-did-not-render-fill": "#777d88",
+ "--color-commit-did-not-render-fill-text": "#000000",
+ "--color-commit-did-not-render-pattern": "#666c77",
+ "--color-commit-did-not-render-pattern-text": "#ffffff",
+ "--color-commit-gradient-0": "#37afa9",
+ "--color-commit-gradient-1": "#63b19e",
+ "--color-commit-gradient-2": "#80b393",
+ "--color-commit-gradient-3": "#97b488",
+ "--color-commit-gradient-4": "#abb67d",
+ "--color-commit-gradient-5": "#beb771",
+ "--color-commit-gradient-6": "#cfb965",
+ "--color-commit-gradient-7": "#dfba57",
+ "--color-commit-gradient-8": "#efbb49",
+ "--color-commit-gradient-9": "#febc38",
+ "--color-commit-gradient-text": "#000000",
+ "--color-component-name": "#61dafb",
+ "--color-component-name-inverted": "#282828",
+ "--color-component-badge-background": "rgba(255, 255, 255, 0.25)",
+ "--color-component-badge-background-inverted": "rgba(0, 0, 0, 0.25)",
+ "--color-component-badge-count": "#8f949d",
+ "--color-component-badge-count-inverted": "rgba(255, 255, 255, 0.7)",
+ "--color-console-error-badge-text": "#000000",
+ "--color-console-error-background": "#290000",
+ "--color-console-error-border": "#5c0000",
+ "--color-console-error-icon": "#eb3941",
+ "--color-console-error-text": "#fc7f7f",
+ "--color-console-warning-badge-text": "#000000",
+ "--color-console-warning-background": "#332b00",
+ "--color-console-warning-border": "#665500",
+ "--color-console-warning-icon": "#f4bd00",
+ "--color-console-warning-text": "#f5f2ed",
+ "--color-context-background": "rgba(255,255,255,.95)",
+ "--color-context-background-hover": "rgba(0, 136, 250, 0.1)",
+ "--color-context-background-selected": "#0088fa",
+ "--color-context-border": "#eeeeee",
+ "--color-context-text": "#000000",
+ "--color-context-text-selected": "#ffffff",
+ "--color-dim": "#8f949d",
+ "--color-dimmer": "#777d88",
+ "--color-dimmest": "#4f5766",
+ "--color-error-background": "#200",
+ "--color-error-border": "#900",
+ "--color-error-text": "#f55",
+ "--color-expand-collapse-toggle": "#8f949d",
+ "--color-link": "#61dafb",
+ "--color-modal-background": "rgba(0, 0, 0, 0.75)",
+ "--color-bridge-version-npm-background": "rgba(0, 0, 0, 0.25)",
+ "--color-bridge-version-npm-text": "#ffffff",
+ "--color-bridge-version-number": "yellow",
+ "--color-primitive-hook-badge-background": "rgba(0, 0, 0, 0.25)",
+ "--color-primitive-hook-badge-text": "rgba(255, 255, 255, 0.7)",
+ "--color-record-active": "#fc3a4b",
+ "--color-record-hover": "#a2e9fc",
+ "--color-record-inactive": "#61dafb",
+ "--color-resize-bar": "#282c34",
+ "--color-resize-bar-active": "#31363f",
+ "--color-resize-bar-border": "#3d424a",
+ "--color-resize-bar-dot": "#cfd1d5",
+ "--color-timeline-internal-module": "#303542",
+ "--color-timeline-internal-module-hover": "#363b4a",
+ "--color-timeline-internal-module-text": "#7f8899",
+ "--color-timeline-native-event": "#b2b2b2",
+ "--color-timeline-native-event-hover": "#949494",
+ "--color-timeline-network-primary": "#fcf3dc",
+ "--color-timeline-network-primary-hover": "#e3dbc5",
+ "--color-timeline-network-secondary": "#efc457",
+ "--color-timeline-network-secondary-hover": "#d6af4d",
+ "--color-timeline-priority-background": "#1d2129",
+ "--color-timeline-priority-border": "#282c34",
+ "--color-timeline-user-timing": "#c9cacd",
+ "--color-timeline-user-timing-hover": "#93959a",
+ "--color-timeline-react-idle": "#3d485b",
+ "--color-timeline-react-idle-hover": "#465269",
+ "--color-timeline-react-render": "#2683E2",
+ "--color-timeline-react-render-hover": "#1a76d4",
+ "--color-timeline-react-render-text": "#11365e",
+ "--color-timeline-react-commit": "#731fad",
+ "--color-timeline-react-commit-hover": "#611b94",
+ "--color-timeline-react-commit-text": "#e5c1ff",
+ "--color-timeline-react-layout-effects": "#611b94",
+ "--color-timeline-react-layout-effects-hover": "#51167a",
+ "--color-timeline-react-layout-effects-text": "#e5c1ff",
+ "--color-timeline-react-passive-effects": "#611b94",
+ "--color-timeline-react-passive-effects-hover": "#51167a",
+ "--color-timeline-react-passive-effects-text": "#e5c1ff",
+ "--color-timeline-react-schedule": "#2683E2",
+ "--color-timeline-react-schedule-hover": "#1a76d4",
+ "--color-timeline-react-suspense-rejected": "#f1cc14",
+ "--color-timeline-react-suspense-rejected-hover": "#e4c00f",
+ "--color-timeline-react-suspense-resolved": "#a6e59f",
+ "--color-timeline-react-suspense-resolved-hover": "#89d281",
+ "--color-timeline-react-suspense-unresolved": "#c9cacd",
+ "--color-timeline-react-suspense-unresolved-hover": "#93959a",
+ "--color-timeline-thrown-error": "#fb3655",
+ "--color-timeline-thrown-error-hover": "#f82042",
+ "--color-timeline-text-color": "#282c34",
+ "--color-timeline-text-dim-color": "#555b66",
+ "--color-timeline-react-work-border": "#3d424a",
+ "--color-search-match": "yellow",
+ "--color-search-match-current": "#f7923b",
+ "--color-selected-tree-highlight-active": "rgba(23, 143, 185, 0.15)",
+ "--color-selected-tree-highlight-inactive": "rgba(255, 255, 255, 0.05)",
+ "--color-scroll-caret": "#4f5766",
+ "--color-shadow": "rgba(0, 0, 0, 0.5)",
+ "--color-tab-selected-border": "#178fb9",
+ "--color-text": "#ffffff",
+ "--color-text-invalid": "#ff8080",
+ "--color-text-selected": "#ffffff",
+ "--color-toggle-background-invalid": "#fc3a4b",
+ "--color-toggle-background-on": "#178fb9",
+ "--color-toggle-background-off": "#777d88",
+ "--color-toggle-text": "#ffffff",
+ "--color-warning-background": "#ee1638",
+ "--color-warning-background-hover": "#da1030",
+ "--color-warning-text-color": "#ffffff",
+ "--color-warning-text-color-inverted": "#ee1638",
+ // The styles below should be kept in sync with 'root.css'
+ // They are repeated there because they're used by e.g. tooltips or context menus
+ // which get rendered outside of the DOM subtree (where normal theme/styles are written).
+ "--color-scroll-thumb": "#afb3b9",
+ "--color-scroll-track": "#313640",
+ "--color-tooltip-background": "rgba(255, 255, 255, 0.95)",
+ "--color-tooltip-text": "#000000"
+ },
+ compact: {
+ "--font-size-monospace-small": "9px",
+ "--font-size-monospace-normal": "11px",
+ "--font-size-monospace-large": "15px",
+ "--font-size-sans-small": "10px",
+ "--font-size-sans-normal": "12px",
+ "--font-size-sans-large": "14px",
+ "--line-height-data": "18px"
+ },
+ comfortable: {
+ "--font-size-monospace-small": "10px",
+ "--font-size-monospace-normal": "13px",
+ "--font-size-monospace-large": "17px",
+ "--font-size-sans-small": "12px",
+ "--font-size-sans-normal": "14px",
+ "--font-size-sans-large": "16px",
+ "--line-height-data": "22px"
+ }
+ };
+ var COMFORTABLE_LINE_HEIGHT = parseInt(THEME_STYLES.comfortable["--line-height-data"], 10);
+ var COMPACT_LINE_HEIGHT = parseInt(THEME_STYLES.compact["--line-height-data"], 10);
+ },
+ /* 2 */
+ /***/
+ function(module3, __webpack_exports__, __webpack_require__) {
+ "use strict";
+ (function(process8) {
+ __webpack_require__.d(__webpack_exports__, "c", function() {
+ return getAllEnumerableKeys;
+ });
+ __webpack_require__.d(__webpack_exports__, "f", function() {
+ return getDisplayName;
+ });
+ __webpack_require__.d(__webpack_exports__, "i", function() {
+ return getUID;
+ });
+ __webpack_require__.d(__webpack_exports__, "m", function() {
+ return utfEncodeString;
+ });
+ __webpack_require__.d(__webpack_exports__, "j", function() {
+ return printOperationsArray;
+ });
+ __webpack_require__.d(__webpack_exports__, "e", function() {
+ return getDefaultComponentFilters;
+ });
+ __webpack_require__.d(__webpack_exports__, "h", function() {
+ return getInObject;
+ });
+ __webpack_require__.d(__webpack_exports__, "a", function() {
+ return deletePathInObject;
+ });
+ __webpack_require__.d(__webpack_exports__, "k", function() {
+ return renamePathInObject;
+ });
+ __webpack_require__.d(__webpack_exports__, "l", function() {
+ return setInObject;
+ });
+ __webpack_require__.d(__webpack_exports__, "d", function() {
+ return getDataType;
+ });
+ __webpack_require__.d(__webpack_exports__, "g", function() {
+ return getDisplayNameForReactElement;
+ });
+ __webpack_require__.d(__webpack_exports__, "b", function() {
+ return formatDataForPreview;
+ });
+ var lru_cache__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(19);
+ var lru_cache__WEBPACK_IMPORTED_MODULE_0___default = /* @__PURE__ */ __webpack_require__.n(lru_cache__WEBPACK_IMPORTED_MODULE_0__);
+ var react_is__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(7);
+ var react_is__WEBPACK_IMPORTED_MODULE_1___default = /* @__PURE__ */ __webpack_require__.n(react_is__WEBPACK_IMPORTED_MODULE_1__);
+ var shared_ReactSymbols__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(20);
+ var _constants__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(1);
+ var react_devtools_shared_src_types__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(0);
+ var _storage__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(5);
+ var _hydration__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(12);
+ var _isArray__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(6);
+ function _typeof7(obj) {
+ "@babel/helpers - typeof";
+ if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+ _typeof7 = /* @__PURE__ */ __name(function _typeof8(obj2) {
+ return typeof obj2;
+ }, "_typeof");
+ } else {
+ _typeof7 = /* @__PURE__ */ __name(function _typeof8(obj2) {
+ return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+ }, "_typeof");
+ }
+ return _typeof7(obj);
+ }
+ __name(_typeof7, "_typeof");
+ function _toConsumableArray(arr) {
+ return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray4(arr) || _nonIterableSpread();
+ }
+ __name(_toConsumableArray, "_toConsumableArray");
+ function _nonIterableSpread() {
+ throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+ }
+ __name(_nonIterableSpread, "_nonIterableSpread");
+ function _unsupportedIterableToArray4(o, minLen) {
+ if (!o)
+ return;
+ if (typeof o === "string")
+ return _arrayLikeToArray4(o, minLen);
+ var n = Object.prototype.toString.call(o).slice(8, -1);
+ if (n === "Object" && o.constructor)
+ n = o.constructor.name;
+ if (n === "Map" || n === "Set")
+ return Array.from(o);
+ if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))
+ return _arrayLikeToArray4(o, minLen);
+ }
+ __name(_unsupportedIterableToArray4, "_unsupportedIterableToArray");
+ function _iterableToArray(iter) {
+ if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter))
+ return Array.from(iter);
+ }
+ __name(_iterableToArray, "_iterableToArray");
+ function _arrayWithoutHoles(arr) {
+ if (Array.isArray(arr))
+ return _arrayLikeToArray4(arr);
+ }
+ __name(_arrayWithoutHoles, "_arrayWithoutHoles");
+ function _arrayLikeToArray4(arr, len) {
+ if (len == null || len > arr.length)
+ len = arr.length;
+ for (var i = 0, arr2 = new Array(len); i < len; i++) {
+ arr2[i] = arr[i];
+ }
+ return arr2;
+ }
+ __name(_arrayLikeToArray4, "_arrayLikeToArray");
+ var cachedDisplayNames = /* @__PURE__ */ new WeakMap();
+ var encodedStringCache = new lru_cache__WEBPACK_IMPORTED_MODULE_0___default.a({
+ max: 1e3
+ });
+ function alphaSortKeys(a, b) {
+ if (a.toString() > b.toString()) {
+ return 1;
+ } else if (b.toString() > a.toString()) {
+ return -1;
+ } else {
+ return 0;
+ }
+ }
+ __name(alphaSortKeys, "alphaSortKeys");
+ function getAllEnumerableKeys(obj) {
+ var keys = /* @__PURE__ */ new Set();
+ var current = obj;
+ var _loop = /* @__PURE__ */ __name(function _loop2() {
+ var currentKeys = [].concat(_toConsumableArray(Object.keys(current)), _toConsumableArray(Object.getOwnPropertySymbols(current)));
+ var descriptors2 = Object.getOwnPropertyDescriptors(current);
+ currentKeys.forEach(function(key) {
+ if (descriptors2[key].enumerable) {
+ keys.add(key);
+ }
+ });
+ current = Object.getPrototypeOf(current);
+ }, "_loop");
+ while (current != null) {
+ _loop();
+ }
+ return keys;
+ }
+ __name(getAllEnumerableKeys, "getAllEnumerableKeys");
+ function getDisplayName(type) {
+ var fallbackName = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "Anonymous";
+ var nameFromCache = cachedDisplayNames.get(type);
+ if (nameFromCache != null) {
+ return nameFromCache;
+ }
+ var displayName = fallbackName;
+ if (typeof type.displayName === "string") {
+ displayName = type.displayName;
+ } else if (typeof type.name === "string" && type.name !== "") {
+ displayName = type.name;
+ }
+ cachedDisplayNames.set(type, displayName);
+ return displayName;
+ }
+ __name(getDisplayName, "getDisplayName");
+ var uidCounter = 0;
+ function getUID() {
+ return ++uidCounter;
+ }
+ __name(getUID, "getUID");
+ function utfDecodeString(array) {
+ var string = "";
+ for (var i = 0; i < array.length; i++) {
+ var char = array[i];
+ string += String.fromCodePoint(char);
+ }
+ return string;
+ }
+ __name(utfDecodeString, "utfDecodeString");
+ function surrogatePairToCodePoint(charCode1, charCode2) {
+ return ((charCode1 & 1023) << 10) + (charCode2 & 1023) + 65536;
+ }
+ __name(surrogatePairToCodePoint, "surrogatePairToCodePoint");
+ function utfEncodeString(string) {
+ var cached = encodedStringCache.get(string);
+ if (cached !== void 0) {
+ return cached;
+ }
+ var encoded = [];
+ var i = 0;
+ var charCode;
+ while (i < string.length) {
+ charCode = string.charCodeAt(i);
+ if ((charCode & 63488) === 55296) {
+ encoded.push(surrogatePairToCodePoint(charCode, string.charCodeAt(++i)));
+ } else {
+ encoded.push(charCode);
+ }
+ ++i;
+ }
+ encodedStringCache.set(string, encoded);
+ return encoded;
+ }
+ __name(utfEncodeString, "utfEncodeString");
+ function printOperationsArray(operations) {
+ var rendererID = operations[0];
+ var rootID = operations[1];
+ var logs = ["operations for renderer:".concat(rendererID, " and root:").concat(rootID)];
+ var i = 2;
+ var stringTable = [
+ null
+ // ID = 0 corresponds to the null string.
+ ];
+ var stringTableSize = operations[i++];
+ var stringTableEnd = i + stringTableSize;
+ while (i < stringTableEnd) {
+ var nextLength = operations[i++];
+ var nextString = utfDecodeString(operations.slice(i, i + nextLength));
+ stringTable.push(nextString);
+ i += nextLength;
+ }
+ while (i < operations.length) {
+ var operation = operations[i];
+ switch (operation) {
+ case _constants__WEBPACK_IMPORTED_MODULE_3__[
+ /* TREE_OPERATION_ADD */
+ "j"
+ ]: {
+ var _id = operations[i + 1];
+ var type = operations[i + 2];
+ i += 3;
+ if (type === react_devtools_shared_src_types__WEBPACK_IMPORTED_MODULE_4__[
+ /* ElementTypeRoot */
+ "m"
+ ]) {
+ logs.push("Add new root node ".concat(_id));
+ i++;
+ i++;
+ i++;
+ i++;
+ } else {
+ var parentID = operations[i];
+ i++;
+ i++;
+ var displayNameStringID = operations[i];
+ var displayName = stringTable[displayNameStringID];
+ i++;
+ i++;
+ logs.push("Add node ".concat(_id, " (").concat(displayName || "null", ") as child of ").concat(parentID));
+ }
+ break;
+ }
+ case _constants__WEBPACK_IMPORTED_MODULE_3__[
+ /* TREE_OPERATION_REMOVE */
+ "k"
+ ]: {
+ var removeLength = operations[i + 1];
+ i += 2;
+ for (var removeIndex = 0; removeIndex < removeLength; removeIndex++) {
+ var _id2 = operations[i];
+ i += 1;
+ logs.push("Remove node ".concat(_id2));
+ }
+ break;
+ }
+ case _constants__WEBPACK_IMPORTED_MODULE_3__[
+ /* TREE_OPERATION_REMOVE_ROOT */
+ "l"
+ ]: {
+ i += 1;
+ logs.push("Remove root ".concat(rootID));
+ break;
+ }
+ case _constants__WEBPACK_IMPORTED_MODULE_3__[
+ /* TREE_OPERATION_SET_SUBTREE_MODE */
+ "n"
+ ]: {
+ var _id3 = operations[i + 1];
+ var mode = operations[i + 1];
+ i += 3;
+ logs.push("Mode ".concat(mode, " set for subtree with root ").concat(_id3));
+ break;
+ }
+ case _constants__WEBPACK_IMPORTED_MODULE_3__[
+ /* TREE_OPERATION_REORDER_CHILDREN */
+ "m"
+ ]: {
+ var _id4 = operations[i + 1];
+ var numChildren = operations[i + 2];
+ i += 3;
+ var children = operations.slice(i, i + numChildren);
+ i += numChildren;
+ logs.push("Re-order node ".concat(_id4, " children ").concat(children.join(",")));
+ break;
+ }
+ case _constants__WEBPACK_IMPORTED_MODULE_3__[
+ /* TREE_OPERATION_UPDATE_TREE_BASE_DURATION */
+ "p"
+ ]:
+ i += 3;
+ break;
+ case _constants__WEBPACK_IMPORTED_MODULE_3__[
+ /* TREE_OPERATION_UPDATE_ERRORS_OR_WARNINGS */
+ "o"
+ ]:
+ var id = operations[i + 1];
+ var numErrors = operations[i + 2];
+ var numWarnings = operations[i + 3];
+ i += 4;
+ logs.push("Node ".concat(id, " has ").concat(numErrors, " errors and ").concat(numWarnings, " warnings"));
+ break;
+ default:
+ throw Error('Unsupported Bridge operation "'.concat(operation, '"'));
+ }
+ }
+ console.log(logs.join("\n "));
+ }
+ __name(printOperationsArray, "printOperationsArray");
+ function getDefaultComponentFilters() {
+ return [{
+ type: react_devtools_shared_src_types__WEBPACK_IMPORTED_MODULE_4__[
+ /* ComponentFilterElementType */
+ "b"
+ ],
+ value: react_devtools_shared_src_types__WEBPACK_IMPORTED_MODULE_4__[
+ /* ElementTypeHostComponent */
+ "i"
+ ],
+ isEnabled: true
+ }];
+ }
+ __name(getDefaultComponentFilters, "getDefaultComponentFilters");
+ function getSavedComponentFilters() {
+ try {
+ var raw = Object(_storage__WEBPACK_IMPORTED_MODULE_5__[
+ /* localStorageGetItem */
+ "a"
+ ])(_constants__WEBPACK_IMPORTED_MODULE_3__[
+ /* LOCAL_STORAGE_FILTER_PREFERENCES_KEY */
+ "a"
+ ]);
+ if (raw != null) {
+ return JSON.parse(raw);
+ }
+ } catch (error) {
+ }
+ return getDefaultComponentFilters();
+ }
+ __name(getSavedComponentFilters, "getSavedComponentFilters");
+ function saveComponentFilters(componentFilters) {
+ Object(_storage__WEBPACK_IMPORTED_MODULE_5__[
+ /* localStorageSetItem */
+ "b"
+ ])(_constants__WEBPACK_IMPORTED_MODULE_3__[
+ /* LOCAL_STORAGE_FILTER_PREFERENCES_KEY */
+ "a"
+ ], JSON.stringify(componentFilters));
+ }
+ __name(saveComponentFilters, "saveComponentFilters");
+ function getAppendComponentStack() {
+ try {
+ var raw = Object(_storage__WEBPACK_IMPORTED_MODULE_5__[
+ /* localStorageGetItem */
+ "a"
+ ])(_constants__WEBPACK_IMPORTED_MODULE_3__[
+ /* LOCAL_STORAGE_SHOULD_PATCH_CONSOLE_KEY */
+ "e"
+ ]);
+ if (raw != null) {
+ return JSON.parse(raw);
+ }
+ } catch (error) {
+ }
+ return true;
+ }
+ __name(getAppendComponentStack, "getAppendComponentStack");
+ function setAppendComponentStack(value) {
+ Object(_storage__WEBPACK_IMPORTED_MODULE_5__[
+ /* localStorageSetItem */
+ "b"
+ ])(_constants__WEBPACK_IMPORTED_MODULE_3__[
+ /* LOCAL_STORAGE_SHOULD_PATCH_CONSOLE_KEY */
+ "e"
+ ], JSON.stringify(value));
+ }
+ __name(setAppendComponentStack, "setAppendComponentStack");
+ function getBreakOnConsoleErrors() {
+ try {
+ var raw = Object(_storage__WEBPACK_IMPORTED_MODULE_5__[
+ /* localStorageGetItem */
+ "a"
+ ])(_constants__WEBPACK_IMPORTED_MODULE_3__[
+ /* LOCAL_STORAGE_SHOULD_BREAK_ON_CONSOLE_ERRORS */
+ "d"
+ ]);
+ if (raw != null) {
+ return JSON.parse(raw);
+ }
+ } catch (error) {
+ }
+ return false;
+ }
+ __name(getBreakOnConsoleErrors, "getBreakOnConsoleErrors");
+ function setBreakOnConsoleErrors(value) {
+ Object(_storage__WEBPACK_IMPORTED_MODULE_5__[
+ /* localStorageSetItem */
+ "b"
+ ])(_constants__WEBPACK_IMPORTED_MODULE_3__[
+ /* LOCAL_STORAGE_SHOULD_BREAK_ON_CONSOLE_ERRORS */
+ "d"
+ ], JSON.stringify(value));
+ }
+ __name(setBreakOnConsoleErrors, "setBreakOnConsoleErrors");
+ function getHideConsoleLogsInStrictMode() {
+ try {
+ var raw = Object(_storage__WEBPACK_IMPORTED_MODULE_5__[
+ /* localStorageGetItem */
+ "a"
+ ])(_constants__WEBPACK_IMPORTED_MODULE_3__[
+ /* LOCAL_STORAGE_HIDE_CONSOLE_LOGS_IN_STRICT_MODE */
+ "b"
+ ]);
+ if (raw != null) {
+ return JSON.parse(raw);
+ }
+ } catch (error) {
+ }
+ return false;
+ }
+ __name(getHideConsoleLogsInStrictMode, "getHideConsoleLogsInStrictMode");
+ function sethideConsoleLogsInStrictMode(value) {
+ Object(_storage__WEBPACK_IMPORTED_MODULE_5__[
+ /* localStorageSetItem */
+ "b"
+ ])(_constants__WEBPACK_IMPORTED_MODULE_3__[
+ /* LOCAL_STORAGE_HIDE_CONSOLE_LOGS_IN_STRICT_MODE */
+ "b"
+ ], JSON.stringify(value));
+ }
+ __name(sethideConsoleLogsInStrictMode, "sethideConsoleLogsInStrictMode");
+ function getShowInlineWarningsAndErrors() {
+ try {
+ var raw = Object(_storage__WEBPACK_IMPORTED_MODULE_5__[
+ /* localStorageGetItem */
+ "a"
+ ])(_constants__WEBPACK_IMPORTED_MODULE_3__[
+ /* LOCAL_STORAGE_SHOW_INLINE_WARNINGS_AND_ERRORS_KEY */
+ "f"
+ ]);
+ if (raw != null) {
+ return JSON.parse(raw);
+ }
+ } catch (error) {
+ }
+ return true;
+ }
+ __name(getShowInlineWarningsAndErrors, "getShowInlineWarningsAndErrors");
+ function setShowInlineWarningsAndErrors(value) {
+ Object(_storage__WEBPACK_IMPORTED_MODULE_5__[
+ /* localStorageSetItem */
+ "b"
+ ])(_constants__WEBPACK_IMPORTED_MODULE_3__[
+ /* LOCAL_STORAGE_SHOW_INLINE_WARNINGS_AND_ERRORS_KEY */
+ "f"
+ ], JSON.stringify(value));
+ }
+ __name(setShowInlineWarningsAndErrors, "setShowInlineWarningsAndErrors");
+ function getDefaultOpenInEditorURL() {
+ return typeof process8.env.EDITOR_URL === "string" ? process8.env.EDITOR_URL : "";
+ }
+ __name(getDefaultOpenInEditorURL, "getDefaultOpenInEditorURL");
+ function getOpenInEditorURL() {
+ try {
+ var raw = Object(_storage__WEBPACK_IMPORTED_MODULE_5__[
+ /* localStorageGetItem */
+ "a"
+ ])(_constants__WEBPACK_IMPORTED_MODULE_3__[
+ /* LOCAL_STORAGE_OPEN_IN_EDITOR_URL */
+ "c"
+ ]);
+ if (raw != null) {
+ return JSON.parse(raw);
+ }
+ } catch (error) {
+ }
+ return getDefaultOpenInEditorURL();
+ }
+ __name(getOpenInEditorURL, "getOpenInEditorURL");
+ function separateDisplayNameAndHOCs(displayName, type) {
+ if (displayName === null) {
+ return [null, null];
+ }
+ var hocDisplayNames = null;
+ switch (type) {
+ case react_devtools_shared_src_types__WEBPACK_IMPORTED_MODULE_4__[
+ /* ElementTypeClass */
+ "e"
+ ]:
+ case react_devtools_shared_src_types__WEBPACK_IMPORTED_MODULE_4__[
+ /* ElementTypeForwardRef */
+ "g"
+ ]:
+ case react_devtools_shared_src_types__WEBPACK_IMPORTED_MODULE_4__[
+ /* ElementTypeFunction */
+ "h"
+ ]:
+ case react_devtools_shared_src_types__WEBPACK_IMPORTED_MODULE_4__[
+ /* ElementTypeMemo */
+ "j"
+ ]:
+ if (displayName.indexOf("(") >= 0) {
+ var matches = displayName.match(/[^()]+/g);
+ if (matches != null) {
+ displayName = matches.pop();
+ hocDisplayNames = matches;
+ }
+ }
+ break;
+ default:
+ break;
+ }
+ if (type === react_devtools_shared_src_types__WEBPACK_IMPORTED_MODULE_4__[
+ /* ElementTypeMemo */
+ "j"
+ ]) {
+ if (hocDisplayNames === null) {
+ hocDisplayNames = ["Memo"];
+ } else {
+ hocDisplayNames.unshift("Memo");
+ }
+ } else if (type === react_devtools_shared_src_types__WEBPACK_IMPORTED_MODULE_4__[
+ /* ElementTypeForwardRef */
+ "g"
+ ]) {
+ if (hocDisplayNames === null) {
+ hocDisplayNames = ["ForwardRef"];
+ } else {
+ hocDisplayNames.unshift("ForwardRef");
+ }
+ }
+ return [displayName, hocDisplayNames];
+ }
+ __name(separateDisplayNameAndHOCs, "separateDisplayNameAndHOCs");
+ function shallowDiffers(prev, next) {
+ for (var attribute in prev) {
+ if (!(attribute in next)) {
+ return true;
+ }
+ }
+ for (var _attribute in next) {
+ if (prev[_attribute] !== next[_attribute]) {
+ return true;
+ }
+ }
+ return false;
+ }
+ __name(shallowDiffers, "shallowDiffers");
+ function getInObject(object, path45) {
+ return path45.reduce(function(reduced, attr) {
+ if (reduced) {
+ if (hasOwnProperty.call(reduced, attr)) {
+ return reduced[attr];
+ }
+ if (typeof reduced[Symbol.iterator] === "function") {
+ return Array.from(reduced)[attr];
+ }
+ }
+ return null;
+ }, object);
+ }
+ __name(getInObject, "getInObject");
+ function deletePathInObject(object, path45) {
+ var length = path45.length;
+ var last = path45[length - 1];
+ if (object != null) {
+ var parent = getInObject(object, path45.slice(0, length - 1));
+ if (parent) {
+ if (Object(_isArray__WEBPACK_IMPORTED_MODULE_7__[
+ /* default */
+ "a"
+ ])(parent)) {
+ parent.splice(last, 1);
+ } else {
+ delete parent[last];
+ }
+ }
+ }
+ }
+ __name(deletePathInObject, "deletePathInObject");
+ function renamePathInObject(object, oldPath, newPath) {
+ var length = oldPath.length;
+ if (object != null) {
+ var parent = getInObject(object, oldPath.slice(0, length - 1));
+ if (parent) {
+ var lastOld = oldPath[length - 1];
+ var lastNew = newPath[length - 1];
+ parent[lastNew] = parent[lastOld];
+ if (Object(_isArray__WEBPACK_IMPORTED_MODULE_7__[
+ /* default */
+ "a"
+ ])(parent)) {
+ parent.splice(lastOld, 1);
+ } else {
+ delete parent[lastOld];
+ }
+ }
+ }
+ }
+ __name(renamePathInObject, "renamePathInObject");
+ function setInObject(object, path45, value) {
+ var length = path45.length;
+ var last = path45[length - 1];
+ if (object != null) {
+ var parent = getInObject(object, path45.slice(0, length - 1));
+ if (parent) {
+ parent[last] = value;
+ }
+ }
+ }
+ __name(setInObject, "setInObject");
+ function getDataType(data) {
+ if (data === null) {
+ return "null";
+ } else if (data === void 0) {
+ return "undefined";
+ }
+ if (Object(react_is__WEBPACK_IMPORTED_MODULE_1__["isElement"])(data)) {
+ return "react_element";
+ }
+ if (typeof HTMLElement !== "undefined" && data instanceof HTMLElement) {
+ return "html_element";
+ }
+ var type = _typeof7(data);
+ switch (type) {
+ case "bigint":
+ return "bigint";
+ case "boolean":
+ return "boolean";
+ case "function":
+ return "function";
+ case "number":
+ if (Number.isNaN(data)) {
+ return "nan";
+ } else if (!Number.isFinite(data)) {
+ return "infinity";
+ } else {
+ return "number";
+ }
+ case "object":
+ if (Object(_isArray__WEBPACK_IMPORTED_MODULE_7__[
+ /* default */
+ "a"
+ ])(data)) {
+ return "array";
+ } else if (ArrayBuffer.isView(data)) {
+ return hasOwnProperty.call(data.constructor, "BYTES_PER_ELEMENT") ? "typed_array" : "data_view";
+ } else if (data.constructor && data.constructor.name === "ArrayBuffer") {
+ return "array_buffer";
+ } else if (typeof data[Symbol.iterator] === "function") {
+ var iterator = data[Symbol.iterator]();
+ if (!iterator) {
+ } else {
+ return iterator === data ? "opaque_iterator" : "iterator";
+ }
+ } else if (data.constructor && data.constructor.name === "RegExp") {
+ return "regexp";
+ } else {
+ var toStringValue = Object.prototype.toString.call(data);
+ if (toStringValue === "[object Date]") {
+ return "date";
+ } else if (toStringValue === "[object HTMLAllCollection]") {
+ return "html_all_collection";
+ }
+ }
+ return "object";
+ case "string":
+ return "string";
+ case "symbol":
+ return "symbol";
+ case "undefined":
+ if (Object.prototype.toString.call(data) === "[object HTMLAllCollection]") {
+ return "html_all_collection";
+ }
+ return "undefined";
+ default:
+ return "unknown";
+ }
+ }
+ __name(getDataType, "getDataType");
+ function getDisplayNameForReactElement(element) {
+ var elementType = Object(react_is__WEBPACK_IMPORTED_MODULE_1__["typeOf"])(element);
+ switch (elementType) {
+ case react_is__WEBPACK_IMPORTED_MODULE_1__["ContextConsumer"]:
+ return "ContextConsumer";
+ case react_is__WEBPACK_IMPORTED_MODULE_1__["ContextProvider"]:
+ return "ContextProvider";
+ case react_is__WEBPACK_IMPORTED_MODULE_1__["ForwardRef"]:
+ return "ForwardRef";
+ case react_is__WEBPACK_IMPORTED_MODULE_1__["Fragment"]:
+ return "Fragment";
+ case react_is__WEBPACK_IMPORTED_MODULE_1__["Lazy"]:
+ return "Lazy";
+ case react_is__WEBPACK_IMPORTED_MODULE_1__["Memo"]:
+ return "Memo";
+ case react_is__WEBPACK_IMPORTED_MODULE_1__["Portal"]:
+ return "Portal";
+ case react_is__WEBPACK_IMPORTED_MODULE_1__["Profiler"]:
+ return "Profiler";
+ case react_is__WEBPACK_IMPORTED_MODULE_1__["StrictMode"]:
+ return "StrictMode";
+ case react_is__WEBPACK_IMPORTED_MODULE_1__["Suspense"]:
+ return "Suspense";
+ case shared_ReactSymbols__WEBPACK_IMPORTED_MODULE_2__[
+ /* REACT_SUSPENSE_LIST_TYPE */
+ "a"
+ ]:
+ return "SuspenseList";
+ default:
+ var type = element.type;
+ if (typeof type === "string") {
+ return type;
+ } else if (typeof type === "function") {
+ return getDisplayName(type, "Anonymous");
+ } else if (type != null) {
+ return "NotImplementedInDevtools";
+ } else {
+ return "Element";
+ }
+ }
+ }
+ __name(getDisplayNameForReactElement, "getDisplayNameForReactElement");
+ var MAX_PREVIEW_STRING_LENGTH = 50;
+ function truncateForDisplay(string) {
+ var length = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : MAX_PREVIEW_STRING_LENGTH;
+ if (string.length > length) {
+ return string.substr(0, length) + "\u2026";
+ } else {
+ return string;
+ }
+ }
+ __name(truncateForDisplay, "truncateForDisplay");
+ function formatDataForPreview(data, showFormattedValue) {
+ if (data != null && hasOwnProperty.call(data, _hydration__WEBPACK_IMPORTED_MODULE_6__[
+ /* meta */
+ "b"
+ ].type)) {
+ return showFormattedValue ? data[_hydration__WEBPACK_IMPORTED_MODULE_6__[
+ /* meta */
+ "b"
+ ].preview_long] : data[_hydration__WEBPACK_IMPORTED_MODULE_6__[
+ /* meta */
+ "b"
+ ].preview_short];
+ }
+ var type = getDataType(data);
+ switch (type) {
+ case "html_element":
+ return "<".concat(truncateForDisplay(data.tagName.toLowerCase()), " />");
+ case "function":
+ return truncateForDisplay("\u0192 ".concat(typeof data.name === "function" ? "" : data.name, "() {}"));
+ case "string":
+ return '"'.concat(data, '"');
+ case "bigint":
+ return truncateForDisplay(data.toString() + "n");
+ case "regexp":
+ return truncateForDisplay(data.toString());
+ case "symbol":
+ return truncateForDisplay(data.toString());
+ case "react_element":
+ return "<".concat(truncateForDisplay(getDisplayNameForReactElement(data) || "Unknown"), " />");
+ case "array_buffer":
+ return "ArrayBuffer(".concat(data.byteLength, ")");
+ case "data_view":
+ return "DataView(".concat(data.buffer.byteLength, ")");
+ case "array":
+ if (showFormattedValue) {
+ var formatted = "";
+ for (var i = 0; i < data.length; i++) {
+ if (i > 0) {
+ formatted += ", ";
+ }
+ formatted += formatDataForPreview(data[i], false);
+ if (formatted.length > MAX_PREVIEW_STRING_LENGTH) {
+ break;
+ }
+ }
+ return "[".concat(truncateForDisplay(formatted), "]");
+ } else {
+ var length = hasOwnProperty.call(data, _hydration__WEBPACK_IMPORTED_MODULE_6__[
+ /* meta */
+ "b"
+ ].size) ? data[_hydration__WEBPACK_IMPORTED_MODULE_6__[
+ /* meta */
+ "b"
+ ].size] : data.length;
+ return "Array(".concat(length, ")");
+ }
+ case "typed_array":
+ var shortName = "".concat(data.constructor.name, "(").concat(data.length, ")");
+ if (showFormattedValue) {
+ var _formatted = "";
+ for (var _i = 0; _i < data.length; _i++) {
+ if (_i > 0) {
+ _formatted += ", ";
+ }
+ _formatted += data[_i];
+ if (_formatted.length > MAX_PREVIEW_STRING_LENGTH) {
+ break;
+ }
+ }
+ return "".concat(shortName, " [").concat(truncateForDisplay(_formatted), "]");
+ } else {
+ return shortName;
+ }
+ case "iterator":
+ var name = data.constructor.name;
+ if (showFormattedValue) {
+ var array = Array.from(data);
+ var _formatted2 = "";
+ for (var _i2 = 0; _i2 < array.length; _i2++) {
+ var entryOrEntries = array[_i2];
+ if (_i2 > 0) {
+ _formatted2 += ", ";
+ }
+ if (Object(_isArray__WEBPACK_IMPORTED_MODULE_7__[
+ /* default */
+ "a"
+ ])(entryOrEntries)) {
+ var key = formatDataForPreview(entryOrEntries[0], true);
+ var value = formatDataForPreview(entryOrEntries[1], false);
+ _formatted2 += "".concat(key, " => ").concat(value);
+ } else {
+ _formatted2 += formatDataForPreview(entryOrEntries, false);
+ }
+ if (_formatted2.length > MAX_PREVIEW_STRING_LENGTH) {
+ break;
+ }
+ }
+ return "".concat(name, "(").concat(data.size, ") {").concat(truncateForDisplay(_formatted2), "}");
+ } else {
+ return "".concat(name, "(").concat(data.size, ")");
+ }
+ case "opaque_iterator": {
+ return data[Symbol.toStringTag];
+ }
+ case "date":
+ return data.toString();
+ case "object":
+ if (showFormattedValue) {
+ var keys = Array.from(getAllEnumerableKeys(data)).sort(alphaSortKeys);
+ var _formatted3 = "";
+ for (var _i3 = 0; _i3 < keys.length; _i3++) {
+ var _key = keys[_i3];
+ if (_i3 > 0) {
+ _formatted3 += ", ";
+ }
+ _formatted3 += "".concat(_key.toString(), ": ").concat(formatDataForPreview(data[_key], false));
+ if (_formatted3.length > MAX_PREVIEW_STRING_LENGTH) {
+ break;
+ }
+ }
+ return "{".concat(truncateForDisplay(_formatted3), "}");
+ } else {
+ return "{\u2026}";
+ }
+ case "boolean":
+ case "number":
+ case "infinity":
+ case "nan":
+ case "null":
+ case "undefined":
+ return data;
+ default:
+ try {
+ return truncateForDisplay(String(data));
+ } catch (error) {
+ return "unserializable";
+ }
+ }
+ }
+ __name(formatDataForPreview, "formatDataForPreview");
+ }).call(this, __webpack_require__(17));
+ },
+ /* 3 */
+ /***/
+ function(module3, __webpack_exports__, __webpack_require__) {
+ "use strict";
+ __webpack_require__.d(__webpack_exports__, "a", function() {
+ return CONCURRENT_MODE_NUMBER;
+ });
+ __webpack_require__.d(__webpack_exports__, "b", function() {
+ return CONCURRENT_MODE_SYMBOL_STRING;
+ });
+ __webpack_require__.d(__webpack_exports__, "c", function() {
+ return CONTEXT_NUMBER;
+ });
+ __webpack_require__.d(__webpack_exports__, "d", function() {
+ return CONTEXT_SYMBOL_STRING;
+ });
+ __webpack_require__.d(__webpack_exports__, "e", function() {
+ return DEPRECATED_ASYNC_MODE_SYMBOL_STRING;
+ });
+ __webpack_require__.d(__webpack_exports__, "f", function() {
+ return FORWARD_REF_NUMBER;
+ });
+ __webpack_require__.d(__webpack_exports__, "g", function() {
+ return FORWARD_REF_SYMBOL_STRING;
+ });
+ __webpack_require__.d(__webpack_exports__, "h", function() {
+ return LAZY_NUMBER;
+ });
+ __webpack_require__.d(__webpack_exports__, "i", function() {
+ return LAZY_SYMBOL_STRING;
+ });
+ __webpack_require__.d(__webpack_exports__, "j", function() {
+ return MEMO_NUMBER;
+ });
+ __webpack_require__.d(__webpack_exports__, "k", function() {
+ return MEMO_SYMBOL_STRING;
+ });
+ __webpack_require__.d(__webpack_exports__, "l", function() {
+ return PROFILER_NUMBER;
+ });
+ __webpack_require__.d(__webpack_exports__, "m", function() {
+ return PROFILER_SYMBOL_STRING;
+ });
+ __webpack_require__.d(__webpack_exports__, "n", function() {
+ return PROVIDER_NUMBER;
+ });
+ __webpack_require__.d(__webpack_exports__, "o", function() {
+ return PROVIDER_SYMBOL_STRING;
+ });
+ __webpack_require__.d(__webpack_exports__, "p", function() {
+ return SCOPE_NUMBER;
+ });
+ __webpack_require__.d(__webpack_exports__, "q", function() {
+ return SCOPE_SYMBOL_STRING;
+ });
+ __webpack_require__.d(__webpack_exports__, "r", function() {
+ return STRICT_MODE_NUMBER;
+ });
+ __webpack_require__.d(__webpack_exports__, "s", function() {
+ return STRICT_MODE_SYMBOL_STRING;
+ });
+ __webpack_require__.d(__webpack_exports__, "v", function() {
+ return SUSPENSE_NUMBER;
+ });
+ __webpack_require__.d(__webpack_exports__, "w", function() {
+ return SUSPENSE_SYMBOL_STRING;
+ });
+ __webpack_require__.d(__webpack_exports__, "t", function() {
+ return SUSPENSE_LIST_NUMBER;
+ });
+ __webpack_require__.d(__webpack_exports__, "u", function() {
+ return SUSPENSE_LIST_SYMBOL_STRING;
+ });
+ var CONCURRENT_MODE_NUMBER = 60111;
+ var CONCURRENT_MODE_SYMBOL_STRING = "Symbol(react.concurrent_mode)";
+ var CONTEXT_NUMBER = 60110;
+ var CONTEXT_SYMBOL_STRING = "Symbol(react.context)";
+ var DEPRECATED_ASYNC_MODE_SYMBOL_STRING = "Symbol(react.async_mode)";
+ var ELEMENT_NUMBER = 60103;
+ var ELEMENT_SYMBOL_STRING = "Symbol(react.element)";
+ var DEBUG_TRACING_MODE_NUMBER = 60129;
+ var DEBUG_TRACING_MODE_SYMBOL_STRING = "Symbol(react.debug_trace_mode)";
+ var FORWARD_REF_NUMBER = 60112;
+ var FORWARD_REF_SYMBOL_STRING = "Symbol(react.forward_ref)";
+ var FRAGMENT_NUMBER = 60107;
+ var FRAGMENT_SYMBOL_STRING = "Symbol(react.fragment)";
+ var LAZY_NUMBER = 60116;
+ var LAZY_SYMBOL_STRING = "Symbol(react.lazy)";
+ var MEMO_NUMBER = 60115;
+ var MEMO_SYMBOL_STRING = "Symbol(react.memo)";
+ var PORTAL_NUMBER = 60106;
+ var PORTAL_SYMBOL_STRING = "Symbol(react.portal)";
+ var PROFILER_NUMBER = 60114;
+ var PROFILER_SYMBOL_STRING = "Symbol(react.profiler)";
+ var PROVIDER_NUMBER = 60109;
+ var PROVIDER_SYMBOL_STRING = "Symbol(react.provider)";
+ var SCOPE_NUMBER = 60119;
+ var SCOPE_SYMBOL_STRING = "Symbol(react.scope)";
+ var STRICT_MODE_NUMBER = 60108;
+ var STRICT_MODE_SYMBOL_STRING = "Symbol(react.strict_mode)";
+ var SUSPENSE_NUMBER = 60113;
+ var SUSPENSE_SYMBOL_STRING = "Symbol(react.suspense)";
+ var SUSPENSE_LIST_NUMBER = 60120;
+ var SUSPENSE_LIST_SYMBOL_STRING = "Symbol(react.suspense_list)";
+ },
+ /* 4 */
+ /***/
+ function(module3, __webpack_exports__, __webpack_require__) {
+ "use strict";
+ __webpack_require__.d(__webpack_exports__, "a", function() {
+ return cleanForBridge;
+ });
+ __webpack_require__.d(__webpack_exports__, "b", function() {
+ return copyToClipboard;
+ });
+ __webpack_require__.d(__webpack_exports__, "c", function() {
+ return copyWithDelete;
+ });
+ __webpack_require__.d(__webpack_exports__, "d", function() {
+ return copyWithRename;
+ });
+ __webpack_require__.d(__webpack_exports__, "e", function() {
+ return copyWithSet;
+ });
+ __webpack_require__.d(__webpack_exports__, "g", function() {
+ return getEffectDurations;
+ });
+ __webpack_require__.d(__webpack_exports__, "f", function() {
+ return format8;
+ });
+ __webpack_require__.d(__webpack_exports__, "h", function() {
+ return isSynchronousXHRSupported;
+ });
+ var clipboard_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(18);
+ var clipboard_js__WEBPACK_IMPORTED_MODULE_0___default = /* @__PURE__ */ __webpack_require__.n(clipboard_js__WEBPACK_IMPORTED_MODULE_0__);
+ var _hydration__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(12);
+ var shared_isArray__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(9);
+ function _typeof7(obj) {
+ "@babel/helpers - typeof";
+ if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+ _typeof7 = /* @__PURE__ */ __name(function _typeof8(obj2) {
+ return typeof obj2;
+ }, "_typeof");
+ } else {
+ _typeof7 = /* @__PURE__ */ __name(function _typeof8(obj2) {
+ return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+ }, "_typeof");
+ }
+ return _typeof7(obj);
+ }
+ __name(_typeof7, "_typeof");
+ function ownKeys11(object, enumerableOnly) {
+ var keys = Object.keys(object);
+ if (Object.getOwnPropertySymbols) {
+ var symbols = Object.getOwnPropertySymbols(object);
+ if (enumerableOnly)
+ symbols = symbols.filter(function(sym) {
+ return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+ });
+ keys.push.apply(keys, symbols);
+ }
+ return keys;
+ }
+ __name(ownKeys11, "ownKeys");
+ function _objectSpread11(target) {
+ for (var i = 1; i < arguments.length; i++) {
+ var source = arguments[i] != null ? arguments[i] : {};
+ if (i % 2) {
+ ownKeys11(Object(source), true).forEach(function(key) {
+ _defineProperty11(target, key, source[key]);
+ });
+ } else if (Object.getOwnPropertyDescriptors) {
+ Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+ } else {
+ ownKeys11(Object(source)).forEach(function(key) {
+ Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+ });
+ }
+ }
+ return target;
+ }
+ __name(_objectSpread11, "_objectSpread");
+ function _defineProperty11(obj, key, value) {
+ if (key in obj) {
+ Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
+ } else {
+ obj[key] = value;
+ }
+ return obj;
+ }
+ __name(_defineProperty11, "_defineProperty");
+ function cleanForBridge(data, isPathAllowed) {
+ var path45 = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : [];
+ if (data !== null) {
+ var cleanedPaths = [];
+ var unserializablePaths = [];
+ var cleanedData = Object(_hydration__WEBPACK_IMPORTED_MODULE_1__[
+ /* dehydrate */
+ "a"
+ ])(data, cleanedPaths, unserializablePaths, path45, isPathAllowed);
+ return {
+ data: cleanedData,
+ cleaned: cleanedPaths,
+ unserializable: unserializablePaths
+ };
+ } else {
+ return null;
+ }
+ }
+ __name(cleanForBridge, "cleanForBridge");
+ function copyToClipboard(value) {
+ var safeToCopy = serializeToString(value);
+ var text = safeToCopy === void 0 ? "undefined" : safeToCopy;
+ var clipboardCopyText = window.__REACT_DEVTOOLS_GLOBAL_HOOK__.clipboardCopyText;
+ if (typeof clipboardCopyText === "function") {
+ clipboardCopyText(text).catch(function(err) {
+ });
+ } else {
+ Object(clipboard_js__WEBPACK_IMPORTED_MODULE_0__["copy"])(text);
+ }
+ }
+ __name(copyToClipboard, "copyToClipboard");
+ function copyWithDelete(obj, path45) {
+ var index = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : 0;
+ var key = path45[index];
+ var updated = Object(shared_isArray__WEBPACK_IMPORTED_MODULE_2__[
+ /* default */
+ "a"
+ ])(obj) ? obj.slice() : _objectSpread11({}, obj);
+ if (index + 1 === path45.length) {
+ if (Object(shared_isArray__WEBPACK_IMPORTED_MODULE_2__[
+ /* default */
+ "a"
+ ])(updated)) {
+ updated.splice(key, 1);
+ } else {
+ delete updated[key];
+ }
+ } else {
+ updated[key] = copyWithDelete(obj[key], path45, index + 1);
+ }
+ return updated;
+ }
+ __name(copyWithDelete, "copyWithDelete");
+ function copyWithRename(obj, oldPath, newPath) {
+ var index = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : 0;
+ var oldKey = oldPath[index];
+ var updated = Object(shared_isArray__WEBPACK_IMPORTED_MODULE_2__[
+ /* default */
+ "a"
+ ])(obj) ? obj.slice() : _objectSpread11({}, obj);
+ if (index + 1 === oldPath.length) {
+ var newKey = newPath[index];
+ updated[newKey] = updated[oldKey];
+ if (Object(shared_isArray__WEBPACK_IMPORTED_MODULE_2__[
+ /* default */
+ "a"
+ ])(updated)) {
+ updated.splice(oldKey, 1);
+ } else {
+ delete updated[oldKey];
+ }
+ } else {
+ updated[oldKey] = copyWithRename(obj[oldKey], oldPath, newPath, index + 1);
+ }
+ return updated;
+ }
+ __name(copyWithRename, "copyWithRename");
+ function copyWithSet(obj, path45, value) {
+ var index = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : 0;
+ if (index >= path45.length) {
+ return value;
+ }
+ var key = path45[index];
+ var updated = Object(shared_isArray__WEBPACK_IMPORTED_MODULE_2__[
+ /* default */
+ "a"
+ ])(obj) ? obj.slice() : _objectSpread11({}, obj);
+ updated[key] = copyWithSet(obj[key], path45, value, index + 1);
+ return updated;
+ }
+ __name(copyWithSet, "copyWithSet");
+ function getEffectDurations(root) {
+ var effectDuration = null;
+ var passiveEffectDuration = null;
+ var hostRoot = root.current;
+ if (hostRoot != null) {
+ var stateNode = hostRoot.stateNode;
+ if (stateNode != null) {
+ effectDuration = stateNode.effectDuration != null ? stateNode.effectDuration : null;
+ passiveEffectDuration = stateNode.passiveEffectDuration != null ? stateNode.passiveEffectDuration : null;
+ }
+ }
+ return {
+ effectDuration,
+ passiveEffectDuration
+ };
+ }
+ __name(getEffectDurations, "getEffectDurations");
+ function serializeToString(data) {
+ var cache2 = /* @__PURE__ */ new Set();
+ return JSON.stringify(data, function(key, value) {
+ if (_typeof7(value) === "object" && value !== null) {
+ if (cache2.has(value)) {
+ return;
+ }
+ cache2.add(value);
+ }
+ if (typeof value === "bigint") {
+ return value.toString() + "n";
+ }
+ return value;
+ });
+ }
+ __name(serializeToString, "serializeToString");
+ function format8(maybeMessage) {
+ for (var _len = arguments.length, inputArgs = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+ inputArgs[_key - 1] = arguments[_key];
+ }
+ var args = inputArgs.slice();
+ var formatted = String(maybeMessage);
+ if (typeof maybeMessage === "string") {
+ if (args.length) {
+ var REGEXP = /(%?)(%([jds]))/g;
+ formatted = formatted.replace(REGEXP, function(match, escaped, ptn, flag) {
+ var arg = args.shift();
+ switch (flag) {
+ case "s":
+ arg += "";
+ break;
+ case "d":
+ case "i":
+ arg = parseInt(arg, 10).toString();
+ break;
+ case "f":
+ arg = parseFloat(arg).toString();
+ break;
+ }
+ if (!escaped) {
+ return arg;
+ }
+ args.unshift(arg);
+ return match;
+ });
+ }
+ }
+ if (args.length) {
+ for (var i = 0; i < args.length; i++) {
+ formatted += " " + String(args[i]);
+ }
+ }
+ formatted = formatted.replace(/%{2,2}/g, "%");
+ return String(formatted);
+ }
+ __name(format8, "format");
+ function isSynchronousXHRSupported() {
+ return !!(window.document && window.document.featurePolicy && window.document.featurePolicy.allowsFeature("sync-xhr"));
+ }
+ __name(isSynchronousXHRSupported, "isSynchronousXHRSupported");
+ },
+ /* 5 */
+ /***/
+ function(module3, __webpack_exports__, __webpack_require__) {
+ "use strict";
+ __webpack_require__.d(__webpack_exports__, "a", function() {
+ return localStorageGetItem;
+ });
+ __webpack_require__.d(__webpack_exports__, "b", function() {
+ return localStorageSetItem;
+ });
+ __webpack_require__.d(__webpack_exports__, "c", function() {
+ return sessionStorageGetItem;
+ });
+ __webpack_require__.d(__webpack_exports__, "d", function() {
+ return sessionStorageRemoveItem;
+ });
+ __webpack_require__.d(__webpack_exports__, "e", function() {
+ return sessionStorageSetItem;
+ });
+ function localStorageGetItem(key) {
+ try {
+ return localStorage.getItem(key);
+ } catch (error) {
+ return null;
+ }
+ }
+ __name(localStorageGetItem, "localStorageGetItem");
+ function localStorageRemoveItem(key) {
+ try {
+ localStorage.removeItem(key);
+ } catch (error) {
+ }
+ }
+ __name(localStorageRemoveItem, "localStorageRemoveItem");
+ function localStorageSetItem(key, value) {
+ try {
+ return localStorage.setItem(key, value);
+ } catch (error) {
+ }
+ }
+ __name(localStorageSetItem, "localStorageSetItem");
+ function sessionStorageGetItem(key) {
+ try {
+ return sessionStorage.getItem(key);
+ } catch (error) {
+ return null;
+ }
+ }
+ __name(sessionStorageGetItem, "sessionStorageGetItem");
+ function sessionStorageRemoveItem(key) {
+ try {
+ sessionStorage.removeItem(key);
+ } catch (error) {
+ }
+ }
+ __name(sessionStorageRemoveItem, "sessionStorageRemoveItem");
+ function sessionStorageSetItem(key, value) {
+ try {
+ return sessionStorage.setItem(key, value);
+ } catch (error) {
+ }
+ }
+ __name(sessionStorageSetItem, "sessionStorageSetItem");
+ },
+ /* 6 */
+ /***/
+ function(module3, __webpack_exports__, __webpack_require__) {
+ "use strict";
+ var isArray = Array.isArray;
+ __webpack_exports__["a"] = isArray;
+ },
+ /* 7 */
+ /***/
+ function(module3, exports3, __webpack_require__) {
+ "use strict";
+ if (true) {
+ module3.exports = __webpack_require__(27);
+ } else {
+ }
+ },
+ /* 8 */
+ /***/
+ function(module3, exports3, __webpack_require__) {
+ "use strict";
+ var getOwnPropertySymbols = Object.getOwnPropertySymbols;
+ var hasOwnProperty2 = 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);
+ }
+ __name(toObject, "toObject");
+ 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 (err) {
+ return false;
+ }
+ }
+ __name(shouldUseNative, "shouldUseNative");
+ module3.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 (hasOwnProperty2.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;
+ };
+ },
+ /* 9 */
+ /***/
+ function(module3, __webpack_exports__, __webpack_require__) {
+ "use strict";
+ var isArrayImpl = Array.isArray;
+ function isArray(a) {
+ return isArrayImpl(a);
+ }
+ __name(isArray, "isArray");
+ __webpack_exports__["a"] = isArray;
+ },
+ /* 10 */
+ /***/
+ function(module3, __webpack_exports__, __webpack_require__) {
+ "use strict";
+ (function(global2) {
+ __webpack_require__.d(__webpack_exports__, "c", function() {
+ return registerRenderer;
+ });
+ __webpack_require__.d(__webpack_exports__, "a", function() {
+ return patch;
+ });
+ __webpack_require__.d(__webpack_exports__, "b", function() {
+ return patchForStrictMode;
+ });
+ __webpack_require__.d(__webpack_exports__, "d", function() {
+ return unpatchForStrictMode;
+ });
+ var _utils__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(4);
+ var _renderer__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(16);
+ var _DevToolsFiberComponentStack__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(22);
+ var react_devtools_feature_flags__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(13);
+ function _createForOfIteratorHelper(o, allowArrayLike) {
+ var it2;
+ if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) {
+ if (Array.isArray(o) || (it2 = _unsupportedIterableToArray4(o)) || allowArrayLike && o && typeof o.length === "number") {
+ if (it2)
+ o = it2;
+ var i = 0;
+ var F = /* @__PURE__ */ __name(function F2() {
+ }, "F");
+ return { s: F, n: /* @__PURE__ */ __name(function n() {
+ if (i >= o.length)
+ return { done: true };
+ return { done: false, value: o[i++] };
+ }, "n"), e: /* @__PURE__ */ __name(function e2(_e) {
+ throw _e;
+ }, "e"), f: F };
+ }
+ throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+ }
+ var normalCompletion = true, didErr = false, err;
+ return { s: /* @__PURE__ */ __name(function s() {
+ it2 = o[Symbol.iterator]();
+ }, "s"), n: /* @__PURE__ */ __name(function n() {
+ var step = it2.next();
+ normalCompletion = step.done;
+ return step;
+ }, "n"), e: /* @__PURE__ */ __name(function e2(_e2) {
+ didErr = true;
+ err = _e2;
+ }, "e"), f: /* @__PURE__ */ __name(function f() {
+ try {
+ if (!normalCompletion && it2.return != null)
+ it2.return();
+ } finally {
+ if (didErr)
+ throw err;
+ }
+ }, "f") };
+ }
+ __name(_createForOfIteratorHelper, "_createForOfIteratorHelper");
+ function _unsupportedIterableToArray4(o, minLen) {
+ if (!o)
+ return;
+ if (typeof o === "string")
+ return _arrayLikeToArray4(o, minLen);
+ var n = Object.prototype.toString.call(o).slice(8, -1);
+ if (n === "Object" && o.constructor)
+ n = o.constructor.name;
+ if (n === "Map" || n === "Set")
+ return Array.from(o);
+ if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))
+ return _arrayLikeToArray4(o, minLen);
+ }
+ __name(_unsupportedIterableToArray4, "_unsupportedIterableToArray");
+ function _arrayLikeToArray4(arr, len) {
+ if (len == null || len > arr.length)
+ len = arr.length;
+ for (var i = 0, arr2 = new Array(len); i < len; i++) {
+ arr2[i] = arr[i];
+ }
+ return arr2;
+ }
+ __name(_arrayLikeToArray4, "_arrayLikeToArray");
+ var OVERRIDE_CONSOLE_METHODS = ["error", "trace", "warn"];
+ var DIMMED_NODE_CONSOLE_COLOR = "\x1B[2m%s\x1B[0m";
+ var PREFIX_REGEX = /\s{4}(in|at)\s{1}/;
+ var ROW_COLUMN_NUMBER_REGEX = /:\d+:\d+(\n|$)/;
+ function isStringComponentStack(text) {
+ return PREFIX_REGEX.test(text) || ROW_COLUMN_NUMBER_REGEX.test(text);
+ }
+ __name(isStringComponentStack, "isStringComponentStack");
+ var STYLE_DIRECTIVE_REGEX = /^%c/;
+ function isStrictModeOverride(args, method2) {
+ return args.length === 2 && STYLE_DIRECTIVE_REGEX.test(args[0]) && args[1] === "color: ".concat(getConsoleColor(method2) || "");
+ }
+ __name(isStrictModeOverride, "isStrictModeOverride");
+ function getConsoleColor(method2) {
+ switch (method2) {
+ case "warn":
+ return consoleSettingsRef.browserTheme === "light" ? "rgba(250, 180, 50, 0.75)" : "rgba(250, 180, 50, 0.5)";
+ case "error":
+ return consoleSettingsRef.browserTheme === "light" ? "rgba(250, 123, 130, 0.75)" : "rgba(250, 123, 130, 0.5)";
+ case "log":
+ default:
+ return consoleSettingsRef.browserTheme === "light" ? "rgba(125, 125, 125, 0.75)" : "rgba(125, 125, 125, 0.5)";
+ }
+ }
+ __name(getConsoleColor, "getConsoleColor");
+ var injectedRenderers = /* @__PURE__ */ new Map();
+ var targetConsole = console;
+ var targetConsoleMethods = {};
+ for (var method in console) {
+ targetConsoleMethods[method] = console[method];
+ }
+ var unpatchFn = null;
+ var isNode = false;
+ try {
+ isNode = void 0 === global2;
+ } catch (error) {
+ }
+ function dangerous_setTargetConsoleForTesting(targetConsoleForTesting) {
+ targetConsole = targetConsoleForTesting;
+ targetConsoleMethods = {};
+ for (var _method in targetConsole) {
+ targetConsoleMethods[_method] = console[_method];
+ }
+ }
+ __name(dangerous_setTargetConsoleForTesting, "dangerous_setTargetConsoleForTesting");
+ function registerRenderer(renderer, onErrorOrWarning) {
+ var currentDispatcherRef = renderer.currentDispatcherRef, getCurrentFiber = renderer.getCurrentFiber, findFiberByHostInstance = renderer.findFiberByHostInstance, version2 = renderer.version;
+ if (typeof findFiberByHostInstance !== "function") {
+ return;
+ }
+ if (currentDispatcherRef != null && typeof getCurrentFiber === "function") {
+ var _getInternalReactCons = Object(_renderer__WEBPACK_IMPORTED_MODULE_1__[
+ /* getInternalReactConstants */
+ "b"
+ ])(version2), ReactTypeOfWork = _getInternalReactCons.ReactTypeOfWork;
+ injectedRenderers.set(renderer, {
+ currentDispatcherRef,
+ getCurrentFiber,
+ workTagMap: ReactTypeOfWork,
+ onErrorOrWarning
+ });
+ }
+ }
+ __name(registerRenderer, "registerRenderer");
+ var consoleSettingsRef = {
+ appendComponentStack: false,
+ breakOnConsoleErrors: false,
+ showInlineWarningsAndErrors: false,
+ hideConsoleLogsInStrictMode: false,
+ browserTheme: "dark"
+ };
+ function patch(_ref) {
+ var appendComponentStack = _ref.appendComponentStack, breakOnConsoleErrors = _ref.breakOnConsoleErrors, showInlineWarningsAndErrors = _ref.showInlineWarningsAndErrors, hideConsoleLogsInStrictMode = _ref.hideConsoleLogsInStrictMode, browserTheme = _ref.browserTheme;
+ consoleSettingsRef.appendComponentStack = appendComponentStack;
+ consoleSettingsRef.breakOnConsoleErrors = breakOnConsoleErrors;
+ consoleSettingsRef.showInlineWarningsAndErrors = showInlineWarningsAndErrors;
+ consoleSettingsRef.hideConsoleLogsInStrictMode = hideConsoleLogsInStrictMode;
+ consoleSettingsRef.browserTheme = browserTheme;
+ if (appendComponentStack || breakOnConsoleErrors || showInlineWarningsAndErrors) {
+ if (unpatchFn !== null) {
+ return;
+ }
+ var originalConsoleMethods = {};
+ unpatchFn = /* @__PURE__ */ __name(function unpatchFn2() {
+ for (var _method2 in originalConsoleMethods) {
+ try {
+ targetConsole[_method2] = originalConsoleMethods[_method2];
+ } catch (error) {
+ }
+ }
+ }, "unpatchFn");
+ OVERRIDE_CONSOLE_METHODS.forEach(function(method2) {
+ try {
+ var originalMethod = originalConsoleMethods[method2] = targetConsole[method2].__REACT_DEVTOOLS_ORIGINAL_METHOD__ ? targetConsole[method2].__REACT_DEVTOOLS_ORIGINAL_METHOD__ : targetConsole[method2];
+ var overrideMethod = /* @__PURE__ */ __name(function overrideMethod2() {
+ var shouldAppendWarningStack = false;
+ for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+ args[_key] = arguments[_key];
+ }
+ if (method2 !== "log") {
+ if (consoleSettingsRef.appendComponentStack) {
+ var lastArg = args.length > 0 ? args[args.length - 1] : null;
+ var alreadyHasComponentStack = typeof lastArg === "string" && isStringComponentStack(lastArg);
+ shouldAppendWarningStack = !alreadyHasComponentStack;
+ }
+ }
+ var shouldShowInlineWarningsAndErrors = consoleSettingsRef.showInlineWarningsAndErrors && (method2 === "error" || method2 === "warn");
+ var _iterator = _createForOfIteratorHelper(injectedRenderers.values()), _step;
+ try {
+ for (_iterator.s(); !(_step = _iterator.n()).done; ) {
+ var _step$value = _step.value, currentDispatcherRef = _step$value.currentDispatcherRef, getCurrentFiber = _step$value.getCurrentFiber, onErrorOrWarning = _step$value.onErrorOrWarning, workTagMap = _step$value.workTagMap;
+ var current = getCurrentFiber();
+ if (current != null) {
+ try {
+ if (shouldShowInlineWarningsAndErrors) {
+ if (typeof onErrorOrWarning === "function") {
+ onErrorOrWarning(
+ current,
+ method2,
+ // Copy args before we mutate them (e.g. adding the component stack)
+ args.slice()
+ );
+ }
+ }
+ if (shouldAppendWarningStack) {
+ var componentStack = Object(_DevToolsFiberComponentStack__WEBPACK_IMPORTED_MODULE_2__[
+ /* getStackByFiberInDevAndProd */
+ "a"
+ ])(workTagMap, current, currentDispatcherRef);
+ if (componentStack !== "") {
+ if (isStrictModeOverride(args, method2)) {
+ args[0] = Object(_utils__WEBPACK_IMPORTED_MODULE_0__[
+ /* format */
+ "f"
+ ])(args[0], componentStack);
+ } else {
+ args.push(componentStack);
+ }
+ }
+ }
+ } catch (error) {
+ setTimeout(function() {
+ throw error;
+ }, 0);
+ } finally {
+ break;
+ }
+ }
+ }
+ } catch (err) {
+ _iterator.e(err);
+ } finally {
+ _iterator.f();
+ }
+ if (consoleSettingsRef.breakOnConsoleErrors) {
+ debugger;
+ }
+ originalMethod.apply(void 0, args);
+ }, "overrideMethod");
+ overrideMethod.__REACT_DEVTOOLS_ORIGINAL_METHOD__ = originalMethod;
+ originalMethod.__REACT_DEVTOOLS_OVERRIDE_METHOD__ = overrideMethod;
+ targetConsole[method2] = overrideMethod;
+ } catch (error) {
+ }
+ });
+ } else {
+ unpatch();
+ }
+ }
+ __name(patch, "patch");
+ function unpatch() {
+ if (unpatchFn !== null) {
+ unpatchFn();
+ unpatchFn = null;
+ }
+ }
+ __name(unpatch, "unpatch");
+ var unpatchForStrictModeFn = null;
+ function patchForStrictMode() {
+ if (react_devtools_feature_flags__WEBPACK_IMPORTED_MODULE_3__[
+ /* consoleManagedByDevToolsDuringStrictMode */
+ "a"
+ ]) {
+ var overrideConsoleMethods = ["error", "trace", "warn", "log"];
+ if (unpatchForStrictModeFn !== null) {
+ return;
+ }
+ var originalConsoleMethods = {};
+ unpatchForStrictModeFn = /* @__PURE__ */ __name(function unpatchForStrictModeFn2() {
+ for (var _method3 in originalConsoleMethods) {
+ try {
+ targetConsole[_method3] = originalConsoleMethods[_method3];
+ } catch (error) {
+ }
+ }
+ }, "unpatchForStrictModeFn");
+ overrideConsoleMethods.forEach(function(method2) {
+ try {
+ var originalMethod = originalConsoleMethods[method2] = targetConsole[method2].__REACT_DEVTOOLS_STRICT_MODE_ORIGINAL_METHOD__ ? targetConsole[method2].__REACT_DEVTOOLS_STRICT_MODE_ORIGINAL_METHOD__ : targetConsole[method2];
+ var overrideMethod = /* @__PURE__ */ __name(function overrideMethod2() {
+ if (!consoleSettingsRef.hideConsoleLogsInStrictMode) {
+ if (isNode) {
+ originalMethod(DIMMED_NODE_CONSOLE_COLOR, _utils__WEBPACK_IMPORTED_MODULE_0__[
+ /* format */
+ "f"
+ ].apply(void 0, arguments));
+ } else {
+ var color = getConsoleColor(method2);
+ if (color) {
+ originalMethod("%c".concat(_utils__WEBPACK_IMPORTED_MODULE_0__[
+ /* format */
+ "f"
+ ].apply(void 0, arguments)), "color: ".concat(color));
+ } else {
+ throw Error("Console color is not defined");
+ }
+ }
+ }
+ }, "overrideMethod");
+ overrideMethod.__REACT_DEVTOOLS_STRICT_MODE_ORIGINAL_METHOD__ = originalMethod;
+ originalMethod.__REACT_DEVTOOLS_STRICT_MODE_OVERRIDE_METHOD__ = overrideMethod;
+ targetConsole[method2] = overrideMethod;
+ } catch (error) {
+ }
+ });
+ }
+ }
+ __name(patchForStrictMode, "patchForStrictMode");
+ function unpatchForStrictMode() {
+ if (react_devtools_feature_flags__WEBPACK_IMPORTED_MODULE_3__[
+ /* consoleManagedByDevToolsDuringStrictMode */
+ "a"
+ ]) {
+ if (unpatchForStrictModeFn !== null) {
+ unpatchForStrictModeFn();
+ unpatchForStrictModeFn = null;
+ }
+ }
+ }
+ __name(unpatchForStrictMode, "unpatchForStrictMode");
+ }).call(this, __webpack_require__(14));
+ },
+ /* 11 */
+ /***/
+ function(module3, exports3, __webpack_require__) {
+ (function(process8) {
+ function _typeof7(obj) {
+ "@babel/helpers - typeof";
+ if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+ _typeof7 = /* @__PURE__ */ __name(function _typeof8(obj2) {
+ return typeof obj2;
+ }, "_typeof");
+ } else {
+ _typeof7 = /* @__PURE__ */ __name(function _typeof8(obj2) {
+ return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+ }, "_typeof");
+ }
+ return _typeof7(obj);
+ }
+ __name(_typeof7, "_typeof");
+ exports3 = module3.exports = SemVer;
+ var debug;
+ if ((typeof process8 === "undefined" ? "undefined" : _typeof7(process8)) === "object" && process8.env && process8.env.NODE_DEBUG && /\bsemver\b/i.test(process8.env.NODE_DEBUG)) {
+ debug = /* @__PURE__ */ __name(function debug2() {
+ var args = Array.prototype.slice.call(arguments, 0);
+ args.unshift("SEMVER");
+ console.log.apply(console, args);
+ }, "debug");
+ } else {
+ debug = /* @__PURE__ */ __name(function debug2() {
+ }, "debug");
+ }
+ exports3.SEMVER_SPEC_VERSION = "2.0.0";
+ var MAX_LENGTH = 256;
+ var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || /* istanbul ignore next */
+ 9007199254740991;
+ var MAX_SAFE_COMPONENT_LENGTH = 16;
+ var re = exports3.re = [];
+ var src = exports3.src = [];
+ var t2 = exports3.tokens = {};
+ var R = 0;
+ function tok(n) {
+ t2[n] = R++;
+ }
+ __name(tok, "tok");
+ tok("NUMERICIDENTIFIER");
+ src[t2.NUMERICIDENTIFIER] = "0|[1-9]\\d*";
+ tok("NUMERICIDENTIFIERLOOSE");
+ src[t2.NUMERICIDENTIFIERLOOSE] = "[0-9]+";
+ tok("NONNUMERICIDENTIFIER");
+ src[t2.NONNUMERICIDENTIFIER] = "\\d*[a-zA-Z-][a-zA-Z0-9-]*";
+ tok("MAINVERSION");
+ src[t2.MAINVERSION] = "(" + src[t2.NUMERICIDENTIFIER] + ")\\.(" + src[t2.NUMERICIDENTIFIER] + ")\\.(" + src[t2.NUMERICIDENTIFIER] + ")";
+ tok("MAINVERSIONLOOSE");
+ src[t2.MAINVERSIONLOOSE] = "(" + src[t2.NUMERICIDENTIFIERLOOSE] + ")\\.(" + src[t2.NUMERICIDENTIFIERLOOSE] + ")\\.(" + src[t2.NUMERICIDENTIFIERLOOSE] + ")";
+ tok("PRERELEASEIDENTIFIER");
+ src[t2.PRERELEASEIDENTIFIER] = "(?:" + src[t2.NUMERICIDENTIFIER] + "|" + src[t2.NONNUMERICIDENTIFIER] + ")";
+ tok("PRERELEASEIDENTIFIERLOOSE");
+ src[t2.PRERELEASEIDENTIFIERLOOSE] = "(?:" + src[t2.NUMERICIDENTIFIERLOOSE] + "|" + src[t2.NONNUMERICIDENTIFIER] + ")";
+ tok("PRERELEASE");
+ src[t2.PRERELEASE] = "(?:-(" + src[t2.PRERELEASEIDENTIFIER] + "(?:\\." + src[t2.PRERELEASEIDENTIFIER] + ")*))";
+ tok("PRERELEASELOOSE");
+ src[t2.PRERELEASELOOSE] = "(?:-?(" + src[t2.PRERELEASEIDENTIFIERLOOSE] + "(?:\\." + src[t2.PRERELEASEIDENTIFIERLOOSE] + ")*))";
+ tok("BUILDIDENTIFIER");
+ src[t2.BUILDIDENTIFIER] = "[0-9A-Za-z-]+";
+ tok("BUILD");
+ src[t2.BUILD] = "(?:\\+(" + src[t2.BUILDIDENTIFIER] + "(?:\\." + src[t2.BUILDIDENTIFIER] + ")*))";
+ tok("FULL");
+ tok("FULLPLAIN");
+ src[t2.FULLPLAIN] = "v?" + src[t2.MAINVERSION] + src[t2.PRERELEASE] + "?" + src[t2.BUILD] + "?";
+ src[t2.FULL] = "^" + src[t2.FULLPLAIN] + "$";
+ tok("LOOSEPLAIN");
+ src[t2.LOOSEPLAIN] = "[v=\\s]*" + src[t2.MAINVERSIONLOOSE] + src[t2.PRERELEASELOOSE] + "?" + src[t2.BUILD] + "?";
+ tok("LOOSE");
+ src[t2.LOOSE] = "^" + src[t2.LOOSEPLAIN] + "$";
+ tok("GTLT");
+ src[t2.GTLT] = "((?:<|>)?=?)";
+ tok("XRANGEIDENTIFIERLOOSE");
+ src[t2.XRANGEIDENTIFIERLOOSE] = src[t2.NUMERICIDENTIFIERLOOSE] + "|x|X|\\*";
+ tok("XRANGEIDENTIFIER");
+ src[t2.XRANGEIDENTIFIER] = src[t2.NUMERICIDENTIFIER] + "|x|X|\\*";
+ tok("XRANGEPLAIN");
+ src[t2.XRANGEPLAIN] = "[v=\\s]*(" + src[t2.XRANGEIDENTIFIER] + ")(?:\\.(" + src[t2.XRANGEIDENTIFIER] + ")(?:\\.(" + src[t2.XRANGEIDENTIFIER] + ")(?:" + src[t2.PRERELEASE] + ")?" + src[t2.BUILD] + "?)?)?";
+ tok("XRANGEPLAINLOOSE");
+ src[t2.XRANGEPLAINLOOSE] = "[v=\\s]*(" + src[t2.XRANGEIDENTIFIERLOOSE] + ")(?:\\.(" + src[t2.XRANGEIDENTIFIERLOOSE] + ")(?:\\.(" + src[t2.XRANGEIDENTIFIERLOOSE] + ")(?:" + src[t2.PRERELEASELOOSE] + ")?" + src[t2.BUILD] + "?)?)?";
+ tok("XRANGE");
+ src[t2.XRANGE] = "^" + src[t2.GTLT] + "\\s*" + src[t2.XRANGEPLAIN] + "$";
+ tok("XRANGELOOSE");
+ src[t2.XRANGELOOSE] = "^" + src[t2.GTLT] + "\\s*" + src[t2.XRANGEPLAINLOOSE] + "$";
+ tok("COERCE");
+ src[t2.COERCE] = "(^|[^\\d])(\\d{1," + MAX_SAFE_COMPONENT_LENGTH + "})(?:\\.(\\d{1," + MAX_SAFE_COMPONENT_LENGTH + "}))?(?:\\.(\\d{1," + MAX_SAFE_COMPONENT_LENGTH + "}))?(?:$|[^\\d])";
+ tok("COERCERTL");
+ re[t2.COERCERTL] = new RegExp(src[t2.COERCE], "g");
+ tok("LONETILDE");
+ src[t2.LONETILDE] = "(?:~>?)";
+ tok("TILDETRIM");
+ src[t2.TILDETRIM] = "(\\s*)" + src[t2.LONETILDE] + "\\s+";
+ re[t2.TILDETRIM] = new RegExp(src[t2.TILDETRIM], "g");
+ var tildeTrimReplace = "$1~";
+ tok("TILDE");
+ src[t2.TILDE] = "^" + src[t2.LONETILDE] + src[t2.XRANGEPLAIN] + "$";
+ tok("TILDELOOSE");
+ src[t2.TILDELOOSE] = "^" + src[t2.LONETILDE] + src[t2.XRANGEPLAINLOOSE] + "$";
+ tok("LONECARET");
+ src[t2.LONECARET] = "(?:\\^)";
+ tok("CARETTRIM");
+ src[t2.CARETTRIM] = "(\\s*)" + src[t2.LONECARET] + "\\s+";
+ re[t2.CARETTRIM] = new RegExp(src[t2.CARETTRIM], "g");
+ var caretTrimReplace = "$1^";
+ tok("CARET");
+ src[t2.CARET] = "^" + src[t2.LONECARET] + src[t2.XRANGEPLAIN] + "$";
+ tok("CARETLOOSE");
+ src[t2.CARETLOOSE] = "^" + src[t2.LONECARET] + src[t2.XRANGEPLAINLOOSE] + "$";
+ tok("COMPARATORLOOSE");
+ src[t2.COMPARATORLOOSE] = "^" + src[t2.GTLT] + "\\s*(" + src[t2.LOOSEPLAIN] + ")$|^$";
+ tok("COMPARATOR");
+ src[t2.COMPARATOR] = "^" + src[t2.GTLT] + "\\s*(" + src[t2.FULLPLAIN] + ")$|^$";
+ tok("COMPARATORTRIM");
+ src[t2.COMPARATORTRIM] = "(\\s*)" + src[t2.GTLT] + "\\s*(" + src[t2.LOOSEPLAIN] + "|" + src[t2.XRANGEPLAIN] + ")";
+ re[t2.COMPARATORTRIM] = new RegExp(src[t2.COMPARATORTRIM], "g");
+ var comparatorTrimReplace = "$1$2$3";
+ tok("HYPHENRANGE");
+ src[t2.HYPHENRANGE] = "^\\s*(" + src[t2.XRANGEPLAIN] + ")\\s+-\\s+(" + src[t2.XRANGEPLAIN] + ")\\s*$";
+ tok("HYPHENRANGELOOSE");
+ src[t2.HYPHENRANGELOOSE] = "^\\s*(" + src[t2.XRANGEPLAINLOOSE] + ")\\s+-\\s+(" + src[t2.XRANGEPLAINLOOSE] + ")\\s*$";
+ tok("STAR");
+ src[t2.STAR] = "(<|>)?=?\\s*\\*";
+ for (var i = 0; i < R; i++) {
+ debug(i, src[i]);
+ if (!re[i]) {
+ re[i] = new RegExp(src[i]);
+ }
+ }
+ exports3.parse = parse4;
+ function parse4(version2, options14) {
+ if (!options14 || _typeof7(options14) !== "object") {
+ options14 = {
+ loose: !!options14,
+ includePrerelease: false
+ };
+ }
+ if (version2 instanceof SemVer) {
+ return version2;
+ }
+ if (typeof version2 !== "string") {
+ return null;
+ }
+ if (version2.length > MAX_LENGTH) {
+ return null;
+ }
+ var r = options14.loose ? re[t2.LOOSE] : re[t2.FULL];
+ if (!r.test(version2)) {
+ return null;
+ }
+ try {
+ return new SemVer(version2, options14);
+ } catch (er) {
+ return null;
+ }
+ }
+ __name(parse4, "parse");
+ exports3.valid = valid;
+ function valid(version2, options14) {
+ var v = parse4(version2, options14);
+ return v ? v.version : null;
+ }
+ __name(valid, "valid");
+ exports3.clean = clean;
+ function clean(version2, options14) {
+ var s = parse4(version2.trim().replace(/^[=v]+/, ""), options14);
+ return s ? s.version : null;
+ }
+ __name(clean, "clean");
+ exports3.SemVer = SemVer;
+ function SemVer(version2, options14) {
+ if (!options14 || _typeof7(options14) !== "object") {
+ options14 = {
+ loose: !!options14,
+ includePrerelease: false
+ };
+ }
+ if (version2 instanceof SemVer) {
+ if (version2.loose === options14.loose) {
+ return version2;
+ } else {
+ version2 = version2.version;
+ }
+ } else if (typeof version2 !== "string") {
+ throw new TypeError("Invalid Version: " + version2);
+ }
+ if (version2.length > MAX_LENGTH) {
+ throw new TypeError("version is longer than " + MAX_LENGTH + " characters");
+ }
+ if (!(this instanceof SemVer)) {
+ return new SemVer(version2, options14);
+ }
+ debug("SemVer", version2, options14);
+ this.options = options14;
+ this.loose = !!options14.loose;
+ var m = version2.trim().match(options14.loose ? re[t2.LOOSE] : re[t2.FULL]);
+ if (!m) {
+ throw new TypeError("Invalid Version: " + version2);
+ }
+ this.raw = version2;
+ this.major = +m[1];
+ this.minor = +m[2];
+ this.patch = +m[3];
+ if (this.major > MAX_SAFE_INTEGER || this.major < 0) {
+ throw new TypeError("Invalid major version");
+ }
+ if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) {
+ throw new TypeError("Invalid minor version");
+ }
+ if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) {
+ throw new TypeError("Invalid patch version");
+ }
+ if (!m[4]) {
+ this.prerelease = [];
+ } else {
+ this.prerelease = m[4].split(".").map(function(id) {
+ if (/^[0-9]+$/.test(id)) {
+ var num = +id;
+ if (num >= 0 && num < MAX_SAFE_INTEGER) {
+ return num;
+ }
+ }
+ return id;
+ });
+ }
+ this.build = m[5] ? m[5].split(".") : [];
+ this.format();
+ }
+ __name(SemVer, "SemVer");
+ SemVer.prototype.format = function() {
+ this.version = this.major + "." + this.minor + "." + this.patch;
+ if (this.prerelease.length) {
+ this.version += "-" + this.prerelease.join(".");
+ }
+ return this.version;
+ };
+ SemVer.prototype.toString = function() {
+ return this.version;
+ };
+ SemVer.prototype.compare = function(other) {
+ debug("SemVer.compare", this.version, this.options, other);
+ if (!(other instanceof SemVer)) {
+ other = new SemVer(other, this.options);
+ }
+ return this.compareMain(other) || this.comparePre(other);
+ };
+ SemVer.prototype.compareMain = function(other) {
+ if (!(other instanceof SemVer)) {
+ other = new SemVer(other, this.options);
+ }
+ return compareIdentifiers(this.major, other.major) || compareIdentifiers(this.minor, other.minor) || compareIdentifiers(this.patch, other.patch);
+ };
+ SemVer.prototype.comparePre = function(other) {
+ if (!(other instanceof SemVer)) {
+ other = new SemVer(other, this.options);
+ }
+ if (this.prerelease.length && !other.prerelease.length) {
+ return -1;
+ } else if (!this.prerelease.length && other.prerelease.length) {
+ return 1;
+ } else if (!this.prerelease.length && !other.prerelease.length) {
+ return 0;
+ }
+ var i2 = 0;
+ do {
+ var a = this.prerelease[i2];
+ var b = other.prerelease[i2];
+ debug("prerelease compare", i2, a, b);
+ if (a === void 0 && b === void 0) {
+ return 0;
+ } else if (b === void 0) {
+ return 1;
+ } else if (a === void 0) {
+ return -1;
+ } else if (a === b) {
+ continue;
+ } else {
+ return compareIdentifiers(a, b);
+ }
+ } while (++i2);
+ };
+ SemVer.prototype.compareBuild = function(other) {
+ if (!(other instanceof SemVer)) {
+ other = new SemVer(other, this.options);
+ }
+ var i2 = 0;
+ do {
+ var a = this.build[i2];
+ var b = other.build[i2];
+ debug("prerelease compare", i2, a, b);
+ if (a === void 0 && b === void 0) {
+ return 0;
+ } else if (b === void 0) {
+ return 1;
+ } else if (a === void 0) {
+ return -1;
+ } else if (a === b) {
+ continue;
+ } else {
+ return compareIdentifiers(a, b);
+ }
+ } while (++i2);
+ };
+ SemVer.prototype.inc = function(release, identifier) {
+ switch (release) {
+ case "premajor":
+ this.prerelease.length = 0;
+ this.patch = 0;
+ this.minor = 0;
+ this.major++;
+ this.inc("pre", identifier);
+ break;
+ case "preminor":
+ this.prerelease.length = 0;
+ this.patch = 0;
+ this.minor++;
+ this.inc("pre", identifier);
+ break;
+ case "prepatch":
+ this.prerelease.length = 0;
+ this.inc("patch", identifier);
+ this.inc("pre", identifier);
+ break;
+ case "prerelease":
+ if (this.prerelease.length === 0) {
+ this.inc("patch", identifier);
+ }
+ this.inc("pre", identifier);
+ break;
+ case "major":
+ if (this.minor !== 0 || this.patch !== 0 || this.prerelease.length === 0) {
+ this.major++;
+ }
+ this.minor = 0;
+ this.patch = 0;
+ this.prerelease = [];
+ break;
+ case "minor":
+ if (this.patch !== 0 || this.prerelease.length === 0) {
+ this.minor++;
+ }
+ this.patch = 0;
+ this.prerelease = [];
+ break;
+ case "patch":
+ if (this.prerelease.length === 0) {
+ this.patch++;
+ }
+ this.prerelease = [];
+ break;
+ case "pre":
+ if (this.prerelease.length === 0) {
+ this.prerelease = [0];
+ } else {
+ var i2 = this.prerelease.length;
+ while (--i2 >= 0) {
+ if (typeof this.prerelease[i2] === "number") {
+ this.prerelease[i2]++;
+ i2 = -2;
+ }
+ }
+ if (i2 === -1) {
+ this.prerelease.push(0);
+ }
+ }
+ if (identifier) {
+ if (this.prerelease[0] === identifier) {
+ if (isNaN(this.prerelease[1])) {
+ this.prerelease = [identifier, 0];
+ }
+ } else {
+ this.prerelease = [identifier, 0];
+ }
+ }
+ break;
+ default:
+ throw new Error("invalid increment argument: " + release);
+ }
+ this.format();
+ this.raw = this.version;
+ return this;
+ };
+ exports3.inc = inc;
+ function inc(version2, release, loose, identifier) {
+ if (typeof loose === "string") {
+ identifier = loose;
+ loose = void 0;
+ }
+ try {
+ return new SemVer(version2, loose).inc(release, identifier).version;
+ } catch (er) {
+ return null;
+ }
+ }
+ __name(inc, "inc");
+ exports3.diff = diff;
+ function diff(version1, version2) {
+ if (eq(version1, version2)) {
+ return null;
+ } else {
+ var v1 = parse4(version1);
+ var v2 = parse4(version2);
+ var prefix = "";
+ if (v1.prerelease.length || v2.prerelease.length) {
+ prefix = "pre";
+ var defaultResult = "prerelease";
+ }
+ for (var key in v1) {
+ if (key === "major" || key === "minor" || key === "patch") {
+ if (v1[key] !== v2[key]) {
+ return prefix + key;
+ }
+ }
+ }
+ return defaultResult;
+ }
+ }
+ __name(diff, "diff");
+ exports3.compareIdentifiers = compareIdentifiers;
+ var numeric = /^[0-9]+$/;
+ function compareIdentifiers(a, b) {
+ var anum = numeric.test(a);
+ var bnum = numeric.test(b);
+ if (anum && bnum) {
+ a = +a;
+ b = +b;
+ }
+ return a === b ? 0 : anum && !bnum ? -1 : bnum && !anum ? 1 : a < b ? -1 : 1;
+ }
+ __name(compareIdentifiers, "compareIdentifiers");
+ exports3.rcompareIdentifiers = rcompareIdentifiers;
+ function rcompareIdentifiers(a, b) {
+ return compareIdentifiers(b, a);
+ }
+ __name(rcompareIdentifiers, "rcompareIdentifiers");
+ exports3.major = major;
+ function major(a, loose) {
+ return new SemVer(a, loose).major;
+ }
+ __name(major, "major");
+ exports3.minor = minor;
+ function minor(a, loose) {
+ return new SemVer(a, loose).minor;
+ }
+ __name(minor, "minor");
+ exports3.patch = patch;
+ function patch(a, loose) {
+ return new SemVer(a, loose).patch;
+ }
+ __name(patch, "patch");
+ exports3.compare = compare;
+ function compare(a, b, loose) {
+ return new SemVer(a, loose).compare(new SemVer(b, loose));
+ }
+ __name(compare, "compare");
+ exports3.compareLoose = compareLoose;
+ function compareLoose(a, b) {
+ return compare(a, b, true);
+ }
+ __name(compareLoose, "compareLoose");
+ exports3.compareBuild = compareBuild;
+ function compareBuild(a, b, loose) {
+ var versionA = new SemVer(a, loose);
+ var versionB = new SemVer(b, loose);
+ return versionA.compare(versionB) || versionA.compareBuild(versionB);
+ }
+ __name(compareBuild, "compareBuild");
+ exports3.rcompare = rcompare;
+ function rcompare(a, b, loose) {
+ return compare(b, a, loose);
+ }
+ __name(rcompare, "rcompare");
+ exports3.sort = sort;
+ function sort(list, loose) {
+ return list.sort(function(a, b) {
+ return exports3.compareBuild(a, b, loose);
+ });
+ }
+ __name(sort, "sort");
+ exports3.rsort = rsort;
+ function rsort(list, loose) {
+ return list.sort(function(a, b) {
+ return exports3.compareBuild(b, a, loose);
+ });
+ }
+ __name(rsort, "rsort");
+ exports3.gt = gt;
+ function gt(a, b, loose) {
+ return compare(a, b, loose) > 0;
+ }
+ __name(gt, "gt");
+ exports3.lt = lt2;
+ function lt2(a, b, loose) {
+ return compare(a, b, loose) < 0;
+ }
+ __name(lt2, "lt");
+ exports3.eq = eq;
+ function eq(a, b, loose) {
+ return compare(a, b, loose) === 0;
+ }
+ __name(eq, "eq");
+ exports3.neq = neq;
+ function neq(a, b, loose) {
+ return compare(a, b, loose) !== 0;
+ }
+ __name(neq, "neq");
+ exports3.gte = gte;
+ function gte(a, b, loose) {
+ return compare(a, b, loose) >= 0;
+ }
+ __name(gte, "gte");
+ exports3.lte = lte;
+ function lte(a, b, loose) {
+ return compare(a, b, loose) <= 0;
+ }
+ __name(lte, "lte");
+ exports3.cmp = cmp;
+ function cmp(a, op, b, loose) {
+ switch (op) {
+ case "===":
+ if (_typeof7(a) === "object")
+ a = a.version;
+ if (_typeof7(b) === "object")
+ b = b.version;
+ return a === b;
+ case "!==":
+ if (_typeof7(a) === "object")
+ a = a.version;
+ if (_typeof7(b) === "object")
+ b = b.version;
+ return a !== b;
+ case "":
+ case "=":
+ case "==":
+ return eq(a, b, loose);
+ case "!=":
+ return neq(a, b, loose);
+ case ">":
+ return gt(a, b, loose);
+ case ">=":
+ return gte(a, b, loose);
+ case "<":
+ return lt2(a, b, loose);
+ case "<=":
+ return lte(a, b, loose);
+ default:
+ throw new TypeError("Invalid operator: " + op);
+ }
+ }
+ __name(cmp, "cmp");
+ exports3.Comparator = Comparator;
+ function Comparator(comp, options14) {
+ if (!options14 || _typeof7(options14) !== "object") {
+ options14 = {
+ loose: !!options14,
+ includePrerelease: false
+ };
+ }
+ if (comp instanceof Comparator) {
+ if (comp.loose === !!options14.loose) {
+ return comp;
+ } else {
+ comp = comp.value;
+ }
+ }
+ if (!(this instanceof Comparator)) {
+ return new Comparator(comp, options14);
+ }
+ debug("comparator", comp, options14);
+ this.options = options14;
+ this.loose = !!options14.loose;
+ this.parse(comp);
+ if (this.semver === ANY) {
+ this.value = "";
+ } else {
+ this.value = this.operator + this.semver.version;
+ }
+ debug("comp", this);
+ }
+ __name(Comparator, "Comparator");
+ var ANY = {};
+ Comparator.prototype.parse = function(comp) {
+ var r = this.options.loose ? re[t2.COMPARATORLOOSE] : re[t2.COMPARATOR];
+ var m = comp.match(r);
+ if (!m) {
+ throw new TypeError("Invalid comparator: " + comp);
+ }
+ this.operator = m[1] !== void 0 ? m[1] : "";
+ if (this.operator === "=") {
+ this.operator = "";
+ }
+ if (!m[2]) {
+ this.semver = ANY;
+ } else {
+ this.semver = new SemVer(m[2], this.options.loose);
+ }
+ };
+ Comparator.prototype.toString = function() {
+ return this.value;
+ };
+ Comparator.prototype.test = function(version2) {
+ debug("Comparator.test", version2, this.options.loose);
+ if (this.semver === ANY || version2 === ANY) {
+ return true;
+ }
+ if (typeof version2 === "string") {
+ try {
+ version2 = new SemVer(version2, this.options);
+ } catch (er) {
+ return false;
+ }
+ }
+ return cmp(version2, this.operator, this.semver, this.options);
+ };
+ Comparator.prototype.intersects = function(comp, options14) {
+ if (!(comp instanceof Comparator)) {
+ throw new TypeError("a Comparator is required");
+ }
+ if (!options14 || _typeof7(options14) !== "object") {
+ options14 = {
+ loose: !!options14,
+ includePrerelease: false
+ };
+ }
+ var rangeTmp;
+ if (this.operator === "") {
+ if (this.value === "") {
+ return true;
+ }
+ rangeTmp = new Range(comp.value, options14);
+ return satisfies(this.value, rangeTmp, options14);
+ } else if (comp.operator === "") {
+ if (comp.value === "") {
+ return true;
+ }
+ rangeTmp = new Range(this.value, options14);
+ return satisfies(comp.semver, rangeTmp, options14);
+ }
+ var sameDirectionIncreasing = (this.operator === ">=" || this.operator === ">") && (comp.operator === ">=" || comp.operator === ">");
+ var sameDirectionDecreasing = (this.operator === "<=" || this.operator === "<") && (comp.operator === "<=" || comp.operator === "<");
+ var sameSemVer = this.semver.version === comp.semver.version;
+ var differentDirectionsInclusive = (this.operator === ">=" || this.operator === "<=") && (comp.operator === ">=" || comp.operator === "<=");
+ var oppositeDirectionsLessThan = cmp(this.semver, "<", comp.semver, options14) && (this.operator === ">=" || this.operator === ">") && (comp.operator === "<=" || comp.operator === "<");
+ var oppositeDirectionsGreaterThan = cmp(this.semver, ">", comp.semver, options14) && (this.operator === "<=" || this.operator === "<") && (comp.operator === ">=" || comp.operator === ">");
+ return sameDirectionIncreasing || sameDirectionDecreasing || sameSemVer && differentDirectionsInclusive || oppositeDirectionsLessThan || oppositeDirectionsGreaterThan;
+ };
+ exports3.Range = Range;
+ function Range(range, options14) {
+ if (!options14 || _typeof7(options14) !== "object") {
+ options14 = {
+ loose: !!options14,
+ includePrerelease: false
+ };
+ }
+ if (range instanceof Range) {
+ if (range.loose === !!options14.loose && range.includePrerelease === !!options14.includePrerelease) {
+ return range;
+ } else {
+ return new Range(range.raw, options14);
+ }
+ }
+ if (range instanceof Comparator) {
+ return new Range(range.value, options14);
+ }
+ if (!(this instanceof Range)) {
+ return new Range(range, options14);
+ }
+ this.options = options14;
+ this.loose = !!options14.loose;
+ this.includePrerelease = !!options14.includePrerelease;
+ this.raw = range;
+ this.set = range.split(/\s*\|\|\s*/).map(function(range2) {
+ return this.parseRange(range2.trim());
+ }, this).filter(function(c) {
+ return c.length;
+ });
+ if (!this.set.length) {
+ throw new TypeError("Invalid SemVer Range: " + range);
+ }
+ this.format();
+ }
+ __name(Range, "Range");
+ Range.prototype.format = function() {
+ this.range = this.set.map(function(comps) {
+ return comps.join(" ").trim();
+ }).join("||").trim();
+ return this.range;
+ };
+ Range.prototype.toString = function() {
+ return this.range;
+ };
+ Range.prototype.parseRange = function(range) {
+ var loose = this.options.loose;
+ range = range.trim();
+ var hr = loose ? re[t2.HYPHENRANGELOOSE] : re[t2.HYPHENRANGE];
+ range = range.replace(hr, hyphenReplace);
+ debug("hyphen replace", range);
+ range = range.replace(re[t2.COMPARATORTRIM], comparatorTrimReplace);
+ debug("comparator trim", range, re[t2.COMPARATORTRIM]);
+ range = range.replace(re[t2.TILDETRIM], tildeTrimReplace);
+ range = range.replace(re[t2.CARETTRIM], caretTrimReplace);
+ range = range.split(/\s+/).join(" ");
+ var compRe = loose ? re[t2.COMPARATORLOOSE] : re[t2.COMPARATOR];
+ var set = range.split(" ").map(function(comp) {
+ return parseComparator(comp, this.options);
+ }, this).join(" ").split(/\s+/);
+ if (this.options.loose) {
+ set = set.filter(function(comp) {
+ return !!comp.match(compRe);
+ });
+ }
+ set = set.map(function(comp) {
+ return new Comparator(comp, this.options);
+ }, this);
+ return set;
+ };
+ Range.prototype.intersects = function(range, options14) {
+ if (!(range instanceof Range)) {
+ throw new TypeError("a Range is required");
+ }
+ return this.set.some(function(thisComparators) {
+ return isSatisfiable(thisComparators, options14) && range.set.some(function(rangeComparators) {
+ return isSatisfiable(rangeComparators, options14) && thisComparators.every(function(thisComparator) {
+ return rangeComparators.every(function(rangeComparator) {
+ return thisComparator.intersects(rangeComparator, options14);
+ });
+ });
+ });
+ });
+ };
+ function isSatisfiable(comparators, options14) {
+ var result = true;
+ var remainingComparators = comparators.slice();
+ var testComparator = remainingComparators.pop();
+ while (result && remainingComparators.length) {
+ result = remainingComparators.every(function(otherComparator) {
+ return testComparator.intersects(otherComparator, options14);
+ });
+ testComparator = remainingComparators.pop();
+ }
+ return result;
+ }
+ __name(isSatisfiable, "isSatisfiable");
+ exports3.toComparators = toComparators;
+ function toComparators(range, options14) {
+ return new Range(range, options14).set.map(function(comp) {
+ return comp.map(function(c) {
+ return c.value;
+ }).join(" ").trim().split(" ");
+ });
+ }
+ __name(toComparators, "toComparators");
+ function parseComparator(comp, options14) {
+ debug("comp", comp, options14);
+ comp = replaceCarets(comp, options14);
+ debug("caret", comp);
+ comp = replaceTildes(comp, options14);
+ debug("tildes", comp);
+ comp = replaceXRanges(comp, options14);
+ debug("xrange", comp);
+ comp = replaceStars(comp, options14);
+ debug("stars", comp);
+ return comp;
+ }
+ __name(parseComparator, "parseComparator");
+ function isX(id) {
+ return !id || id.toLowerCase() === "x" || id === "*";
+ }
+ __name(isX, "isX");
+ function replaceTildes(comp, options14) {
+ return comp.trim().split(/\s+/).map(function(comp2) {
+ return replaceTilde(comp2, options14);
+ }).join(" ");
+ }
+ __name(replaceTildes, "replaceTildes");
+ function replaceTilde(comp, options14) {
+ var r = options14.loose ? re[t2.TILDELOOSE] : re[t2.TILDE];
+ return comp.replace(r, function(_2, M, m, p, pr) {
+ debug("tilde", comp, _2, M, m, p, pr);
+ var ret;
+ if (isX(M)) {
+ ret = "";
+ } else if (isX(m)) {
+ ret = ">=" + M + ".0.0 <" + (+M + 1) + ".0.0";
+ } else if (isX(p)) {
+ ret = ">=" + M + "." + m + ".0 <" + M + "." + (+m + 1) + ".0";
+ } else if (pr) {
+ debug("replaceTilde pr", pr);
+ ret = ">=" + M + "." + m + "." + p + "-" + pr + " <" + M + "." + (+m + 1) + ".0";
+ } else {
+ ret = ">=" + M + "." + m + "." + p + " <" + M + "." + (+m + 1) + ".0";
+ }
+ debug("tilde return", ret);
+ return ret;
+ });
+ }
+ __name(replaceTilde, "replaceTilde");
+ function replaceCarets(comp, options14) {
+ return comp.trim().split(/\s+/).map(function(comp2) {
+ return replaceCaret(comp2, options14);
+ }).join(" ");
+ }
+ __name(replaceCarets, "replaceCarets");
+ function replaceCaret(comp, options14) {
+ debug("caret", comp, options14);
+ var r = options14.loose ? re[t2.CARETLOOSE] : re[t2.CARET];
+ return comp.replace(r, function(_2, M, m, p, pr) {
+ debug("caret", comp, _2, M, m, p, pr);
+ var ret;
+ if (isX(M)) {
+ ret = "";
+ } else if (isX(m)) {
+ ret = ">=" + M + ".0.0 <" + (+M + 1) + ".0.0";
+ } else if (isX(p)) {
+ if (M === "0") {
+ ret = ">=" + M + "." + m + ".0 <" + M + "." + (+m + 1) + ".0";
+ } else {
+ ret = ">=" + M + "." + m + ".0 <" + (+M + 1) + ".0.0";
+ }
+ } else if (pr) {
+ debug("replaceCaret pr", pr);
+ if (M === "0") {
+ if (m === "0") {
+ ret = ">=" + M + "." + m + "." + p + "-" + pr + " <" + M + "." + m + "." + (+p + 1);
+ } else {
+ ret = ">=" + M + "." + m + "." + p + "-" + pr + " <" + M + "." + (+m + 1) + ".0";
+ }
+ } else {
+ ret = ">=" + M + "." + m + "." + p + "-" + pr + " <" + (+M + 1) + ".0.0";
+ }
+ } else {
+ debug("no pr");
+ if (M === "0") {
+ if (m === "0") {
+ ret = ">=" + M + "." + m + "." + p + " <" + M + "." + m + "." + (+p + 1);
+ } else {
+ ret = ">=" + M + "." + m + "." + p + " <" + M + "." + (+m + 1) + ".0";
+ }
+ } else {
+ ret = ">=" + M + "." + m + "." + p + " <" + (+M + 1) + ".0.0";
+ }
+ }
+ debug("caret return", ret);
+ return ret;
+ });
+ }
+ __name(replaceCaret, "replaceCaret");
+ function replaceXRanges(comp, options14) {
+ debug("replaceXRanges", comp, options14);
+ return comp.split(/\s+/).map(function(comp2) {
+ return replaceXRange(comp2, options14);
+ }).join(" ");
+ }
+ __name(replaceXRanges, "replaceXRanges");
+ function replaceXRange(comp, options14) {
+ comp = comp.trim();
+ var r = options14.loose ? re[t2.XRANGELOOSE] : re[t2.XRANGE];
+ return comp.replace(r, function(ret, gtlt, M, m, p, pr) {
+ debug("xRange", comp, ret, gtlt, M, m, p, pr);
+ var xM = isX(M);
+ var xm = xM || isX(m);
+ var xp = xm || isX(p);
+ var anyX = xp;
+ if (gtlt === "=" && anyX) {
+ gtlt = "";
+ }
+ pr = options14.includePrerelease ? "-0" : "";
+ if (xM) {
+ if (gtlt === ">" || gtlt === "<") {
+ ret = "<0.0.0-0";
+ } else {
+ ret = "*";
+ }
+ } else if (gtlt && anyX) {
+ if (xm) {
+ m = 0;
+ }
+ p = 0;
+ if (gtlt === ">") {
+ gtlt = ">=";
+ if (xm) {
+ M = +M + 1;
+ m = 0;
+ p = 0;
+ } else {
+ m = +m + 1;
+ p = 0;
+ }
+ } else if (gtlt === "<=") {
+ gtlt = "<";
+ if (xm) {
+ M = +M + 1;
+ } else {
+ m = +m + 1;
+ }
+ }
+ ret = gtlt + M + "." + m + "." + p + pr;
+ } else if (xm) {
+ ret = ">=" + M + ".0.0" + pr + " <" + (+M + 1) + ".0.0" + pr;
+ } else if (xp) {
+ ret = ">=" + M + "." + m + ".0" + pr + " <" + M + "." + (+m + 1) + ".0" + pr;
+ }
+ debug("xRange return", ret);
+ return ret;
+ });
+ }
+ __name(replaceXRange, "replaceXRange");
+ function replaceStars(comp, options14) {
+ debug("replaceStars", comp, options14);
+ return comp.trim().replace(re[t2.STAR], "");
+ }
+ __name(replaceStars, "replaceStars");
+ function hyphenReplace($0, from, fM, fm, fp, fpr, fb, to, tM, tm, tp, tpr, tb) {
+ if (isX(fM)) {
+ from = "";
+ } else if (isX(fm)) {
+ from = ">=" + fM + ".0.0";
+ } else if (isX(fp)) {
+ from = ">=" + fM + "." + fm + ".0";
+ } else {
+ from = ">=" + from;
+ }
+ if (isX(tM)) {
+ to = "";
+ } else if (isX(tm)) {
+ to = "<" + (+tM + 1) + ".0.0";
+ } else if (isX(tp)) {
+ to = "<" + tM + "." + (+tm + 1) + ".0";
+ } else if (tpr) {
+ to = "<=" + tM + "." + tm + "." + tp + "-" + tpr;
+ } else {
+ to = "<=" + to;
+ }
+ return (from + " " + to).trim();
+ }
+ __name(hyphenReplace, "hyphenReplace");
+ Range.prototype.test = function(version2) {
+ if (!version2) {
+ return false;
+ }
+ if (typeof version2 === "string") {
+ try {
+ version2 = new SemVer(version2, this.options);
+ } catch (er) {
+ return false;
+ }
+ }
+ for (var i2 = 0; i2 < this.set.length; i2++) {
+ if (testSet(this.set[i2], version2, this.options)) {
+ return true;
+ }
+ }
+ return false;
+ };
+ function testSet(set, version2, options14) {
+ for (var i2 = 0; i2 < set.length; i2++) {
+ if (!set[i2].test(version2)) {
+ return false;
+ }
+ }
+ if (version2.prerelease.length && !options14.includePrerelease) {
+ for (i2 = 0; i2 < set.length; i2++) {
+ debug(set[i2].semver);
+ if (set[i2].semver === ANY) {
+ continue;
+ }
+ if (set[i2].semver.prerelease.length > 0) {
+ var allowed = set[i2].semver;
+ if (allowed.major === version2.major && allowed.minor === version2.minor && allowed.patch === version2.patch) {
+ return true;
+ }
+ }
+ }
+ return false;
+ }
+ return true;
+ }
+ __name(testSet, "testSet");
+ exports3.satisfies = satisfies;
+ function satisfies(version2, range, options14) {
+ try {
+ range = new Range(range, options14);
+ } catch (er) {
+ return false;
+ }
+ return range.test(version2);
+ }
+ __name(satisfies, "satisfies");
+ exports3.maxSatisfying = maxSatisfying;
+ function maxSatisfying(versions, range, options14) {
+ var max = null;
+ var maxSV = null;
+ try {
+ var rangeObj = new Range(range, options14);
+ } catch (er) {
+ return null;
+ }
+ versions.forEach(function(v) {
+ if (rangeObj.test(v)) {
+ if (!max || maxSV.compare(v) === -1) {
+ max = v;
+ maxSV = new SemVer(max, options14);
+ }
+ }
+ });
+ return max;
+ }
+ __name(maxSatisfying, "maxSatisfying");
+ exports3.minSatisfying = minSatisfying;
+ function minSatisfying(versions, range, options14) {
+ var min = null;
+ var minSV = null;
+ try {
+ var rangeObj = new Range(range, options14);
+ } catch (er) {
+ return null;
+ }
+ versions.forEach(function(v) {
+ if (rangeObj.test(v)) {
+ if (!min || minSV.compare(v) === 1) {
+ min = v;
+ minSV = new SemVer(min, options14);
+ }
+ }
+ });
+ return min;
+ }
+ __name(minSatisfying, "minSatisfying");
+ exports3.minVersion = minVersion;
+ function minVersion(range, loose) {
+ range = new Range(range, loose);
+ var minver = new SemVer("0.0.0");
+ if (range.test(minver)) {
+ return minver;
+ }
+ minver = new SemVer("0.0.0-0");
+ if (range.test(minver)) {
+ return minver;
+ }
+ minver = null;
+ for (var i2 = 0; i2 < range.set.length; ++i2) {
+ var comparators = range.set[i2];
+ comparators.forEach(function(comparator) {
+ var compver = new SemVer(comparator.semver.version);
+ switch (comparator.operator) {
+ case ">":
+ if (compver.prerelease.length === 0) {
+ compver.patch++;
+ } else {
+ compver.prerelease.push(0);
+ }
+ compver.raw = compver.format();
+ case "":
+ case ">=":
+ if (!minver || gt(minver, compver)) {
+ minver = compver;
+ }
+ break;
+ case "<":
+ case "<=":
+ break;
+ default:
+ throw new Error("Unexpected operation: " + comparator.operator);
+ }
+ });
+ }
+ if (minver && range.test(minver)) {
+ return minver;
+ }
+ return null;
+ }
+ __name(minVersion, "minVersion");
+ exports3.validRange = validRange;
+ function validRange(range, options14) {
+ try {
+ return new Range(range, options14).range || "*";
+ } catch (er) {
+ return null;
+ }
+ }
+ __name(validRange, "validRange");
+ exports3.ltr = ltr;
+ function ltr(version2, range, options14) {
+ return outside(version2, range, "<", options14);
+ }
+ __name(ltr, "ltr");
+ exports3.gtr = gtr;
+ function gtr(version2, range, options14) {
+ return outside(version2, range, ">", options14);
+ }
+ __name(gtr, "gtr");
+ exports3.outside = outside;
+ function outside(version2, range, hilo, options14) {
+ version2 = new SemVer(version2, options14);
+ range = new Range(range, options14);
+ var gtfn, ltefn, ltfn, comp, ecomp;
+ switch (hilo) {
+ case ">":
+ gtfn = gt;
+ ltefn = lte;
+ ltfn = lt2;
+ comp = ">";
+ ecomp = ">=";
+ break;
+ case "<":
+ gtfn = lt2;
+ ltefn = gte;
+ ltfn = gt;
+ comp = "<";
+ ecomp = "<=";
+ break;
+ default:
+ throw new TypeError('Must provide a hilo val of "<" or ">"');
+ }
+ if (satisfies(version2, range, options14)) {
+ return false;
+ }
+ for (var i2 = 0; i2 < range.set.length; ++i2) {
+ var comparators = range.set[i2];
+ var high = null;
+ var low = null;
+ comparators.forEach(function(comparator) {
+ if (comparator.semver === ANY) {
+ comparator = new Comparator(">=0.0.0");
+ }
+ high = high || comparator;
+ low = low || comparator;
+ if (gtfn(comparator.semver, high.semver, options14)) {
+ high = comparator;
+ } else if (ltfn(comparator.semver, low.semver, options14)) {
+ low = comparator;
+ }
+ });
+ if (high.operator === comp || high.operator === ecomp) {
+ return false;
+ }
+ if ((!low.operator || low.operator === comp) && ltefn(version2, low.semver)) {
+ return false;
+ } else if (low.operator === ecomp && ltfn(version2, low.semver)) {
+ return false;
+ }
+ }
+ return true;
+ }
+ __name(outside, "outside");
+ exports3.prerelease = prerelease;
+ function prerelease(version2, options14) {
+ var parsed = parse4(version2, options14);
+ return parsed && parsed.prerelease.length ? parsed.prerelease : null;
+ }
+ __name(prerelease, "prerelease");
+ exports3.intersects = intersects;
+ function intersects(r1, r22, options14) {
+ r1 = new Range(r1, options14);
+ r22 = new Range(r22, options14);
+ return r1.intersects(r22);
+ }
+ __name(intersects, "intersects");
+ exports3.coerce = coerce;
+ function coerce(version2, options14) {
+ if (version2 instanceof SemVer) {
+ return version2;
+ }
+ if (typeof version2 === "number") {
+ version2 = String(version2);
+ }
+ if (typeof version2 !== "string") {
+ return null;
+ }
+ options14 = options14 || {};
+ var match = null;
+ if (!options14.rtl) {
+ match = version2.match(re[t2.COERCE]);
+ } else {
+ var next;
+ while ((next = re[t2.COERCERTL].exec(version2)) && (!match || match.index + match[0].length !== version2.length)) {
+ if (!match || next.index + next[0].length !== match.index + match[0].length) {
+ match = next;
+ }
+ re[t2.COERCERTL].lastIndex = next.index + next[1].length + next[2].length;
+ }
+ re[t2.COERCERTL].lastIndex = -1;
+ }
+ if (match === null) {
+ return null;
+ }
+ return parse4(match[2] + "." + (match[3] || "0") + "." + (match[4] || "0"), options14);
+ }
+ __name(coerce, "coerce");
+ }).call(this, __webpack_require__(17));
+ },
+ /* 12 */
+ /***/
+ function(module3, __webpack_exports__, __webpack_require__) {
+ "use strict";
+ __webpack_require__.d(__webpack_exports__, "b", function() {
+ return meta;
+ });
+ __webpack_require__.d(__webpack_exports__, "a", function() {
+ return dehydrate;
+ });
+ var _utils__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(2);
+ function ownKeys11(object, enumerableOnly) {
+ var keys = Object.keys(object);
+ if (Object.getOwnPropertySymbols) {
+ var symbols = Object.getOwnPropertySymbols(object);
+ if (enumerableOnly)
+ symbols = symbols.filter(function(sym) {
+ return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+ });
+ keys.push.apply(keys, symbols);
+ }
+ return keys;
+ }
+ __name(ownKeys11, "ownKeys");
+ function _objectSpread11(target) {
+ for (var i = 1; i < arguments.length; i++) {
+ var source = arguments[i] != null ? arguments[i] : {};
+ if (i % 2) {
+ ownKeys11(Object(source), true).forEach(function(key) {
+ _defineProperty11(target, key, source[key]);
+ });
+ } else if (Object.getOwnPropertyDescriptors) {
+ Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+ } else {
+ ownKeys11(Object(source)).forEach(function(key) {
+ Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+ });
+ }
+ }
+ return target;
+ }
+ __name(_objectSpread11, "_objectSpread");
+ function _defineProperty11(obj, key, value) {
+ if (key in obj) {
+ Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
+ } else {
+ obj[key] = value;
+ }
+ return obj;
+ }
+ __name(_defineProperty11, "_defineProperty");
+ var meta = {
+ inspectable: Symbol("inspectable"),
+ inspected: Symbol("inspected"),
+ name: Symbol("name"),
+ preview_long: Symbol("preview_long"),
+ preview_short: Symbol("preview_short"),
+ readonly: Symbol("readonly"),
+ size: Symbol("size"),
+ type: Symbol("type"),
+ unserializable: Symbol("unserializable")
+ };
+ var LEVEL_THRESHOLD = 2;
+ function createDehydrated(type, inspectable, data, cleaned, path45) {
+ cleaned.push(path45);
+ var dehydrated = {
+ inspectable,
+ type,
+ preview_long: Object(_utils__WEBPACK_IMPORTED_MODULE_0__[
+ /* formatDataForPreview */
+ "b"
+ ])(data, true),
+ preview_short: Object(_utils__WEBPACK_IMPORTED_MODULE_0__[
+ /* formatDataForPreview */
+ "b"
+ ])(data, false),
+ name: !data.constructor || data.constructor.name === "Object" ? "" : data.constructor.name
+ };
+ if (type === "array" || type === "typed_array") {
+ dehydrated.size = data.length;
+ } else if (type === "object") {
+ dehydrated.size = Object.keys(data).length;
+ }
+ if (type === "iterator" || type === "typed_array") {
+ dehydrated.readonly = true;
+ }
+ return dehydrated;
+ }
+ __name(createDehydrated, "createDehydrated");
+ function dehydrate(data, cleaned, unserializable, path45, isPathAllowed) {
+ var level = arguments.length > 5 && arguments[5] !== void 0 ? arguments[5] : 0;
+ var type = Object(_utils__WEBPACK_IMPORTED_MODULE_0__[
+ /* getDataType */
+ "d"
+ ])(data);
+ var isPathAllowedCheck;
+ switch (type) {
+ case "html_element":
+ cleaned.push(path45);
+ return {
+ inspectable: false,
+ preview_short: Object(_utils__WEBPACK_IMPORTED_MODULE_0__[
+ /* formatDataForPreview */
+ "b"
+ ])(data, false),
+ preview_long: Object(_utils__WEBPACK_IMPORTED_MODULE_0__[
+ /* formatDataForPreview */
+ "b"
+ ])(data, true),
+ name: data.tagName,
+ type
+ };
+ case "function":
+ cleaned.push(path45);
+ return {
+ inspectable: false,
+ preview_short: Object(_utils__WEBPACK_IMPORTED_MODULE_0__[
+ /* formatDataForPreview */
+ "b"
+ ])(data, false),
+ preview_long: Object(_utils__WEBPACK_IMPORTED_MODULE_0__[
+ /* formatDataForPreview */
+ "b"
+ ])(data, true),
+ name: typeof data.name === "function" || !data.name ? "function" : data.name,
+ type
+ };
+ case "string":
+ isPathAllowedCheck = isPathAllowed(path45);
+ if (isPathAllowedCheck) {
+ return data;
+ } else {
+ return data.length <= 500 ? data : data.slice(0, 500) + "...";
+ }
+ case "bigint":
+ cleaned.push(path45);
+ return {
+ inspectable: false,
+ preview_short: Object(_utils__WEBPACK_IMPORTED_MODULE_0__[
+ /* formatDataForPreview */
+ "b"
+ ])(data, false),
+ preview_long: Object(_utils__WEBPACK_IMPORTED_MODULE_0__[
+ /* formatDataForPreview */
+ "b"
+ ])(data, true),
+ name: data.toString(),
+ type
+ };
+ case "symbol":
+ cleaned.push(path45);
+ return {
+ inspectable: false,
+ preview_short: Object(_utils__WEBPACK_IMPORTED_MODULE_0__[
+ /* formatDataForPreview */
+ "b"
+ ])(data, false),
+ preview_long: Object(_utils__WEBPACK_IMPORTED_MODULE_0__[
+ /* formatDataForPreview */
+ "b"
+ ])(data, true),
+ name: data.toString(),
+ type
+ };
+ case "react_element":
+ cleaned.push(path45);
+ return {
+ inspectable: false,
+ preview_short: Object(_utils__WEBPACK_IMPORTED_MODULE_0__[
+ /* formatDataForPreview */
+ "b"
+ ])(data, false),
+ preview_long: Object(_utils__WEBPACK_IMPORTED_MODULE_0__[
+ /* formatDataForPreview */
+ "b"
+ ])(data, true),
+ name: Object(_utils__WEBPACK_IMPORTED_MODULE_0__[
+ /* getDisplayNameForReactElement */
+ "g"
+ ])(data) || "Unknown",
+ type
+ };
+ case "array_buffer":
+ case "data_view":
+ cleaned.push(path45);
+ return {
+ inspectable: false,
+ preview_short: Object(_utils__WEBPACK_IMPORTED_MODULE_0__[
+ /* formatDataForPreview */
+ "b"
+ ])(data, false),
+ preview_long: Object(_utils__WEBPACK_IMPORTED_MODULE_0__[
+ /* formatDataForPreview */
+ "b"
+ ])(data, true),
+ name: type === "data_view" ? "DataView" : "ArrayBuffer",
+ size: data.byteLength,
+ type
+ };
+ case "array":
+ isPathAllowedCheck = isPathAllowed(path45);
+ if (level >= LEVEL_THRESHOLD && !isPathAllowedCheck) {
+ return createDehydrated(type, true, data, cleaned, path45);
+ }
+ return data.map(function(item, i) {
+ return dehydrate(item, cleaned, unserializable, path45.concat([i]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
+ });
+ case "html_all_collection":
+ case "typed_array":
+ case "iterator":
+ isPathAllowedCheck = isPathAllowed(path45);
+ if (level >= LEVEL_THRESHOLD && !isPathAllowedCheck) {
+ return createDehydrated(type, true, data, cleaned, path45);
+ } else {
+ var unserializableValue = {
+ unserializable: true,
+ type,
+ readonly: true,
+ size: type === "typed_array" ? data.length : void 0,
+ preview_short: Object(_utils__WEBPACK_IMPORTED_MODULE_0__[
+ /* formatDataForPreview */
+ "b"
+ ])(data, false),
+ preview_long: Object(_utils__WEBPACK_IMPORTED_MODULE_0__[
+ /* formatDataForPreview */
+ "b"
+ ])(data, true),
+ name: !data.constructor || data.constructor.name === "Object" ? "" : data.constructor.name
+ };
+ Array.from(data).forEach(function(item, i) {
+ return unserializableValue[i] = dehydrate(item, cleaned, unserializable, path45.concat([i]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
+ });
+ unserializable.push(path45);
+ return unserializableValue;
+ }
+ case "opaque_iterator":
+ cleaned.push(path45);
+ return {
+ inspectable: false,
+ preview_short: Object(_utils__WEBPACK_IMPORTED_MODULE_0__[
+ /* formatDataForPreview */
+ "b"
+ ])(data, false),
+ preview_long: Object(_utils__WEBPACK_IMPORTED_MODULE_0__[
+ /* formatDataForPreview */
+ "b"
+ ])(data, true),
+ name: data[Symbol.toStringTag],
+ type
+ };
+ case "date":
+ cleaned.push(path45);
+ return {
+ inspectable: false,
+ preview_short: Object(_utils__WEBPACK_IMPORTED_MODULE_0__[
+ /* formatDataForPreview */
+ "b"
+ ])(data, false),
+ preview_long: Object(_utils__WEBPACK_IMPORTED_MODULE_0__[
+ /* formatDataForPreview */
+ "b"
+ ])(data, true),
+ name: data.toString(),
+ type
+ };
+ case "regexp":
+ cleaned.push(path45);
+ return {
+ inspectable: false,
+ preview_short: Object(_utils__WEBPACK_IMPORTED_MODULE_0__[
+ /* formatDataForPreview */
+ "b"
+ ])(data, false),
+ preview_long: Object(_utils__WEBPACK_IMPORTED_MODULE_0__[
+ /* formatDataForPreview */
+ "b"
+ ])(data, true),
+ name: data.toString(),
+ type
+ };
+ case "object":
+ isPathAllowedCheck = isPathAllowed(path45);
+ if (level >= LEVEL_THRESHOLD && !isPathAllowedCheck) {
+ return createDehydrated(type, true, data, cleaned, path45);
+ } else {
+ var object = {};
+ Object(_utils__WEBPACK_IMPORTED_MODULE_0__[
+ /* getAllEnumerableKeys */
+ "c"
+ ])(data).forEach(function(key) {
+ var name = key.toString();
+ object[name] = dehydrate(data[key], cleaned, unserializable, path45.concat([name]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
+ });
+ return object;
+ }
+ case "infinity":
+ case "nan":
+ case "undefined":
+ cleaned.push(path45);
+ return {
+ type
+ };
+ default:
+ return data;
+ }
+ }
+ __name(dehydrate, "dehydrate");
+ function fillInPath(object, data, path45, value) {
+ var target = Object(_utils__WEBPACK_IMPORTED_MODULE_0__[
+ /* getInObject */
+ "h"
+ ])(object, path45);
+ if (target != null) {
+ if (!target[meta.unserializable]) {
+ delete target[meta.inspectable];
+ delete target[meta.inspected];
+ delete target[meta.name];
+ delete target[meta.preview_long];
+ delete target[meta.preview_short];
+ delete target[meta.readonly];
+ delete target[meta.size];
+ delete target[meta.type];
+ }
+ }
+ if (value !== null && data.unserializable.length > 0) {
+ var unserializablePath = data.unserializable[0];
+ var isMatch = unserializablePath.length === path45.length;
+ for (var i = 0; i < path45.length; i++) {
+ if (path45[i] !== unserializablePath[i]) {
+ isMatch = false;
+ break;
+ }
+ }
+ if (isMatch) {
+ upgradeUnserializable(value, value);
+ }
+ }
+ Object(_utils__WEBPACK_IMPORTED_MODULE_0__[
+ /* setInObject */
+ "l"
+ ])(object, path45, value);
+ }
+ __name(fillInPath, "fillInPath");
+ function hydrate(object, cleaned, unserializable) {
+ cleaned.forEach(function(path45) {
+ var length = path45.length;
+ var last = path45[length - 1];
+ var parent = Object(_utils__WEBPACK_IMPORTED_MODULE_0__[
+ /* getInObject */
+ "h"
+ ])(object, path45.slice(0, length - 1));
+ if (!parent || !parent.hasOwnProperty(last)) {
+ return;
+ }
+ var value = parent[last];
+ if (!value) {
+ return;
+ } else if (value.type === "infinity") {
+ parent[last] = Infinity;
+ } else if (value.type === "nan") {
+ parent[last] = NaN;
+ } else if (value.type === "undefined") {
+ parent[last] = void 0;
+ } else {
+ var replaced = {};
+ replaced[meta.inspectable] = !!value.inspectable;
+ replaced[meta.inspected] = false;
+ replaced[meta.name] = value.name;
+ replaced[meta.preview_long] = value.preview_long;
+ replaced[meta.preview_short] = value.preview_short;
+ replaced[meta.size] = value.size;
+ replaced[meta.readonly] = !!value.readonly;
+ replaced[meta.type] = value.type;
+ parent[last] = replaced;
+ }
+ });
+ unserializable.forEach(function(path45) {
+ var length = path45.length;
+ var last = path45[length - 1];
+ var parent = Object(_utils__WEBPACK_IMPORTED_MODULE_0__[
+ /* getInObject */
+ "h"
+ ])(object, path45.slice(0, length - 1));
+ if (!parent || !parent.hasOwnProperty(last)) {
+ return;
+ }
+ var node = parent[last];
+ var replacement = _objectSpread11({}, node);
+ upgradeUnserializable(replacement, node);
+ parent[last] = replacement;
+ });
+ return object;
+ }
+ __name(hydrate, "hydrate");
+ function upgradeUnserializable(destination, source) {
+ var _Object$definePropert;
+ Object.defineProperties(destination, (_Object$definePropert = {}, _defineProperty11(_Object$definePropert, meta.inspected, {
+ configurable: true,
+ enumerable: false,
+ value: !!source.inspected
+ }), _defineProperty11(_Object$definePropert, meta.name, {
+ configurable: true,
+ enumerable: false,
+ value: source.name
+ }), _defineProperty11(_Object$definePropert, meta.preview_long, {
+ configurable: true,
+ enumerable: false,
+ value: source.preview_long
+ }), _defineProperty11(_Object$definePropert, meta.preview_short, {
+ configurable: true,
+ enumerable: false,
+ value: source.preview_short
+ }), _defineProperty11(_Object$definePropert, meta.size, {
+ configurable: true,
+ enumerable: false,
+ value: source.size
+ }), _defineProperty11(_Object$definePropert, meta.readonly, {
+ configurable: true,
+ enumerable: false,
+ value: !!source.readonly
+ }), _defineProperty11(_Object$definePropert, meta.type, {
+ configurable: true,
+ enumerable: false,
+ value: source.type
+ }), _defineProperty11(_Object$definePropert, meta.unserializable, {
+ configurable: true,
+ enumerable: false,
+ value: !!source.unserializable
+ }), _Object$definePropert));
+ delete destination.inspected;
+ delete destination.name;
+ delete destination.preview_long;
+ delete destination.preview_short;
+ delete destination.size;
+ delete destination.readonly;
+ delete destination.type;
+ delete destination.unserializable;
+ }
+ __name(upgradeUnserializable, "upgradeUnserializable");
+ },
+ /* 13 */
+ /***/
+ function(module3, __webpack_exports__, __webpack_require__) {
+ "use strict";
+ __webpack_require__.d(__webpack_exports__, "a", function() {
+ return consoleManagedByDevToolsDuringStrictMode;
+ });
+ __webpack_require__.d(__webpack_exports__, "b", function() {
+ return enableProfilerChangedHookIndices;
+ });
+ __webpack_require__.d(__webpack_exports__, "c", function() {
+ return enableStyleXFeatures;
+ });
+ var consoleManagedByDevToolsDuringStrictMode = false;
+ var enableLogger = false;
+ var enableNamedHooksFeature = true;
+ var enableProfilerChangedHookIndices = true;
+ var enableStyleXFeatures = false;
+ var isInternalFacebookBuild = false;
+ null;
+ },
+ /* 14 */
+ /***/
+ function(module3, exports3) {
+ function _typeof7(obj) {
+ "@babel/helpers - typeof";
+ if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+ _typeof7 = /* @__PURE__ */ __name(function _typeof8(obj2) {
+ return typeof obj2;
+ }, "_typeof");
+ } else {
+ _typeof7 = /* @__PURE__ */ __name(function _typeof8(obj2) {
+ return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+ }, "_typeof");
+ }
+ return _typeof7(obj);
+ }
+ __name(_typeof7, "_typeof");
+ var g;
+ g = function() {
+ return this;
+ }();
+ try {
+ g = g || new Function("return this")();
+ } catch (e2) {
+ if ((typeof window === "undefined" ? "undefined" : _typeof7(window)) === "object")
+ g = window;
+ }
+ module3.exports = g;
+ },
+ /* 15 */
+ /***/
+ function(module3, exports3, __webpack_require__) {
+ (function(global2) {
+ function _typeof7(obj) {
+ "@babel/helpers - typeof";
+ if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+ _typeof7 = /* @__PURE__ */ __name(function _typeof8(obj2) {
+ return typeof obj2;
+ }, "_typeof");
+ } else {
+ _typeof7 = /* @__PURE__ */ __name(function _typeof8(obj2) {
+ return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+ }, "_typeof");
+ }
+ return _typeof7(obj);
+ }
+ __name(_typeof7, "_typeof");
+ var FUNC_ERROR_TEXT = "Expected a function";
+ var NAN = 0 / 0;
+ var symbolTag = "[object Symbol]";
+ var reTrim = /^\s+|\s+$/g;
+ var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;
+ var reIsBinary = /^0b[01]+$/i;
+ var reIsOctal = /^0o[0-7]+$/i;
+ var freeParseInt = parseInt;
+ var freeGlobal = (typeof global2 === "undefined" ? "undefined" : _typeof7(global2)) == "object" && global2 && global2.Object === Object && global2;
+ var freeSelf = (typeof self === "undefined" ? "undefined" : _typeof7(self)) == "object" && self && self.Object === Object && self;
+ var root = freeGlobal || freeSelf || Function("return this")();
+ var objectProto = Object.prototype;
+ var objectToString = objectProto.toString;
+ var nativeMax = Math.max, nativeMin = Math.min;
+ var now = /* @__PURE__ */ __name(function now2() {
+ return root.Date.now();
+ }, "now");
+ function debounce(func, wait, options14) {
+ var lastArgs, lastThis, maxWait, result, timerId, lastCallTime, lastInvokeTime = 0, leading = false, maxing = false, trailing = true;
+ if (typeof func != "function") {
+ throw new TypeError(FUNC_ERROR_TEXT);
+ }
+ wait = toNumber(wait) || 0;
+ if (isObject2(options14)) {
+ leading = !!options14.leading;
+ maxing = "maxWait" in options14;
+ maxWait = maxing ? nativeMax(toNumber(options14.maxWait) || 0, wait) : maxWait;
+ trailing = "trailing" in options14 ? !!options14.trailing : trailing;
+ }
+ function invokeFunc(time) {
+ var args = lastArgs, thisArg = lastThis;
+ lastArgs = lastThis = void 0;
+ lastInvokeTime = time;
+ result = func.apply(thisArg, args);
+ return result;
+ }
+ __name(invokeFunc, "invokeFunc");
+ function leadingEdge(time) {
+ lastInvokeTime = time;
+ timerId = setTimeout(timerExpired, wait);
+ return leading ? invokeFunc(time) : result;
+ }
+ __name(leadingEdge, "leadingEdge");
+ function remainingWait(time) {
+ var timeSinceLastCall = time - lastCallTime, timeSinceLastInvoke = time - lastInvokeTime, result2 = wait - timeSinceLastCall;
+ return maxing ? nativeMin(result2, maxWait - timeSinceLastInvoke) : result2;
+ }
+ __name(remainingWait, "remainingWait");
+ function shouldInvoke(time) {
+ var timeSinceLastCall = time - lastCallTime, timeSinceLastInvoke = time - lastInvokeTime;
+ return lastCallTime === void 0 || timeSinceLastCall >= wait || timeSinceLastCall < 0 || maxing && timeSinceLastInvoke >= maxWait;
+ }
+ __name(shouldInvoke, "shouldInvoke");
+ function timerExpired() {
+ var time = now();
+ if (shouldInvoke(time)) {
+ return trailingEdge(time);
+ }
+ timerId = setTimeout(timerExpired, remainingWait(time));
+ }
+ __name(timerExpired, "timerExpired");
+ function trailingEdge(time) {
+ timerId = void 0;
+ if (trailing && lastArgs) {
+ return invokeFunc(time);
+ }
+ lastArgs = lastThis = void 0;
+ return result;
+ }
+ __name(trailingEdge, "trailingEdge");
+ function cancel2() {
+ if (timerId !== void 0) {
+ clearTimeout(timerId);
+ }
+ lastInvokeTime = 0;
+ lastArgs = lastCallTime = lastThis = timerId = void 0;
+ }
+ __name(cancel2, "cancel");
+ function flush() {
+ return timerId === void 0 ? result : trailingEdge(now());
+ }
+ __name(flush, "flush");
+ function debounced() {
+ var time = now(), isInvoking = shouldInvoke(time);
+ lastArgs = arguments;
+ lastThis = this;
+ lastCallTime = time;
+ if (isInvoking) {
+ if (timerId === void 0) {
+ return leadingEdge(lastCallTime);
+ }
+ if (maxing) {
+ timerId = setTimeout(timerExpired, wait);
+ return invokeFunc(lastCallTime);
+ }
+ }
+ if (timerId === void 0) {
+ timerId = setTimeout(timerExpired, wait);
+ }
+ return result;
+ }
+ __name(debounced, "debounced");
+ debounced.cancel = cancel2;
+ debounced.flush = flush;
+ return debounced;
+ }
+ __name(debounce, "debounce");
+ function throttle(func, wait, options14) {
+ var leading = true, trailing = true;
+ if (typeof func != "function") {
+ throw new TypeError(FUNC_ERROR_TEXT);
+ }
+ if (isObject2(options14)) {
+ leading = "leading" in options14 ? !!options14.leading : leading;
+ trailing = "trailing" in options14 ? !!options14.trailing : trailing;
+ }
+ return debounce(func, wait, {
+ "leading": leading,
+ "maxWait": wait,
+ "trailing": trailing
+ });
+ }
+ __name(throttle, "throttle");
+ function isObject2(value) {
+ var type = _typeof7(value);
+ return !!value && (type == "object" || type == "function");
+ }
+ __name(isObject2, "isObject");
+ function isObjectLike(value) {
+ return !!value && _typeof7(value) == "object";
+ }
+ __name(isObjectLike, "isObjectLike");
+ function isSymbol(value) {
+ return _typeof7(value) == "symbol" || isObjectLike(value) && objectToString.call(value) == symbolTag;
+ }
+ __name(isSymbol, "isSymbol");
+ function toNumber(value) {
+ if (typeof value == "number") {
+ return value;
+ }
+ if (isSymbol(value)) {
+ return NAN;
+ }
+ if (isObject2(value)) {
+ var other = typeof value.valueOf == "function" ? value.valueOf() : value;
+ value = isObject2(other) ? other + "" : other;
+ }
+ if (typeof value != "string") {
+ return value === 0 ? value : +value;
+ }
+ value = value.replace(reTrim, "");
+ var isBinary = reIsBinary.test(value);
+ return isBinary || reIsOctal.test(value) ? freeParseInt(value.slice(2), isBinary ? 2 : 8) : reIsBadHex.test(value) ? NAN : +value;
+ }
+ __name(toNumber, "toNumber");
+ module3.exports = throttle;
+ }).call(this, __webpack_require__(14));
+ },
+ /* 16 */
+ /***/
+ function(module3, __webpack_exports__, __webpack_require__) {
+ "use strict";
+ __webpack_require__.d(__webpack_exports__, "b", function() {
+ return (
+ /* binding */
+ getInternalReactConstants
+ );
+ });
+ __webpack_require__.d(__webpack_exports__, "a", function() {
+ return (
+ /* binding */
+ attach
+ );
+ });
+ var semver = __webpack_require__(11);
+ var types = __webpack_require__(0);
+ var utils = __webpack_require__(2);
+ var storage = __webpack_require__(5);
+ var backend_utils = __webpack_require__(4);
+ var constants3 = __webpack_require__(1);
+ var react_debug_tools = __webpack_require__(21);
+ var backend_console = __webpack_require__(10);
+ var ReactSymbols = __webpack_require__(3);
+ var DevToolsFeatureFlags_core_oss = __webpack_require__(13);
+ function is2(x, y) {
+ return x === y && (x !== 0 || 1 / x === 1 / y) || x !== x && y !== y;
+ }
+ __name(is2, "is");
+ var objectIs = typeof Object.is === "function" ? Object.is : is2;
+ var shared_objectIs = objectIs;
+ var isArray = __webpack_require__(9);
+ var hasOwnProperty_hasOwnProperty = Object.prototype.hasOwnProperty;
+ var shared_hasOwnProperty = hasOwnProperty_hasOwnProperty;
+ var src_isArray = __webpack_require__(6);
+ var cachedStyleNameToValueMap = /* @__PURE__ */ new Map();
+ function getStyleXData(data) {
+ var sources = /* @__PURE__ */ new Set();
+ var resolvedStyles = {};
+ crawlData(data, sources, resolvedStyles);
+ return {
+ sources: Array.from(sources).sort(),
+ resolvedStyles
+ };
+ }
+ __name(getStyleXData, "getStyleXData");
+ function crawlData(data, sources, resolvedStyles) {
+ if (Object(src_isArray[
+ "a"
+ /* default */
+ ])(data)) {
+ data.forEach(function(entry) {
+ if (Object(src_isArray[
+ "a"
+ /* default */
+ ])(entry)) {
+ crawlData(entry, sources, resolvedStyles);
+ } else {
+ crawlObjectProperties(entry, sources, resolvedStyles);
+ }
+ });
+ } else {
+ crawlObjectProperties(data, sources, resolvedStyles);
+ }
+ resolvedStyles = Object.fromEntries(Object.entries(resolvedStyles).sort());
+ }
+ __name(crawlData, "crawlData");
+ function crawlObjectProperties(entry, sources, resolvedStyles) {
+ var keys = Object.keys(entry);
+ keys.forEach(function(key) {
+ var value = entry[key];
+ if (typeof value === "string") {
+ if (key === value) {
+ sources.add(key);
+ } else {
+ resolvedStyles[key] = getPropertyValueForStyleName(value);
+ }
+ } else {
+ var nestedStyle = {};
+ resolvedStyles[key] = nestedStyle;
+ crawlData([value], sources, nestedStyle);
+ }
+ });
+ }
+ __name(crawlObjectProperties, "crawlObjectProperties");
+ function getPropertyValueForStyleName(styleName) {
+ if (cachedStyleNameToValueMap.has(styleName)) {
+ return cachedStyleNameToValueMap.get(styleName);
+ }
+ for (var styleSheetIndex = 0; styleSheetIndex < document.styleSheets.length; styleSheetIndex++) {
+ var styleSheet = document.styleSheets[styleSheetIndex];
+ var rules = styleSheet.rules || styleSheet.cssRules;
+ for (var ruleIndex = 0; ruleIndex < rules.length; ruleIndex++) {
+ var rule = rules[ruleIndex];
+ var cssText = rule.cssText, selectorText = rule.selectorText, style = rule.style;
+ if (selectorText != null) {
+ if (selectorText.startsWith(".".concat(styleName))) {
+ var match = cssText.match(/{ *([a-z\-]+):/);
+ if (match !== null) {
+ var property = match[1];
+ var value = style.getPropertyValue(property);
+ cachedStyleNameToValueMap.set(styleName, value);
+ return value;
+ } else {
+ return null;
+ }
+ }
+ }
+ }
+ }
+ return null;
+ }
+ __name(getPropertyValueForStyleName, "getPropertyValueForStyleName");
+ var REACT_TOTAL_NUM_LANES = 31;
+ var SCHEDULING_PROFILER_VERSION = 1;
+ var SNAPSHOT_MAX_HEIGHT = 60;
+ function _typeof7(obj) {
+ "@babel/helpers - typeof";
+ if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+ _typeof7 = /* @__PURE__ */ __name(function _typeof8(obj2) {
+ return typeof obj2;
+ }, "_typeof");
+ } else {
+ _typeof7 = /* @__PURE__ */ __name(function _typeof8(obj2) {
+ return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+ }, "_typeof");
+ }
+ return _typeof7(obj);
+ }
+ __name(_typeof7, "_typeof");
+ function _slicedToArray3(arr, i) {
+ return _arrayWithHoles3(arr) || _iterableToArrayLimit3(arr, i) || _unsupportedIterableToArray4(arr, i) || _nonIterableRest3();
+ }
+ __name(_slicedToArray3, "_slicedToArray");
+ function _nonIterableRest3() {
+ throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+ }
+ __name(_nonIterableRest3, "_nonIterableRest");
+ function _unsupportedIterableToArray4(o, minLen) {
+ if (!o)
+ return;
+ if (typeof o === "string")
+ return _arrayLikeToArray4(o, minLen);
+ var n = Object.prototype.toString.call(o).slice(8, -1);
+ if (n === "Object" && o.constructor)
+ n = o.constructor.name;
+ if (n === "Map" || n === "Set")
+ return Array.from(o);
+ if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))
+ return _arrayLikeToArray4(o, minLen);
+ }
+ __name(_unsupportedIterableToArray4, "_unsupportedIterableToArray");
+ function _arrayLikeToArray4(arr, len) {
+ if (len == null || len > arr.length)
+ len = arr.length;
+ for (var i = 0, arr2 = new Array(len); i < len; i++) {
+ arr2[i] = arr[i];
+ }
+ return arr2;
+ }
+ __name(_arrayLikeToArray4, "_arrayLikeToArray");
+ function _iterableToArrayLimit3(arr, i) {
+ if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr)))
+ return;
+ 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 (err) {
+ _d = true;
+ _e = err;
+ } finally {
+ try {
+ if (!_n && _i["return"] != null)
+ _i["return"]();
+ } finally {
+ if (_d)
+ throw _e;
+ }
+ }
+ return _arr;
+ }
+ __name(_iterableToArrayLimit3, "_iterableToArrayLimit");
+ function _arrayWithHoles3(arr) {
+ if (Array.isArray(arr))
+ return arr;
+ }
+ __name(_arrayWithHoles3, "_arrayWithHoles");
+ var performanceTarget = null;
+ var supportsUserTiming = typeof performance !== "undefined" && typeof performance.mark === "function" && typeof performance.clearMarks === "function";
+ var supportsUserTimingV3 = false;
+ if (supportsUserTiming) {
+ var CHECK_V3_MARK = "__v3";
+ var markOptions = {};
+ Object.defineProperty(markOptions, "startTime", {
+ get: /* @__PURE__ */ __name(function get() {
+ supportsUserTimingV3 = true;
+ return 0;
+ }, "get"),
+ set: /* @__PURE__ */ __name(function set() {
+ }, "set")
+ });
+ try {
+ performance.mark(CHECK_V3_MARK, markOptions);
+ } catch (error) {
+ } finally {
+ performance.clearMarks(CHECK_V3_MARK);
+ }
+ }
+ if (supportsUserTimingV3) {
+ performanceTarget = performance;
+ }
+ function setPerformanceMock_ONLY_FOR_TESTING(performanceMock) {
+ performanceTarget = performanceMock;
+ supportsUserTiming = performanceMock !== null;
+ supportsUserTimingV3 = performanceMock !== null;
+ }
+ __name(setPerformanceMock_ONLY_FOR_TESTING, "setPerformanceMock_ONLY_FOR_TESTING");
+ function markAndClear(markName) {
+ performanceTarget.mark(markName);
+ performanceTarget.clearMarks(markName);
+ }
+ __name(markAndClear, "markAndClear");
+ function createProfilingHooks(_ref) {
+ var getDisplayNameForFiber = _ref.getDisplayNameForFiber, getLaneLabelMap = _ref.getLaneLabelMap, reactVersion = _ref.reactVersion;
+ function markMetadata() {
+ markAndClear("--react-version-".concat(reactVersion));
+ markAndClear("--profiler-version-".concat(SCHEDULING_PROFILER_VERSION));
+ if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.getInternalModuleRanges === "function") {
+ var ranges = __REACT_DEVTOOLS_GLOBAL_HOOK__.getInternalModuleRanges();
+ if (Object(isArray[
+ "a"
+ /* default */
+ ])(ranges)) {
+ for (var i = 0; i < ranges.length; i++) {
+ var range = ranges[i];
+ if (Object(isArray[
+ "a"
+ /* default */
+ ])(range) && range.length === 2) {
+ var _ranges$i = _slicedToArray3(ranges[i], 2), startStackFrame = _ranges$i[0], stopStackFrame = _ranges$i[1];
+ markAndClear("--react-internal-module-start-".concat(startStackFrame));
+ markAndClear("--react-internal-module-stop-".concat(stopStackFrame));
+ }
+ }
+ }
+ }
+ if (typeof getLaneLabelMap === "function") {
+ var map = getLaneLabelMap();
+ if (map != null) {
+ var labels = Array.from(map.values()).join(",");
+ markAndClear("--react-lane-labels-".concat(labels));
+ }
+ }
+ }
+ __name(markMetadata, "markMetadata");
+ function markCommitStarted(lanes) {
+ if (supportsUserTimingV3) {
+ markAndClear("--commit-start-".concat(lanes));
+ markMetadata();
+ }
+ }
+ __name(markCommitStarted, "markCommitStarted");
+ function markCommitStopped() {
+ if (supportsUserTimingV3) {
+ markAndClear("--commit-stop");
+ }
+ }
+ __name(markCommitStopped, "markCommitStopped");
+ function markComponentRenderStarted(fiber) {
+ if (supportsUserTimingV3) {
+ var componentName = getDisplayNameForFiber(fiber) || "Unknown";
+ markAndClear("--component-render-start-".concat(componentName));
+ }
+ }
+ __name(markComponentRenderStarted, "markComponentRenderStarted");
+ function markComponentRenderStopped() {
+ if (supportsUserTimingV3) {
+ markAndClear("--component-render-stop");
+ }
+ }
+ __name(markComponentRenderStopped, "markComponentRenderStopped");
+ function markComponentPassiveEffectMountStarted(fiber) {
+ if (supportsUserTimingV3) {
+ var componentName = getDisplayNameForFiber(fiber) || "Unknown";
+ markAndClear("--component-passive-effect-mount-start-".concat(componentName));
+ }
+ }
+ __name(markComponentPassiveEffectMountStarted, "markComponentPassiveEffectMountStarted");
+ function markComponentPassiveEffectMountStopped() {
+ if (supportsUserTimingV3) {
+ markAndClear("--component-passive-effect-mount-stop");
+ }
+ }
+ __name(markComponentPassiveEffectMountStopped, "markComponentPassiveEffectMountStopped");
+ function markComponentPassiveEffectUnmountStarted(fiber) {
+ if (supportsUserTimingV3) {
+ var componentName = getDisplayNameForFiber(fiber) || "Unknown";
+ markAndClear("--component-passive-effect-unmount-start-".concat(componentName));
+ }
+ }
+ __name(markComponentPassiveEffectUnmountStarted, "markComponentPassiveEffectUnmountStarted");
+ function markComponentPassiveEffectUnmountStopped() {
+ if (supportsUserTimingV3) {
+ markAndClear("--component-passive-effect-unmount-stop");
+ }
+ }
+ __name(markComponentPassiveEffectUnmountStopped, "markComponentPassiveEffectUnmountStopped");
+ function markComponentLayoutEffectMountStarted(fiber) {
+ if (supportsUserTimingV3) {
+ var componentName = getDisplayNameForFiber(fiber) || "Unknown";
+ markAndClear("--component-layout-effect-mount-start-".concat(componentName));
+ }
+ }
+ __name(markComponentLayoutEffectMountStarted, "markComponentLayoutEffectMountStarted");
+ function markComponentLayoutEffectMountStopped() {
+ if (supportsUserTimingV3) {
+ markAndClear("--component-layout-effect-mount-stop");
+ }
+ }
+ __name(markComponentLayoutEffectMountStopped, "markComponentLayoutEffectMountStopped");
+ function markComponentLayoutEffectUnmountStarted(fiber) {
+ if (supportsUserTimingV3) {
+ var componentName = getDisplayNameForFiber(fiber) || "Unknown";
+ markAndClear("--component-layout-effect-unmount-start-".concat(componentName));
+ }
+ }
+ __name(markComponentLayoutEffectUnmountStarted, "markComponentLayoutEffectUnmountStarted");
+ function markComponentLayoutEffectUnmountStopped() {
+ if (supportsUserTimingV3) {
+ markAndClear("--component-layout-effect-unmount-stop");
+ }
+ }
+ __name(markComponentLayoutEffectUnmountStopped, "markComponentLayoutEffectUnmountStopped");
+ function markComponentErrored(fiber, thrownValue, lanes) {
+ if (supportsUserTimingV3) {
+ var componentName = getDisplayNameForFiber(fiber) || "Unknown";
+ var phase = fiber.alternate === null ? "mount" : "update";
+ var message = "";
+ if (thrownValue !== null && _typeof7(thrownValue) === "object" && typeof thrownValue.message === "string") {
+ message = thrownValue.message;
+ } else if (typeof thrownValue === "string") {
+ message = thrownValue;
+ }
+ markAndClear("--error-".concat(componentName, "-").concat(phase, "-").concat(message));
+ }
+ }
+ __name(markComponentErrored, "markComponentErrored");
+ var PossiblyWeakMap = typeof WeakMap === "function" ? WeakMap : Map;
+ var wakeableIDs = new PossiblyWeakMap();
+ var wakeableID = 0;
+ function getWakeableID(wakeable) {
+ if (!wakeableIDs.has(wakeable)) {
+ wakeableIDs.set(wakeable, wakeableID++);
+ }
+ return wakeableIDs.get(wakeable);
+ }
+ __name(getWakeableID, "getWakeableID");
+ function markComponentSuspended(fiber, wakeable, lanes) {
+ if (supportsUserTimingV3) {
+ var eventType = wakeableIDs.has(wakeable) ? "resuspend" : "suspend";
+ var id = getWakeableID(wakeable);
+ var componentName = getDisplayNameForFiber(fiber) || "Unknown";
+ var phase = fiber.alternate === null ? "mount" : "update";
+ var displayName = wakeable.displayName || "";
+ markAndClear("--suspense-".concat(eventType, "-").concat(id, "-").concat(componentName, "-").concat(phase, "-").concat(lanes, "-").concat(displayName));
+ wakeable.then(function() {
+ return markAndClear("--suspense-resolved-".concat(id, "-").concat(componentName));
+ }, function() {
+ return markAndClear("--suspense-rejected-".concat(id, "-").concat(componentName));
+ });
+ }
+ }
+ __name(markComponentSuspended, "markComponentSuspended");
+ function markLayoutEffectsStarted(lanes) {
+ if (supportsUserTimingV3) {
+ markAndClear("--layout-effects-start-".concat(lanes));
+ }
+ }
+ __name(markLayoutEffectsStarted, "markLayoutEffectsStarted");
+ function markLayoutEffectsStopped() {
+ if (supportsUserTimingV3) {
+ markAndClear("--layout-effects-stop");
+ }
+ }
+ __name(markLayoutEffectsStopped, "markLayoutEffectsStopped");
+ function markPassiveEffectsStarted(lanes) {
+ if (supportsUserTimingV3) {
+ markAndClear("--passive-effects-start-".concat(lanes));
+ }
+ }
+ __name(markPassiveEffectsStarted, "markPassiveEffectsStarted");
+ function markPassiveEffectsStopped() {
+ if (supportsUserTimingV3) {
+ markAndClear("--passive-effects-stop");
+ }
+ }
+ __name(markPassiveEffectsStopped, "markPassiveEffectsStopped");
+ function markRenderStarted(lanes) {
+ if (supportsUserTimingV3) {
+ markAndClear("--render-start-".concat(lanes));
+ }
+ }
+ __name(markRenderStarted, "markRenderStarted");
+ function markRenderYielded() {
+ if (supportsUserTimingV3) {
+ markAndClear("--render-yield");
+ }
+ }
+ __name(markRenderYielded, "markRenderYielded");
+ function markRenderStopped() {
+ if (supportsUserTimingV3) {
+ markAndClear("--render-stop");
+ }
+ }
+ __name(markRenderStopped, "markRenderStopped");
+ function markRenderScheduled(lane) {
+ if (supportsUserTimingV3) {
+ markAndClear("--schedule-render-".concat(lane));
+ }
+ }
+ __name(markRenderScheduled, "markRenderScheduled");
+ function markForceUpdateScheduled(fiber, lane) {
+ if (supportsUserTimingV3) {
+ var componentName = getDisplayNameForFiber(fiber) || "Unknown";
+ markAndClear("--schedule-forced-update-".concat(lane, "-").concat(componentName));
+ }
+ }
+ __name(markForceUpdateScheduled, "markForceUpdateScheduled");
+ function markStateUpdateScheduled(fiber, lane) {
+ if (supportsUserTimingV3) {
+ var componentName = getDisplayNameForFiber(fiber) || "Unknown";
+ markAndClear("--schedule-state-update-".concat(lane, "-").concat(componentName));
+ }
+ }
+ __name(markStateUpdateScheduled, "markStateUpdateScheduled");
+ return {
+ markCommitStarted,
+ markCommitStopped,
+ markComponentRenderStarted,
+ markComponentRenderStopped,
+ markComponentPassiveEffectMountStarted,
+ markComponentPassiveEffectMountStopped,
+ markComponentPassiveEffectUnmountStarted,
+ markComponentPassiveEffectUnmountStopped,
+ markComponentLayoutEffectMountStarted,
+ markComponentLayoutEffectMountStopped,
+ markComponentLayoutEffectUnmountStarted,
+ markComponentLayoutEffectUnmountStopped,
+ markComponentErrored,
+ markComponentSuspended,
+ markLayoutEffectsStarted,
+ markLayoutEffectsStopped,
+ markPassiveEffectsStarted,
+ markPassiveEffectsStopped,
+ markRenderStarted,
+ markRenderYielded,
+ markRenderStopped,
+ markRenderScheduled,
+ markForceUpdateScheduled,
+ markStateUpdateScheduled
+ };
+ }
+ __name(createProfilingHooks, "createProfilingHooks");
+ function ownKeys11(object, enumerableOnly) {
+ var keys = Object.keys(object);
+ if (Object.getOwnPropertySymbols) {
+ var symbols = Object.getOwnPropertySymbols(object);
+ if (enumerableOnly)
+ symbols = symbols.filter(function(sym) {
+ return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+ });
+ keys.push.apply(keys, symbols);
+ }
+ return keys;
+ }
+ __name(ownKeys11, "ownKeys");
+ function _objectSpread11(target) {
+ for (var i = 1; i < arguments.length; i++) {
+ var source = arguments[i] != null ? arguments[i] : {};
+ if (i % 2) {
+ ownKeys11(Object(source), true).forEach(function(key) {
+ _defineProperty11(target, key, source[key]);
+ });
+ } else if (Object.getOwnPropertyDescriptors) {
+ Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+ } else {
+ ownKeys11(Object(source)).forEach(function(key) {
+ Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+ });
+ }
+ }
+ return target;
+ }
+ __name(_objectSpread11, "_objectSpread");
+ function _defineProperty11(obj, key, value) {
+ if (key in obj) {
+ Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
+ } else {
+ obj[key] = value;
+ }
+ return obj;
+ }
+ __name(_defineProperty11, "_defineProperty");
+ function renderer_slicedToArray(arr, i) {
+ return renderer_arrayWithHoles(arr) || renderer_iterableToArrayLimit(arr, i) || renderer_unsupportedIterableToArray(arr, i) || renderer_nonIterableRest();
+ }
+ __name(renderer_slicedToArray, "renderer_slicedToArray");
+ function renderer_nonIterableRest() {
+ throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+ }
+ __name(renderer_nonIterableRest, "renderer_nonIterableRest");
+ function renderer_iterableToArrayLimit(arr, i) {
+ if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr)))
+ return;
+ 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 (err) {
+ _d = true;
+ _e = err;
+ } finally {
+ try {
+ if (!_n && _i["return"] != null)
+ _i["return"]();
+ } finally {
+ if (_d)
+ throw _e;
+ }
+ }
+ return _arr;
+ }
+ __name(renderer_iterableToArrayLimit, "renderer_iterableToArrayLimit");
+ function renderer_arrayWithHoles(arr) {
+ if (Array.isArray(arr))
+ return arr;
+ }
+ __name(renderer_arrayWithHoles, "renderer_arrayWithHoles");
+ function _toConsumableArray(arr) {
+ return _arrayWithoutHoles(arr) || _iterableToArray(arr) || renderer_unsupportedIterableToArray(arr) || _nonIterableSpread();
+ }
+ __name(_toConsumableArray, "_toConsumableArray");
+ function _nonIterableSpread() {
+ throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+ }
+ __name(_nonIterableSpread, "_nonIterableSpread");
+ function _iterableToArray(iter) {
+ if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter))
+ return Array.from(iter);
+ }
+ __name(_iterableToArray, "_iterableToArray");
+ function _arrayWithoutHoles(arr) {
+ if (Array.isArray(arr))
+ return renderer_arrayLikeToArray(arr);
+ }
+ __name(_arrayWithoutHoles, "_arrayWithoutHoles");
+ function _createForOfIteratorHelper(o, allowArrayLike) {
+ var it2;
+ if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) {
+ if (Array.isArray(o) || (it2 = renderer_unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
+ if (it2)
+ o = it2;
+ var i = 0;
+ var F = /* @__PURE__ */ __name(function F2() {
+ }, "F");
+ return { s: F, n: /* @__PURE__ */ __name(function n() {
+ if (i >= o.length)
+ return { done: true };
+ return { done: false, value: o[i++] };
+ }, "n"), e: /* @__PURE__ */ __name(function e2(_e2) {
+ throw _e2;
+ }, "e"), f: F };
+ }
+ throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+ }
+ var normalCompletion = true, didErr = false, err;
+ return { s: /* @__PURE__ */ __name(function s() {
+ it2 = o[Symbol.iterator]();
+ }, "s"), n: /* @__PURE__ */ __name(function n() {
+ var step = it2.next();
+ normalCompletion = step.done;
+ return step;
+ }, "n"), e: /* @__PURE__ */ __name(function e2(_e3) {
+ didErr = true;
+ err = _e3;
+ }, "e"), f: /* @__PURE__ */ __name(function f() {
+ try {
+ if (!normalCompletion && it2.return != null)
+ it2.return();
+ } finally {
+ if (didErr)
+ throw err;
+ }
+ }, "f") };
+ }
+ __name(_createForOfIteratorHelper, "_createForOfIteratorHelper");
+ function renderer_unsupportedIterableToArray(o, minLen) {
+ if (!o)
+ return;
+ if (typeof o === "string")
+ return renderer_arrayLikeToArray(o, minLen);
+ var n = Object.prototype.toString.call(o).slice(8, -1);
+ if (n === "Object" && o.constructor)
+ n = o.constructor.name;
+ if (n === "Map" || n === "Set")
+ return Array.from(o);
+ if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))
+ return renderer_arrayLikeToArray(o, minLen);
+ }
+ __name(renderer_unsupportedIterableToArray, "renderer_unsupportedIterableToArray");
+ function renderer_arrayLikeToArray(arr, len) {
+ if (len == null || len > arr.length)
+ len = arr.length;
+ for (var i = 0, arr2 = new Array(len); i < len; i++) {
+ arr2[i] = arr[i];
+ }
+ return arr2;
+ }
+ __name(renderer_arrayLikeToArray, "renderer_arrayLikeToArray");
+ function renderer_typeof(obj) {
+ "@babel/helpers - typeof";
+ if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+ renderer_typeof = /* @__PURE__ */ __name(function _typeof8(obj2) {
+ return typeof obj2;
+ }, "_typeof");
+ } else {
+ renderer_typeof = /* @__PURE__ */ __name(function _typeof8(obj2) {
+ return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+ }, "_typeof");
+ }
+ return renderer_typeof(obj);
+ }
+ __name(renderer_typeof, "renderer_typeof");
+ function getFiberFlags(fiber) {
+ return fiber.flags !== void 0 ? fiber.flags : fiber.effectTag;
+ }
+ __name(getFiberFlags, "getFiberFlags");
+ var getCurrentTime = (typeof performance === "undefined" ? "undefined" : renderer_typeof(performance)) === "object" && typeof performance.now === "function" ? function() {
+ return performance.now();
+ } : function() {
+ return Date.now();
+ };
+ function getInternalReactConstants(version2) {
+ var ReactTypeOfSideEffect = {
+ DidCapture: 128,
+ NoFlags: 0,
+ PerformedWork: 1,
+ Placement: 2,
+ Incomplete: 8192,
+ Hydrating: 4096
+ };
+ var ReactPriorityLevels = {
+ ImmediatePriority: 99,
+ UserBlockingPriority: 98,
+ NormalPriority: 97,
+ LowPriority: 96,
+ IdlePriority: 95,
+ NoPriority: 90
+ };
+ if (Object(semver["gt"])(version2, "17.0.2")) {
+ ReactPriorityLevels = {
+ ImmediatePriority: 1,
+ UserBlockingPriority: 2,
+ NormalPriority: 3,
+ LowPriority: 4,
+ IdlePriority: 5,
+ NoPriority: 0
+ };
+ }
+ var StrictModeBits = 0;
+ if (Object(semver["gte"])(version2, "18.0.0-alpha")) {
+ StrictModeBits = 24;
+ } else if (Object(semver["gte"])(version2, "16.9.0")) {
+ StrictModeBits = 1;
+ } else if (Object(semver["gte"])(version2, "16.3.0")) {
+ StrictModeBits = 2;
+ }
+ var ReactTypeOfWork = null;
+ if (Object(semver["gt"])(version2, "17.0.1")) {
+ ReactTypeOfWork = {
+ CacheComponent: 24,
+ // Experimental
+ ClassComponent: 1,
+ ContextConsumer: 9,
+ ContextProvider: 10,
+ CoroutineComponent: -1,
+ // Removed
+ CoroutineHandlerPhase: -1,
+ // Removed
+ DehydratedSuspenseComponent: 18,
+ // Behind a flag
+ ForwardRef: 11,
+ Fragment: 7,
+ FunctionComponent: 0,
+ HostComponent: 5,
+ HostPortal: 4,
+ HostRoot: 3,
+ HostText: 6,
+ IncompleteClassComponent: 17,
+ IndeterminateComponent: 2,
+ LazyComponent: 16,
+ LegacyHiddenComponent: 23,
+ MemoComponent: 14,
+ Mode: 8,
+ OffscreenComponent: 22,
+ // Experimental
+ Profiler: 12,
+ ScopeComponent: 21,
+ // Experimental
+ SimpleMemoComponent: 15,
+ SuspenseComponent: 13,
+ SuspenseListComponent: 19,
+ // Experimental
+ YieldComponent: -1
+ // Removed
+ };
+ } else if (Object(semver["gte"])(version2, "17.0.0-alpha")) {
+ ReactTypeOfWork = {
+ CacheComponent: -1,
+ // Doesn't exist yet
+ ClassComponent: 1,
+ ContextConsumer: 9,
+ ContextProvider: 10,
+ CoroutineComponent: -1,
+ // Removed
+ CoroutineHandlerPhase: -1,
+ // Removed
+ DehydratedSuspenseComponent: 18,
+ // Behind a flag
+ ForwardRef: 11,
+ Fragment: 7,
+ FunctionComponent: 0,
+ HostComponent: 5,
+ HostPortal: 4,
+ HostRoot: 3,
+ HostText: 6,
+ IncompleteClassComponent: 17,
+ IndeterminateComponent: 2,
+ LazyComponent: 16,
+ LegacyHiddenComponent: 24,
+ MemoComponent: 14,
+ Mode: 8,
+ OffscreenComponent: 23,
+ // Experimental
+ Profiler: 12,
+ ScopeComponent: 21,
+ // Experimental
+ SimpleMemoComponent: 15,
+ SuspenseComponent: 13,
+ SuspenseListComponent: 19,
+ // Experimental
+ YieldComponent: -1
+ // Removed
+ };
+ } else if (Object(semver["gte"])(version2, "16.6.0-beta.0")) {
+ ReactTypeOfWork = {
+ CacheComponent: -1,
+ // Doesn't exist yet
+ ClassComponent: 1,
+ ContextConsumer: 9,
+ ContextProvider: 10,
+ CoroutineComponent: -1,
+ // Removed
+ CoroutineHandlerPhase: -1,
+ // Removed
+ DehydratedSuspenseComponent: 18,
+ // Behind a flag
+ ForwardRef: 11,
+ Fragment: 7,
+ FunctionComponent: 0,
+ HostComponent: 5,
+ HostPortal: 4,
+ HostRoot: 3,
+ HostText: 6,
+ IncompleteClassComponent: 17,
+ IndeterminateComponent: 2,
+ LazyComponent: 16,
+ LegacyHiddenComponent: -1,
+ MemoComponent: 14,
+ Mode: 8,
+ OffscreenComponent: -1,
+ // Experimental
+ Profiler: 12,
+ ScopeComponent: -1,
+ // Experimental
+ SimpleMemoComponent: 15,
+ SuspenseComponent: 13,
+ SuspenseListComponent: 19,
+ // Experimental
+ YieldComponent: -1
+ // Removed
+ };
+ } else if (Object(semver["gte"])(version2, "16.4.3-alpha")) {
+ ReactTypeOfWork = {
+ CacheComponent: -1,
+ // Doesn't exist yet
+ ClassComponent: 2,
+ ContextConsumer: 11,
+ ContextProvider: 12,
+ CoroutineComponent: -1,
+ // Removed
+ CoroutineHandlerPhase: -1,
+ // Removed
+ DehydratedSuspenseComponent: -1,
+ // Doesn't exist yet
+ ForwardRef: 13,
+ Fragment: 9,
+ FunctionComponent: 0,
+ HostComponent: 7,
+ HostPortal: 6,
+ HostRoot: 5,
+ HostText: 8,
+ IncompleteClassComponent: -1,
+ // Doesn't exist yet
+ IndeterminateComponent: 4,
+ LazyComponent: -1,
+ // Doesn't exist yet
+ LegacyHiddenComponent: -1,
+ MemoComponent: -1,
+ // Doesn't exist yet
+ Mode: 10,
+ OffscreenComponent: -1,
+ // Experimental
+ Profiler: 15,
+ ScopeComponent: -1,
+ // Experimental
+ SimpleMemoComponent: -1,
+ // Doesn't exist yet
+ SuspenseComponent: 16,
+ SuspenseListComponent: -1,
+ // Doesn't exist yet
+ YieldComponent: -1
+ // Removed
+ };
+ } else {
+ ReactTypeOfWork = {
+ CacheComponent: -1,
+ // Doesn't exist yet
+ ClassComponent: 2,
+ ContextConsumer: 12,
+ ContextProvider: 13,
+ CoroutineComponent: 7,
+ CoroutineHandlerPhase: 8,
+ DehydratedSuspenseComponent: -1,
+ // Doesn't exist yet
+ ForwardRef: 14,
+ Fragment: 10,
+ FunctionComponent: 1,
+ HostComponent: 5,
+ HostPortal: 4,
+ HostRoot: 3,
+ HostText: 6,
+ IncompleteClassComponent: -1,
+ // Doesn't exist yet
+ IndeterminateComponent: 0,
+ LazyComponent: -1,
+ // Doesn't exist yet
+ LegacyHiddenComponent: -1,
+ MemoComponent: -1,
+ // Doesn't exist yet
+ Mode: 11,
+ OffscreenComponent: -1,
+ // Experimental
+ Profiler: 15,
+ ScopeComponent: -1,
+ // Experimental
+ SimpleMemoComponent: -1,
+ // Doesn't exist yet
+ SuspenseComponent: 16,
+ SuspenseListComponent: -1,
+ // Doesn't exist yet
+ YieldComponent: 9
+ };
+ }
+ function getTypeSymbol(type) {
+ var symbolOrNumber = renderer_typeof(type) === "object" && type !== null ? type.$$typeof : type;
+ return renderer_typeof(symbolOrNumber) === "symbol" ? symbolOrNumber.toString() : symbolOrNumber;
+ }
+ __name(getTypeSymbol, "getTypeSymbol");
+ var _ReactTypeOfWork = ReactTypeOfWork, CacheComponent = _ReactTypeOfWork.CacheComponent, ClassComponent = _ReactTypeOfWork.ClassComponent, IncompleteClassComponent = _ReactTypeOfWork.IncompleteClassComponent, FunctionComponent = _ReactTypeOfWork.FunctionComponent, IndeterminateComponent = _ReactTypeOfWork.IndeterminateComponent, ForwardRef = _ReactTypeOfWork.ForwardRef, HostRoot = _ReactTypeOfWork.HostRoot, HostComponent = _ReactTypeOfWork.HostComponent, HostPortal = _ReactTypeOfWork.HostPortal, HostText = _ReactTypeOfWork.HostText, Fragment = _ReactTypeOfWork.Fragment, LazyComponent = _ReactTypeOfWork.LazyComponent, LegacyHiddenComponent = _ReactTypeOfWork.LegacyHiddenComponent, MemoComponent = _ReactTypeOfWork.MemoComponent, OffscreenComponent = _ReactTypeOfWork.OffscreenComponent, Profiler = _ReactTypeOfWork.Profiler, ScopeComponent = _ReactTypeOfWork.ScopeComponent, SimpleMemoComponent = _ReactTypeOfWork.SimpleMemoComponent, SuspenseComponent = _ReactTypeOfWork.SuspenseComponent, SuspenseListComponent = _ReactTypeOfWork.SuspenseListComponent;
+ function resolveFiberType(type) {
+ var typeSymbol = getTypeSymbol(type);
+ switch (typeSymbol) {
+ case ReactSymbols[
+ "j"
+ /* MEMO_NUMBER */
+ ]:
+ case ReactSymbols[
+ "k"
+ /* MEMO_SYMBOL_STRING */
+ ]:
+ return resolveFiberType(type.type);
+ case ReactSymbols[
+ "f"
+ /* FORWARD_REF_NUMBER */
+ ]:
+ case ReactSymbols[
+ "g"
+ /* FORWARD_REF_SYMBOL_STRING */
+ ]:
+ return type.render;
+ default:
+ return type;
+ }
+ }
+ __name(resolveFiberType, "resolveFiberType");
+ function getDisplayNameForFiber(fiber) {
+ var elementType = fiber.elementType, type = fiber.type, tag = fiber.tag;
+ var resolvedType = type;
+ if (renderer_typeof(type) === "object" && type !== null) {
+ resolvedType = resolveFiberType(type);
+ }
+ var resolvedContext = null;
+ switch (tag) {
+ case CacheComponent:
+ return "Cache";
+ case ClassComponent:
+ case IncompleteClassComponent:
+ return Object(utils[
+ "f"
+ /* getDisplayName */
+ ])(resolvedType);
+ case FunctionComponent:
+ case IndeterminateComponent:
+ return Object(utils[
+ "f"
+ /* getDisplayName */
+ ])(resolvedType);
+ case ForwardRef:
+ return type && type.displayName || Object(utils[
+ "f"
+ /* getDisplayName */
+ ])(resolvedType, "Anonymous");
+ case HostRoot:
+ var fiberRoot = fiber.stateNode;
+ if (fiberRoot != null && fiberRoot._debugRootType !== null) {
+ return fiberRoot._debugRootType;
+ }
+ return null;
+ case HostComponent:
+ return type;
+ case HostPortal:
+ case HostText:
+ case Fragment:
+ return null;
+ case LazyComponent:
+ return "Lazy";
+ case MemoComponent:
+ case SimpleMemoComponent:
+ return elementType && elementType.displayName || type && type.displayName || Object(utils[
+ "f"
+ /* getDisplayName */
+ ])(resolvedType, "Anonymous");
+ case SuspenseComponent:
+ return "Suspense";
+ case LegacyHiddenComponent:
+ return "LegacyHidden";
+ case OffscreenComponent:
+ return "Offscreen";
+ case ScopeComponent:
+ return "Scope";
+ case SuspenseListComponent:
+ return "SuspenseList";
+ case Profiler:
+ return "Profiler";
+ default:
+ var typeSymbol = getTypeSymbol(type);
+ switch (typeSymbol) {
+ case ReactSymbols[
+ "a"
+ /* CONCURRENT_MODE_NUMBER */
+ ]:
+ case ReactSymbols[
+ "b"
+ /* CONCURRENT_MODE_SYMBOL_STRING */
+ ]:
+ case ReactSymbols[
+ "e"
+ /* DEPRECATED_ASYNC_MODE_SYMBOL_STRING */
+ ]:
+ return null;
+ case ReactSymbols[
+ "n"
+ /* PROVIDER_NUMBER */
+ ]:
+ case ReactSymbols[
+ "o"
+ /* PROVIDER_SYMBOL_STRING */
+ ]:
+ resolvedContext = fiber.type._context || fiber.type.context;
+ return "".concat(resolvedContext.displayName || "Context", ".Provider");
+ case ReactSymbols[
+ "c"
+ /* CONTEXT_NUMBER */
+ ]:
+ case ReactSymbols[
+ "d"
+ /* CONTEXT_SYMBOL_STRING */
+ ]:
+ resolvedContext = fiber.type._context || fiber.type;
+ return "".concat(resolvedContext.displayName || "Context", ".Consumer");
+ case ReactSymbols[
+ "r"
+ /* STRICT_MODE_NUMBER */
+ ]:
+ case ReactSymbols[
+ "s"
+ /* STRICT_MODE_SYMBOL_STRING */
+ ]:
+ return null;
+ case ReactSymbols[
+ "l"
+ /* PROFILER_NUMBER */
+ ]:
+ case ReactSymbols[
+ "m"
+ /* PROFILER_SYMBOL_STRING */
+ ]:
+ return "Profiler(".concat(fiber.memoizedProps.id, ")");
+ case ReactSymbols[
+ "p"
+ /* SCOPE_NUMBER */
+ ]:
+ case ReactSymbols[
+ "q"
+ /* SCOPE_SYMBOL_STRING */
+ ]:
+ return "Scope";
+ default:
+ return null;
+ }
+ }
+ }
+ __name(getDisplayNameForFiber, "getDisplayNameForFiber");
+ return {
+ getDisplayNameForFiber,
+ getTypeSymbol,
+ ReactPriorityLevels,
+ ReactTypeOfWork,
+ ReactTypeOfSideEffect,
+ StrictModeBits
+ };
+ }
+ __name(getInternalReactConstants, "getInternalReactConstants");
+ function attach(hook, rendererID, renderer, global2) {
+ var version2 = renderer.reconcilerVersion || renderer.version;
+ var _getInternalReactCons = getInternalReactConstants(version2), getDisplayNameForFiber = _getInternalReactCons.getDisplayNameForFiber, getTypeSymbol = _getInternalReactCons.getTypeSymbol, ReactPriorityLevels = _getInternalReactCons.ReactPriorityLevels, ReactTypeOfWork = _getInternalReactCons.ReactTypeOfWork, ReactTypeOfSideEffect = _getInternalReactCons.ReactTypeOfSideEffect, StrictModeBits = _getInternalReactCons.StrictModeBits;
+ var DidCapture = ReactTypeOfSideEffect.DidCapture, Hydrating = ReactTypeOfSideEffect.Hydrating, NoFlags = ReactTypeOfSideEffect.NoFlags, PerformedWork = ReactTypeOfSideEffect.PerformedWork, Placement = ReactTypeOfSideEffect.Placement;
+ var CacheComponent = ReactTypeOfWork.CacheComponent, ClassComponent = ReactTypeOfWork.ClassComponent, ContextConsumer = ReactTypeOfWork.ContextConsumer, DehydratedSuspenseComponent = ReactTypeOfWork.DehydratedSuspenseComponent, ForwardRef = ReactTypeOfWork.ForwardRef, Fragment = ReactTypeOfWork.Fragment, FunctionComponent = ReactTypeOfWork.FunctionComponent, HostRoot = ReactTypeOfWork.HostRoot, HostPortal = ReactTypeOfWork.HostPortal, HostComponent = ReactTypeOfWork.HostComponent, HostText = ReactTypeOfWork.HostText, IncompleteClassComponent = ReactTypeOfWork.IncompleteClassComponent, IndeterminateComponent = ReactTypeOfWork.IndeterminateComponent, LegacyHiddenComponent = ReactTypeOfWork.LegacyHiddenComponent, MemoComponent = ReactTypeOfWork.MemoComponent, OffscreenComponent = ReactTypeOfWork.OffscreenComponent, SimpleMemoComponent = ReactTypeOfWork.SimpleMemoComponent, SuspenseComponent = ReactTypeOfWork.SuspenseComponent, SuspenseListComponent = ReactTypeOfWork.SuspenseListComponent;
+ var ImmediatePriority = ReactPriorityLevels.ImmediatePriority, UserBlockingPriority = ReactPriorityLevels.UserBlockingPriority, NormalPriority = ReactPriorityLevels.NormalPriority, LowPriority = ReactPriorityLevels.LowPriority, IdlePriority = ReactPriorityLevels.IdlePriority, NoPriority = ReactPriorityLevels.NoPriority;
+ var getLaneLabelMap = renderer.getLaneLabelMap, injectProfilingHooks = renderer.injectProfilingHooks, overrideHookState = renderer.overrideHookState, overrideHookStateDeletePath = renderer.overrideHookStateDeletePath, overrideHookStateRenamePath = renderer.overrideHookStateRenamePath, overrideProps = renderer.overrideProps, overridePropsDeletePath = renderer.overridePropsDeletePath, overridePropsRenamePath = renderer.overridePropsRenamePath, scheduleRefresh = renderer.scheduleRefresh, setErrorHandler = renderer.setErrorHandler, setSuspenseHandler = renderer.setSuspenseHandler, scheduleUpdate = renderer.scheduleUpdate;
+ var supportsTogglingError = typeof setErrorHandler === "function" && typeof scheduleUpdate === "function";
+ var supportsTogglingSuspense = typeof setSuspenseHandler === "function" && typeof scheduleUpdate === "function";
+ if (typeof scheduleRefresh === "function") {
+ renderer.scheduleRefresh = function() {
+ try {
+ hook.emit("fastRefreshScheduled");
+ } finally {
+ return scheduleRefresh.apply(void 0, arguments);
+ }
+ };
+ }
+ if (typeof injectProfilingHooks === "function") {
+ injectProfilingHooks(createProfilingHooks({
+ getDisplayNameForFiber,
+ getLaneLabelMap,
+ reactVersion: version2
+ }));
+ }
+ var fibersWithChangedErrorOrWarningCounts = /* @__PURE__ */ new Set();
+ var pendingFiberToErrorsMap = /* @__PURE__ */ new Map();
+ var pendingFiberToWarningsMap = /* @__PURE__ */ new Map();
+ var fiberIDToErrorsMap = /* @__PURE__ */ new Map();
+ var fiberIDToWarningsMap = /* @__PURE__ */ new Map();
+ function clearErrorsAndWarnings() {
+ var _iterator = _createForOfIteratorHelper(fiberIDToErrorsMap.keys()), _step;
+ try {
+ for (_iterator.s(); !(_step = _iterator.n()).done; ) {
+ var id = _step.value;
+ var _fiber = idToArbitraryFiberMap.get(id);
+ if (_fiber != null) {
+ fibersWithChangedErrorOrWarningCounts.add(_fiber);
+ updateMostRecentlyInspectedElementIfNecessary(id);
+ }
+ }
+ } catch (err) {
+ _iterator.e(err);
+ } finally {
+ _iterator.f();
+ }
+ var _iterator2 = _createForOfIteratorHelper(fiberIDToWarningsMap.keys()), _step2;
+ try {
+ for (_iterator2.s(); !(_step2 = _iterator2.n()).done; ) {
+ var _id = _step2.value;
+ var _fiber2 = idToArbitraryFiberMap.get(_id);
+ if (_fiber2 != null) {
+ fibersWithChangedErrorOrWarningCounts.add(_fiber2);
+ updateMostRecentlyInspectedElementIfNecessary(_id);
+ }
+ }
+ } catch (err) {
+ _iterator2.e(err);
+ } finally {
+ _iterator2.f();
+ }
+ fiberIDToErrorsMap.clear();
+ fiberIDToWarningsMap.clear();
+ flushPendingEvents();
+ }
+ __name(clearErrorsAndWarnings, "clearErrorsAndWarnings");
+ function clearMessageCountHelper(fiberID, pendingFiberToMessageCountMap, fiberIDToMessageCountMap) {
+ var fiber = idToArbitraryFiberMap.get(fiberID);
+ if (fiber != null) {
+ pendingFiberToErrorsMap.delete(fiber);
+ if (fiberIDToMessageCountMap.has(fiberID)) {
+ fiberIDToMessageCountMap.delete(fiberID);
+ fibersWithChangedErrorOrWarningCounts.add(fiber);
+ flushPendingEvents();
+ updateMostRecentlyInspectedElementIfNecessary(fiberID);
+ } else {
+ fibersWithChangedErrorOrWarningCounts.delete(fiber);
+ }
+ }
+ }
+ __name(clearMessageCountHelper, "clearMessageCountHelper");
+ function clearErrorsForFiberID(fiberID) {
+ clearMessageCountHelper(fiberID, pendingFiberToErrorsMap, fiberIDToErrorsMap);
+ }
+ __name(clearErrorsForFiberID, "clearErrorsForFiberID");
+ function clearWarningsForFiberID(fiberID) {
+ clearMessageCountHelper(fiberID, pendingFiberToWarningsMap, fiberIDToWarningsMap);
+ }
+ __name(clearWarningsForFiberID, "clearWarningsForFiberID");
+ function updateMostRecentlyInspectedElementIfNecessary(fiberID) {
+ if (mostRecentlyInspectedElement !== null && mostRecentlyInspectedElement.id === fiberID) {
+ hasElementUpdatedSinceLastInspected = true;
+ }
+ }
+ __name(updateMostRecentlyInspectedElementIfNecessary, "updateMostRecentlyInspectedElementIfNecessary");
+ function onErrorOrWarning(fiber, type, args) {
+ if (type === "error") {
+ var maybeID = getFiberIDUnsafe(fiber);
+ if (maybeID != null && forceErrorForFiberIDs.get(maybeID) === true) {
+ return;
+ }
+ }
+ var message = backend_utils[
+ "f"
+ /* format */
+ ].apply(void 0, _toConsumableArray(args));
+ if (constants3[
+ "q"
+ /* __DEBUG__ */
+ ]) {
+ debug("onErrorOrWarning", fiber, null, "".concat(type, ': "').concat(message, '"'));
+ }
+ fibersWithChangedErrorOrWarningCounts.add(fiber);
+ var fiberMap = type === "error" ? pendingFiberToErrorsMap : pendingFiberToWarningsMap;
+ var messageMap = fiberMap.get(fiber);
+ if (messageMap != null) {
+ var count = messageMap.get(message) || 0;
+ messageMap.set(message, count + 1);
+ } else {
+ fiberMap.set(fiber, /* @__PURE__ */ new Map([[message, 1]]));
+ }
+ flushPendingErrorsAndWarningsAfterDelay();
+ }
+ __name(onErrorOrWarning, "onErrorOrWarning");
+ if (true) {
+ Object(backend_console[
+ "c"
+ /* registerRenderer */
+ ])(renderer, onErrorOrWarning);
+ var appendComponentStack = window.__REACT_DEVTOOLS_APPEND_COMPONENT_STACK__ !== false;
+ var breakOnConsoleErrors = window.__REACT_DEVTOOLS_BREAK_ON_CONSOLE_ERRORS__ === true;
+ var showInlineWarningsAndErrors = window.__REACT_DEVTOOLS_SHOW_INLINE_WARNINGS_AND_ERRORS__ !== false;
+ var hideConsoleLogsInStrictMode = window.__REACT_DEVTOOLS_HIDE_CONSOLE_LOGS_IN_STRICT_MODE__ === true;
+ var browserTheme = window.__REACT_DEVTOOLS_BROWSER_THEME__;
+ Object(backend_console[
+ "a"
+ /* patch */
+ ])({
+ appendComponentStack,
+ breakOnConsoleErrors,
+ showInlineWarningsAndErrors,
+ hideConsoleLogsInStrictMode,
+ browserTheme
+ });
+ }
+ var debug = /* @__PURE__ */ __name(function debug2(name, fiber, parentFiber) {
+ var extraString = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : "";
+ if (constants3[
+ "q"
+ /* __DEBUG__ */
+ ]) {
+ var displayName = fiber.tag + ":" + (getDisplayNameForFiber(fiber) || "null");
+ var maybeID = getFiberIDUnsafe(fiber) || "";
+ var parentDisplayName = parentFiber ? parentFiber.tag + ":" + (getDisplayNameForFiber(parentFiber) || "null") : "";
+ var maybeParentID = parentFiber ? getFiberIDUnsafe(parentFiber) || "" : "";
+ console.groupCollapsed("[renderer] %c".concat(name, " %c").concat(displayName, " (").concat(maybeID, ") %c").concat(parentFiber ? "".concat(parentDisplayName, " (").concat(maybeParentID, ")") : "", " %c").concat(extraString), "color: red; font-weight: bold;", "color: blue;", "color: purple;", "color: black;");
+ console.log(new Error().stack.split("\n").slice(1).join("\n"));
+ console.groupEnd();
+ }
+ }, "debug");
+ var hideElementsWithDisplayNames = /* @__PURE__ */ new Set();
+ var hideElementsWithPaths = /* @__PURE__ */ new Set();
+ var hideElementsWithTypes = /* @__PURE__ */ new Set();
+ var traceUpdatesEnabled = false;
+ var traceUpdatesForNodes = /* @__PURE__ */ new Set();
+ function applyComponentFilters(componentFilters) {
+ hideElementsWithTypes.clear();
+ hideElementsWithDisplayNames.clear();
+ hideElementsWithPaths.clear();
+ componentFilters.forEach(function(componentFilter) {
+ if (!componentFilter.isEnabled) {
+ return;
+ }
+ switch (componentFilter.type) {
+ case types[
+ "a"
+ /* ComponentFilterDisplayName */
+ ]:
+ if (componentFilter.isValid && componentFilter.value !== "") {
+ hideElementsWithDisplayNames.add(new RegExp(componentFilter.value, "i"));
+ }
+ break;
+ case types[
+ "b"
+ /* ComponentFilterElementType */
+ ]:
+ hideElementsWithTypes.add(componentFilter.value);
+ break;
+ case types[
+ "d"
+ /* ComponentFilterLocation */
+ ]:
+ if (componentFilter.isValid && componentFilter.value !== "") {
+ hideElementsWithPaths.add(new RegExp(componentFilter.value, "i"));
+ }
+ break;
+ case types[
+ "c"
+ /* ComponentFilterHOC */
+ ]:
+ hideElementsWithDisplayNames.add(new RegExp("\\("));
+ break;
+ default:
+ console.warn('Invalid component filter type "'.concat(componentFilter.type, '"'));
+ break;
+ }
+ });
+ }
+ __name(applyComponentFilters, "applyComponentFilters");
+ if (window.__REACT_DEVTOOLS_COMPONENT_FILTERS__ != null) {
+ applyComponentFilters(window.__REACT_DEVTOOLS_COMPONENT_FILTERS__);
+ } else {
+ applyComponentFilters(Object(utils[
+ "e"
+ /* getDefaultComponentFilters */
+ ])());
+ }
+ function updateComponentFilters(componentFilters) {
+ if (isProfiling) {
+ throw Error("Cannot modify filter preferences while profiling");
+ }
+ hook.getFiberRoots(rendererID).forEach(function(root) {
+ currentRootID = getOrGenerateFiberID(root.current);
+ pushOperation(constants3[
+ "l"
+ /* TREE_OPERATION_REMOVE_ROOT */
+ ]);
+ flushPendingEvents(root);
+ currentRootID = -1;
+ });
+ applyComponentFilters(componentFilters);
+ rootDisplayNameCounter.clear();
+ hook.getFiberRoots(rendererID).forEach(function(root) {
+ currentRootID = getOrGenerateFiberID(root.current);
+ setRootPseudoKey(currentRootID, root.current);
+ mountFiberRecursively(root.current, null, false, false);
+ flushPendingEvents(root);
+ currentRootID = -1;
+ });
+ reevaluateErrorsAndWarnings();
+ flushPendingEvents();
+ }
+ __name(updateComponentFilters, "updateComponentFilters");
+ function shouldFilterFiber(fiber) {
+ var _debugSource = fiber._debugSource, tag = fiber.tag, type = fiber.type;
+ switch (tag) {
+ case DehydratedSuspenseComponent:
+ return true;
+ case HostPortal:
+ case HostText:
+ case Fragment:
+ case LegacyHiddenComponent:
+ case OffscreenComponent:
+ return true;
+ case HostRoot:
+ return false;
+ default:
+ var typeSymbol = getTypeSymbol(type);
+ switch (typeSymbol) {
+ case ReactSymbols[
+ "a"
+ /* CONCURRENT_MODE_NUMBER */
+ ]:
+ case ReactSymbols[
+ "b"
+ /* CONCURRENT_MODE_SYMBOL_STRING */
+ ]:
+ case ReactSymbols[
+ "e"
+ /* DEPRECATED_ASYNC_MODE_SYMBOL_STRING */
+ ]:
+ case ReactSymbols[
+ "r"
+ /* STRICT_MODE_NUMBER */
+ ]:
+ case ReactSymbols[
+ "s"
+ /* STRICT_MODE_SYMBOL_STRING */
+ ]:
+ return true;
+ default:
+ break;
+ }
+ }
+ var elementType = getElementTypeForFiber(fiber);
+ if (hideElementsWithTypes.has(elementType)) {
+ return true;
+ }
+ if (hideElementsWithDisplayNames.size > 0) {
+ var displayName = getDisplayNameForFiber(fiber);
+ if (displayName != null) {
+ var _iterator3 = _createForOfIteratorHelper(hideElementsWithDisplayNames), _step3;
+ try {
+ for (_iterator3.s(); !(_step3 = _iterator3.n()).done; ) {
+ var displayNameRegExp = _step3.value;
+ if (displayNameRegExp.test(displayName)) {
+ return true;
+ }
+ }
+ } catch (err) {
+ _iterator3.e(err);
+ } finally {
+ _iterator3.f();
+ }
+ }
+ }
+ if (_debugSource != null && hideElementsWithPaths.size > 0) {
+ var fileName = _debugSource.fileName;
+ var _iterator4 = _createForOfIteratorHelper(hideElementsWithPaths), _step4;
+ try {
+ for (_iterator4.s(); !(_step4 = _iterator4.n()).done; ) {
+ var pathRegExp = _step4.value;
+ if (pathRegExp.test(fileName)) {
+ return true;
+ }
+ }
+ } catch (err) {
+ _iterator4.e(err);
+ } finally {
+ _iterator4.f();
+ }
+ }
+ return false;
+ }
+ __name(shouldFilterFiber, "shouldFilterFiber");
+ function getElementTypeForFiber(fiber) {
+ var type = fiber.type, tag = fiber.tag;
+ switch (tag) {
+ case ClassComponent:
+ case IncompleteClassComponent:
+ return types[
+ "e"
+ /* ElementTypeClass */
+ ];
+ case FunctionComponent:
+ case IndeterminateComponent:
+ return types[
+ "h"
+ /* ElementTypeFunction */
+ ];
+ case ForwardRef:
+ return types[
+ "g"
+ /* ElementTypeForwardRef */
+ ];
+ case HostRoot:
+ return types[
+ "m"
+ /* ElementTypeRoot */
+ ];
+ case HostComponent:
+ return types[
+ "i"
+ /* ElementTypeHostComponent */
+ ];
+ case HostPortal:
+ case HostText:
+ case Fragment:
+ return types[
+ "k"
+ /* ElementTypeOtherOrUnknown */
+ ];
+ case MemoComponent:
+ case SimpleMemoComponent:
+ return types[
+ "j"
+ /* ElementTypeMemo */
+ ];
+ case SuspenseComponent:
+ return types[
+ "n"
+ /* ElementTypeSuspense */
+ ];
+ case SuspenseListComponent:
+ return types[
+ "o"
+ /* ElementTypeSuspenseList */
+ ];
+ default:
+ var typeSymbol = getTypeSymbol(type);
+ switch (typeSymbol) {
+ case ReactSymbols[
+ "a"
+ /* CONCURRENT_MODE_NUMBER */
+ ]:
+ case ReactSymbols[
+ "b"
+ /* CONCURRENT_MODE_SYMBOL_STRING */
+ ]:
+ case ReactSymbols[
+ "e"
+ /* DEPRECATED_ASYNC_MODE_SYMBOL_STRING */
+ ]:
+ return types[
+ "k"
+ /* ElementTypeOtherOrUnknown */
+ ];
+ case ReactSymbols[
+ "n"
+ /* PROVIDER_NUMBER */
+ ]:
+ case ReactSymbols[
+ "o"
+ /* PROVIDER_SYMBOL_STRING */
+ ]:
+ return types[
+ "f"
+ /* ElementTypeContext */
+ ];
+ case ReactSymbols[
+ "c"
+ /* CONTEXT_NUMBER */
+ ]:
+ case ReactSymbols[
+ "d"
+ /* CONTEXT_SYMBOL_STRING */
+ ]:
+ return types[
+ "f"
+ /* ElementTypeContext */
+ ];
+ case ReactSymbols[
+ "r"
+ /* STRICT_MODE_NUMBER */
+ ]:
+ case ReactSymbols[
+ "s"
+ /* STRICT_MODE_SYMBOL_STRING */
+ ]:
+ return types[
+ "k"
+ /* ElementTypeOtherOrUnknown */
+ ];
+ case ReactSymbols[
+ "l"
+ /* PROFILER_NUMBER */
+ ]:
+ case ReactSymbols[
+ "m"
+ /* PROFILER_SYMBOL_STRING */
+ ]:
+ return types[
+ "l"
+ /* ElementTypeProfiler */
+ ];
+ default:
+ return types[
+ "k"
+ /* ElementTypeOtherOrUnknown */
+ ];
+ }
+ }
+ }
+ __name(getElementTypeForFiber, "getElementTypeForFiber");
+ var fiberToIDMap = /* @__PURE__ */ new Map();
+ var idToArbitraryFiberMap = /* @__PURE__ */ new Map();
+ var idToTreeBaseDurationMap = /* @__PURE__ */ new Map();
+ var idToRootMap = /* @__PURE__ */ new Map();
+ var currentRootID = -1;
+ function getOrGenerateFiberID(fiber) {
+ var id = null;
+ if (fiberToIDMap.has(fiber)) {
+ id = fiberToIDMap.get(fiber);
+ } else {
+ var _alternate = fiber.alternate;
+ if (_alternate !== null && fiberToIDMap.has(_alternate)) {
+ id = fiberToIDMap.get(_alternate);
+ }
+ }
+ var didGenerateID = false;
+ if (id === null) {
+ didGenerateID = true;
+ id = Object(utils[
+ "i"
+ /* getUID */
+ ])();
+ }
+ var refinedID = id;
+ if (!fiberToIDMap.has(fiber)) {
+ fiberToIDMap.set(fiber, refinedID);
+ idToArbitraryFiberMap.set(refinedID, fiber);
+ }
+ var alternate = fiber.alternate;
+ if (alternate !== null) {
+ if (!fiberToIDMap.has(alternate)) {
+ fiberToIDMap.set(alternate, refinedID);
+ }
+ }
+ if (constants3[
+ "q"
+ /* __DEBUG__ */
+ ]) {
+ if (didGenerateID) {
+ debug("getOrGenerateFiberID()", fiber, fiber.return, "Generated a new UID");
+ }
+ }
+ return refinedID;
+ }
+ __name(getOrGenerateFiberID, "getOrGenerateFiberID");
+ function getFiberIDThrows(fiber) {
+ var maybeID = getFiberIDUnsafe(fiber);
+ if (maybeID !== null) {
+ return maybeID;
+ }
+ throw Error('Could not find ID for Fiber "'.concat(getDisplayNameForFiber(fiber) || "", '"'));
+ }
+ __name(getFiberIDThrows, "getFiberIDThrows");
+ function getFiberIDUnsafe(fiber) {
+ if (fiberToIDMap.has(fiber)) {
+ return fiberToIDMap.get(fiber);
+ } else {
+ var alternate = fiber.alternate;
+ if (alternate !== null && fiberToIDMap.has(alternate)) {
+ return fiberToIDMap.get(alternate);
+ }
+ }
+ return null;
+ }
+ __name(getFiberIDUnsafe, "getFiberIDUnsafe");
+ function untrackFiberID(fiber) {
+ if (constants3[
+ "q"
+ /* __DEBUG__ */
+ ]) {
+ debug("untrackFiberID()", fiber, fiber.return, "schedule after delay");
+ }
+ untrackFibersSet.add(fiber);
+ var alternate = fiber.alternate;
+ if (alternate !== null) {
+ untrackFibersSet.add(alternate);
+ }
+ if (untrackFibersTimeoutID === null) {
+ untrackFibersTimeoutID = setTimeout(untrackFibers, 1e3);
+ }
+ }
+ __name(untrackFiberID, "untrackFiberID");
+ var untrackFibersSet = /* @__PURE__ */ new Set();
+ var untrackFibersTimeoutID = null;
+ function untrackFibers() {
+ if (untrackFibersTimeoutID !== null) {
+ clearTimeout(untrackFibersTimeoutID);
+ untrackFibersTimeoutID = null;
+ }
+ untrackFibersSet.forEach(function(fiber) {
+ var fiberID = getFiberIDUnsafe(fiber);
+ if (fiberID !== null) {
+ idToArbitraryFiberMap.delete(fiberID);
+ clearErrorsForFiberID(fiberID);
+ clearWarningsForFiberID(fiberID);
+ }
+ fiberToIDMap.delete(fiber);
+ var alternate = fiber.alternate;
+ if (alternate !== null) {
+ fiberToIDMap.delete(alternate);
+ }
+ if (forceErrorForFiberIDs.has(fiberID)) {
+ forceErrorForFiberIDs.delete(fiberID);
+ if (forceErrorForFiberIDs.size === 0 && setErrorHandler != null) {
+ setErrorHandler(shouldErrorFiberAlwaysNull);
+ }
+ }
+ });
+ untrackFibersSet.clear();
+ }
+ __name(untrackFibers, "untrackFibers");
+ function getChangeDescription(prevFiber, nextFiber) {
+ switch (getElementTypeForFiber(nextFiber)) {
+ case types[
+ "e"
+ /* ElementTypeClass */
+ ]:
+ case types[
+ "h"
+ /* ElementTypeFunction */
+ ]:
+ case types[
+ "j"
+ /* ElementTypeMemo */
+ ]:
+ case types[
+ "g"
+ /* ElementTypeForwardRef */
+ ]:
+ if (prevFiber === null) {
+ return {
+ context: null,
+ didHooksChange: false,
+ isFirstMount: true,
+ props: null,
+ state: null
+ };
+ } else {
+ var data = {
+ context: getContextChangedKeys(nextFiber),
+ didHooksChange: false,
+ isFirstMount: false,
+ props: getChangedKeys(prevFiber.memoizedProps, nextFiber.memoizedProps),
+ state: getChangedKeys(prevFiber.memoizedState, nextFiber.memoizedState)
+ };
+ if (DevToolsFeatureFlags_core_oss[
+ "b"
+ /* enableProfilerChangedHookIndices */
+ ]) {
+ var indices = getChangedHooksIndices(prevFiber.memoizedState, nextFiber.memoizedState);
+ data.hooks = indices;
+ data.didHooksChange = indices !== null && indices.length > 0;
+ } else {
+ data.didHooksChange = didHooksChange(prevFiber.memoizedState, nextFiber.memoizedState);
+ }
+ return data;
+ }
+ default:
+ return null;
+ }
+ }
+ __name(getChangeDescription, "getChangeDescription");
+ function updateContextsForFiber(fiber) {
+ switch (getElementTypeForFiber(fiber)) {
+ case types[
+ "e"
+ /* ElementTypeClass */
+ ]:
+ case types[
+ "g"
+ /* ElementTypeForwardRef */
+ ]:
+ case types[
+ "h"
+ /* ElementTypeFunction */
+ ]:
+ case types[
+ "j"
+ /* ElementTypeMemo */
+ ]:
+ if (idToContextsMap !== null) {
+ var id = getFiberIDThrows(fiber);
+ var contexts = getContextsForFiber(fiber);
+ if (contexts !== null) {
+ idToContextsMap.set(id, contexts);
+ }
+ }
+ break;
+ default:
+ break;
+ }
+ }
+ __name(updateContextsForFiber, "updateContextsForFiber");
+ var NO_CONTEXT = {};
+ function getContextsForFiber(fiber) {
+ var legacyContext = NO_CONTEXT;
+ var modernContext = NO_CONTEXT;
+ switch (getElementTypeForFiber(fiber)) {
+ case types[
+ "e"
+ /* ElementTypeClass */
+ ]:
+ var instance = fiber.stateNode;
+ if (instance != null) {
+ if (instance.constructor && instance.constructor.contextType != null) {
+ modernContext = instance.context;
+ } else {
+ legacyContext = instance.context;
+ if (legacyContext && Object.keys(legacyContext).length === 0) {
+ legacyContext = NO_CONTEXT;
+ }
+ }
+ }
+ return [legacyContext, modernContext];
+ case types[
+ "g"
+ /* ElementTypeForwardRef */
+ ]:
+ case types[
+ "h"
+ /* ElementTypeFunction */
+ ]:
+ case types[
+ "j"
+ /* ElementTypeMemo */
+ ]:
+ var dependencies = fiber.dependencies;
+ if (dependencies && dependencies.firstContext) {
+ modernContext = dependencies.firstContext;
+ }
+ return [legacyContext, modernContext];
+ default:
+ return null;
+ }
+ }
+ __name(getContextsForFiber, "getContextsForFiber");
+ function crawlToInitializeContextsMap(fiber) {
+ var id = getFiberIDUnsafe(fiber);
+ if (id !== null) {
+ updateContextsForFiber(fiber);
+ var current = fiber.child;
+ while (current !== null) {
+ crawlToInitializeContextsMap(current);
+ current = current.sibling;
+ }
+ }
+ }
+ __name(crawlToInitializeContextsMap, "crawlToInitializeContextsMap");
+ function getContextChangedKeys(fiber) {
+ if (idToContextsMap !== null) {
+ var id = getFiberIDThrows(fiber);
+ var prevContexts = idToContextsMap.has(id) ? idToContextsMap.get(id) : null;
+ var nextContexts = getContextsForFiber(fiber);
+ if (prevContexts == null || nextContexts == null) {
+ return null;
+ }
+ var _prevContexts = renderer_slicedToArray(prevContexts, 2), prevLegacyContext = _prevContexts[0], prevModernContext = _prevContexts[1];
+ var _nextContexts = renderer_slicedToArray(nextContexts, 2), nextLegacyContext = _nextContexts[0], nextModernContext = _nextContexts[1];
+ switch (getElementTypeForFiber(fiber)) {
+ case types[
+ "e"
+ /* ElementTypeClass */
+ ]:
+ if (prevContexts && nextContexts) {
+ if (nextLegacyContext !== NO_CONTEXT) {
+ return getChangedKeys(prevLegacyContext, nextLegacyContext);
+ } else if (nextModernContext !== NO_CONTEXT) {
+ return prevModernContext !== nextModernContext;
+ }
+ }
+ break;
+ case types[
+ "g"
+ /* ElementTypeForwardRef */
+ ]:
+ case types[
+ "h"
+ /* ElementTypeFunction */
+ ]:
+ case types[
+ "j"
+ /* ElementTypeMemo */
+ ]:
+ if (nextModernContext !== NO_CONTEXT) {
+ var prevContext = prevModernContext;
+ var nextContext = nextModernContext;
+ while (prevContext && nextContext) {
+ if (!shared_objectIs(prevContext.memoizedValue, nextContext.memoizedValue)) {
+ return true;
+ }
+ prevContext = prevContext.next;
+ nextContext = nextContext.next;
+ }
+ return false;
+ }
+ break;
+ default:
+ break;
+ }
+ }
+ return null;
+ }
+ __name(getContextChangedKeys, "getContextChangedKeys");
+ function areHookInputsEqual(nextDeps, prevDeps) {
+ if (prevDeps === null) {
+ return false;
+ }
+ for (var i = 0; i < prevDeps.length && i < nextDeps.length; i++) {
+ if (shared_objectIs(nextDeps[i], prevDeps[i])) {
+ continue;
+ }
+ return false;
+ }
+ return true;
+ }
+ __name(areHookInputsEqual, "areHookInputsEqual");
+ function isEffect(memoizedState) {
+ if (memoizedState === null || renderer_typeof(memoizedState) !== "object") {
+ return false;
+ }
+ var deps = memoizedState.deps;
+ var boundHasOwnProperty = shared_hasOwnProperty.bind(memoizedState);
+ return boundHasOwnProperty("create") && boundHasOwnProperty("destroy") && boundHasOwnProperty("deps") && boundHasOwnProperty("next") && boundHasOwnProperty("tag") && (deps === null || Object(isArray[
+ "a"
+ /* default */
+ ])(deps));
+ }
+ __name(isEffect, "isEffect");
+ function didHookChange(prev, next) {
+ var prevMemoizedState = prev.memoizedState;
+ var nextMemoizedState = next.memoizedState;
+ if (isEffect(prevMemoizedState) && isEffect(nextMemoizedState)) {
+ return prevMemoizedState !== nextMemoizedState && !areHookInputsEqual(nextMemoizedState.deps, prevMemoizedState.deps);
+ }
+ return nextMemoizedState !== prevMemoizedState;
+ }
+ __name(didHookChange, "didHookChange");
+ function didHooksChange(prev, next) {
+ if (prev == null || next == null) {
+ return false;
+ }
+ if (next.hasOwnProperty("baseState") && next.hasOwnProperty("memoizedState") && next.hasOwnProperty("next") && next.hasOwnProperty("queue")) {
+ while (next !== null) {
+ if (didHookChange(prev, next)) {
+ return true;
+ } else {
+ next = next.next;
+ prev = prev.next;
+ }
+ }
+ }
+ return false;
+ }
+ __name(didHooksChange, "didHooksChange");
+ function getChangedHooksIndices(prev, next) {
+ if (DevToolsFeatureFlags_core_oss[
+ "b"
+ /* enableProfilerChangedHookIndices */
+ ]) {
+ if (prev == null || next == null) {
+ return null;
+ }
+ var indices = [];
+ var index = 0;
+ if (next.hasOwnProperty("baseState") && next.hasOwnProperty("memoizedState") && next.hasOwnProperty("next") && next.hasOwnProperty("queue")) {
+ while (next !== null) {
+ if (didHookChange(prev, next)) {
+ indices.push(index);
+ }
+ next = next.next;
+ prev = prev.next;
+ index++;
+ }
+ }
+ return indices;
+ }
+ return null;
+ }
+ __name(getChangedHooksIndices, "getChangedHooksIndices");
+ function getChangedKeys(prev, next) {
+ if (prev == null || next == null) {
+ return null;
+ }
+ if (next.hasOwnProperty("baseState") && next.hasOwnProperty("memoizedState") && next.hasOwnProperty("next") && next.hasOwnProperty("queue")) {
+ return null;
+ }
+ var keys = new Set([].concat(_toConsumableArray(Object.keys(prev)), _toConsumableArray(Object.keys(next))));
+ var changedKeys = [];
+ var _iterator5 = _createForOfIteratorHelper(keys), _step5;
+ try {
+ for (_iterator5.s(); !(_step5 = _iterator5.n()).done; ) {
+ var key = _step5.value;
+ if (prev[key] !== next[key]) {
+ changedKeys.push(key);
+ }
+ }
+ } catch (err) {
+ _iterator5.e(err);
+ } finally {
+ _iterator5.f();
+ }
+ return changedKeys;
+ }
+ __name(getChangedKeys, "getChangedKeys");
+ function didFiberRender(prevFiber, nextFiber) {
+ switch (nextFiber.tag) {
+ case ClassComponent:
+ case FunctionComponent:
+ case ContextConsumer:
+ case MemoComponent:
+ case SimpleMemoComponent:
+ return (getFiberFlags(nextFiber) & PerformedWork) === PerformedWork;
+ default:
+ return prevFiber.memoizedProps !== nextFiber.memoizedProps || prevFiber.memoizedState !== nextFiber.memoizedState || prevFiber.ref !== nextFiber.ref;
+ }
+ }
+ __name(didFiberRender, "didFiberRender");
+ var pendingOperations = [];
+ var pendingRealUnmountedIDs = [];
+ var pendingSimulatedUnmountedIDs = [];
+ var pendingOperationsQueue = [];
+ var pendingStringTable = /* @__PURE__ */ new Map();
+ var pendingStringTableLength = 0;
+ var pendingUnmountedRootID = null;
+ function pushOperation(op) {
+ if (false) {
+ }
+ pendingOperations.push(op);
+ }
+ __name(pushOperation, "pushOperation");
+ function flushOrQueueOperations(operations) {
+ if (operations.length === 3) {
+ if (!isProfiling || currentCommitProfilingMetadata == null || currentCommitProfilingMetadata.durations.length === 0) {
+ return;
+ }
+ }
+ if (pendingOperationsQueue !== null) {
+ pendingOperationsQueue.push(operations);
+ } else {
+ hook.emit("operations", operations);
+ }
+ }
+ __name(flushOrQueueOperations, "flushOrQueueOperations");
+ var flushPendingErrorsAndWarningsAfterDelayTimeoutID = null;
+ function clearPendingErrorsAndWarningsAfterDelay() {
+ if (flushPendingErrorsAndWarningsAfterDelayTimeoutID !== null) {
+ clearTimeout(flushPendingErrorsAndWarningsAfterDelayTimeoutID);
+ flushPendingErrorsAndWarningsAfterDelayTimeoutID = null;
+ }
+ }
+ __name(clearPendingErrorsAndWarningsAfterDelay, "clearPendingErrorsAndWarningsAfterDelay");
+ function flushPendingErrorsAndWarningsAfterDelay() {
+ clearPendingErrorsAndWarningsAfterDelay();
+ flushPendingErrorsAndWarningsAfterDelayTimeoutID = setTimeout(function() {
+ flushPendingErrorsAndWarningsAfterDelayTimeoutID = null;
+ if (pendingOperations.length > 0) {
+ return;
+ }
+ recordPendingErrorsAndWarnings();
+ if (pendingOperations.length === 0) {
+ return;
+ }
+ var operations = new Array(3 + pendingOperations.length);
+ operations[0] = rendererID;
+ operations[1] = currentRootID;
+ operations[2] = 0;
+ for (var j = 0; j < pendingOperations.length; j++) {
+ operations[3 + j] = pendingOperations[j];
+ }
+ flushOrQueueOperations(operations);
+ pendingOperations.length = 0;
+ }, 1e3);
+ }
+ __name(flushPendingErrorsAndWarningsAfterDelay, "flushPendingErrorsAndWarningsAfterDelay");
+ function reevaluateErrorsAndWarnings() {
+ fibersWithChangedErrorOrWarningCounts.clear();
+ fiberIDToErrorsMap.forEach(function(countMap, fiberID) {
+ var fiber = idToArbitraryFiberMap.get(fiberID);
+ if (fiber != null) {
+ fibersWithChangedErrorOrWarningCounts.add(fiber);
+ }
+ });
+ fiberIDToWarningsMap.forEach(function(countMap, fiberID) {
+ var fiber = idToArbitraryFiberMap.get(fiberID);
+ if (fiber != null) {
+ fibersWithChangedErrorOrWarningCounts.add(fiber);
+ }
+ });
+ recordPendingErrorsAndWarnings();
+ }
+ __name(reevaluateErrorsAndWarnings, "reevaluateErrorsAndWarnings");
+ function mergeMapsAndGetCountHelper(fiber, fiberID, pendingFiberToMessageCountMap, fiberIDToMessageCountMap) {
+ var newCount = 0;
+ var messageCountMap = fiberIDToMessageCountMap.get(fiberID);
+ var pendingMessageCountMap = pendingFiberToMessageCountMap.get(fiber);
+ if (pendingMessageCountMap != null) {
+ if (messageCountMap == null) {
+ messageCountMap = pendingMessageCountMap;
+ fiberIDToMessageCountMap.set(fiberID, pendingMessageCountMap);
+ } else {
+ var refinedMessageCountMap = messageCountMap;
+ pendingMessageCountMap.forEach(function(pendingCount, message) {
+ var previousCount = refinedMessageCountMap.get(message) || 0;
+ refinedMessageCountMap.set(message, previousCount + pendingCount);
+ });
+ }
+ }
+ if (!shouldFilterFiber(fiber)) {
+ if (messageCountMap != null) {
+ messageCountMap.forEach(function(count) {
+ newCount += count;
+ });
+ }
+ }
+ pendingFiberToMessageCountMap.delete(fiber);
+ return newCount;
+ }
+ __name(mergeMapsAndGetCountHelper, "mergeMapsAndGetCountHelper");
+ function recordPendingErrorsAndWarnings() {
+ clearPendingErrorsAndWarningsAfterDelay();
+ fibersWithChangedErrorOrWarningCounts.forEach(function(fiber) {
+ var fiberID = getFiberIDUnsafe(fiber);
+ if (fiberID === null) {
+ } else {
+ var errorCount = mergeMapsAndGetCountHelper(fiber, fiberID, pendingFiberToErrorsMap, fiberIDToErrorsMap);
+ var warningCount = mergeMapsAndGetCountHelper(fiber, fiberID, pendingFiberToWarningsMap, fiberIDToWarningsMap);
+ pushOperation(constants3[
+ "o"
+ /* TREE_OPERATION_UPDATE_ERRORS_OR_WARNINGS */
+ ]);
+ pushOperation(fiberID);
+ pushOperation(errorCount);
+ pushOperation(warningCount);
+ }
+ pendingFiberToErrorsMap.delete(fiber);
+ pendingFiberToWarningsMap.delete(fiber);
+ });
+ fibersWithChangedErrorOrWarningCounts.clear();
+ }
+ __name(recordPendingErrorsAndWarnings, "recordPendingErrorsAndWarnings");
+ function flushPendingEvents(root) {
+ recordPendingErrorsAndWarnings();
+ if (pendingOperations.length === 0 && pendingRealUnmountedIDs.length === 0 && pendingSimulatedUnmountedIDs.length === 0 && pendingUnmountedRootID === null) {
+ if (!isProfiling) {
+ return;
+ }
+ }
+ var numUnmountIDs = pendingRealUnmountedIDs.length + pendingSimulatedUnmountedIDs.length + (pendingUnmountedRootID === null ? 0 : 1);
+ var operations = new Array(
+ // Identify which renderer this update is coming from.
+ 2 + // [rendererID, rootFiberID]
+ // How big is the string table?
+ 1 + // [stringTableLength]
+ // Then goes the actual string table.
+ pendingStringTableLength + // All unmounts are batched in a single message.
+ // [TREE_OPERATION_REMOVE, removedIDLength, ...ids]
+ (numUnmountIDs > 0 ? 2 + numUnmountIDs : 0) + // Regular operations
+ pendingOperations.length
+ );
+ var i = 0;
+ operations[i++] = rendererID;
+ operations[i++] = currentRootID;
+ operations[i++] = pendingStringTableLength;
+ pendingStringTable.forEach(function(entry, stringKey) {
+ var encodedString = entry.encodedString;
+ var length = encodedString.length;
+ operations[i++] = length;
+ for (var j2 = 0; j2 < length; j2++) {
+ operations[i + j2] = encodedString[j2];
+ }
+ i += length;
+ });
+ if (numUnmountIDs > 0) {
+ operations[i++] = constants3[
+ "k"
+ /* TREE_OPERATION_REMOVE */
+ ];
+ operations[i++] = numUnmountIDs;
+ for (var j = pendingRealUnmountedIDs.length - 1; j >= 0; j--) {
+ operations[i++] = pendingRealUnmountedIDs[j];
+ }
+ for (var _j = 0; _j < pendingSimulatedUnmountedIDs.length; _j++) {
+ operations[i + _j] = pendingSimulatedUnmountedIDs[_j];
+ }
+ i += pendingSimulatedUnmountedIDs.length;
+ if (pendingUnmountedRootID !== null) {
+ operations[i] = pendingUnmountedRootID;
+ i++;
+ }
+ }
+ for (var _j2 = 0; _j2 < pendingOperations.length; _j2++) {
+ operations[i + _j2] = pendingOperations[_j2];
+ }
+ i += pendingOperations.length;
+ flushOrQueueOperations(operations);
+ pendingOperations.length = 0;
+ pendingRealUnmountedIDs.length = 0;
+ pendingSimulatedUnmountedIDs.length = 0;
+ pendingUnmountedRootID = null;
+ pendingStringTable.clear();
+ pendingStringTableLength = 0;
+ }
+ __name(flushPendingEvents, "flushPendingEvents");
+ function getStringID(string) {
+ if (string === null) {
+ return 0;
+ }
+ var existingEntry = pendingStringTable.get(string);
+ if (existingEntry !== void 0) {
+ return existingEntry.id;
+ }
+ var id = pendingStringTable.size + 1;
+ var encodedString = Object(utils[
+ "m"
+ /* utfEncodeString */
+ ])(string);
+ pendingStringTable.set(string, {
+ encodedString,
+ id
+ });
+ pendingStringTableLength += encodedString.length + 1;
+ return id;
+ }
+ __name(getStringID, "getStringID");
+ function recordMount(fiber, parentFiber) {
+ var isRoot = fiber.tag === HostRoot;
+ var id = getOrGenerateFiberID(fiber);
+ if (constants3[
+ "q"
+ /* __DEBUG__ */
+ ]) {
+ debug("recordMount()", fiber, parentFiber);
+ }
+ var hasOwnerMetadata = fiber.hasOwnProperty("_debugOwner");
+ var isProfilingSupported = fiber.hasOwnProperty("treeBaseDuration");
+ if (isRoot) {
+ pushOperation(constants3[
+ "j"
+ /* TREE_OPERATION_ADD */
+ ]);
+ pushOperation(id);
+ pushOperation(types[
+ "m"
+ /* ElementTypeRoot */
+ ]);
+ pushOperation((fiber.mode & StrictModeBits) !== 0 ? 1 : 0);
+ pushOperation(isProfilingSupported ? 1 : 0);
+ pushOperation(StrictModeBits !== 0 ? 1 : 0);
+ pushOperation(hasOwnerMetadata ? 1 : 0);
+ if (isProfiling) {
+ if (displayNamesByRootID !== null) {
+ displayNamesByRootID.set(id, getDisplayNameForRoot(fiber));
+ }
+ }
+ } else {
+ var key = fiber.key;
+ var displayName = getDisplayNameForFiber(fiber);
+ var elementType = getElementTypeForFiber(fiber);
+ var _debugOwner = fiber._debugOwner;
+ var ownerID = _debugOwner != null ? getOrGenerateFiberID(_debugOwner) : 0;
+ var parentID = parentFiber ? getFiberIDThrows(parentFiber) : 0;
+ var displayNameStringID = getStringID(displayName);
+ var keyString = key === null ? null : String(key);
+ var keyStringID = getStringID(keyString);
+ pushOperation(constants3[
+ "j"
+ /* TREE_OPERATION_ADD */
+ ]);
+ pushOperation(id);
+ pushOperation(elementType);
+ pushOperation(parentID);
+ pushOperation(ownerID);
+ pushOperation(displayNameStringID);
+ pushOperation(keyStringID);
+ if ((fiber.mode & StrictModeBits) !== 0 && (parentFiber.mode & StrictModeBits) === 0) {
+ pushOperation(constants3[
+ "n"
+ /* TREE_OPERATION_SET_SUBTREE_MODE */
+ ]);
+ pushOperation(id);
+ pushOperation(types[
+ "p"
+ /* StrictMode */
+ ]);
+ }
+ }
+ if (isProfilingSupported) {
+ idToRootMap.set(id, currentRootID);
+ recordProfilingDurations(fiber);
+ }
+ }
+ __name(recordMount, "recordMount");
+ function recordUnmount(fiber, isSimulated) {
+ if (constants3[
+ "q"
+ /* __DEBUG__ */
+ ]) {
+ debug("recordUnmount()", fiber, null, isSimulated ? "unmount is simulated" : "");
+ }
+ if (trackedPathMatchFiber !== null) {
+ if (fiber === trackedPathMatchFiber || fiber === trackedPathMatchFiber.alternate) {
+ setTrackedPath(null);
+ }
+ }
+ var unsafeID = getFiberIDUnsafe(fiber);
+ if (unsafeID === null) {
+ return;
+ }
+ var id = unsafeID;
+ var isRoot = fiber.tag === HostRoot;
+ if (isRoot) {
+ pendingUnmountedRootID = id;
+ } else if (!shouldFilterFiber(fiber)) {
+ if (isSimulated) {
+ pendingSimulatedUnmountedIDs.push(id);
+ } else {
+ pendingRealUnmountedIDs.push(id);
+ }
+ }
+ if (!fiber._debugNeedsRemount) {
+ untrackFiberID(fiber);
+ var isProfilingSupported = fiber.hasOwnProperty("treeBaseDuration");
+ if (isProfilingSupported) {
+ idToRootMap.delete(id);
+ idToTreeBaseDurationMap.delete(id);
+ }
+ }
+ }
+ __name(recordUnmount, "recordUnmount");
+ function mountFiberRecursively(firstChild, parentFiber, traverseSiblings, traceNearestHostComponentUpdate) {
+ var fiber = firstChild;
+ while (fiber !== null) {
+ getOrGenerateFiberID(fiber);
+ if (constants3[
+ "q"
+ /* __DEBUG__ */
+ ]) {
+ debug("mountFiberRecursively()", fiber, parentFiber);
+ }
+ var mightSiblingsBeOnTrackedPath = updateTrackedPathStateBeforeMount(fiber);
+ var shouldIncludeInTree = !shouldFilterFiber(fiber);
+ if (shouldIncludeInTree) {
+ recordMount(fiber, parentFiber);
+ }
+ if (traceUpdatesEnabled) {
+ if (traceNearestHostComponentUpdate) {
+ var elementType = getElementTypeForFiber(fiber);
+ if (elementType === types[
+ "i"
+ /* ElementTypeHostComponent */
+ ]) {
+ traceUpdatesForNodes.add(fiber.stateNode);
+ traceNearestHostComponentUpdate = false;
+ }
+ }
+ }
+ var isSuspense = fiber.tag === ReactTypeOfWork.SuspenseComponent;
+ if (isSuspense) {
+ var isTimedOut = fiber.memoizedState !== null;
+ if (isTimedOut) {
+ var primaryChildFragment = fiber.child;
+ var fallbackChildFragment = primaryChildFragment ? primaryChildFragment.sibling : null;
+ var fallbackChild = fallbackChildFragment ? fallbackChildFragment.child : null;
+ if (fallbackChild !== null) {
+ mountFiberRecursively(fallbackChild, shouldIncludeInTree ? fiber : parentFiber, true, traceNearestHostComponentUpdate);
+ }
+ } else {
+ var primaryChild = null;
+ var areSuspenseChildrenConditionallyWrapped = OffscreenComponent === -1;
+ if (areSuspenseChildrenConditionallyWrapped) {
+ primaryChild = fiber.child;
+ } else if (fiber.child !== null) {
+ primaryChild = fiber.child.child;
+ }
+ if (primaryChild !== null) {
+ mountFiberRecursively(primaryChild, shouldIncludeInTree ? fiber : parentFiber, true, traceNearestHostComponentUpdate);
+ }
+ }
+ } else {
+ if (fiber.child !== null) {
+ mountFiberRecursively(fiber.child, shouldIncludeInTree ? fiber : parentFiber, true, traceNearestHostComponentUpdate);
+ }
+ }
+ updateTrackedPathStateAfterMount(mightSiblingsBeOnTrackedPath);
+ fiber = traverseSiblings ? fiber.sibling : null;
+ }
+ }
+ __name(mountFiberRecursively, "mountFiberRecursively");
+ function unmountFiberChildrenRecursively(fiber) {
+ if (constants3[
+ "q"
+ /* __DEBUG__ */
+ ]) {
+ debug("unmountFiberChildrenRecursively()", fiber);
+ }
+ var isTimedOutSuspense = fiber.tag === ReactTypeOfWork.SuspenseComponent && fiber.memoizedState !== null;
+ var child = fiber.child;
+ if (isTimedOutSuspense) {
+ var primaryChildFragment = fiber.child;
+ var fallbackChildFragment = primaryChildFragment ? primaryChildFragment.sibling : null;
+ child = fallbackChildFragment ? fallbackChildFragment.child : null;
+ }
+ while (child !== null) {
+ if (child.return !== null) {
+ unmountFiberChildrenRecursively(child);
+ recordUnmount(child, true);
+ }
+ child = child.sibling;
+ }
+ }
+ __name(unmountFiberChildrenRecursively, "unmountFiberChildrenRecursively");
+ function recordProfilingDurations(fiber) {
+ var id = getFiberIDThrows(fiber);
+ var actualDuration = fiber.actualDuration, treeBaseDuration = fiber.treeBaseDuration;
+ idToTreeBaseDurationMap.set(id, treeBaseDuration || 0);
+ if (isProfiling) {
+ var alternate = fiber.alternate;
+ if (alternate == null || treeBaseDuration !== alternate.treeBaseDuration) {
+ var convertedTreeBaseDuration = Math.floor((treeBaseDuration || 0) * 1e3);
+ pushOperation(constants3[
+ "p"
+ /* TREE_OPERATION_UPDATE_TREE_BASE_DURATION */
+ ]);
+ pushOperation(id);
+ pushOperation(convertedTreeBaseDuration);
+ }
+ if (alternate == null || didFiberRender(alternate, fiber)) {
+ if (actualDuration != null) {
+ var selfDuration = actualDuration;
+ var child = fiber.child;
+ while (child !== null) {
+ selfDuration -= child.actualDuration || 0;
+ child = child.sibling;
+ }
+ var metadata = currentCommitProfilingMetadata;
+ metadata.durations.push(id, actualDuration, selfDuration);
+ metadata.maxActualDuration = Math.max(metadata.maxActualDuration, actualDuration);
+ if (recordChangeDescriptions) {
+ var changeDescription = getChangeDescription(alternate, fiber);
+ if (changeDescription !== null) {
+ if (metadata.changeDescriptions !== null) {
+ metadata.changeDescriptions.set(id, changeDescription);
+ }
+ }
+ updateContextsForFiber(fiber);
+ }
+ }
+ }
+ }
+ }
+ __name(recordProfilingDurations, "recordProfilingDurations");
+ function recordResetChildren(fiber, childSet) {
+ if (constants3[
+ "q"
+ /* __DEBUG__ */
+ ]) {
+ debug("recordResetChildren()", childSet, fiber);
+ }
+ var nextChildren = [];
+ var child = childSet;
+ while (child !== null) {
+ findReorderedChildrenRecursively(child, nextChildren);
+ child = child.sibling;
+ }
+ var numChildren = nextChildren.length;
+ if (numChildren < 2) {
+ return;
+ }
+ pushOperation(constants3[
+ "m"
+ /* TREE_OPERATION_REORDER_CHILDREN */
+ ]);
+ pushOperation(getFiberIDThrows(fiber));
+ pushOperation(numChildren);
+ for (var i = 0; i < nextChildren.length; i++) {
+ pushOperation(nextChildren[i]);
+ }
+ }
+ __name(recordResetChildren, "recordResetChildren");
+ function findReorderedChildrenRecursively(fiber, nextChildren) {
+ if (!shouldFilterFiber(fiber)) {
+ nextChildren.push(getFiberIDThrows(fiber));
+ } else {
+ var child = fiber.child;
+ var isTimedOutSuspense = fiber.tag === SuspenseComponent && fiber.memoizedState !== null;
+ if (isTimedOutSuspense) {
+ var primaryChildFragment = fiber.child;
+ var fallbackChildFragment = primaryChildFragment ? primaryChildFragment.sibling : null;
+ var fallbackChild = fallbackChildFragment ? fallbackChildFragment.child : null;
+ if (fallbackChild !== null) {
+ child = fallbackChild;
+ }
+ }
+ while (child !== null) {
+ findReorderedChildrenRecursively(child, nextChildren);
+ child = child.sibling;
+ }
+ }
+ }
+ __name(findReorderedChildrenRecursively, "findReorderedChildrenRecursively");
+ function updateFiberRecursively(nextFiber, prevFiber, parentFiber, traceNearestHostComponentUpdate) {
+ var id = getOrGenerateFiberID(nextFiber);
+ if (constants3[
+ "q"
+ /* __DEBUG__ */
+ ]) {
+ debug("updateFiberRecursively()", nextFiber, parentFiber);
+ }
+ if (traceUpdatesEnabled) {
+ var elementType = getElementTypeForFiber(nextFiber);
+ if (traceNearestHostComponentUpdate) {
+ if (elementType === types[
+ "i"
+ /* ElementTypeHostComponent */
+ ]) {
+ traceUpdatesForNodes.add(nextFiber.stateNode);
+ traceNearestHostComponentUpdate = false;
+ }
+ } else {
+ if (elementType === types[
+ "h"
+ /* ElementTypeFunction */
+ ] || elementType === types[
+ "e"
+ /* ElementTypeClass */
+ ] || elementType === types[
+ "f"
+ /* ElementTypeContext */
+ ] || elementType === types[
+ "j"
+ /* ElementTypeMemo */
+ ] || elementType === types[
+ "g"
+ /* ElementTypeForwardRef */
+ ]) {
+ traceNearestHostComponentUpdate = didFiberRender(prevFiber, nextFiber);
+ }
+ }
+ }
+ if (mostRecentlyInspectedElement !== null && mostRecentlyInspectedElement.id === id && didFiberRender(prevFiber, nextFiber)) {
+ hasElementUpdatedSinceLastInspected = true;
+ }
+ var shouldIncludeInTree = !shouldFilterFiber(nextFiber);
+ var isSuspense = nextFiber.tag === SuspenseComponent;
+ var shouldResetChildren = false;
+ var prevDidTimeout = isSuspense && prevFiber.memoizedState !== null;
+ var nextDidTimeOut = isSuspense && nextFiber.memoizedState !== null;
+ if (prevDidTimeout && nextDidTimeOut) {
+ var nextFiberChild = nextFiber.child;
+ var nextFallbackChildSet = nextFiberChild ? nextFiberChild.sibling : null;
+ var prevFiberChild = prevFiber.child;
+ var prevFallbackChildSet = prevFiberChild ? prevFiberChild.sibling : null;
+ if (nextFallbackChildSet != null && prevFallbackChildSet != null && updateFiberRecursively(nextFallbackChildSet, prevFallbackChildSet, nextFiber, traceNearestHostComponentUpdate)) {
+ shouldResetChildren = true;
+ }
+ } else if (prevDidTimeout && !nextDidTimeOut) {
+ var nextPrimaryChildSet = nextFiber.child;
+ if (nextPrimaryChildSet !== null) {
+ mountFiberRecursively(nextPrimaryChildSet, shouldIncludeInTree ? nextFiber : parentFiber, true, traceNearestHostComponentUpdate);
+ }
+ shouldResetChildren = true;
+ } else if (!prevDidTimeout && nextDidTimeOut) {
+ unmountFiberChildrenRecursively(prevFiber);
+ var _nextFiberChild = nextFiber.child;
+ var _nextFallbackChildSet = _nextFiberChild ? _nextFiberChild.sibling : null;
+ if (_nextFallbackChildSet != null) {
+ mountFiberRecursively(_nextFallbackChildSet, shouldIncludeInTree ? nextFiber : parentFiber, true, traceNearestHostComponentUpdate);
+ shouldResetChildren = true;
+ }
+ } else {
+ if (nextFiber.child !== prevFiber.child) {
+ var nextChild = nextFiber.child;
+ var prevChildAtSameIndex = prevFiber.child;
+ while (nextChild) {
+ if (nextChild.alternate) {
+ var prevChild = nextChild.alternate;
+ if (updateFiberRecursively(nextChild, prevChild, shouldIncludeInTree ? nextFiber : parentFiber, traceNearestHostComponentUpdate)) {
+ shouldResetChildren = true;
+ }
+ if (prevChild !== prevChildAtSameIndex) {
+ shouldResetChildren = true;
+ }
+ } else {
+ mountFiberRecursively(nextChild, shouldIncludeInTree ? nextFiber : parentFiber, false, traceNearestHostComponentUpdate);
+ shouldResetChildren = true;
+ }
+ nextChild = nextChild.sibling;
+ if (!shouldResetChildren && prevChildAtSameIndex !== null) {
+ prevChildAtSameIndex = prevChildAtSameIndex.sibling;
+ }
+ }
+ if (prevChildAtSameIndex !== null) {
+ shouldResetChildren = true;
+ }
+ } else {
+ if (traceUpdatesEnabled) {
+ if (traceNearestHostComponentUpdate) {
+ var hostFibers = findAllCurrentHostFibers(getFiberIDThrows(nextFiber));
+ hostFibers.forEach(function(hostFiber) {
+ traceUpdatesForNodes.add(hostFiber.stateNode);
+ });
+ }
+ }
+ }
+ }
+ if (shouldIncludeInTree) {
+ var isProfilingSupported = nextFiber.hasOwnProperty("treeBaseDuration");
+ if (isProfilingSupported) {
+ recordProfilingDurations(nextFiber);
+ }
+ }
+ if (shouldResetChildren) {
+ if (shouldIncludeInTree) {
+ var nextChildSet = nextFiber.child;
+ if (nextDidTimeOut) {
+ var _nextFiberChild2 = nextFiber.child;
+ nextChildSet = _nextFiberChild2 ? _nextFiberChild2.sibling : null;
+ }
+ if (nextChildSet != null) {
+ recordResetChildren(nextFiber, nextChildSet);
+ }
+ return false;
+ } else {
+ return true;
+ }
+ } else {
+ return false;
+ }
+ }
+ __name(updateFiberRecursively, "updateFiberRecursively");
+ function cleanup() {
+ }
+ __name(cleanup, "cleanup");
+ function rootSupportsProfiling(root) {
+ if (root.memoizedInteractions != null) {
+ return true;
+ } else if (root.current != null && root.current.hasOwnProperty("treeBaseDuration")) {
+ return true;
+ } else {
+ return false;
+ }
+ }
+ __name(rootSupportsProfiling, "rootSupportsProfiling");
+ function flushInitialOperations() {
+ var localPendingOperationsQueue = pendingOperationsQueue;
+ pendingOperationsQueue = null;
+ if (localPendingOperationsQueue !== null && localPendingOperationsQueue.length > 0) {
+ localPendingOperationsQueue.forEach(function(operations) {
+ hook.emit("operations", operations);
+ });
+ } else {
+ if (trackedPath !== null) {
+ mightBeOnTrackedPath = true;
+ }
+ hook.getFiberRoots(rendererID).forEach(function(root) {
+ currentRootID = getOrGenerateFiberID(root.current);
+ setRootPseudoKey(currentRootID, root.current);
+ if (isProfiling && rootSupportsProfiling(root)) {
+ currentCommitProfilingMetadata = {
+ changeDescriptions: recordChangeDescriptions ? /* @__PURE__ */ new Map() : null,
+ durations: [],
+ commitTime: getCurrentTime() - profilingStartTime,
+ maxActualDuration: 0,
+ priorityLevel: null,
+ updaters: getUpdatersList(root),
+ effectDuration: null,
+ passiveEffectDuration: null
+ };
+ }
+ mountFiberRecursively(root.current, null, false, false);
+ flushPendingEvents(root);
+ currentRootID = -1;
+ });
+ }
+ }
+ __name(flushInitialOperations, "flushInitialOperations");
+ function getUpdatersList(root) {
+ return root.memoizedUpdaters != null ? Array.from(root.memoizedUpdaters).filter(function(fiber) {
+ return getFiberIDUnsafe(fiber) !== null;
+ }).map(fiberToSerializedElement) : null;
+ }
+ __name(getUpdatersList, "getUpdatersList");
+ function handleCommitFiberUnmount(fiber) {
+ recordUnmount(fiber, false);
+ }
+ __name(handleCommitFiberUnmount, "handleCommitFiberUnmount");
+ function handlePostCommitFiberRoot(root) {
+ if (isProfiling && rootSupportsProfiling(root)) {
+ if (currentCommitProfilingMetadata !== null) {
+ var _getEffectDurations = Object(backend_utils[
+ "g"
+ /* getEffectDurations */
+ ])(root), effectDuration = _getEffectDurations.effectDuration, passiveEffectDuration = _getEffectDurations.passiveEffectDuration;
+ currentCommitProfilingMetadata.effectDuration = effectDuration;
+ currentCommitProfilingMetadata.passiveEffectDuration = passiveEffectDuration;
+ }
+ }
+ }
+ __name(handlePostCommitFiberRoot, "handlePostCommitFiberRoot");
+ function handleCommitFiberRoot(root, priorityLevel) {
+ var current = root.current;
+ var alternate = current.alternate;
+ untrackFibers();
+ currentRootID = getOrGenerateFiberID(current);
+ if (trackedPath !== null) {
+ mightBeOnTrackedPath = true;
+ }
+ if (traceUpdatesEnabled) {
+ traceUpdatesForNodes.clear();
+ }
+ var isProfilingSupported = rootSupportsProfiling(root);
+ if (isProfiling && isProfilingSupported) {
+ currentCommitProfilingMetadata = {
+ changeDescriptions: recordChangeDescriptions ? /* @__PURE__ */ new Map() : null,
+ durations: [],
+ commitTime: getCurrentTime() - profilingStartTime,
+ maxActualDuration: 0,
+ priorityLevel: priorityLevel == null ? null : formatPriorityLevel(priorityLevel),
+ updaters: getUpdatersList(root),
+ // Initialize to null; if new enough React version is running,
+ // these values will be read during separate handlePostCommitFiberRoot() call.
+ effectDuration: null,
+ passiveEffectDuration: null
+ };
+ }
+ if (alternate) {
+ var wasMounted = alternate.memoizedState != null && alternate.memoizedState.element != null;
+ var isMounted = current.memoizedState != null && current.memoizedState.element != null;
+ if (!wasMounted && isMounted) {
+ setRootPseudoKey(currentRootID, current);
+ mountFiberRecursively(current, null, false, false);
+ } else if (wasMounted && isMounted) {
+ updateFiberRecursively(current, alternate, null, false);
+ } else if (wasMounted && !isMounted) {
+ removeRootPseudoKey(currentRootID);
+ recordUnmount(current, false);
+ }
+ } else {
+ setRootPseudoKey(currentRootID, current);
+ mountFiberRecursively(current, null, false, false);
+ }
+ if (isProfiling && isProfilingSupported) {
+ if (currentCommitProfilingMetadata != null && currentCommitProfilingMetadata.durations.length > 0) {
+ var commitProfilingMetadata = rootToCommitProfilingMetadataMap.get(currentRootID);
+ if (commitProfilingMetadata != null) {
+ commitProfilingMetadata.push(currentCommitProfilingMetadata);
+ } else {
+ rootToCommitProfilingMetadataMap.set(currentRootID, [currentCommitProfilingMetadata]);
+ }
+ }
+ }
+ flushPendingEvents(root);
+ if (traceUpdatesEnabled) {
+ hook.emit("traceUpdates", traceUpdatesForNodes);
+ }
+ currentRootID = -1;
+ }
+ __name(handleCommitFiberRoot, "handleCommitFiberRoot");
+ function findAllCurrentHostFibers(id) {
+ var fibers = [];
+ var fiber = findCurrentFiberUsingSlowPathById(id);
+ if (!fiber) {
+ return fibers;
+ }
+ var node = fiber;
+ while (true) {
+ if (node.tag === HostComponent || node.tag === HostText) {
+ fibers.push(node);
+ } else if (node.child) {
+ node.child.return = node;
+ node = node.child;
+ continue;
+ }
+ if (node === fiber) {
+ return fibers;
+ }
+ while (!node.sibling) {
+ if (!node.return || node.return === fiber) {
+ return fibers;
+ }
+ node = node.return;
+ }
+ node.sibling.return = node.return;
+ node = node.sibling;
+ }
+ return fibers;
+ }
+ __name(findAllCurrentHostFibers, "findAllCurrentHostFibers");
+ function findNativeNodesForFiberID(id) {
+ try {
+ var _fiber3 = findCurrentFiberUsingSlowPathById(id);
+ if (_fiber3 === null) {
+ return null;
+ }
+ var isTimedOutSuspense = _fiber3.tag === SuspenseComponent && _fiber3.memoizedState !== null;
+ if (isTimedOutSuspense) {
+ var maybeFallbackFiber = _fiber3.child && _fiber3.child.sibling;
+ if (maybeFallbackFiber != null) {
+ _fiber3 = maybeFallbackFiber;
+ }
+ }
+ var hostFibers = findAllCurrentHostFibers(id);
+ return hostFibers.map(function(hostFiber) {
+ return hostFiber.stateNode;
+ }).filter(Boolean);
+ } catch (err) {
+ return null;
+ }
+ }
+ __name(findNativeNodesForFiberID, "findNativeNodesForFiberID");
+ function getDisplayNameForFiberID(id) {
+ var fiber = idToArbitraryFiberMap.get(id);
+ return fiber != null ? getDisplayNameForFiber(fiber) : null;
+ }
+ __name(getDisplayNameForFiberID, "getDisplayNameForFiberID");
+ function getFiberIDForNative(hostInstance) {
+ var findNearestUnfilteredAncestor = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : false;
+ var fiber = renderer.findFiberByHostInstance(hostInstance);
+ if (fiber != null) {
+ if (findNearestUnfilteredAncestor) {
+ while (fiber !== null && shouldFilterFiber(fiber)) {
+ fiber = fiber.return;
+ }
+ }
+ return getFiberIDThrows(fiber);
+ }
+ return null;
+ }
+ __name(getFiberIDForNative, "getFiberIDForNative");
+ function assertIsMounted(fiber) {
+ if (getNearestMountedFiber(fiber) !== fiber) {
+ throw new Error("Unable to find node on an unmounted component.");
+ }
+ }
+ __name(assertIsMounted, "assertIsMounted");
+ function getNearestMountedFiber(fiber) {
+ var node = fiber;
+ var nearestMounted = fiber;
+ if (!fiber.alternate) {
+ var nextNode = node;
+ do {
+ node = nextNode;
+ if ((node.flags & (Placement | Hydrating)) !== NoFlags) {
+ nearestMounted = node.return;
+ }
+ nextNode = node.return;
+ } while (nextNode);
+ } else {
+ while (node.return) {
+ node = node.return;
+ }
+ }
+ if (node.tag === HostRoot) {
+ return nearestMounted;
+ }
+ return null;
+ }
+ __name(getNearestMountedFiber, "getNearestMountedFiber");
+ function findCurrentFiberUsingSlowPathById(id) {
+ var fiber = idToArbitraryFiberMap.get(id);
+ if (fiber == null) {
+ console.warn('Could not find Fiber with id "'.concat(id, '"'));
+ return null;
+ }
+ var alternate = fiber.alternate;
+ if (!alternate) {
+ var nearestMounted = getNearestMountedFiber(fiber);
+ if (nearestMounted === null) {
+ throw new Error("Unable to find node on an unmounted component.");
+ }
+ if (nearestMounted !== fiber) {
+ return null;
+ }
+ return fiber;
+ }
+ var a = fiber;
+ var b = alternate;
+ while (true) {
+ var parentA = a.return;
+ if (parentA === null) {
+ break;
+ }
+ var parentB = parentA.alternate;
+ if (parentB === null) {
+ var nextParent = parentA.return;
+ if (nextParent !== null) {
+ a = b = nextParent;
+ continue;
+ }
+ break;
+ }
+ if (parentA.child === parentB.child) {
+ var child = parentA.child;
+ while (child) {
+ if (child === a) {
+ assertIsMounted(parentA);
+ return fiber;
+ }
+ if (child === b) {
+ assertIsMounted(parentA);
+ return alternate;
+ }
+ child = child.sibling;
+ }
+ throw new Error("Unable to find node on an unmounted component.");
+ }
+ if (a.return !== b.return) {
+ a = parentA;
+ b = parentB;
+ } else {
+ var didFindChild = false;
+ var _child = parentA.child;
+ while (_child) {
+ if (_child === a) {
+ didFindChild = true;
+ a = parentA;
+ b = parentB;
+ break;
+ }
+ if (_child === b) {
+ didFindChild = true;
+ b = parentA;
+ a = parentB;
+ break;
+ }
+ _child = _child.sibling;
+ }
+ if (!didFindChild) {
+ _child = parentB.child;
+ while (_child) {
+ if (_child === a) {
+ didFindChild = true;
+ a = parentB;
+ b = parentA;
+ break;
+ }
+ if (_child === b) {
+ didFindChild = true;
+ b = parentB;
+ a = parentA;
+ break;
+ }
+ _child = _child.sibling;
+ }
+ if (!didFindChild) {
+ throw new Error("Child was not found in either parent set. This indicates a bug in React related to the return pointer. Please file an issue.");
+ }
+ }
+ }
+ if (a.alternate !== b) {
+ throw new Error("Return fibers should always be each others' alternates. This error is likely caused by a bug in React. Please file an issue.");
+ }
+ }
+ if (a.tag !== HostRoot) {
+ throw new Error("Unable to find node on an unmounted component.");
+ }
+ if (a.stateNode.current === a) {
+ return fiber;
+ }
+ return alternate;
+ }
+ __name(findCurrentFiberUsingSlowPathById, "findCurrentFiberUsingSlowPathById");
+ function prepareViewAttributeSource(id, path45) {
+ if (isMostRecentlyInspectedElement(id)) {
+ window.$attribute = Object(utils[
+ "h"
+ /* getInObject */
+ ])(mostRecentlyInspectedElement, path45);
+ }
+ }
+ __name(prepareViewAttributeSource, "prepareViewAttributeSource");
+ function prepareViewElementSource(id) {
+ var fiber = idToArbitraryFiberMap.get(id);
+ if (fiber == null) {
+ console.warn('Could not find Fiber with id "'.concat(id, '"'));
+ return;
+ }
+ var elementType = fiber.elementType, tag = fiber.tag, type = fiber.type;
+ switch (tag) {
+ case ClassComponent:
+ case IncompleteClassComponent:
+ case IndeterminateComponent:
+ case FunctionComponent:
+ global2.$type = type;
+ break;
+ case ForwardRef:
+ global2.$type = type.render;
+ break;
+ case MemoComponent:
+ case SimpleMemoComponent:
+ global2.$type = elementType != null && elementType.type != null ? elementType.type : type;
+ break;
+ default:
+ global2.$type = null;
+ break;
+ }
+ }
+ __name(prepareViewElementSource, "prepareViewElementSource");
+ function fiberToSerializedElement(fiber) {
+ return {
+ displayName: getDisplayNameForFiber(fiber) || "Anonymous",
+ id: getFiberIDThrows(fiber),
+ key: fiber.key,
+ type: getElementTypeForFiber(fiber)
+ };
+ }
+ __name(fiberToSerializedElement, "fiberToSerializedElement");
+ function getOwnersList(id) {
+ var fiber = findCurrentFiberUsingSlowPathById(id);
+ if (fiber == null) {
+ return null;
+ }
+ var _debugOwner = fiber._debugOwner;
+ var owners = [fiberToSerializedElement(fiber)];
+ if (_debugOwner) {
+ var owner = _debugOwner;
+ while (owner !== null) {
+ owners.unshift(fiberToSerializedElement(owner));
+ owner = owner._debugOwner || null;
+ }
+ }
+ return owners;
+ }
+ __name(getOwnersList, "getOwnersList");
+ function getInstanceAndStyle(id) {
+ var instance = null;
+ var style = null;
+ var fiber = findCurrentFiberUsingSlowPathById(id);
+ if (fiber !== null) {
+ instance = fiber.stateNode;
+ if (fiber.memoizedProps !== null) {
+ style = fiber.memoizedProps.style;
+ }
+ }
+ return {
+ instance,
+ style
+ };
+ }
+ __name(getInstanceAndStyle, "getInstanceAndStyle");
+ function isErrorBoundary(fiber) {
+ var tag = fiber.tag, type = fiber.type;
+ switch (tag) {
+ case ClassComponent:
+ case IncompleteClassComponent:
+ var instance = fiber.stateNode;
+ return typeof type.getDerivedStateFromError === "function" || instance !== null && typeof instance.componentDidCatch === "function";
+ default:
+ return false;
+ }
+ }
+ __name(isErrorBoundary, "isErrorBoundary");
+ function getNearestErrorBoundaryID(fiber) {
+ var parent = fiber.return;
+ while (parent !== null) {
+ if (isErrorBoundary(parent)) {
+ return getFiberIDUnsafe(parent);
+ }
+ parent = parent.return;
+ }
+ return null;
+ }
+ __name(getNearestErrorBoundaryID, "getNearestErrorBoundaryID");
+ function inspectElementRaw(id) {
+ var fiber = findCurrentFiberUsingSlowPathById(id);
+ if (fiber == null) {
+ return null;
+ }
+ var _debugOwner = fiber._debugOwner, _debugSource = fiber._debugSource, stateNode = fiber.stateNode, key = fiber.key, memoizedProps = fiber.memoizedProps, memoizedState = fiber.memoizedState, dependencies = fiber.dependencies, tag = fiber.tag, type = fiber.type;
+ var elementType = getElementTypeForFiber(fiber);
+ var usesHooks = (tag === FunctionComponent || tag === SimpleMemoComponent || tag === ForwardRef) && (!!memoizedState || !!dependencies);
+ var showState = !usesHooks && tag !== CacheComponent;
+ var typeSymbol = getTypeSymbol(type);
+ var canViewSource = false;
+ var context2 = null;
+ if (tag === ClassComponent || tag === FunctionComponent || tag === IncompleteClassComponent || tag === IndeterminateComponent || tag === MemoComponent || tag === ForwardRef || tag === SimpleMemoComponent) {
+ canViewSource = true;
+ if (stateNode && stateNode.context != null) {
+ var shouldHideContext = elementType === types[
+ "e"
+ /* ElementTypeClass */
+ ] && !(type.contextTypes || type.contextType);
+ if (!shouldHideContext) {
+ context2 = stateNode.context;
+ }
+ }
+ } else if (typeSymbol === ReactSymbols[
+ "c"
+ /* CONTEXT_NUMBER */
+ ] || typeSymbol === ReactSymbols[
+ "d"
+ /* CONTEXT_SYMBOL_STRING */
+ ]) {
+ var consumerResolvedContext = type._context || type;
+ context2 = consumerResolvedContext._currentValue || null;
+ var _current = fiber.return;
+ while (_current !== null) {
+ var currentType = _current.type;
+ var currentTypeSymbol = getTypeSymbol(currentType);
+ if (currentTypeSymbol === ReactSymbols[
+ "n"
+ /* PROVIDER_NUMBER */
+ ] || currentTypeSymbol === ReactSymbols[
+ "o"
+ /* PROVIDER_SYMBOL_STRING */
+ ]) {
+ var providerResolvedContext = currentType._context || currentType.context;
+ if (providerResolvedContext === consumerResolvedContext) {
+ context2 = _current.memoizedProps.value;
+ break;
+ }
+ }
+ _current = _current.return;
+ }
+ }
+ var hasLegacyContext = false;
+ if (context2 !== null) {
+ hasLegacyContext = !!type.contextTypes;
+ context2 = {
+ value: context2
+ };
+ }
+ var owners = null;
+ if (_debugOwner) {
+ owners = [];
+ var owner = _debugOwner;
+ while (owner !== null) {
+ owners.push(fiberToSerializedElement(owner));
+ owner = owner._debugOwner || null;
+ }
+ }
+ var isTimedOutSuspense = tag === SuspenseComponent && memoizedState !== null;
+ var hooks = null;
+ if (usesHooks) {
+ var originalConsoleMethods = {};
+ for (var method in console) {
+ try {
+ originalConsoleMethods[method] = console[method];
+ console[method] = function() {
+ };
+ } catch (error) {
+ }
+ }
+ try {
+ hooks = Object(react_debug_tools["inspectHooksOfFiber"])(
+ fiber,
+ renderer.currentDispatcherRef,
+ true
+ // Include source location info for hooks
+ );
+ } finally {
+ for (var _method in originalConsoleMethods) {
+ try {
+ console[_method] = originalConsoleMethods[_method];
+ } catch (error) {
+ }
+ }
+ }
+ }
+ var rootType = null;
+ var current = fiber;
+ while (current.return !== null) {
+ current = current.return;
+ }
+ var fiberRoot = current.stateNode;
+ if (fiberRoot != null && fiberRoot._debugRootType !== null) {
+ rootType = fiberRoot._debugRootType;
+ }
+ var errors = fiberIDToErrorsMap.get(id) || /* @__PURE__ */ new Map();
+ var warnings = fiberIDToWarningsMap.get(id) || /* @__PURE__ */ new Map();
+ var isErrored = (fiber.flags & DidCapture) !== NoFlags || forceErrorForFiberIDs.get(id) === true;
+ var targetErrorBoundaryID;
+ if (isErrorBoundary(fiber)) {
+ targetErrorBoundaryID = isErrored ? id : getNearestErrorBoundaryID(fiber);
+ } else {
+ targetErrorBoundaryID = getNearestErrorBoundaryID(fiber);
+ }
+ var plugins = {
+ stylex: null
+ };
+ if (DevToolsFeatureFlags_core_oss[
+ "c"
+ /* enableStyleXFeatures */
+ ]) {
+ if (memoizedProps.hasOwnProperty("xstyle")) {
+ plugins.stylex = getStyleXData(memoizedProps.xstyle);
+ }
+ }
+ return {
+ id,
+ // Does the current renderer support editable hooks and function props?
+ canEditHooks: typeof overrideHookState === "function",
+ canEditFunctionProps: typeof overrideProps === "function",
+ // Does the current renderer support advanced editing interface?
+ canEditHooksAndDeletePaths: typeof overrideHookStateDeletePath === "function",
+ canEditHooksAndRenamePaths: typeof overrideHookStateRenamePath === "function",
+ canEditFunctionPropsDeletePaths: typeof overridePropsDeletePath === "function",
+ canEditFunctionPropsRenamePaths: typeof overridePropsRenamePath === "function",
+ canToggleError: supportsTogglingError && targetErrorBoundaryID != null,
+ // Is this error boundary in error state.
+ isErrored,
+ targetErrorBoundaryID,
+ canToggleSuspense: supportsTogglingSuspense && // If it's showing the real content, we can always flip fallback.
+ (!isTimedOutSuspense || // If it's showing fallback because we previously forced it to,
+ // allow toggling it back to remove the fallback override.
+ forceFallbackForSuspenseIDs.has(id)),
+ // Can view component source location.
+ canViewSource,
+ // Does the component have legacy context attached to it.
+ hasLegacyContext,
+ key: key != null ? key : null,
+ displayName: getDisplayNameForFiber(fiber),
+ type: elementType,
+ // Inspectable properties.
+ // TODO Review sanitization approach for the below inspectable values.
+ context: context2,
+ hooks,
+ props: memoizedProps,
+ state: showState ? memoizedState : null,
+ errors: Array.from(errors.entries()),
+ warnings: Array.from(warnings.entries()),
+ // List of owners
+ owners,
+ // Location of component in source code.
+ source: _debugSource || null,
+ rootType,
+ rendererPackageName: renderer.rendererPackageName,
+ rendererVersion: renderer.version,
+ plugins
+ };
+ }
+ __name(inspectElementRaw, "inspectElementRaw");
+ var mostRecentlyInspectedElement = null;
+ var hasElementUpdatedSinceLastInspected = false;
+ var currentlyInspectedPaths = {};
+ function isMostRecentlyInspectedElement(id) {
+ return mostRecentlyInspectedElement !== null && mostRecentlyInspectedElement.id === id;
+ }
+ __name(isMostRecentlyInspectedElement, "isMostRecentlyInspectedElement");
+ function isMostRecentlyInspectedElementCurrent(id) {
+ return isMostRecentlyInspectedElement(id) && !hasElementUpdatedSinceLastInspected;
+ }
+ __name(isMostRecentlyInspectedElementCurrent, "isMostRecentlyInspectedElementCurrent");
+ function mergeInspectedPaths(path45) {
+ var current = currentlyInspectedPaths;
+ path45.forEach(function(key) {
+ if (!current[key]) {
+ current[key] = {};
+ }
+ current = current[key];
+ });
+ }
+ __name(mergeInspectedPaths, "mergeInspectedPaths");
+ function createIsPathAllowed(key, secondaryCategory) {
+ return /* @__PURE__ */ __name(function isPathAllowed(path45) {
+ switch (secondaryCategory) {
+ case "hooks":
+ if (path45.length === 1) {
+ return true;
+ }
+ if (path45[path45.length - 2] === "hookSource" && path45[path45.length - 1] === "fileName") {
+ return true;
+ }
+ if (path45[path45.length - 1] === "subHooks" || path45[path45.length - 2] === "subHooks") {
+ return true;
+ }
+ break;
+ default:
+ break;
+ }
+ var current = key === null ? currentlyInspectedPaths : currentlyInspectedPaths[key];
+ if (!current) {
+ return false;
+ }
+ for (var i = 0; i < path45.length; i++) {
+ current = current[path45[i]];
+ if (!current) {
+ return false;
+ }
+ }
+ return true;
+ }, "isPathAllowed");
+ }
+ __name(createIsPathAllowed, "createIsPathAllowed");
+ function updateSelectedElement(inspectedElement) {
+ var hooks = inspectedElement.hooks, id = inspectedElement.id, props = inspectedElement.props;
+ var fiber = idToArbitraryFiberMap.get(id);
+ if (fiber == null) {
+ console.warn('Could not find Fiber with id "'.concat(id, '"'));
+ return;
+ }
+ var elementType = fiber.elementType, stateNode = fiber.stateNode, tag = fiber.tag, type = fiber.type;
+ switch (tag) {
+ case ClassComponent:
+ case IncompleteClassComponent:
+ case IndeterminateComponent:
+ global2.$r = stateNode;
+ break;
+ case FunctionComponent:
+ global2.$r = {
+ hooks,
+ props,
+ type
+ };
+ break;
+ case ForwardRef:
+ global2.$r = {
+ hooks,
+ props,
+ type: type.render
+ };
+ break;
+ case MemoComponent:
+ case SimpleMemoComponent:
+ global2.$r = {
+ hooks,
+ props,
+ type: elementType != null && elementType.type != null ? elementType.type : type
+ };
+ break;
+ default:
+ global2.$r = null;
+ break;
+ }
+ }
+ __name(updateSelectedElement, "updateSelectedElement");
+ function storeAsGlobal(id, path45, count) {
+ if (isMostRecentlyInspectedElement(id)) {
+ var value = Object(utils[
+ "h"
+ /* getInObject */
+ ])(mostRecentlyInspectedElement, path45);
+ var key = "$reactTemp".concat(count);
+ window[key] = value;
+ console.log(key);
+ console.log(value);
+ }
+ }
+ __name(storeAsGlobal, "storeAsGlobal");
+ function copyElementPath(id, path45) {
+ if (isMostRecentlyInspectedElement(id)) {
+ Object(backend_utils[
+ "b"
+ /* copyToClipboard */
+ ])(Object(utils[
+ "h"
+ /* getInObject */
+ ])(mostRecentlyInspectedElement, path45));
+ }
+ }
+ __name(copyElementPath, "copyElementPath");
+ function inspectElement(requestID, id, path45, forceFullData) {
+ if (path45 !== null) {
+ mergeInspectedPaths(path45);
+ }
+ if (isMostRecentlyInspectedElement(id) && !forceFullData) {
+ if (!hasElementUpdatedSinceLastInspected) {
+ if (path45 !== null) {
+ var secondaryCategory = null;
+ if (path45[0] === "hooks") {
+ secondaryCategory = "hooks";
+ }
+ return {
+ id,
+ responseID: requestID,
+ type: "hydrated-path",
+ path: path45,
+ value: Object(backend_utils[
+ "a"
+ /* cleanForBridge */
+ ])(Object(utils[
+ "h"
+ /* getInObject */
+ ])(mostRecentlyInspectedElement, path45), createIsPathAllowed(null, secondaryCategory), path45)
+ };
+ } else {
+ return {
+ id,
+ responseID: requestID,
+ type: "no-change"
+ };
+ }
+ }
+ } else {
+ currentlyInspectedPaths = {};
+ }
+ hasElementUpdatedSinceLastInspected = false;
+ try {
+ mostRecentlyInspectedElement = inspectElementRaw(id);
+ } catch (error) {
+ console.error("Error inspecting element.\n\n", error);
+ return {
+ type: "error",
+ id,
+ responseID: requestID,
+ message: error.message,
+ stack: error.stack
+ };
+ }
+ if (mostRecentlyInspectedElement === null) {
+ return {
+ id,
+ responseID: requestID,
+ type: "not-found"
+ };
+ }
+ updateSelectedElement(mostRecentlyInspectedElement);
+ var cleanedInspectedElement = _objectSpread11({}, mostRecentlyInspectedElement);
+ cleanedInspectedElement.context = Object(backend_utils[
+ "a"
+ /* cleanForBridge */
+ ])(cleanedInspectedElement.context, createIsPathAllowed("context", null));
+ cleanedInspectedElement.hooks = Object(backend_utils[
+ "a"
+ /* cleanForBridge */
+ ])(cleanedInspectedElement.hooks, createIsPathAllowed("hooks", "hooks"));
+ cleanedInspectedElement.props = Object(backend_utils[
+ "a"
+ /* cleanForBridge */
+ ])(cleanedInspectedElement.props, createIsPathAllowed("props", null));
+ cleanedInspectedElement.state = Object(backend_utils[
+ "a"
+ /* cleanForBridge */
+ ])(cleanedInspectedElement.state, createIsPathAllowed("state", null));
+ return {
+ id,
+ responseID: requestID,
+ type: "full-data",
+ value: cleanedInspectedElement
+ };
+ }
+ __name(inspectElement, "inspectElement");
+ function logElementToConsole(id) {
+ var result = isMostRecentlyInspectedElementCurrent(id) ? mostRecentlyInspectedElement : inspectElementRaw(id);
+ if (result === null) {
+ console.warn('Could not find Fiber with id "'.concat(id, '"'));
+ return;
+ }
+ var supportsGroup = typeof console.groupCollapsed === "function";
+ if (supportsGroup) {
+ console.groupCollapsed(
+ "[Click to expand] %c<".concat(result.displayName || "Component", " />"),
+ // --dom-tag-name-color is the CSS variable Chrome styles HTML elements with in the console.
+ "color: var(--dom-tag-name-color); font-weight: normal;"
+ );
+ }
+ if (result.props !== null) {
+ console.log("Props:", result.props);
+ }
+ if (result.state !== null) {
+ console.log("State:", result.state);
+ }
+ if (result.hooks !== null) {
+ console.log("Hooks:", result.hooks);
+ }
+ var nativeNodes = findNativeNodesForFiberID(id);
+ if (nativeNodes !== null) {
+ console.log("Nodes:", nativeNodes);
+ }
+ if (result.source !== null) {
+ console.log("Location:", result.source);
+ }
+ if (window.chrome || /firefox/i.test(navigator.userAgent)) {
+ console.log("Right-click any value to save it as a global variable for further inspection.");
+ }
+ if (supportsGroup) {
+ console.groupEnd();
+ }
+ }
+ __name(logElementToConsole, "logElementToConsole");
+ function deletePath(type, id, hookID, path45) {
+ var fiber = findCurrentFiberUsingSlowPathById(id);
+ if (fiber !== null) {
+ var instance = fiber.stateNode;
+ switch (type) {
+ case "context":
+ path45 = path45.slice(1);
+ switch (fiber.tag) {
+ case ClassComponent:
+ if (path45.length === 0) {
+ } else {
+ Object(utils[
+ "a"
+ /* deletePathInObject */
+ ])(instance.context, path45);
+ }
+ instance.forceUpdate();
+ break;
+ case FunctionComponent:
+ break;
+ }
+ break;
+ case "hooks":
+ if (typeof overrideHookStateDeletePath === "function") {
+ overrideHookStateDeletePath(fiber, hookID, path45);
+ }
+ break;
+ case "props":
+ if (instance === null) {
+ if (typeof overridePropsDeletePath === "function") {
+ overridePropsDeletePath(fiber, path45);
+ }
+ } else {
+ fiber.pendingProps = Object(backend_utils[
+ "c"
+ /* copyWithDelete */
+ ])(instance.props, path45);
+ instance.forceUpdate();
+ }
+ break;
+ case "state":
+ Object(utils[
+ "a"
+ /* deletePathInObject */
+ ])(instance.state, path45);
+ instance.forceUpdate();
+ break;
+ }
+ }
+ }
+ __name(deletePath, "deletePath");
+ function renamePath(type, id, hookID, oldPath, newPath) {
+ var fiber = findCurrentFiberUsingSlowPathById(id);
+ if (fiber !== null) {
+ var instance = fiber.stateNode;
+ switch (type) {
+ case "context":
+ oldPath = oldPath.slice(1);
+ newPath = newPath.slice(1);
+ switch (fiber.tag) {
+ case ClassComponent:
+ if (oldPath.length === 0) {
+ } else {
+ Object(utils[
+ "k"
+ /* renamePathInObject */
+ ])(instance.context, oldPath, newPath);
+ }
+ instance.forceUpdate();
+ break;
+ case FunctionComponent:
+ break;
+ }
+ break;
+ case "hooks":
+ if (typeof overrideHookStateRenamePath === "function") {
+ overrideHookStateRenamePath(fiber, hookID, oldPath, newPath);
+ }
+ break;
+ case "props":
+ if (instance === null) {
+ if (typeof overridePropsRenamePath === "function") {
+ overridePropsRenamePath(fiber, oldPath, newPath);
+ }
+ } else {
+ fiber.pendingProps = Object(backend_utils[
+ "d"
+ /* copyWithRename */
+ ])(instance.props, oldPath, newPath);
+ instance.forceUpdate();
+ }
+ break;
+ case "state":
+ Object(utils[
+ "k"
+ /* renamePathInObject */
+ ])(instance.state, oldPath, newPath);
+ instance.forceUpdate();
+ break;
+ }
+ }
+ }
+ __name(renamePath, "renamePath");
+ function overrideValueAtPath(type, id, hookID, path45, value) {
+ var fiber = findCurrentFiberUsingSlowPathById(id);
+ if (fiber !== null) {
+ var instance = fiber.stateNode;
+ switch (type) {
+ case "context":
+ path45 = path45.slice(1);
+ switch (fiber.tag) {
+ case ClassComponent:
+ if (path45.length === 0) {
+ instance.context = value;
+ } else {
+ Object(utils[
+ "l"
+ /* setInObject */
+ ])(instance.context, path45, value);
+ }
+ instance.forceUpdate();
+ break;
+ case FunctionComponent:
+ break;
+ }
+ break;
+ case "hooks":
+ if (typeof overrideHookState === "function") {
+ overrideHookState(fiber, hookID, path45, value);
+ }
+ break;
+ case "props":
+ switch (fiber.tag) {
+ case ClassComponent:
+ fiber.pendingProps = Object(backend_utils[
+ "e"
+ /* copyWithSet */
+ ])(instance.props, path45, value);
+ instance.forceUpdate();
+ break;
+ default:
+ if (typeof overrideProps === "function") {
+ overrideProps(fiber, path45, value);
+ }
+ break;
+ }
+ break;
+ case "state":
+ switch (fiber.tag) {
+ case ClassComponent:
+ Object(utils[
+ "l"
+ /* setInObject */
+ ])(instance.state, path45, value);
+ instance.forceUpdate();
+ break;
+ }
+ break;
+ }
+ }
+ }
+ __name(overrideValueAtPath, "overrideValueAtPath");
+ var currentCommitProfilingMetadata = null;
+ var displayNamesByRootID = null;
+ var idToContextsMap = null;
+ var initialTreeBaseDurationsMap = null;
+ var initialIDToRootMap = null;
+ var isProfiling = false;
+ var profilingStartTime = 0;
+ var recordChangeDescriptions = false;
+ var rootToCommitProfilingMetadataMap = null;
+ function getProfilingData() {
+ var dataForRoots = [];
+ if (rootToCommitProfilingMetadataMap === null) {
+ throw Error("getProfilingData() called before any profiling data was recorded");
+ }
+ rootToCommitProfilingMetadataMap.forEach(function(commitProfilingMetadata, rootID) {
+ var commitData = [];
+ var initialTreeBaseDurations = [];
+ var displayName = displayNamesByRootID !== null && displayNamesByRootID.get(rootID) || "Unknown";
+ if (initialTreeBaseDurationsMap != null) {
+ initialTreeBaseDurationsMap.forEach(function(treeBaseDuration, id) {
+ if (initialIDToRootMap != null && initialIDToRootMap.get(id) === rootID) {
+ initialTreeBaseDurations.push([id, treeBaseDuration]);
+ }
+ });
+ }
+ commitProfilingMetadata.forEach(function(commitProfilingData, commitIndex) {
+ var changeDescriptions = commitProfilingData.changeDescriptions, durations = commitProfilingData.durations, effectDuration = commitProfilingData.effectDuration, maxActualDuration = commitProfilingData.maxActualDuration, passiveEffectDuration = commitProfilingData.passiveEffectDuration, priorityLevel = commitProfilingData.priorityLevel, commitTime = commitProfilingData.commitTime, updaters = commitProfilingData.updaters;
+ var fiberActualDurations = [];
+ var fiberSelfDurations = [];
+ for (var i = 0; i < durations.length; i += 3) {
+ var fiberID = durations[i];
+ fiberActualDurations.push([fiberID, durations[i + 1]]);
+ fiberSelfDurations.push([fiberID, durations[i + 2]]);
+ }
+ commitData.push({
+ changeDescriptions: changeDescriptions !== null ? Array.from(changeDescriptions.entries()) : null,
+ duration: maxActualDuration,
+ effectDuration,
+ fiberActualDurations,
+ fiberSelfDurations,
+ passiveEffectDuration,
+ priorityLevel,
+ timestamp: commitTime,
+ updaters
+ });
+ });
+ dataForRoots.push({
+ commitData,
+ displayName,
+ initialTreeBaseDurations,
+ rootID
+ });
+ });
+ return {
+ dataForRoots,
+ rendererID
+ };
+ }
+ __name(getProfilingData, "getProfilingData");
+ function startProfiling(shouldRecordChangeDescriptions) {
+ if (isProfiling) {
+ return;
+ }
+ recordChangeDescriptions = shouldRecordChangeDescriptions;
+ displayNamesByRootID = /* @__PURE__ */ new Map();
+ initialTreeBaseDurationsMap = new Map(idToTreeBaseDurationMap);
+ initialIDToRootMap = new Map(idToRootMap);
+ idToContextsMap = /* @__PURE__ */ new Map();
+ hook.getFiberRoots(rendererID).forEach(function(root) {
+ var rootID = getFiberIDThrows(root.current);
+ displayNamesByRootID.set(rootID, getDisplayNameForRoot(root.current));
+ if (shouldRecordChangeDescriptions) {
+ crawlToInitializeContextsMap(root.current);
+ }
+ });
+ isProfiling = true;
+ profilingStartTime = getCurrentTime();
+ rootToCommitProfilingMetadataMap = /* @__PURE__ */ new Map();
+ }
+ __name(startProfiling, "startProfiling");
+ function stopProfiling() {
+ isProfiling = false;
+ recordChangeDescriptions = false;
+ }
+ __name(stopProfiling, "stopProfiling");
+ if (Object(storage[
+ "c"
+ /* sessionStorageGetItem */
+ ])(constants3[
+ "i"
+ /* SESSION_STORAGE_RELOAD_AND_PROFILE_KEY */
+ ]) === "true") {
+ startProfiling(Object(storage[
+ "c"
+ /* sessionStorageGetItem */
+ ])(constants3[
+ "h"
+ /* SESSION_STORAGE_RECORD_CHANGE_DESCRIPTIONS_KEY */
+ ]) === "true");
+ }
+ function shouldErrorFiberAlwaysNull() {
+ return null;
+ }
+ __name(shouldErrorFiberAlwaysNull, "shouldErrorFiberAlwaysNull");
+ var forceErrorForFiberIDs = /* @__PURE__ */ new Map();
+ function shouldErrorFiberAccordingToMap(fiber) {
+ if (typeof setErrorHandler !== "function") {
+ throw new Error("Expected overrideError() to not get called for earlier React versions.");
+ }
+ var id = getFiberIDUnsafe(fiber);
+ if (id === null) {
+ return null;
+ }
+ var status = null;
+ if (forceErrorForFiberIDs.has(id)) {
+ status = forceErrorForFiberIDs.get(id);
+ if (status === false) {
+ forceErrorForFiberIDs.delete(id);
+ if (forceErrorForFiberIDs.size === 0) {
+ setErrorHandler(shouldErrorFiberAlwaysNull);
+ }
+ }
+ }
+ return status;
+ }
+ __name(shouldErrorFiberAccordingToMap, "shouldErrorFiberAccordingToMap");
+ function overrideError(id, forceError) {
+ if (typeof setErrorHandler !== "function" || typeof scheduleUpdate !== "function") {
+ throw new Error("Expected overrideError() to not get called for earlier React versions.");
+ }
+ forceErrorForFiberIDs.set(id, forceError);
+ if (forceErrorForFiberIDs.size === 1) {
+ setErrorHandler(shouldErrorFiberAccordingToMap);
+ }
+ var fiber = idToArbitraryFiberMap.get(id);
+ if (fiber != null) {
+ scheduleUpdate(fiber);
+ }
+ }
+ __name(overrideError, "overrideError");
+ function shouldSuspendFiberAlwaysFalse() {
+ return false;
+ }
+ __name(shouldSuspendFiberAlwaysFalse, "shouldSuspendFiberAlwaysFalse");
+ var forceFallbackForSuspenseIDs = /* @__PURE__ */ new Set();
+ function shouldSuspendFiberAccordingToSet(fiber) {
+ var maybeID = getFiberIDUnsafe(fiber);
+ return maybeID !== null && forceFallbackForSuspenseIDs.has(maybeID);
+ }
+ __name(shouldSuspendFiberAccordingToSet, "shouldSuspendFiberAccordingToSet");
+ function overrideSuspense(id, forceFallback) {
+ if (typeof setSuspenseHandler !== "function" || typeof scheduleUpdate !== "function") {
+ throw new Error("Expected overrideSuspense() to not get called for earlier React versions.");
+ }
+ if (forceFallback) {
+ forceFallbackForSuspenseIDs.add(id);
+ if (forceFallbackForSuspenseIDs.size === 1) {
+ setSuspenseHandler(shouldSuspendFiberAccordingToSet);
+ }
+ } else {
+ forceFallbackForSuspenseIDs.delete(id);
+ if (forceFallbackForSuspenseIDs.size === 0) {
+ setSuspenseHandler(shouldSuspendFiberAlwaysFalse);
+ }
+ }
+ var fiber = idToArbitraryFiberMap.get(id);
+ if (fiber != null) {
+ scheduleUpdate(fiber);
+ }
+ }
+ __name(overrideSuspense, "overrideSuspense");
+ var trackedPath = null;
+ var trackedPathMatchFiber = null;
+ var trackedPathMatchDepth = -1;
+ var mightBeOnTrackedPath = false;
+ function setTrackedPath(path45) {
+ if (path45 === null) {
+ trackedPathMatchFiber = null;
+ trackedPathMatchDepth = -1;
+ mightBeOnTrackedPath = false;
+ }
+ trackedPath = path45;
+ }
+ __name(setTrackedPath, "setTrackedPath");
+ function updateTrackedPathStateBeforeMount(fiber) {
+ if (trackedPath === null || !mightBeOnTrackedPath) {
+ return false;
+ }
+ var returnFiber = fiber.return;
+ var returnAlternate = returnFiber !== null ? returnFiber.alternate : null;
+ if (trackedPathMatchFiber === returnFiber || trackedPathMatchFiber === returnAlternate && returnAlternate !== null) {
+ var actualFrame = getPathFrame(fiber);
+ var expectedFrame = trackedPath[trackedPathMatchDepth + 1];
+ if (expectedFrame === void 0) {
+ throw new Error("Expected to see a frame at the next depth.");
+ }
+ if (actualFrame.index === expectedFrame.index && actualFrame.key === expectedFrame.key && actualFrame.displayName === expectedFrame.displayName) {
+ trackedPathMatchFiber = fiber;
+ trackedPathMatchDepth++;
+ if (trackedPathMatchDepth === trackedPath.length - 1) {
+ mightBeOnTrackedPath = false;
+ } else {
+ mightBeOnTrackedPath = true;
+ }
+ return false;
+ }
+ }
+ mightBeOnTrackedPath = false;
+ return true;
+ }
+ __name(updateTrackedPathStateBeforeMount, "updateTrackedPathStateBeforeMount");
+ function updateTrackedPathStateAfterMount(mightSiblingsBeOnTrackedPath) {
+ mightBeOnTrackedPath = mightSiblingsBeOnTrackedPath;
+ }
+ __name(updateTrackedPathStateAfterMount, "updateTrackedPathStateAfterMount");
+ var rootPseudoKeys = /* @__PURE__ */ new Map();
+ var rootDisplayNameCounter = /* @__PURE__ */ new Map();
+ function setRootPseudoKey(id, fiber) {
+ var name = getDisplayNameForRoot(fiber);
+ var counter = rootDisplayNameCounter.get(name) || 0;
+ rootDisplayNameCounter.set(name, counter + 1);
+ var pseudoKey = "".concat(name, ":").concat(counter);
+ rootPseudoKeys.set(id, pseudoKey);
+ }
+ __name(setRootPseudoKey, "setRootPseudoKey");
+ function removeRootPseudoKey(id) {
+ var pseudoKey = rootPseudoKeys.get(id);
+ if (pseudoKey === void 0) {
+ throw new Error("Expected root pseudo key to be known.");
+ }
+ var name = pseudoKey.substring(0, pseudoKey.lastIndexOf(":"));
+ var counter = rootDisplayNameCounter.get(name);
+ if (counter === void 0) {
+ throw new Error("Expected counter to be known.");
+ }
+ if (counter > 1) {
+ rootDisplayNameCounter.set(name, counter - 1);
+ } else {
+ rootDisplayNameCounter.delete(name);
+ }
+ rootPseudoKeys.delete(id);
+ }
+ __name(removeRootPseudoKey, "removeRootPseudoKey");
+ function getDisplayNameForRoot(fiber) {
+ var preferredDisplayName = null;
+ var fallbackDisplayName = null;
+ var child = fiber.child;
+ for (var i = 0; i < 3; i++) {
+ if (child === null) {
+ break;
+ }
+ var displayName = getDisplayNameForFiber(child);
+ if (displayName !== null) {
+ if (typeof child.type === "function") {
+ preferredDisplayName = displayName;
+ } else if (fallbackDisplayName === null) {
+ fallbackDisplayName = displayName;
+ }
+ }
+ if (preferredDisplayName !== null) {
+ break;
+ }
+ child = child.child;
+ }
+ return preferredDisplayName || fallbackDisplayName || "Anonymous";
+ }
+ __name(getDisplayNameForRoot, "getDisplayNameForRoot");
+ function getPathFrame(fiber) {
+ var key = fiber.key;
+ var displayName = getDisplayNameForFiber(fiber);
+ var index = fiber.index;
+ switch (fiber.tag) {
+ case HostRoot:
+ var id = getFiberIDThrows(fiber);
+ var pseudoKey = rootPseudoKeys.get(id);
+ if (pseudoKey === void 0) {
+ throw new Error("Expected mounted root to have known pseudo key.");
+ }
+ displayName = pseudoKey;
+ break;
+ case HostComponent:
+ displayName = fiber.type;
+ break;
+ default:
+ break;
+ }
+ return {
+ displayName,
+ key,
+ index
+ };
+ }
+ __name(getPathFrame, "getPathFrame");
+ function getPathForElement(id) {
+ var fiber = idToArbitraryFiberMap.get(id);
+ if (fiber == null) {
+ return null;
+ }
+ var keyPath = [];
+ while (fiber !== null) {
+ keyPath.push(getPathFrame(fiber));
+ fiber = fiber.return;
+ }
+ keyPath.reverse();
+ return keyPath;
+ }
+ __name(getPathForElement, "getPathForElement");
+ function getBestMatchForTrackedPath() {
+ if (trackedPath === null) {
+ return null;
+ }
+ if (trackedPathMatchFiber === null) {
+ return null;
+ }
+ var fiber = trackedPathMatchFiber;
+ while (fiber !== null && shouldFilterFiber(fiber)) {
+ fiber = fiber.return;
+ }
+ if (fiber === null) {
+ return null;
+ }
+ return {
+ id: getFiberIDThrows(fiber),
+ isFullMatch: trackedPathMatchDepth === trackedPath.length - 1
+ };
+ }
+ __name(getBestMatchForTrackedPath, "getBestMatchForTrackedPath");
+ var formatPriorityLevel = /* @__PURE__ */ __name(function formatPriorityLevel2(priorityLevel) {
+ if (priorityLevel == null) {
+ return "Unknown";
+ }
+ switch (priorityLevel) {
+ case ImmediatePriority:
+ return "Immediate";
+ case UserBlockingPriority:
+ return "User-Blocking";
+ case NormalPriority:
+ return "Normal";
+ case LowPriority:
+ return "Low";
+ case IdlePriority:
+ return "Idle";
+ case NoPriority:
+ default:
+ return "Unknown";
+ }
+ }, "formatPriorityLevel");
+ function setTraceUpdatesEnabled(isEnabled) {
+ traceUpdatesEnabled = isEnabled;
+ }
+ __name(setTraceUpdatesEnabled, "setTraceUpdatesEnabled");
+ return {
+ cleanup,
+ clearErrorsAndWarnings,
+ clearErrorsForFiberID,
+ clearWarningsForFiberID,
+ copyElementPath,
+ deletePath,
+ findNativeNodesForFiberID,
+ flushInitialOperations,
+ getBestMatchForTrackedPath,
+ getDisplayNameForFiberID,
+ getFiberIDForNative,
+ getInstanceAndStyle,
+ getOwnersList,
+ getPathForElement,
+ getProfilingData,
+ handleCommitFiberRoot,
+ handleCommitFiberUnmount,
+ handlePostCommitFiberRoot,
+ inspectElement,
+ logElementToConsole,
+ patchConsoleForStrictMode: backend_console[
+ "b"
+ /* patchForStrictMode */
+ ],
+ prepareViewAttributeSource,
+ prepareViewElementSource,
+ overrideError,
+ overrideSuspense,
+ overrideValueAtPath,
+ renamePath,
+ renderer,
+ setTraceUpdatesEnabled,
+ setTrackedPath,
+ startProfiling,
+ stopProfiling,
+ storeAsGlobal,
+ unpatchConsoleForStrictMode: backend_console[
+ "d"
+ /* unpatchForStrictMode */
+ ],
+ updateComponentFilters
+ };
+ }
+ __name(attach, "attach");
+ },
+ /* 17 */
+ /***/
+ function(module3, exports3) {
+ var process8 = module3.exports = {};
+ var cachedSetTimeout;
+ var cachedClearTimeout;
+ function defaultSetTimout() {
+ throw new Error("setTimeout has not been defined");
+ }
+ __name(defaultSetTimout, "defaultSetTimout");
+ function defaultClearTimeout() {
+ throw new Error("clearTimeout has not been defined");
+ }
+ __name(defaultClearTimeout, "defaultClearTimeout");
+ (function() {
+ try {
+ if (typeof setTimeout === "function") {
+ cachedSetTimeout = setTimeout;
+ } else {
+ cachedSetTimeout = defaultSetTimout;
+ }
+ } catch (e2) {
+ cachedSetTimeout = defaultSetTimout;
+ }
+ try {
+ if (typeof clearTimeout === "function") {
+ cachedClearTimeout = clearTimeout;
+ } else {
+ cachedClearTimeout = defaultClearTimeout;
+ }
+ } catch (e2) {
+ cachedClearTimeout = defaultClearTimeout;
+ }
+ })();
+ function runTimeout(fun) {
+ if (cachedSetTimeout === setTimeout) {
+ return setTimeout(fun, 0);
+ }
+ if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
+ cachedSetTimeout = setTimeout;
+ return setTimeout(fun, 0);
+ }
+ try {
+ return cachedSetTimeout(fun, 0);
+ } catch (e2) {
+ try {
+ return cachedSetTimeout.call(null, fun, 0);
+ } catch (e3) {
+ return cachedSetTimeout.call(this, fun, 0);
+ }
+ }
+ }
+ __name(runTimeout, "runTimeout");
+ function runClearTimeout(marker) {
+ if (cachedClearTimeout === clearTimeout) {
+ return clearTimeout(marker);
+ }
+ if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
+ cachedClearTimeout = clearTimeout;
+ return clearTimeout(marker);
+ }
+ try {
+ return cachedClearTimeout(marker);
+ } catch (e2) {
+ try {
+ return cachedClearTimeout.call(null, marker);
+ } catch (e3) {
+ return cachedClearTimeout.call(this, marker);
+ }
+ }
+ }
+ __name(runClearTimeout, "runClearTimeout");
+ var queue = [];
+ var draining = false;
+ var currentQueue;
+ var queueIndex = -1;
+ function cleanUpNextTick() {
+ if (!draining || !currentQueue) {
+ return;
+ }
+ draining = false;
+ if (currentQueue.length) {
+ queue = currentQueue.concat(queue);
+ } else {
+ queueIndex = -1;
+ }
+ if (queue.length) {
+ drainQueue();
+ }
+ }
+ __name(cleanUpNextTick, "cleanUpNextTick");
+ function drainQueue() {
+ if (draining) {
+ return;
+ }
+ var timeout = runTimeout(cleanUpNextTick);
+ draining = true;
+ var len = queue.length;
+ while (len) {
+ currentQueue = queue;
+ queue = [];
+ while (++queueIndex < len) {
+ if (currentQueue) {
+ currentQueue[queueIndex].run();
+ }
+ }
+ queueIndex = -1;
+ len = queue.length;
+ }
+ currentQueue = null;
+ draining = false;
+ runClearTimeout(timeout);
+ }
+ __name(drainQueue, "drainQueue");
+ process8.nextTick = function(fun) {
+ var args = new Array(arguments.length - 1);
+ if (arguments.length > 1) {
+ for (var i = 1; i < arguments.length; i++) {
+ args[i - 1] = arguments[i];
+ }
+ }
+ queue.push(new Item(fun, args));
+ if (queue.length === 1 && !draining) {
+ runTimeout(drainQueue);
+ }
+ };
+ function Item(fun, array) {
+ this.fun = fun;
+ this.array = array;
+ }
+ __name(Item, "Item");
+ Item.prototype.run = function() {
+ this.fun.apply(null, this.array);
+ };
+ process8.title = "browser";
+ process8.browser = true;
+ process8.env = {};
+ process8.argv = [];
+ process8.version = "";
+ process8.versions = {};
+ function noop() {
+ }
+ __name(noop, "noop");
+ process8.on = noop;
+ process8.addListener = noop;
+ process8.once = noop;
+ process8.off = noop;
+ process8.removeListener = noop;
+ process8.removeAllListeners = noop;
+ process8.emit = noop;
+ process8.prependListener = noop;
+ process8.prependOnceListener = noop;
+ process8.listeners = function(name) {
+ return [];
+ };
+ process8.binding = function(name) {
+ throw new Error("process.binding is not supported");
+ };
+ process8.cwd = function() {
+ return "/";
+ };
+ process8.chdir = function(dir) {
+ throw new Error("process.chdir is not supported");
+ };
+ process8.umask = function() {
+ return 0;
+ };
+ },
+ /* 18 */
+ /***/
+ function(module3, exports3, __webpack_require__) {
+ (function(setImmediate2) {
+ function _typeof7(obj) {
+ "@babel/helpers - typeof";
+ if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+ _typeof7 = /* @__PURE__ */ __name(function _typeof8(obj2) {
+ return typeof obj2;
+ }, "_typeof");
+ } else {
+ _typeof7 = /* @__PURE__ */ __name(function _typeof8(obj2) {
+ return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+ }, "_typeof");
+ }
+ return _typeof7(obj);
+ }
+ __name(_typeof7, "_typeof");
+ (function(name, definition) {
+ if (true) {
+ module3.exports = definition();
+ } else {
+ }
+ })("clipboard", function() {
+ if (typeof document === "undefined" || !document.addEventListener) {
+ return null;
+ }
+ var clipboard6 = {};
+ clipboard6.copy = function() {
+ var _intercept = false;
+ var _data = null;
+ var _bogusSelection = false;
+ function cleanup() {
+ _intercept = false;
+ _data = null;
+ if (_bogusSelection) {
+ window.getSelection().removeAllRanges();
+ }
+ _bogusSelection = false;
+ }
+ __name(cleanup, "cleanup");
+ document.addEventListener("copy", function(e2) {
+ if (_intercept) {
+ for (var key in _data) {
+ e2.clipboardData.setData(key, _data[key]);
+ }
+ e2.preventDefault();
+ }
+ });
+ function bogusSelect() {
+ var sel = document.getSelection();
+ if (!document.queryCommandEnabled("copy") && sel.isCollapsed) {
+ var range = document.createRange();
+ range.selectNodeContents(document.body);
+ sel.removeAllRanges();
+ sel.addRange(range);
+ _bogusSelection = true;
+ }
+ }
+ __name(bogusSelect, "bogusSelect");
+ ;
+ return function(data) {
+ return new Promise(function(resolve18, reject) {
+ _intercept = true;
+ if (typeof data === "string") {
+ _data = {
+ "text/plain": data
+ };
+ } else if (data instanceof Node) {
+ _data = {
+ "text/html": new XMLSerializer().serializeToString(data)
+ };
+ } else if (data instanceof Object) {
+ _data = data;
+ } else {
+ reject("Invalid data type. Must be string, DOM node, or an object mapping MIME types to strings.");
+ }
+ function triggerCopy(tryBogusSelect) {
+ try {
+ if (document.execCommand("copy")) {
+ cleanup();
+ resolve18();
+ } else {
+ if (!tryBogusSelect) {
+ bogusSelect();
+ triggerCopy(true);
+ } else {
+ cleanup();
+ throw new Error("Unable to copy. Perhaps it's not available in your browser?");
+ }
+ }
+ } catch (e2) {
+ cleanup();
+ reject(e2);
+ }
+ }
+ __name(triggerCopy, "triggerCopy");
+ triggerCopy(false);
+ });
+ };
+ }();
+ clipboard6.paste = function() {
+ var _intercept = false;
+ var _resolve;
+ var _dataType;
+ document.addEventListener("paste", function(e2) {
+ if (_intercept) {
+ _intercept = false;
+ e2.preventDefault();
+ var resolve18 = _resolve;
+ _resolve = null;
+ resolve18(e2.clipboardData.getData(_dataType));
+ }
+ });
+ return function(dataType) {
+ return new Promise(function(resolve18, reject) {
+ _intercept = true;
+ _resolve = resolve18;
+ _dataType = dataType || "text/plain";
+ try {
+ if (!document.execCommand("paste")) {
+ _intercept = false;
+ reject(new Error("Unable to paste. Pasting only works in Internet Explorer at the moment."));
+ }
+ } catch (e2) {
+ _intercept = false;
+ reject(new Error(e2));
+ }
+ });
+ };
+ }();
+ if (typeof ClipboardEvent === "undefined" && typeof window.clipboardData !== "undefined" && typeof window.clipboardData.setData !== "undefined") {
+ (function(a) {
+ function b(a2, b2) {
+ return function() {
+ a2.apply(b2, arguments);
+ };
+ }
+ __name(b, "b");
+ function c(a2) {
+ if ("object" != _typeof7(this))
+ throw new TypeError("Promises must be constructed via new");
+ if ("function" != typeof a2)
+ throw new TypeError("not a function");
+ this._state = null, this._value = null, this._deferreds = [], i(a2, b(e2, this), b(f, this));
+ }
+ __name(c, "c");
+ function d(a2) {
+ var b2 = this;
+ return null === this._state ? void this._deferreds.push(a2) : void j(function() {
+ var c2 = b2._state ? a2.onFulfilled : a2.onRejected;
+ if (null === c2)
+ return void (b2._state ? a2.resolve : a2.reject)(b2._value);
+ var d2;
+ try {
+ d2 = c2(b2._value);
+ } catch (e3) {
+ return void a2.reject(e3);
+ }
+ a2.resolve(d2);
+ });
+ }
+ __name(d, "d");
+ function e2(a2) {
+ try {
+ if (a2 === this)
+ throw new TypeError("A promise cannot be resolved with itself.");
+ if (a2 && ("object" == _typeof7(a2) || "function" == typeof a2)) {
+ var c2 = a2.then;
+ if ("function" == typeof c2)
+ return void i(b(c2, a2), b(e2, this), b(f, this));
+ }
+ this._state = true, this._value = a2, g.call(this);
+ } catch (d2) {
+ f.call(this, d2);
+ }
+ }
+ __name(e2, "e");
+ function f(a2) {
+ this._state = false, this._value = a2, g.call(this);
+ }
+ __name(f, "f");
+ function g() {
+ for (var a2 = 0, b2 = this._deferreds.length; b2 > a2; a2++) {
+ d.call(this, this._deferreds[a2]);
+ }
+ this._deferreds = null;
+ }
+ __name(g, "g");
+ function h(a2, b2, c2, d2) {
+ this.onFulfilled = "function" == typeof a2 ? a2 : null, this.onRejected = "function" == typeof b2 ? b2 : null, this.resolve = c2, this.reject = d2;
+ }
+ __name(h, "h");
+ function i(a2, b2, c2) {
+ var d2 = false;
+ try {
+ a2(function(a3) {
+ d2 || (d2 = true, b2(a3));
+ }, function(a3) {
+ d2 || (d2 = true, c2(a3));
+ });
+ } catch (e3) {
+ if (d2)
+ return;
+ d2 = true, c2(e3);
+ }
+ }
+ __name(i, "i");
+ var j = c.immediateFn || "function" == typeof setImmediate2 && setImmediate2 || function(a2) {
+ setTimeout(a2, 1);
+ }, k = Array.isArray || function(a2) {
+ return "[object Array]" === Object.prototype.toString.call(a2);
+ };
+ c.prototype["catch"] = function(a2) {
+ return this.then(null, a2);
+ }, c.prototype.then = function(a2, b2) {
+ var e3 = this;
+ return new c(function(c2, f2) {
+ d.call(e3, new h(a2, b2, c2, f2));
+ });
+ }, c.all = function() {
+ var a2 = Array.prototype.slice.call(1 === arguments.length && k(arguments[0]) ? arguments[0] : arguments);
+ return new c(function(b2, c2) {
+ function d2(f3, g2) {
+ try {
+ if (g2 && ("object" == _typeof7(g2) || "function" == typeof g2)) {
+ var h2 = g2.then;
+ if ("function" == typeof h2)
+ return void h2.call(g2, function(a3) {
+ d2(f3, a3);
+ }, c2);
+ }
+ a2[f3] = g2, 0 === --e3 && b2(a2);
+ } catch (i2) {
+ c2(i2);
+ }
+ }
+ __name(d2, "d");
+ if (0 === a2.length)
+ return b2([]);
+ for (var e3 = a2.length, f2 = 0; f2 < a2.length; f2++) {
+ d2(f2, a2[f2]);
+ }
+ });
+ }, c.resolve = function(a2) {
+ return a2 && "object" == _typeof7(a2) && a2.constructor === c ? a2 : new c(function(b2) {
+ b2(a2);
+ });
+ }, c.reject = function(a2) {
+ return new c(function(b2, c2) {
+ c2(a2);
+ });
+ }, c.race = function(a2) {
+ return new c(function(b2, c2) {
+ for (var d2 = 0, e3 = a2.length; e3 > d2; d2++) {
+ a2[d2].then(b2, c2);
+ }
+ });
+ }, module3.exports ? module3.exports = c : a.Promise || (a.Promise = c);
+ })(this);
+ clipboard6.copy = function(data) {
+ return new Promise(function(resolve18, reject) {
+ if (typeof data !== "string" && !("text/plain" in data)) {
+ throw new Error("You must provide a text/plain type.");
+ }
+ var strData = typeof data === "string" ? data : data["text/plain"];
+ var copySucceeded = window.clipboardData.setData("Text", strData);
+ if (copySucceeded) {
+ resolve18();
+ } else {
+ reject(new Error("Copying was rejected."));
+ }
+ });
+ };
+ clipboard6.paste = function() {
+ return new Promise(function(resolve18, reject) {
+ var strData = window.clipboardData.getData("Text");
+ if (strData) {
+ resolve18(strData);
+ } else {
+ reject(new Error("Pasting was rejected."));
+ }
+ });
+ };
+ }
+ return clipboard6;
+ });
+ }).call(this, __webpack_require__(23).setImmediate);
+ },
+ /* 19 */
+ /***/
+ function(module3, exports3, __webpack_require__) {
+ "use strict";
+ function _classCallCheck5(instance, Constructor) {
+ if (!(instance instanceof Constructor)) {
+ throw new TypeError("Cannot call a class as a function");
+ }
+ }
+ __name(_classCallCheck5, "_classCallCheck");
+ function _defineProperties5(target, props) {
+ for (var i = 0; i < props.length; i++) {
+ var descriptor2 = props[i];
+ descriptor2.enumerable = descriptor2.enumerable || false;
+ descriptor2.configurable = true;
+ if ("value" in descriptor2)
+ descriptor2.writable = true;
+ Object.defineProperty(target, descriptor2.key, descriptor2);
+ }
+ }
+ __name(_defineProperties5, "_defineProperties");
+ function _createClass5(Constructor, protoProps, staticProps) {
+ if (protoProps)
+ _defineProperties5(Constructor.prototype, protoProps);
+ if (staticProps)
+ _defineProperties5(Constructor, staticProps);
+ return Constructor;
+ }
+ __name(_createClass5, "_createClass");
+ var Yallist = __webpack_require__(25);
+ var MAX = Symbol("max");
+ var LENGTH = Symbol("length");
+ var LENGTH_CALCULATOR = Symbol("lengthCalculator");
+ var ALLOW_STALE = Symbol("allowStale");
+ var MAX_AGE = Symbol("maxAge");
+ var DISPOSE = Symbol("dispose");
+ var NO_DISPOSE_ON_SET = Symbol("noDisposeOnSet");
+ var LRU_LIST = Symbol("lruList");
+ var CACHE = Symbol("cache");
+ var UPDATE_AGE_ON_GET = Symbol("updateAgeOnGet");
+ var naiveLength = /* @__PURE__ */ __name(function naiveLength2() {
+ return 1;
+ }, "naiveLength");
+ var LRUCache = /* @__PURE__ */ function() {
+ function LRUCache2(options14) {
+ _classCallCheck5(this, LRUCache2);
+ if (typeof options14 === "number")
+ options14 = {
+ max: options14
+ };
+ if (!options14)
+ options14 = {};
+ if (options14.max && (typeof options14.max !== "number" || options14.max < 0))
+ throw new TypeError("max must be a non-negative number");
+ var max = this[MAX] = options14.max || Infinity;
+ var lc = options14.length || naiveLength;
+ this[LENGTH_CALCULATOR] = typeof lc !== "function" ? naiveLength : lc;
+ this[ALLOW_STALE] = options14.stale || false;
+ if (options14.maxAge && typeof options14.maxAge !== "number")
+ throw new TypeError("maxAge must be a number");
+ this[MAX_AGE] = options14.maxAge || 0;
+ this[DISPOSE] = options14.dispose;
+ this[NO_DISPOSE_ON_SET] = options14.noDisposeOnSet || false;
+ this[UPDATE_AGE_ON_GET] = options14.updateAgeOnGet || false;
+ this.reset();
+ }
+ __name(LRUCache2, "LRUCache");
+ _createClass5(LRUCache2, [{
+ key: "rforEach",
+ value: /* @__PURE__ */ __name(function rforEach(fn2, thisp) {
+ thisp = thisp || this;
+ for (var walker = this[LRU_LIST].tail; walker !== null; ) {
+ var prev = walker.prev;
+ forEachStep(this, fn2, walker, thisp);
+ walker = prev;
+ }
+ }, "rforEach")
+ }, {
+ key: "forEach",
+ value: /* @__PURE__ */ __name(function forEach(fn2, thisp) {
+ thisp = thisp || this;
+ for (var walker = this[LRU_LIST].head; walker !== null; ) {
+ var next = walker.next;
+ forEachStep(this, fn2, walker, thisp);
+ walker = next;
+ }
+ }, "forEach")
+ }, {
+ key: "keys",
+ value: /* @__PURE__ */ __name(function keys() {
+ return this[LRU_LIST].toArray().map(function(k) {
+ return k.key;
+ });
+ }, "keys")
+ }, {
+ key: "values",
+ value: /* @__PURE__ */ __name(function values() {
+ return this[LRU_LIST].toArray().map(function(k) {
+ return k.value;
+ });
+ }, "values")
+ }, {
+ key: "reset",
+ value: /* @__PURE__ */ __name(function reset() {
+ var _this = this;
+ if (this[DISPOSE] && this[LRU_LIST] && this[LRU_LIST].length) {
+ this[LRU_LIST].forEach(function(hit) {
+ return _this[DISPOSE](hit.key, hit.value);
+ });
+ }
+ this[CACHE] = /* @__PURE__ */ new Map();
+ this[LRU_LIST] = new Yallist();
+ this[LENGTH] = 0;
+ }, "reset")
+ }, {
+ key: "dump",
+ value: /* @__PURE__ */ __name(function dump() {
+ var _this2 = this;
+ return this[LRU_LIST].map(function(hit) {
+ return isStale(_this2, hit) ? false : {
+ k: hit.key,
+ v: hit.value,
+ e: hit.now + (hit.maxAge || 0)
+ };
+ }).toArray().filter(function(h) {
+ return h;
+ });
+ }, "dump")
+ }, {
+ key: "dumpLru",
+ value: /* @__PURE__ */ __name(function dumpLru() {
+ return this[LRU_LIST];
+ }, "dumpLru")
+ }, {
+ key: "set",
+ value: /* @__PURE__ */ __name(function set(key, value, maxAge) {
+ maxAge = maxAge || this[MAX_AGE];
+ if (maxAge && typeof maxAge !== "number")
+ throw new TypeError("maxAge must be a number");
+ var now = maxAge ? Date.now() : 0;
+ var len = this[LENGTH_CALCULATOR](value, key);
+ if (this[CACHE].has(key)) {
+ if (len > this[MAX]) {
+ _del(this, this[CACHE].get(key));
+ return false;
+ }
+ var node = this[CACHE].get(key);
+ var item = node.value;
+ if (this[DISPOSE]) {
+ if (!this[NO_DISPOSE_ON_SET])
+ this[DISPOSE](key, item.value);
+ }
+ item.now = now;
+ item.maxAge = maxAge;
+ item.value = value;
+ this[LENGTH] += len - item.length;
+ item.length = len;
+ this.get(key);
+ trim(this);
+ return true;
+ }
+ var hit = new Entry(key, value, len, now, maxAge);
+ if (hit.length > this[MAX]) {
+ if (this[DISPOSE])
+ this[DISPOSE](key, value);
+ return false;
+ }
+ this[LENGTH] += hit.length;
+ this[LRU_LIST].unshift(hit);
+ this[CACHE].set(key, this[LRU_LIST].head);
+ trim(this);
+ return true;
+ }, "set")
+ }, {
+ key: "has",
+ value: /* @__PURE__ */ __name(function has(key) {
+ if (!this[CACHE].has(key))
+ return false;
+ var hit = this[CACHE].get(key).value;
+ return !isStale(this, hit);
+ }, "has")
+ }, {
+ key: "get",
+ value: /* @__PURE__ */ __name(function get(key) {
+ return _get(this, key, true);
+ }, "get")
+ }, {
+ key: "peek",
+ value: /* @__PURE__ */ __name(function peek(key) {
+ return _get(this, key, false);
+ }, "peek")
+ }, {
+ key: "pop",
+ value: /* @__PURE__ */ __name(function pop() {
+ var node = this[LRU_LIST].tail;
+ if (!node)
+ return null;
+ _del(this, node);
+ return node.value;
+ }, "pop")
+ }, {
+ key: "del",
+ value: /* @__PURE__ */ __name(function del(key) {
+ _del(this, this[CACHE].get(key));
+ }, "del")
+ }, {
+ key: "load",
+ value: /* @__PURE__ */ __name(function load(arr) {
+ this.reset();
+ var now = Date.now();
+ for (var l = arr.length - 1; l >= 0; l--) {
+ var hit = arr[l];
+ var expiresAt = hit.e || 0;
+ if (expiresAt === 0)
+ this.set(hit.k, hit.v);
+ else {
+ var maxAge = expiresAt - now;
+ if (maxAge > 0) {
+ this.set(hit.k, hit.v, maxAge);
+ }
+ }
+ }
+ }, "load")
+ }, {
+ key: "prune",
+ value: /* @__PURE__ */ __name(function prune() {
+ var _this3 = this;
+ this[CACHE].forEach(function(value, key) {
+ return _get(_this3, key, false);
+ });
+ }, "prune")
+ }, {
+ key: "max",
+ set: /* @__PURE__ */ __name(function set(mL) {
+ if (typeof mL !== "number" || mL < 0)
+ throw new TypeError("max must be a non-negative number");
+ this[MAX] = mL || Infinity;
+ trim(this);
+ }, "set"),
+ get: /* @__PURE__ */ __name(function get() {
+ return this[MAX];
+ }, "get")
+ }, {
+ key: "allowStale",
+ set: /* @__PURE__ */ __name(function set(allowStale) {
+ this[ALLOW_STALE] = !!allowStale;
+ }, "set"),
+ get: /* @__PURE__ */ __name(function get() {
+ return this[ALLOW_STALE];
+ }, "get")
+ }, {
+ key: "maxAge",
+ set: /* @__PURE__ */ __name(function set(mA) {
+ if (typeof mA !== "number")
+ throw new TypeError("maxAge must be a non-negative number");
+ this[MAX_AGE] = mA;
+ trim(this);
+ }, "set"),
+ get: /* @__PURE__ */ __name(function get() {
+ return this[MAX_AGE];
+ }, "get")
+ // resize the cache when the lengthCalculator changes.
+ }, {
+ key: "lengthCalculator",
+ set: /* @__PURE__ */ __name(function set(lC) {
+ var _this4 = this;
+ if (typeof lC !== "function")
+ lC = naiveLength;
+ if (lC !== this[LENGTH_CALCULATOR]) {
+ this[LENGTH_CALCULATOR] = lC;
+ this[LENGTH] = 0;
+ this[LRU_LIST].forEach(function(hit) {
+ hit.length = _this4[LENGTH_CALCULATOR](hit.value, hit.key);
+ _this4[LENGTH] += hit.length;
+ });
+ }
+ trim(this);
+ }, "set"),
+ get: /* @__PURE__ */ __name(function get() {
+ return this[LENGTH_CALCULATOR];
+ }, "get")
+ }, {
+ key: "length",
+ get: /* @__PURE__ */ __name(function get() {
+ return this[LENGTH];
+ }, "get")
+ }, {
+ key: "itemCount",
+ get: /* @__PURE__ */ __name(function get() {
+ return this[LRU_LIST].length;
+ }, "get")
+ }]);
+ return LRUCache2;
+ }();
+ var _get = /* @__PURE__ */ __name(function _get2(self2, key, doUse) {
+ var node = self2[CACHE].get(key);
+ if (node) {
+ var hit = node.value;
+ if (isStale(self2, hit)) {
+ _del(self2, node);
+ if (!self2[ALLOW_STALE])
+ return void 0;
+ } else {
+ if (doUse) {
+ if (self2[UPDATE_AGE_ON_GET])
+ node.value.now = Date.now();
+ self2[LRU_LIST].unshiftNode(node);
+ }
+ }
+ return hit.value;
+ }
+ }, "_get");
+ var isStale = /* @__PURE__ */ __name(function isStale2(self2, hit) {
+ if (!hit || !hit.maxAge && !self2[MAX_AGE])
+ return false;
+ var diff = Date.now() - hit.now;
+ return hit.maxAge ? diff > hit.maxAge : self2[MAX_AGE] && diff > self2[MAX_AGE];
+ }, "isStale");
+ var trim = /* @__PURE__ */ __name(function trim2(self2) {
+ if (self2[LENGTH] > self2[MAX]) {
+ for (var walker = self2[LRU_LIST].tail; self2[LENGTH] > self2[MAX] && walker !== null; ) {
+ var prev = walker.prev;
+ _del(self2, walker);
+ walker = prev;
+ }
+ }
+ }, "trim");
+ var _del = /* @__PURE__ */ __name(function _del2(self2, node) {
+ if (node) {
+ var hit = node.value;
+ if (self2[DISPOSE])
+ self2[DISPOSE](hit.key, hit.value);
+ self2[LENGTH] -= hit.length;
+ self2[CACHE].delete(hit.key);
+ self2[LRU_LIST].removeNode(node);
+ }
+ }, "_del");
+ var Entry = /* @__PURE__ */ __name(function Entry2(key, value, length, now, maxAge) {
+ _classCallCheck5(this, Entry2);
+ this.key = key;
+ this.value = value;
+ this.length = length;
+ this.now = now;
+ this.maxAge = maxAge || 0;
+ }, "Entry");
+ var forEachStep = /* @__PURE__ */ __name(function forEachStep2(self2, fn2, node, thisp) {
+ var hit = node.value;
+ if (isStale(self2, hit)) {
+ _del(self2, node);
+ if (!self2[ALLOW_STALE])
+ hit = void 0;
+ }
+ if (hit)
+ fn2.call(thisp, hit.value, hit.key, self2);
+ }, "forEachStep");
+ module3.exports = LRUCache;
+ },
+ /* 20 */
+ /***/
+ function(module3, __webpack_exports__, __webpack_require__) {
+ "use strict";
+ __webpack_require__.d(__webpack_exports__, "a", function() {
+ return REACT_SUSPENSE_LIST_TYPE;
+ });
+ function _typeof7(obj) {
+ "@babel/helpers - typeof";
+ if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+ _typeof7 = /* @__PURE__ */ __name(function _typeof8(obj2) {
+ return typeof obj2;
+ }, "_typeof");
+ } else {
+ _typeof7 = /* @__PURE__ */ __name(function _typeof8(obj2) {
+ return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+ }, "_typeof");
+ }
+ return _typeof7(obj);
+ }
+ __name(_typeof7, "_typeof");
+ var REACT_ELEMENT_TYPE = 60103;
+ var REACT_PORTAL_TYPE = 60106;
+ var REACT_FRAGMENT_TYPE = 60107;
+ var REACT_STRICT_MODE_TYPE = 60108;
+ var REACT_PROFILER_TYPE = 60114;
+ var REACT_PROVIDER_TYPE = 60109;
+ var REACT_CONTEXT_TYPE = 60110;
+ var REACT_FORWARD_REF_TYPE = 60112;
+ var REACT_SUSPENSE_TYPE = 60113;
+ var REACT_SUSPENSE_LIST_TYPE = 60120;
+ var REACT_MEMO_TYPE = 60115;
+ var REACT_LAZY_TYPE = 60116;
+ var REACT_SCOPE_TYPE = 60119;
+ var REACT_DEBUG_TRACING_MODE_TYPE = 60129;
+ var REACT_OFFSCREEN_TYPE = 60130;
+ var REACT_LEGACY_HIDDEN_TYPE = 60131;
+ var REACT_CACHE_TYPE = 60132;
+ if (typeof Symbol === "function" && Symbol.for) {
+ var symbolFor = Symbol.for;
+ REACT_ELEMENT_TYPE = symbolFor("react.element");
+ REACT_PORTAL_TYPE = symbolFor("react.portal");
+ REACT_FRAGMENT_TYPE = symbolFor("react.fragment");
+ REACT_STRICT_MODE_TYPE = symbolFor("react.strict_mode");
+ REACT_PROFILER_TYPE = symbolFor("react.profiler");
+ REACT_PROVIDER_TYPE = symbolFor("react.provider");
+ REACT_CONTEXT_TYPE = symbolFor("react.context");
+ REACT_FORWARD_REF_TYPE = symbolFor("react.forward_ref");
+ REACT_SUSPENSE_TYPE = symbolFor("react.suspense");
+ REACT_SUSPENSE_LIST_TYPE = symbolFor("react.suspense_list");
+ REACT_MEMO_TYPE = symbolFor("react.memo");
+ REACT_LAZY_TYPE = symbolFor("react.lazy");
+ REACT_SCOPE_TYPE = symbolFor("react.scope");
+ REACT_DEBUG_TRACING_MODE_TYPE = symbolFor("react.debug_trace_mode");
+ REACT_OFFSCREEN_TYPE = symbolFor("react.offscreen");
+ REACT_LEGACY_HIDDEN_TYPE = symbolFor("react.legacy_hidden");
+ REACT_CACHE_TYPE = symbolFor("react.cache");
+ }
+ var MAYBE_ITERATOR_SYMBOL = typeof Symbol === "function" && Symbol.iterator;
+ var FAUX_ITERATOR_SYMBOL = "@@iterator";
+ function getIteratorFn(maybeIterable) {
+ if (maybeIterable === null || _typeof7(maybeIterable) !== "object") {
+ return null;
+ }
+ var maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];
+ if (typeof maybeIterator === "function") {
+ return maybeIterator;
+ }
+ return null;
+ }
+ __name(getIteratorFn, "getIteratorFn");
+ },
+ /* 21 */
+ /***/
+ function(module3, exports3, __webpack_require__) {
+ "use strict";
+ if (true) {
+ module3.exports = __webpack_require__(28);
+ } else {
+ }
+ },
+ /* 22 */
+ /***/
+ function(module3, __webpack_exports__, __webpack_require__) {
+ "use strict";
+ __webpack_require__.d(__webpack_exports__, "a", function() {
+ return (
+ /* binding */
+ getStackByFiberInDevAndProd
+ );
+ });
+ var ReactSymbols = __webpack_require__(3);
+ function ownKeys11(object, enumerableOnly) {
+ var keys = Object.keys(object);
+ if (Object.getOwnPropertySymbols) {
+ var symbols = Object.getOwnPropertySymbols(object);
+ if (enumerableOnly)
+ symbols = symbols.filter(function(sym) {
+ return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+ });
+ keys.push.apply(keys, symbols);
+ }
+ return keys;
+ }
+ __name(ownKeys11, "ownKeys");
+ function _objectSpread11(target) {
+ for (var i = 1; i < arguments.length; i++) {
+ var source = arguments[i] != null ? arguments[i] : {};
+ if (i % 2) {
+ ownKeys11(Object(source), true).forEach(function(key) {
+ _defineProperty11(target, key, source[key]);
+ });
+ } else if (Object.getOwnPropertyDescriptors) {
+ Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+ } else {
+ ownKeys11(Object(source)).forEach(function(key) {
+ Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+ });
+ }
+ }
+ return target;
+ }
+ __name(_objectSpread11, "_objectSpread");
+ function _defineProperty11(obj, key, value) {
+ if (key in obj) {
+ Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
+ } else {
+ obj[key] = value;
+ }
+ return obj;
+ }
+ __name(_defineProperty11, "_defineProperty");
+ var disabledDepth = 0;
+ var prevLog;
+ var prevInfo;
+ var prevWarn;
+ var prevError;
+ var prevGroup;
+ var prevGroupCollapsed;
+ var prevGroupEnd;
+ function disabledLog() {
+ }
+ __name(disabledLog, "disabledLog");
+ disabledLog.__reactDisabledLog = true;
+ function disableLogs() {
+ if (disabledDepth === 0) {
+ prevLog = console.log;
+ prevInfo = console.info;
+ prevWarn = console.warn;
+ prevError = console.error;
+ prevGroup = console.group;
+ prevGroupCollapsed = console.groupCollapsed;
+ prevGroupEnd = console.groupEnd;
+ var props = {
+ configurable: true,
+ enumerable: true,
+ value: disabledLog,
+ writable: true
+ };
+ Object.defineProperties(console, {
+ info: props,
+ log: props,
+ warn: props,
+ error: props,
+ group: props,
+ groupCollapsed: props,
+ groupEnd: props
+ });
+ }
+ disabledDepth++;
+ }
+ __name(disableLogs, "disableLogs");
+ function reenableLogs() {
+ disabledDepth--;
+ if (disabledDepth === 0) {
+ var props = {
+ configurable: true,
+ enumerable: true,
+ writable: true
+ };
+ Object.defineProperties(console, {
+ log: _objectSpread11(_objectSpread11({}, props), {}, {
+ value: prevLog
+ }),
+ info: _objectSpread11(_objectSpread11({}, props), {}, {
+ value: prevInfo
+ }),
+ warn: _objectSpread11(_objectSpread11({}, props), {}, {
+ value: prevWarn
+ }),
+ error: _objectSpread11(_objectSpread11({}, props), {}, {
+ value: prevError
+ }),
+ group: _objectSpread11(_objectSpread11({}, props), {}, {
+ value: prevGroup
+ }),
+ groupCollapsed: _objectSpread11(_objectSpread11({}, props), {}, {
+ value: prevGroupCollapsed
+ }),
+ groupEnd: _objectSpread11(_objectSpread11({}, props), {}, {
+ value: prevGroupEnd
+ })
+ });
+ }
+ if (disabledDepth < 0) {
+ console.error("disabledDepth fell below zero. This is a bug in React. Please file an issue.");
+ }
+ }
+ __name(reenableLogs, "reenableLogs");
+ function _typeof7(obj) {
+ "@babel/helpers - typeof";
+ if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+ _typeof7 = /* @__PURE__ */ __name(function _typeof8(obj2) {
+ return typeof obj2;
+ }, "_typeof");
+ } else {
+ _typeof7 = /* @__PURE__ */ __name(function _typeof8(obj2) {
+ return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+ }, "_typeof");
+ }
+ return _typeof7(obj);
+ }
+ __name(_typeof7, "_typeof");
+ var prefix;
+ function describeBuiltInComponentFrame(name, source, ownerFn) {
+ if (prefix === void 0) {
+ try {
+ throw Error();
+ } catch (x) {
+ var match = x.stack.trim().match(/\n( *(at )?)/);
+ prefix = match && match[1] || "";
+ }
+ }
+ return "\n" + prefix + name;
+ }
+ __name(describeBuiltInComponentFrame, "describeBuiltInComponentFrame");
+ var reentry = false;
+ var componentFrameCache;
+ if (false) {
+ var PossiblyWeakMap;
+ }
+ function describeNativeComponentFrame(fn2, construct, currentDispatcherRef) {
+ if (!fn2 || reentry) {
+ return "";
+ }
+ if (false) {
+ var frame;
+ }
+ var control;
+ var previousPrepareStackTrace = Error.prepareStackTrace;
+ Error.prepareStackTrace = void 0;
+ reentry = true;
+ var previousDispatcher = currentDispatcherRef.current;
+ currentDispatcherRef.current = null;
+ disableLogs();
+ try {
+ if (construct) {
+ var Fake = /* @__PURE__ */ __name(function Fake2() {
+ throw Error();
+ }, "Fake");
+ Object.defineProperty(Fake.prototype, "props", {
+ set: /* @__PURE__ */ __name(function set() {
+ throw Error();
+ }, "set")
+ });
+ if ((typeof Reflect === "undefined" ? "undefined" : _typeof7(Reflect)) === "object" && Reflect.construct) {
+ try {
+ Reflect.construct(Fake, []);
+ } catch (x) {
+ control = x;
+ }
+ Reflect.construct(fn2, [], Fake);
+ } else {
+ try {
+ Fake.call();
+ } catch (x) {
+ control = x;
+ }
+ fn2.call(Fake.prototype);
+ }
+ } else {
+ try {
+ throw Error();
+ } catch (x) {
+ control = x;
+ }
+ fn2();
+ }
+ } catch (sample) {
+ if (sample && control && typeof sample.stack === "string") {
+ var sampleLines = sample.stack.split("\n");
+ var controlLines = control.stack.split("\n");
+ var s = sampleLines.length - 1;
+ var c = controlLines.length - 1;
+ while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) {
+ c--;
+ }
+ for (; s >= 1 && c >= 0; s--, c--) {
+ if (sampleLines[s] !== controlLines[c]) {
+ if (s !== 1 || c !== 1) {
+ do {
+ s--;
+ c--;
+ if (c < 0 || sampleLines[s] !== controlLines[c]) {
+ var _frame = "\n" + sampleLines[s].replace(" at new ", " at ");
+ if (false) {
+ }
+ return _frame;
+ }
+ } while (s >= 1 && c >= 0);
+ }
+ break;
+ }
+ }
+ }
+ } finally {
+ reentry = false;
+ Error.prepareStackTrace = previousPrepareStackTrace;
+ currentDispatcherRef.current = previousDispatcher;
+ reenableLogs();
+ }
+ var name = fn2 ? fn2.displayName || fn2.name : "";
+ var syntheticFrame = name ? describeBuiltInComponentFrame(name) : "";
+ if (false) {
+ }
+ return syntheticFrame;
+ }
+ __name(describeNativeComponentFrame, "describeNativeComponentFrame");
+ function describeClassComponentFrame(ctor, source, ownerFn, currentDispatcherRef) {
+ return describeNativeComponentFrame(ctor, true, currentDispatcherRef);
+ }
+ __name(describeClassComponentFrame, "describeClassComponentFrame");
+ function describeFunctionComponentFrame(fn2, source, ownerFn, currentDispatcherRef) {
+ return describeNativeComponentFrame(fn2, false, currentDispatcherRef);
+ }
+ __name(describeFunctionComponentFrame, "describeFunctionComponentFrame");
+ function shouldConstruct(Component2) {
+ var prototype = Component2.prototype;
+ return !!(prototype && prototype.isReactComponent);
+ }
+ __name(shouldConstruct, "shouldConstruct");
+ function describeUnknownElementTypeFrameInDEV(type, source, ownerFn, currentDispatcherRef) {
+ if (true) {
+ return "";
+ }
+ if (type == null) {
+ return "";
+ }
+ if (typeof type === "function") {
+ return describeNativeComponentFrame(type, shouldConstruct(type), currentDispatcherRef);
+ }
+ if (typeof type === "string") {
+ return describeBuiltInComponentFrame(type, source, ownerFn);
+ }
+ switch (type) {
+ case ReactSymbols[
+ "v"
+ /* SUSPENSE_NUMBER */
+ ]:
+ case ReactSymbols[
+ "w"
+ /* SUSPENSE_SYMBOL_STRING */
+ ]:
+ return describeBuiltInComponentFrame("Suspense", source, ownerFn);
+ case ReactSymbols[
+ "t"
+ /* SUSPENSE_LIST_NUMBER */
+ ]:
+ case ReactSymbols[
+ "u"
+ /* SUSPENSE_LIST_SYMBOL_STRING */
+ ]:
+ return describeBuiltInComponentFrame("SuspenseList", source, ownerFn);
+ }
+ if (_typeof7(type) === "object") {
+ switch (type.$$typeof) {
+ case ReactSymbols[
+ "f"
+ /* FORWARD_REF_NUMBER */
+ ]:
+ case ReactSymbols[
+ "g"
+ /* FORWARD_REF_SYMBOL_STRING */
+ ]:
+ return describeFunctionComponentFrame(type.render, source, ownerFn, currentDispatcherRef);
+ case ReactSymbols[
+ "j"
+ /* MEMO_NUMBER */
+ ]:
+ case ReactSymbols[
+ "k"
+ /* MEMO_SYMBOL_STRING */
+ ]:
+ return describeUnknownElementTypeFrameInDEV(type.type, source, ownerFn, currentDispatcherRef);
+ case ReactSymbols[
+ "h"
+ /* LAZY_NUMBER */
+ ]:
+ case ReactSymbols[
+ "i"
+ /* LAZY_SYMBOL_STRING */
+ ]: {
+ var lazyComponent = type;
+ var payload = lazyComponent._payload;
+ var init = lazyComponent._init;
+ try {
+ return describeUnknownElementTypeFrameInDEV(init(payload), source, ownerFn, currentDispatcherRef);
+ } catch (x) {
+ }
+ }
+ }
+ }
+ return "";
+ }
+ __name(describeUnknownElementTypeFrameInDEV, "describeUnknownElementTypeFrameInDEV");
+ function describeFiber(workTagMap, workInProgress, currentDispatcherRef) {
+ var HostComponent = workTagMap.HostComponent, LazyComponent = workTagMap.LazyComponent, SuspenseComponent = workTagMap.SuspenseComponent, SuspenseListComponent = workTagMap.SuspenseListComponent, FunctionComponent = workTagMap.FunctionComponent, IndeterminateComponent = workTagMap.IndeterminateComponent, SimpleMemoComponent = workTagMap.SimpleMemoComponent, ForwardRef = workTagMap.ForwardRef, ClassComponent = workTagMap.ClassComponent;
+ var owner = false ? void 0 : null;
+ var source = false ? void 0 : null;
+ switch (workInProgress.tag) {
+ case HostComponent:
+ return describeBuiltInComponentFrame(workInProgress.type, source, owner);
+ case LazyComponent:
+ return describeBuiltInComponentFrame("Lazy", source, owner);
+ case SuspenseComponent:
+ return describeBuiltInComponentFrame("Suspense", source, owner);
+ case SuspenseListComponent:
+ return describeBuiltInComponentFrame("SuspenseList", source, owner);
+ case FunctionComponent:
+ case IndeterminateComponent:
+ case SimpleMemoComponent:
+ return describeFunctionComponentFrame(workInProgress.type, source, owner, currentDispatcherRef);
+ case ForwardRef:
+ return describeFunctionComponentFrame(workInProgress.type.render, source, owner, currentDispatcherRef);
+ case ClassComponent:
+ return describeClassComponentFrame(workInProgress.type, source, owner, currentDispatcherRef);
+ default:
+ return "";
+ }
+ }
+ __name(describeFiber, "describeFiber");
+ function getStackByFiberInDevAndProd(workTagMap, workInProgress, currentDispatcherRef) {
+ try {
+ var info = "";
+ var node = workInProgress;
+ do {
+ info += describeFiber(workTagMap, node, currentDispatcherRef);
+ node = node.return;
+ } while (node);
+ return info;
+ } catch (x) {
+ return "\nError generating stack: " + x.message + "\n" + x.stack;
+ }
+ }
+ __name(getStackByFiberInDevAndProd, "getStackByFiberInDevAndProd");
+ },
+ /* 23 */
+ /***/
+ function(module3, exports3, __webpack_require__) {
+ (function(global2) {
+ var scope = typeof global2 !== "undefined" && global2 || typeof self !== "undefined" && self || window;
+ var apply = Function.prototype.apply;
+ exports3.setTimeout = function() {
+ return new Timeout(apply.call(setTimeout, scope, arguments), clearTimeout);
+ };
+ exports3.setInterval = function() {
+ return new Timeout(apply.call(setInterval, scope, arguments), clearInterval);
+ };
+ exports3.clearTimeout = exports3.clearInterval = function(timeout) {
+ if (timeout) {
+ timeout.close();
+ }
+ };
+ function Timeout(id, clearFn) {
+ this._id = id;
+ this._clearFn = clearFn;
+ }
+ __name(Timeout, "Timeout");
+ Timeout.prototype.unref = Timeout.prototype.ref = function() {
+ };
+ Timeout.prototype.close = function() {
+ this._clearFn.call(scope, this._id);
+ };
+ exports3.enroll = function(item, msecs) {
+ clearTimeout(item._idleTimeoutId);
+ item._idleTimeout = msecs;
+ };
+ exports3.unenroll = function(item) {
+ clearTimeout(item._idleTimeoutId);
+ item._idleTimeout = -1;
+ };
+ exports3._unrefActive = exports3.active = function(item) {
+ clearTimeout(item._idleTimeoutId);
+ var msecs = item._idleTimeout;
+ if (msecs >= 0) {
+ item._idleTimeoutId = setTimeout(/* @__PURE__ */ __name(function onTimeout() {
+ if (item._onTimeout)
+ item._onTimeout();
+ }, "onTimeout"), msecs);
+ }
+ };
+ __webpack_require__(24);
+ exports3.setImmediate = typeof self !== "undefined" && self.setImmediate || typeof global2 !== "undefined" && global2.setImmediate || this && this.setImmediate;
+ exports3.clearImmediate = typeof self !== "undefined" && self.clearImmediate || typeof global2 !== "undefined" && global2.clearImmediate || this && this.clearImmediate;
+ }).call(this, __webpack_require__(14));
+ },
+ /* 24 */
+ /***/
+ function(module3, exports3, __webpack_require__) {
+ (function(global2, process8) {
+ (function(global3, undefined2) {
+ "use strict";
+ if (global3.setImmediate) {
+ return;
+ }
+ var nextHandle = 1;
+ var tasksByHandle = {};
+ var currentlyRunningATask = false;
+ var doc = global3.document;
+ var registerImmediate;
+ function setImmediate2(callback) {
+ if (typeof callback !== "function") {
+ callback = new Function("" + callback);
+ }
+ var args = new Array(arguments.length - 1);
+ for (var i = 0; i < args.length; i++) {
+ args[i] = arguments[i + 1];
+ }
+ var task = {
+ callback,
+ args
+ };
+ tasksByHandle[nextHandle] = task;
+ registerImmediate(nextHandle);
+ return nextHandle++;
+ }
+ __name(setImmediate2, "setImmediate");
+ function clearImmediate2(handle) {
+ delete tasksByHandle[handle];
+ }
+ __name(clearImmediate2, "clearImmediate");
+ function run(task) {
+ var callback = task.callback;
+ var args = task.args;
+ switch (args.length) {
+ case 0:
+ callback();
+ break;
+ case 1:
+ callback(args[0]);
+ break;
+ case 2:
+ callback(args[0], args[1]);
+ break;
+ case 3:
+ callback(args[0], args[1], args[2]);
+ break;
+ default:
+ callback.apply(undefined2, args);
+ break;
+ }
+ }
+ __name(run, "run");
+ function runIfPresent(handle) {
+ if (currentlyRunningATask) {
+ setTimeout(runIfPresent, 0, handle);
+ } else {
+ var task = tasksByHandle[handle];
+ if (task) {
+ currentlyRunningATask = true;
+ try {
+ run(task);
+ } finally {
+ clearImmediate2(handle);
+ currentlyRunningATask = false;
+ }
+ }
+ }
+ }
+ __name(runIfPresent, "runIfPresent");
+ function installNextTickImplementation() {
+ registerImmediate = /* @__PURE__ */ __name(function registerImmediate2(handle) {
+ process8.nextTick(function() {
+ runIfPresent(handle);
+ });
+ }, "registerImmediate");
+ }
+ __name(installNextTickImplementation, "installNextTickImplementation");
+ function canUsePostMessage() {
+ if (global3.postMessage && !global3.importScripts) {
+ var postMessageIsAsynchronous = true;
+ var oldOnMessage = global3.onmessage;
+ global3.onmessage = function() {
+ postMessageIsAsynchronous = false;
+ };
+ global3.postMessage("", "*");
+ global3.onmessage = oldOnMessage;
+ return postMessageIsAsynchronous;
+ }
+ }
+ __name(canUsePostMessage, "canUsePostMessage");
+ function installPostMessageImplementation() {
+ var messagePrefix = "setImmediate$" + Math.random() + "$";
+ var onGlobalMessage = /* @__PURE__ */ __name(function onGlobalMessage2(event) {
+ if (event.source === global3 && typeof event.data === "string" && event.data.indexOf(messagePrefix) === 0) {
+ runIfPresent(+event.data.slice(messagePrefix.length));
+ }
+ }, "onGlobalMessage");
+ if (global3.addEventListener) {
+ global3.addEventListener("message", onGlobalMessage, false);
+ } else {
+ global3.attachEvent("onmessage", onGlobalMessage);
+ }
+ registerImmediate = /* @__PURE__ */ __name(function registerImmediate2(handle) {
+ global3.postMessage(messagePrefix + handle, "*");
+ }, "registerImmediate");
+ }
+ __name(installPostMessageImplementation, "installPostMessageImplementation");
+ function installMessageChannelImplementation() {
+ var channel = new MessageChannel();
+ channel.port1.onmessage = function(event) {
+ var handle = event.data;
+ runIfPresent(handle);
+ };
+ registerImmediate = /* @__PURE__ */ __name(function registerImmediate2(handle) {
+ channel.port2.postMessage(handle);
+ }, "registerImmediate");
+ }
+ __name(installMessageChannelImplementation, "installMessageChannelImplementation");
+ function installReadyStateChangeImplementation() {
+ var html = doc.documentElement;
+ registerImmediate = /* @__PURE__ */ __name(function registerImmediate2(handle) {
+ var script = doc.createElement("script");
+ script.onreadystatechange = function() {
+ runIfPresent(handle);
+ script.onreadystatechange = null;
+ html.removeChild(script);
+ script = null;
+ };
+ html.appendChild(script);
+ }, "registerImmediate");
+ }
+ __name(installReadyStateChangeImplementation, "installReadyStateChangeImplementation");
+ function installSetTimeoutImplementation() {
+ registerImmediate = /* @__PURE__ */ __name(function registerImmediate2(handle) {
+ setTimeout(runIfPresent, 0, handle);
+ }, "registerImmediate");
+ }
+ __name(installSetTimeoutImplementation, "installSetTimeoutImplementation");
+ var attachTo = Object.getPrototypeOf && Object.getPrototypeOf(global3);
+ attachTo = attachTo && attachTo.setTimeout ? attachTo : global3;
+ if ({}.toString.call(global3.process) === "[object process]") {
+ installNextTickImplementation();
+ } else if (canUsePostMessage()) {
+ installPostMessageImplementation();
+ } else if (global3.MessageChannel) {
+ installMessageChannelImplementation();
+ } else if (doc && "onreadystatechange" in doc.createElement("script")) {
+ installReadyStateChangeImplementation();
+ } else {
+ installSetTimeoutImplementation();
+ }
+ attachTo.setImmediate = setImmediate2;
+ attachTo.clearImmediate = clearImmediate2;
+ })(typeof self === "undefined" ? typeof global2 === "undefined" ? this : global2 : self);
+ }).call(this, __webpack_require__(14), __webpack_require__(17));
+ },
+ /* 25 */
+ /***/
+ function(module3, exports3, __webpack_require__) {
+ "use strict";
+ module3.exports = Yallist;
+ Yallist.Node = Node3;
+ Yallist.create = Yallist;
+ function Yallist(list) {
+ var self2 = this;
+ if (!(self2 instanceof Yallist)) {
+ self2 = new Yallist();
+ }
+ self2.tail = null;
+ self2.head = null;
+ self2.length = 0;
+ if (list && typeof list.forEach === "function") {
+ list.forEach(function(item) {
+ self2.push(item);
+ });
+ } else if (arguments.length > 0) {
+ for (var i = 0, l = arguments.length; i < l; i++) {
+ self2.push(arguments[i]);
+ }
+ }
+ return self2;
+ }
+ __name(Yallist, "Yallist");
+ Yallist.prototype.removeNode = function(node) {
+ if (node.list !== this) {
+ throw new Error("removing node which does not belong to this list");
+ }
+ var next = node.next;
+ var prev = node.prev;
+ if (next) {
+ next.prev = prev;
+ }
+ if (prev) {
+ prev.next = next;
+ }
+ if (node === this.head) {
+ this.head = next;
+ }
+ if (node === this.tail) {
+ this.tail = prev;
+ }
+ node.list.length--;
+ node.next = null;
+ node.prev = null;
+ node.list = null;
+ return next;
+ };
+ Yallist.prototype.unshiftNode = function(node) {
+ if (node === this.head) {
+ return;
+ }
+ if (node.list) {
+ node.list.removeNode(node);
+ }
+ var head = this.head;
+ node.list = this;
+ node.next = head;
+ if (head) {
+ head.prev = node;
+ }
+ this.head = node;
+ if (!this.tail) {
+ this.tail = node;
+ }
+ this.length++;
+ };
+ Yallist.prototype.pushNode = function(node) {
+ if (node === this.tail) {
+ return;
+ }
+ if (node.list) {
+ node.list.removeNode(node);
+ }
+ var tail = this.tail;
+ node.list = this;
+ node.prev = tail;
+ if (tail) {
+ tail.next = node;
+ }
+ this.tail = node;
+ if (!this.head) {
+ this.head = node;
+ }
+ this.length++;
+ };
+ Yallist.prototype.push = function() {
+ for (var i = 0, l = arguments.length; i < l; i++) {
+ push(this, arguments[i]);
+ }
+ return this.length;
+ };
+ Yallist.prototype.unshift = function() {
+ for (var i = 0, l = arguments.length; i < l; i++) {
+ unshift(this, arguments[i]);
+ }
+ return this.length;
+ };
+ Yallist.prototype.pop = function() {
+ if (!this.tail) {
+ return void 0;
+ }
+ var res = this.tail.value;
+ this.tail = this.tail.prev;
+ if (this.tail) {
+ this.tail.next = null;
+ } else {
+ this.head = null;
+ }
+ this.length--;
+ return res;
+ };
+ Yallist.prototype.shift = function() {
+ if (!this.head) {
+ return void 0;
+ }
+ var res = this.head.value;
+ this.head = this.head.next;
+ if (this.head) {
+ this.head.prev = null;
+ } else {
+ this.tail = null;
+ }
+ this.length--;
+ return res;
+ };
+ Yallist.prototype.forEach = function(fn2, thisp) {
+ thisp = thisp || this;
+ for (var walker = this.head, i = 0; walker !== null; i++) {
+ fn2.call(thisp, walker.value, i, this);
+ walker = walker.next;
+ }
+ };
+ Yallist.prototype.forEachReverse = function(fn2, thisp) {
+ thisp = thisp || this;
+ for (var walker = this.tail, i = this.length - 1; walker !== null; i--) {
+ fn2.call(thisp, walker.value, i, this);
+ walker = walker.prev;
+ }
+ };
+ Yallist.prototype.get = function(n) {
+ for (var i = 0, walker = this.head; walker !== null && i < n; i++) {
+ walker = walker.next;
+ }
+ if (i === n && walker !== null) {
+ return walker.value;
+ }
+ };
+ Yallist.prototype.getReverse = function(n) {
+ for (var i = 0, walker = this.tail; walker !== null && i < n; i++) {
+ walker = walker.prev;
+ }
+ if (i === n && walker !== null) {
+ return walker.value;
+ }
+ };
+ Yallist.prototype.map = function(fn2, thisp) {
+ thisp = thisp || this;
+ var res = new Yallist();
+ for (var walker = this.head; walker !== null; ) {
+ res.push(fn2.call(thisp, walker.value, this));
+ walker = walker.next;
+ }
+ return res;
+ };
+ Yallist.prototype.mapReverse = function(fn2, thisp) {
+ thisp = thisp || this;
+ var res = new Yallist();
+ for (var walker = this.tail; walker !== null; ) {
+ res.push(fn2.call(thisp, walker.value, this));
+ walker = walker.prev;
+ }
+ return res;
+ };
+ Yallist.prototype.reduce = function(fn2, initial) {
+ var acc;
+ var walker = this.head;
+ if (arguments.length > 1) {
+ acc = initial;
+ } else if (this.head) {
+ walker = this.head.next;
+ acc = this.head.value;
+ } else {
+ throw new TypeError("Reduce of empty list with no initial value");
+ }
+ for (var i = 0; walker !== null; i++) {
+ acc = fn2(acc, walker.value, i);
+ walker = walker.next;
+ }
+ return acc;
+ };
+ Yallist.prototype.reduceReverse = function(fn2, initial) {
+ var acc;
+ var walker = this.tail;
+ if (arguments.length > 1) {
+ acc = initial;
+ } else if (this.tail) {
+ walker = this.tail.prev;
+ acc = this.tail.value;
+ } else {
+ throw new TypeError("Reduce of empty list with no initial value");
+ }
+ for (var i = this.length - 1; walker !== null; i--) {
+ acc = fn2(acc, walker.value, i);
+ walker = walker.prev;
+ }
+ return acc;
+ };
+ Yallist.prototype.toArray = function() {
+ var arr = new Array(this.length);
+ for (var i = 0, walker = this.head; walker !== null; i++) {
+ arr[i] = walker.value;
+ walker = walker.next;
+ }
+ return arr;
+ };
+ Yallist.prototype.toArrayReverse = function() {
+ var arr = new Array(this.length);
+ for (var i = 0, walker = this.tail; walker !== null; i++) {
+ arr[i] = walker.value;
+ walker = walker.prev;
+ }
+ return arr;
+ };
+ Yallist.prototype.slice = function(from, to) {
+ to = to || this.length;
+ if (to < 0) {
+ to += this.length;
+ }
+ from = from || 0;
+ if (from < 0) {
+ from += this.length;
+ }
+ var ret = new Yallist();
+ if (to < from || to < 0) {
+ return ret;
+ }
+ if (from < 0) {
+ from = 0;
+ }
+ if (to > this.length) {
+ to = this.length;
+ }
+ for (var i = 0, walker = this.head; walker !== null && i < from; i++) {
+ walker = walker.next;
+ }
+ for (; walker !== null && i < to; i++, walker = walker.next) {
+ ret.push(walker.value);
+ }
+ return ret;
+ };
+ Yallist.prototype.sliceReverse = function(from, to) {
+ to = to || this.length;
+ if (to < 0) {
+ to += this.length;
+ }
+ from = from || 0;
+ if (from < 0) {
+ from += this.length;
+ }
+ var ret = new Yallist();
+ if (to < from || to < 0) {
+ return ret;
+ }
+ if (from < 0) {
+ from = 0;
+ }
+ if (to > this.length) {
+ to = this.length;
+ }
+ for (var i = this.length, walker = this.tail; walker !== null && i > to; i--) {
+ walker = walker.prev;
+ }
+ for (; walker !== null && i > from; i--, walker = walker.prev) {
+ ret.push(walker.value);
+ }
+ return ret;
+ };
+ Yallist.prototype.splice = function(start, deleteCount) {
+ if (start > this.length) {
+ start = this.length - 1;
+ }
+ if (start < 0) {
+ start = this.length + start;
+ }
+ for (var i = 0, walker = this.head; walker !== null && i < start; i++) {
+ walker = walker.next;
+ }
+ var ret = [];
+ for (var i = 0; walker && i < deleteCount; i++) {
+ ret.push(walker.value);
+ walker = this.removeNode(walker);
+ }
+ if (walker === null) {
+ walker = this.tail;
+ }
+ if (walker !== this.head && walker !== this.tail) {
+ walker = walker.prev;
+ }
+ for (var i = 2; i < arguments.length; i++) {
+ walker = insert(this, walker, arguments[i]);
+ }
+ return ret;
+ };
+ Yallist.prototype.reverse = function() {
+ var head = this.head;
+ var tail = this.tail;
+ for (var walker = head; walker !== null; walker = walker.prev) {
+ var p = walker.prev;
+ walker.prev = walker.next;
+ walker.next = p;
+ }
+ this.head = tail;
+ this.tail = head;
+ return this;
+ };
+ function insert(self2, node, value) {
+ var inserted = node === self2.head ? new Node3(value, null, node, self2) : new Node3(value, node, node.next, self2);
+ if (inserted.next === null) {
+ self2.tail = inserted;
+ }
+ if (inserted.prev === null) {
+ self2.head = inserted;
+ }
+ self2.length++;
+ return inserted;
+ }
+ __name(insert, "insert");
+ function push(self2, item) {
+ self2.tail = new Node3(item, self2.tail, null, self2);
+ if (!self2.head) {
+ self2.head = self2.tail;
+ }
+ self2.length++;
+ }
+ __name(push, "push");
+ function unshift(self2, item) {
+ self2.head = new Node3(item, null, self2.head, self2);
+ if (!self2.tail) {
+ self2.tail = self2.head;
+ }
+ self2.length++;
+ }
+ __name(unshift, "unshift");
+ function Node3(value, prev, next, list) {
+ if (!(this instanceof Node3)) {
+ return new Node3(value, prev, next, list);
+ }
+ this.list = list;
+ this.value = value;
+ if (prev) {
+ prev.next = this;
+ this.prev = prev;
+ } else {
+ this.prev = null;
+ }
+ if (next) {
+ next.prev = this;
+ this.next = next;
+ } else {
+ this.next = null;
+ }
+ }
+ __name(Node3, "Node");
+ try {
+ __webpack_require__(26)(Yallist);
+ } catch (er) {
+ }
+ },
+ /* 26 */
+ /***/
+ function(module3, exports3, __webpack_require__) {
+ "use strict";
+ module3.exports = function(Yallist) {
+ Yallist.prototype[Symbol.iterator] = /* @__PURE__ */ regeneratorRuntime.mark(/* @__PURE__ */ __name(function _callee() {
+ var walker;
+ return regeneratorRuntime.wrap(/* @__PURE__ */ __name(function _callee$(_context) {
+ while (1) {
+ switch (_context.prev = _context.next) {
+ case 0:
+ walker = this.head;
+ case 1:
+ if (!walker) {
+ _context.next = 7;
+ break;
+ }
+ _context.next = 4;
+ return walker.value;
+ case 4:
+ walker = walker.next;
+ _context.next = 1;
+ break;
+ case 7:
+ case "end":
+ return _context.stop();
+ }
+ }
+ }, "_callee$"), _callee, this);
+ }, "_callee"));
+ };
+ },
+ /* 27 */
+ /***/
+ function(module3, exports3, __webpack_require__) {
+ "use strict";
+ function _typeof7(obj) {
+ "@babel/helpers - typeof";
+ if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+ _typeof7 = /* @__PURE__ */ __name(function _typeof8(obj2) {
+ return typeof obj2;
+ }, "_typeof");
+ } else {
+ _typeof7 = /* @__PURE__ */ __name(function _typeof8(obj2) {
+ return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+ }, "_typeof");
+ }
+ return _typeof7(obj);
+ }
+ __name(_typeof7, "_typeof");
+ var b = 60103, c = 60106, d = 60107, e2 = 60108, f = 60114, g = 60109, h = 60110, k = 60112, l = 60113, m = 60120, n = 60115, p = 60116, q = 60129, r = 60130, u = 60131, v = 60132;
+ if ("function" === typeof Symbol && Symbol.for) {
+ var w = Symbol.for;
+ b = w("react.element");
+ c = w("react.portal");
+ d = w("react.fragment");
+ e2 = w("react.strict_mode");
+ f = w("react.profiler");
+ g = w("react.provider");
+ h = w("react.context");
+ k = w("react.forward_ref");
+ l = w("react.suspense");
+ m = w("react.suspense_list");
+ n = w("react.memo");
+ p = w("react.lazy");
+ q = w("react.debug_trace_mode");
+ r = w("react.offscreen");
+ u = w("react.legacy_hidden");
+ v = w("react.cache");
+ }
+ var x = 0;
+ "function" === typeof Symbol && (x = Symbol.for("react.module.reference"));
+ function y(a) {
+ if ("object" === _typeof7(a) && null !== a) {
+ var t2 = a.$$typeof;
+ switch (t2) {
+ case b:
+ switch (a = a.type, a) {
+ case d:
+ case f:
+ case e2:
+ case l:
+ case m:
+ return a;
+ default:
+ switch (a = a && a.$$typeof, a) {
+ case h:
+ case k:
+ case p:
+ case n:
+ case g:
+ return a;
+ default:
+ return t2;
+ }
+ }
+ case c:
+ return t2;
+ }
+ }
+ }
+ __name(y, "y");
+ var z = g, A = b, B = k, C = d, D = p, E = n, F = c, G = f, H = e2, I = l, J = m;
+ exports3.ContextConsumer = h;
+ exports3.ContextProvider = z;
+ exports3.Element = A;
+ exports3.ForwardRef = B;
+ exports3.Fragment = C;
+ exports3.Lazy = D;
+ exports3.Memo = E;
+ exports3.Portal = F;
+ exports3.Profiler = G;
+ exports3.StrictMode = H;
+ exports3.Suspense = I;
+ exports3.SuspenseList = J;
+ exports3.isAsyncMode = function() {
+ return false;
+ };
+ exports3.isConcurrentMode = function() {
+ return false;
+ };
+ exports3.isContextConsumer = function(a) {
+ return y(a) === h;
+ };
+ exports3.isContextProvider = function(a) {
+ return y(a) === g;
+ };
+ exports3.isElement = function(a) {
+ return "object" === _typeof7(a) && null !== a && a.$$typeof === b;
+ };
+ exports3.isForwardRef = function(a) {
+ return y(a) === k;
+ };
+ exports3.isFragment = function(a) {
+ return y(a) === d;
+ };
+ exports3.isLazy = function(a) {
+ return y(a) === p;
+ };
+ exports3.isMemo = function(a) {
+ return y(a) === n;
+ };
+ exports3.isPortal = function(a) {
+ return y(a) === c;
+ };
+ exports3.isProfiler = function(a) {
+ return y(a) === f;
+ };
+ exports3.isStrictMode = function(a) {
+ return y(a) === e2;
+ };
+ exports3.isSuspense = function(a) {
+ return y(a) === l;
+ };
+ exports3.isSuspenseList = function(a) {
+ return y(a) === m;
+ };
+ exports3.isValidElementType = function(a) {
+ return "string" === typeof a || "function" === typeof a || a === d || a === f || a === q || a === e2 || a === l || a === m || a === u || a === r || a === v || "object" === _typeof7(a) && null !== a && (a.$$typeof === p || a.$$typeof === n || a.$$typeof === g || a.$$typeof === h || a.$$typeof === k || a.$$typeof === x || void 0 !== a.getModuleId) ? true : false;
+ };
+ exports3.typeOf = y;
+ },
+ /* 28 */
+ /***/
+ function(module3, exports3, __webpack_require__) {
+ "use strict";
+ function _typeof7(obj) {
+ "@babel/helpers - typeof";
+ if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+ _typeof7 = /* @__PURE__ */ __name(function _typeof8(obj2) {
+ return typeof obj2;
+ }, "_typeof");
+ } else {
+ _typeof7 = /* @__PURE__ */ __name(function _typeof8(obj2) {
+ return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+ }, "_typeof");
+ }
+ return _typeof7(obj);
+ }
+ __name(_typeof7, "_typeof");
+ var h = __webpack_require__(8), l = __webpack_require__(29), q = __webpack_require__(31).__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED, w = [], x = null;
+ function y() {
+ if (null === x) {
+ var a = /* @__PURE__ */ new Map();
+ try {
+ z.useContext({
+ _currentValue: null
+ }), z.useState(null), z.useReducer(function(a2) {
+ return a2;
+ }, null), z.useRef(null), "function" === typeof z.useCacheRefresh && z.useCacheRefresh(), z.useLayoutEffect(function() {
+ }), z.useInsertionEffect(function() {
+ }), z.useEffect(function() {
+ }), z.useImperativeHandle(void 0, function() {
+ return null;
+ }), z.useDebugValue(null), z.useCallback(function() {
+ }), z.useMemo(function() {
+ return null;
+ });
+ } finally {
+ var b = w;
+ w = [];
+ }
+ for (var e2 = 0; e2 < b.length; e2++) {
+ var f = b[e2];
+ a.set(f.primitive, l.parse(f.stackError));
+ }
+ x = a;
+ }
+ return x;
+ }
+ __name(y, "y");
+ var A = null;
+ function B() {
+ var a = A;
+ null !== a && (A = a.next);
+ return a;
+ }
+ __name(B, "B");
+ var z = {
+ getCacheForType: /* @__PURE__ */ __name(function getCacheForType() {
+ throw Error("Not implemented.");
+ }, "getCacheForType"),
+ readContext: /* @__PURE__ */ __name(function readContext(a) {
+ return a._currentValue;
+ }, "readContext"),
+ useCacheRefresh: /* @__PURE__ */ __name(function useCacheRefresh() {
+ var a = B();
+ w.push({
+ primitive: "CacheRefresh",
+ stackError: Error(),
+ value: null !== a ? a.memoizedState : function() {
+ }
+ });
+ return function() {
+ };
+ }, "useCacheRefresh"),
+ useCallback: /* @__PURE__ */ __name(function useCallback(a) {
+ var b = B();
+ w.push({
+ primitive: "Callback",
+ stackError: Error(),
+ value: null !== b ? b.memoizedState[0] : a
+ });
+ return a;
+ }, "useCallback"),
+ useContext: /* @__PURE__ */ __name(function useContext(a) {
+ w.push({
+ primitive: "Context",
+ stackError: Error(),
+ value: a._currentValue
+ });
+ return a._currentValue;
+ }, "useContext"),
+ useEffect: /* @__PURE__ */ __name(function useEffect7(a) {
+ B();
+ w.push({
+ primitive: "Effect",
+ stackError: Error(),
+ value: a
+ });
+ }, "useEffect"),
+ useImperativeHandle: /* @__PURE__ */ __name(function useImperativeHandle(a) {
+ B();
+ var b = void 0;
+ null !== a && "object" === _typeof7(a) && (b = a.current);
+ w.push({
+ primitive: "ImperativeHandle",
+ stackError: Error(),
+ value: b
+ });
+ }, "useImperativeHandle"),
+ useDebugValue: /* @__PURE__ */ __name(function useDebugValue(a, b) {
+ w.push({
+ primitive: "DebugValue",
+ stackError: Error(),
+ value: "function" === typeof b ? b(a) : a
+ });
+ }, "useDebugValue"),
+ useLayoutEffect: /* @__PURE__ */ __name(function useLayoutEffect(a) {
+ B();
+ w.push({
+ primitive: "LayoutEffect",
+ stackError: Error(),
+ value: a
+ });
+ }, "useLayoutEffect"),
+ useInsertionEffect: /* @__PURE__ */ __name(function useInsertionEffect(a) {
+ B();
+ w.push({
+ primitive: "InsertionEffect",
+ stackError: Error(),
+ value: a
+ });
+ }, "useInsertionEffect"),
+ useMemo: /* @__PURE__ */ __name(function useMemo(a) {
+ var b = B();
+ a = null !== b ? b.memoizedState[0] : a();
+ w.push({
+ primitive: "Memo",
+ stackError: Error(),
+ value: a
+ });
+ return a;
+ }, "useMemo"),
+ useReducer: /* @__PURE__ */ __name(function useReducer(a, b, e2) {
+ a = B();
+ b = null !== a ? a.memoizedState : void 0 !== e2 ? e2(b) : b;
+ w.push({
+ primitive: "Reducer",
+ stackError: Error(),
+ value: b
+ });
+ return [b, function() {
+ }];
+ }, "useReducer"),
+ useRef: /* @__PURE__ */ __name(function useRef6(a) {
+ var b = B();
+ a = null !== b ? b.memoizedState : {
+ current: a
+ };
+ w.push({
+ primitive: "Ref",
+ stackError: Error(),
+ value: a.current
+ });
+ return a;
+ }, "useRef"),
+ useState: /* @__PURE__ */ __name(function useState8(a) {
+ var b = B();
+ a = null !== b ? b.memoizedState : "function" === typeof a ? a() : a;
+ w.push({
+ primitive: "State",
+ stackError: Error(),
+ value: a
+ });
+ return [a, function() {
+ }];
+ }, "useState"),
+ useTransition: /* @__PURE__ */ __name(function useTransition() {
+ B();
+ B();
+ w.push({
+ primitive: "Transition",
+ stackError: Error(),
+ value: void 0
+ });
+ return [false, function() {
+ }];
+ }, "useTransition"),
+ useMutableSource: /* @__PURE__ */ __name(function useMutableSource(a, b) {
+ B();
+ B();
+ B();
+ B();
+ a = b(a._source);
+ w.push({
+ primitive: "MutableSource",
+ stackError: Error(),
+ value: a
+ });
+ return a;
+ }, "useMutableSource"),
+ useSyncExternalStore: /* @__PURE__ */ __name(function useSyncExternalStore(a, b) {
+ B();
+ B();
+ a = b();
+ w.push({
+ primitive: "SyncExternalStore",
+ stackError: Error(),
+ value: a
+ });
+ return a;
+ }, "useSyncExternalStore"),
+ useDeferredValue: /* @__PURE__ */ __name(function useDeferredValue(a) {
+ B();
+ B();
+ w.push({
+ primitive: "DeferredValue",
+ stackError: Error(),
+ value: a
+ });
+ return a;
+ }, "useDeferredValue"),
+ useId: /* @__PURE__ */ __name(function useId() {
+ var a = B();
+ a = null !== a ? a.memoizedState : "";
+ w.push({
+ primitive: "Id",
+ stackError: Error(),
+ value: a
+ });
+ return a;
+ }, "useId")
+ }, C = 0;
+ function D(a, b, e2) {
+ var f = b[e2].source, c = 0;
+ a:
+ for (; c < a.length; c++) {
+ if (a[c].source === f) {
+ for (var m = e2 + 1, r = c + 1; m < b.length && r < a.length; m++, r++) {
+ if (a[r].source !== b[m].source)
+ continue a;
+ }
+ return c;
+ }
+ }
+ return -1;
+ }
+ __name(D, "D");
+ function E(a, b) {
+ if (!a)
+ return false;
+ b = "use" + b;
+ return a.length < b.length ? false : a.lastIndexOf(b) === a.length - b.length;
+ }
+ __name(E, "E");
+ function F(a, b, e2) {
+ for (var f = [], c = null, m = f, r = 0, t2 = [], v = 0; v < b.length; v++) {
+ var u = b[v];
+ var d = a;
+ var k = l.parse(u.stackError);
+ b: {
+ var n = k, p = D(n, d, C);
+ if (-1 !== p)
+ d = p;
+ else {
+ for (var g = 0; g < d.length && 5 > g; g++) {
+ if (p = D(n, d, g), -1 !== p) {
+ C = g;
+ d = p;
+ break b;
+ }
+ }
+ d = -1;
+ }
+ }
+ b: {
+ n = k;
+ p = y().get(u.primitive);
+ if (void 0 !== p)
+ for (g = 0; g < p.length && g < n.length; g++) {
+ if (p[g].source !== n[g].source) {
+ g < n.length - 1 && E(n[g].functionName, u.primitive) && g++;
+ g < n.length - 1 && E(n[g].functionName, u.primitive) && g++;
+ n = g;
+ break b;
+ }
+ }
+ n = -1;
+ }
+ k = -1 === d || -1 === n || 2 > d - n ? null : k.slice(n, d - 1);
+ if (null !== k) {
+ d = 0;
+ if (null !== c) {
+ for (; d < k.length && d < c.length && k[k.length - d - 1].source === c[c.length - d - 1].source; ) {
+ d++;
+ }
+ for (c = c.length - 1; c > d; c--) {
+ m = t2.pop();
+ }
+ }
+ for (c = k.length - d - 1; 1 <= c; c--) {
+ d = [], n = k[c], (p = k[c - 1].functionName) ? (g = p.lastIndexOf("."), -1 === g && (g = 0), "use" === p.substr(g, 3) && (g += 3), p = p.substr(g)) : p = "", p = {
+ id: null,
+ isStateEditable: false,
+ name: p,
+ value: void 0,
+ subHooks: d
+ }, e2 && (p.hookSource = {
+ lineNumber: n.lineNumber,
+ columnNumber: n.columnNumber,
+ functionName: n.functionName,
+ fileName: n.fileName
+ }), m.push(p), t2.push(m), m = d;
+ }
+ c = k;
+ }
+ d = u.primitive;
+ u = {
+ id: "Context" === d || "DebugValue" === d ? null : r++,
+ isStateEditable: "Reducer" === d || "State" === d,
+ name: d,
+ value: u.value,
+ subHooks: []
+ };
+ e2 && (d = {
+ lineNumber: null,
+ functionName: null,
+ fileName: null,
+ columnNumber: null
+ }, k && 1 <= k.length && (k = k[0], d.lineNumber = k.lineNumber, d.functionName = k.functionName, d.fileName = k.fileName, d.columnNumber = k.columnNumber), u.hookSource = d);
+ m.push(u);
+ }
+ G(f, null);
+ return f;
+ }
+ __name(F, "F");
+ function G(a, b) {
+ for (var e2 = [], f = 0; f < a.length; f++) {
+ var c = a[f];
+ "DebugValue" === c.name && 0 === c.subHooks.length ? (a.splice(f, 1), f--, e2.push(c)) : G(c.subHooks, c);
+ }
+ null !== b && (1 === e2.length ? b.value = e2[0].value : 1 < e2.length && (b.value = e2.map(function(a2) {
+ return a2.value;
+ })));
+ }
+ __name(G, "G");
+ function H(a, b, e2) {
+ var f = 3 < arguments.length && void 0 !== arguments[3] ? arguments[3] : false;
+ null == e2 && (e2 = q.ReactCurrentDispatcher);
+ var c = e2.current;
+ e2.current = z;
+ try {
+ var m = Error();
+ a(b);
+ } finally {
+ var r = w;
+ w = [];
+ e2.current = c;
+ }
+ c = l.parse(m);
+ return F(c, r, f);
+ }
+ __name(H, "H");
+ function I(a) {
+ a.forEach(function(a2, e2) {
+ return e2._currentValue = a2;
+ });
+ }
+ __name(I, "I");
+ exports3.inspectHooks = H;
+ exports3.inspectHooksOfFiber = function(a, b) {
+ var e2 = 2 < arguments.length && void 0 !== arguments[2] ? arguments[2] : false;
+ null == b && (b = q.ReactCurrentDispatcher);
+ if (0 !== a.tag && 15 !== a.tag && 11 !== a.tag)
+ throw Error("Unknown Fiber. Needs to be a function component to inspect hooks.");
+ y();
+ var f = a.type, c = a.memoizedProps;
+ if (f !== a.elementType && f && f.defaultProps) {
+ c = h({}, c);
+ var m = f.defaultProps;
+ for (r in m) {
+ void 0 === c[r] && (c[r] = m[r]);
+ }
+ }
+ A = a.memoizedState;
+ var r = /* @__PURE__ */ new Map();
+ try {
+ for (m = a; m; ) {
+ if (10 === m.tag) {
+ var t2 = m.type._context;
+ r.has(t2) || (r.set(t2, t2._currentValue), t2._currentValue = m.memoizedProps.value);
+ }
+ m = m.return;
+ }
+ if (11 === a.tag) {
+ var v = f.render;
+ f = c;
+ var u = a.ref;
+ t2 = b;
+ var d = t2.current;
+ t2.current = z;
+ try {
+ var k = Error();
+ v(f, u);
+ } finally {
+ var n = w;
+ w = [];
+ t2.current = d;
+ }
+ var p = l.parse(k);
+ return F(p, n, e2);
+ }
+ return H(f, c, b, e2);
+ } finally {
+ A = null, I(r);
+ }
+ };
+ },
+ /* 29 */
+ /***/
+ function(module3, exports3, __webpack_require__) {
+ var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;
+ function _typeof7(obj) {
+ "@babel/helpers - typeof";
+ if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+ _typeof7 = /* @__PURE__ */ __name(function _typeof8(obj2) {
+ return typeof obj2;
+ }, "_typeof");
+ } else {
+ _typeof7 = /* @__PURE__ */ __name(function _typeof8(obj2) {
+ return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+ }, "_typeof");
+ }
+ return _typeof7(obj);
+ }
+ __name(_typeof7, "_typeof");
+ (function(root, factory) {
+ "use strict";
+ if (true) {
+ !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(30)], __WEBPACK_AMD_DEFINE_FACTORY__ = factory, __WEBPACK_AMD_DEFINE_RESULT__ = typeof __WEBPACK_AMD_DEFINE_FACTORY__ === "function" ? __WEBPACK_AMD_DEFINE_FACTORY__.apply(exports3, __WEBPACK_AMD_DEFINE_ARRAY__) : __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_RESULT__ !== void 0 && (module3.exports = __WEBPACK_AMD_DEFINE_RESULT__));
+ } else {
+ }
+ })(this, /* @__PURE__ */ __name(function ErrorStackParser(StackFrame) {
+ "use strict";
+ var FIREFOX_SAFARI_STACK_REGEXP = /(^|@)\S+:\d+/;
+ var CHROME_IE_STACK_REGEXP = /^\s*at .*(\S+:\d+|\(native\))/m;
+ var SAFARI_NATIVE_CODE_REGEXP = /^(eval@)?(\[native code])?$/;
+ return {
+ /**
+ * Given an Error object, extract the most information from it.
+ *
+ * @param {Error} error object
+ * @return {Array} of StackFrames
+ */
+ parse: /* @__PURE__ */ __name(function ErrorStackParser$$parse(error) {
+ if (typeof error.stacktrace !== "undefined" || typeof error["opera#sourceloc"] !== "undefined") {
+ return this.parseOpera(error);
+ } else if (error.stack && error.stack.match(CHROME_IE_STACK_REGEXP)) {
+ return this.parseV8OrIE(error);
+ } else if (error.stack) {
+ return this.parseFFOrSafari(error);
+ } else {
+ throw new Error("Cannot parse given Error object");
+ }
+ }, "ErrorStackParser$$parse"),
+ // Separate line and column numbers from a string of the form: (URI:Line:Column)
+ extractLocation: /* @__PURE__ */ __name(function ErrorStackParser$$extractLocation(urlLike) {
+ if (urlLike.indexOf(":") === -1) {
+ return [urlLike];
+ }
+ var regExp = /(.+?)(?::(\d+))?(?::(\d+))?$/;
+ var parts = regExp.exec(urlLike.replace(/[()]/g, ""));
+ return [parts[1], parts[2] || void 0, parts[3] || void 0];
+ }, "ErrorStackParser$$extractLocation"),
+ parseV8OrIE: /* @__PURE__ */ __name(function ErrorStackParser$$parseV8OrIE(error) {
+ var filtered = error.stack.split("\n").filter(function(line) {
+ return !!line.match(CHROME_IE_STACK_REGEXP);
+ }, this);
+ return filtered.map(function(line) {
+ if (line.indexOf("(eval ") > -1) {
+ line = line.replace(/eval code/g, "eval").replace(/(\(eval at [^()]*)|(\),.*$)/g, "");
+ }
+ var sanitizedLine = line.replace(/^\s+/, "").replace(/\(eval code/g, "(");
+ var location = sanitizedLine.match(/ (\((.+):(\d+):(\d+)\)$)/);
+ sanitizedLine = location ? sanitizedLine.replace(location[0], "") : sanitizedLine;
+ var tokens = sanitizedLine.split(/\s+/).slice(1);
+ var locationParts = this.extractLocation(location ? location[1] : tokens.pop());
+ var functionName = tokens.join(" ") || void 0;
+ var fileName = ["eval", ""].indexOf(locationParts[0]) > -1 ? void 0 : locationParts[0];
+ return new StackFrame({
+ functionName,
+ fileName,
+ lineNumber: locationParts[1],
+ columnNumber: locationParts[2],
+ source: line
+ });
+ }, this);
+ }, "ErrorStackParser$$parseV8OrIE"),
+ parseFFOrSafari: /* @__PURE__ */ __name(function ErrorStackParser$$parseFFOrSafari(error) {
+ var filtered = error.stack.split("\n").filter(function(line) {
+ return !line.match(SAFARI_NATIVE_CODE_REGEXP);
+ }, this);
+ return filtered.map(function(line) {
+ if (line.indexOf(" > eval") > -1) {
+ line = line.replace(/ line (\d+)(?: > eval line \d+)* > eval:\d+:\d+/g, ":$1");
+ }
+ if (line.indexOf("@") === -1 && line.indexOf(":") === -1) {
+ return new StackFrame({
+ functionName: line
+ });
+ } else {
+ var functionNameRegex = /((.*".+"[^@]*)?[^@]*)(?:@)/;
+ var matches = line.match(functionNameRegex);
+ var functionName = matches && matches[1] ? matches[1] : void 0;
+ var locationParts = this.extractLocation(line.replace(functionNameRegex, ""));
+ return new StackFrame({
+ functionName,
+ fileName: locationParts[0],
+ lineNumber: locationParts[1],
+ columnNumber: locationParts[2],
+ source: line
+ });
+ }
+ }, this);
+ }, "ErrorStackParser$$parseFFOrSafari"),
+ parseOpera: /* @__PURE__ */ __name(function ErrorStackParser$$parseOpera(e2) {
+ if (!e2.stacktrace || e2.message.indexOf("\n") > -1 && e2.message.split("\n").length > e2.stacktrace.split("\n").length) {
+ return this.parseOpera9(e2);
+ } else if (!e2.stack) {
+ return this.parseOpera10(e2);
+ } else {
+ return this.parseOpera11(e2);
+ }
+ }, "ErrorStackParser$$parseOpera"),
+ parseOpera9: /* @__PURE__ */ __name(function ErrorStackParser$$parseOpera9(e2) {
+ var lineRE = /Line (\d+).*script (?:in )?(\S+)/i;
+ var lines = e2.message.split("\n");
+ var result = [];
+ for (var i = 2, len = lines.length; i < len; i += 2) {
+ var match = lineRE.exec(lines[i]);
+ if (match) {
+ result.push(new StackFrame({
+ fileName: match[2],
+ lineNumber: match[1],
+ source: lines[i]
+ }));
+ }
+ }
+ return result;
+ }, "ErrorStackParser$$parseOpera9"),
+ parseOpera10: /* @__PURE__ */ __name(function ErrorStackParser$$parseOpera10(e2) {
+ var lineRE = /Line (\d+).*script (?:in )?(\S+)(?:: In function (\S+))?$/i;
+ var lines = e2.stacktrace.split("\n");
+ var result = [];
+ for (var i = 0, len = lines.length; i < len; i += 2) {
+ var match = lineRE.exec(lines[i]);
+ if (match) {
+ result.push(new StackFrame({
+ functionName: match[3] || void 0,
+ fileName: match[2],
+ lineNumber: match[1],
+ source: lines[i]
+ }));
+ }
+ }
+ return result;
+ }, "ErrorStackParser$$parseOpera10"),
+ // Opera 10.65+ Error.stack very similar to FF/Safari
+ parseOpera11: /* @__PURE__ */ __name(function ErrorStackParser$$parseOpera11(error) {
+ var filtered = error.stack.split("\n").filter(function(line) {
+ return !!line.match(FIREFOX_SAFARI_STACK_REGEXP) && !line.match(/^Error created at/);
+ }, this);
+ return filtered.map(function(line) {
+ var tokens = line.split("@");
+ var locationParts = this.extractLocation(tokens.pop());
+ var functionCall = tokens.shift() || "";
+ var functionName = functionCall.replace(//, "$2").replace(/\([^)]*\)/g, "") || void 0;
+ var argsRaw;
+ if (functionCall.match(/\(([^)]*)\)/)) {
+ argsRaw = functionCall.replace(/^[^(]+\(([^)]*)\)$/, "$1");
+ }
+ var args = argsRaw === void 0 || argsRaw === "[arguments not available]" ? void 0 : argsRaw.split(",");
+ return new StackFrame({
+ functionName,
+ args,
+ fileName: locationParts[0],
+ lineNumber: locationParts[1],
+ columnNumber: locationParts[2],
+ source: line
+ });
+ }, this);
+ }, "ErrorStackParser$$parseOpera11")
+ };
+ }, "ErrorStackParser"));
+ },
+ /* 30 */
+ /***/
+ function(module3, exports3, __webpack_require__) {
+ var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;
+ function _typeof7(obj) {
+ "@babel/helpers - typeof";
+ if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+ _typeof7 = /* @__PURE__ */ __name(function _typeof8(obj2) {
+ return typeof obj2;
+ }, "_typeof");
+ } else {
+ _typeof7 = /* @__PURE__ */ __name(function _typeof8(obj2) {
+ return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+ }, "_typeof");
+ }
+ return _typeof7(obj);
+ }
+ __name(_typeof7, "_typeof");
+ (function(root, factory) {
+ "use strict";
+ if (true) {
+ !(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_FACTORY__ = factory, __WEBPACK_AMD_DEFINE_RESULT__ = typeof __WEBPACK_AMD_DEFINE_FACTORY__ === "function" ? __WEBPACK_AMD_DEFINE_FACTORY__.apply(exports3, __WEBPACK_AMD_DEFINE_ARRAY__) : __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_RESULT__ !== void 0 && (module3.exports = __WEBPACK_AMD_DEFINE_RESULT__));
+ } else {
+ }
+ })(this, function() {
+ "use strict";
+ function _isNumber(n) {
+ return !isNaN(parseFloat(n)) && isFinite(n);
+ }
+ __name(_isNumber, "_isNumber");
+ function _capitalize(str) {
+ return str.charAt(0).toUpperCase() + str.substring(1);
+ }
+ __name(_capitalize, "_capitalize");
+ function _getter(p) {
+ return function() {
+ return this[p];
+ };
+ }
+ __name(_getter, "_getter");
+ var booleanProps = ["isConstructor", "isEval", "isNative", "isToplevel"];
+ var numericProps = ["columnNumber", "lineNumber"];
+ var stringProps = ["fileName", "functionName", "source"];
+ var arrayProps = ["args"];
+ var props = booleanProps.concat(numericProps, stringProps, arrayProps);
+ function StackFrame(obj) {
+ if (!obj)
+ return;
+ for (var i2 = 0; i2 < props.length; i2++) {
+ if (obj[props[i2]] !== void 0) {
+ this["set" + _capitalize(props[i2])](obj[props[i2]]);
+ }
+ }
+ }
+ __name(StackFrame, "StackFrame");
+ StackFrame.prototype = {
+ getArgs: /* @__PURE__ */ __name(function getArgs() {
+ return this.args;
+ }, "getArgs"),
+ setArgs: /* @__PURE__ */ __name(function setArgs(v) {
+ if (Object.prototype.toString.call(v) !== "[object Array]") {
+ throw new TypeError("Args must be an Array");
+ }
+ this.args = v;
+ }, "setArgs"),
+ getEvalOrigin: /* @__PURE__ */ __name(function getEvalOrigin() {
+ return this.evalOrigin;
+ }, "getEvalOrigin"),
+ setEvalOrigin: /* @__PURE__ */ __name(function setEvalOrigin(v) {
+ if (v instanceof StackFrame) {
+ this.evalOrigin = v;
+ } else if (v instanceof Object) {
+ this.evalOrigin = new StackFrame(v);
+ } else {
+ throw new TypeError("Eval Origin must be an Object or StackFrame");
+ }
+ }, "setEvalOrigin"),
+ toString: /* @__PURE__ */ __name(function toString() {
+ var fileName = this.getFileName() || "";
+ var lineNumber = this.getLineNumber() || "";
+ var columnNumber = this.getColumnNumber() || "";
+ var functionName = this.getFunctionName() || "";
+ if (this.getIsEval()) {
+ if (fileName) {
+ return "[eval] (" + fileName + ":" + lineNumber + ":" + columnNumber + ")";
+ }
+ return "[eval]:" + lineNumber + ":" + columnNumber;
+ }
+ if (functionName) {
+ return functionName + " (" + fileName + ":" + lineNumber + ":" + columnNumber + ")";
+ }
+ return fileName + ":" + lineNumber + ":" + columnNumber;
+ }, "toString")
+ };
+ StackFrame.fromString = /* @__PURE__ */ __name(function StackFrame$$fromString(str) {
+ var argsStartIndex = str.indexOf("(");
+ var argsEndIndex = str.lastIndexOf(")");
+ var functionName = str.substring(0, argsStartIndex);
+ var args = str.substring(argsStartIndex + 1, argsEndIndex).split(",");
+ var locationString = str.substring(argsEndIndex + 1);
+ if (locationString.indexOf("@") === 0) {
+ var parts = /@(.+?)(?::(\d+))?(?::(\d+))?$/.exec(locationString, "");
+ var fileName = parts[1];
+ var lineNumber = parts[2];
+ var columnNumber = parts[3];
+ }
+ return new StackFrame({
+ functionName,
+ args: args || void 0,
+ fileName,
+ lineNumber: lineNumber || void 0,
+ columnNumber: columnNumber || void 0
+ });
+ }, "StackFrame$$fromString");
+ for (var i = 0; i < booleanProps.length; i++) {
+ StackFrame.prototype["get" + _capitalize(booleanProps[i])] = _getter(booleanProps[i]);
+ StackFrame.prototype["set" + _capitalize(booleanProps[i])] = function(p) {
+ return function(v) {
+ this[p] = Boolean(v);
+ };
+ }(booleanProps[i]);
+ }
+ for (var j = 0; j < numericProps.length; j++) {
+ StackFrame.prototype["get" + _capitalize(numericProps[j])] = _getter(numericProps[j]);
+ StackFrame.prototype["set" + _capitalize(numericProps[j])] = function(p) {
+ return function(v) {
+ if (!_isNumber(v)) {
+ throw new TypeError(p + " must be a Number");
+ }
+ this[p] = Number(v);
+ };
+ }(numericProps[j]);
+ }
+ for (var k = 0; k < stringProps.length; k++) {
+ StackFrame.prototype["get" + _capitalize(stringProps[k])] = _getter(stringProps[k]);
+ StackFrame.prototype["set" + _capitalize(stringProps[k])] = function(p) {
+ return function(v) {
+ this[p] = String(v);
+ };
+ }(stringProps[k]);
+ }
+ return StackFrame;
+ });
+ },
+ /* 31 */
+ /***/
+ function(module3, exports3, __webpack_require__) {
+ "use strict";
+ if (true) {
+ module3.exports = __webpack_require__(32);
+ } else {
+ }
+ },
+ /* 32 */
+ /***/
+ function(module3, exports3, __webpack_require__) {
+ "use strict";
+ function _typeof7(obj) {
+ "@babel/helpers - typeof";
+ if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+ _typeof7 = /* @__PURE__ */ __name(function _typeof8(obj2) {
+ return typeof obj2;
+ }, "_typeof");
+ } else {
+ _typeof7 = /* @__PURE__ */ __name(function _typeof8(obj2) {
+ return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+ }, "_typeof");
+ }
+ return _typeof7(obj);
+ }
+ __name(_typeof7, "_typeof");
+ var l = __webpack_require__(8), m = 60103, p = 60106;
+ exports3.Fragment = 60107;
+ exports3.StrictMode = 60108;
+ exports3.Profiler = 60114;
+ var q = 60109, r = 60110, t2 = 60112;
+ exports3.Suspense = 60113;
+ exports3.SuspenseList = 60120;
+ var u = 60115, v = 60116;
+ exports3.unstable_DebugTracingMode = 60129;
+ exports3.unstable_Offscreen = 60130;
+ exports3.unstable_LegacyHidden = 60131;
+ exports3.unstable_Cache = 60132;
+ if ("function" === typeof Symbol && Symbol.for) {
+ var w = Symbol.for;
+ m = w("react.element");
+ p = w("react.portal");
+ exports3.Fragment = w("react.fragment");
+ exports3.StrictMode = w("react.strict_mode");
+ exports3.Profiler = w("react.profiler");
+ q = w("react.provider");
+ r = w("react.context");
+ t2 = w("react.forward_ref");
+ exports3.Suspense = w("react.suspense");
+ exports3.SuspenseList = w("react.suspense_list");
+ u = w("react.memo");
+ v = w("react.lazy");
+ exports3.unstable_DebugTracingMode = w("react.debug_trace_mode");
+ exports3.unstable_Offscreen = w("react.offscreen");
+ exports3.unstable_LegacyHidden = w("react.legacy_hidden");
+ exports3.unstable_Cache = w("react.cache");
+ }
+ var x = "function" === typeof Symbol && Symbol.iterator;
+ function y(a) {
+ if (null === a || "object" !== _typeof7(a))
+ return null;
+ a = x && a[x] || a["@@iterator"];
+ return "function" === typeof a ? a : null;
+ }
+ __name(y, "y");
+ var z = {
+ isMounted: /* @__PURE__ */ __name(function isMounted() {
+ return false;
+ }, "isMounted"),
+ enqueueForceUpdate: /* @__PURE__ */ __name(function enqueueForceUpdate() {
+ }, "enqueueForceUpdate"),
+ enqueueReplaceState: /* @__PURE__ */ __name(function enqueueReplaceState() {
+ }, "enqueueReplaceState"),
+ enqueueSetState: /* @__PURE__ */ __name(function enqueueSetState() {
+ }, "enqueueSetState")
+ }, A = {};
+ function B(a, b, e2) {
+ this.props = a;
+ this.context = b;
+ this.refs = A;
+ this.updater = e2 || z;
+ }
+ __name(B, "B");
+ B.prototype.isReactComponent = {};
+ B.prototype.setState = function(a, b) {
+ if ("object" !== _typeof7(a) && "function" !== typeof a && null != a)
+ throw Error("setState(...): takes an object of state variables to update or a function which returns an object of state variables.");
+ this.updater.enqueueSetState(this, a, b, "setState");
+ };
+ B.prototype.forceUpdate = function(a) {
+ this.updater.enqueueForceUpdate(this, a, "forceUpdate");
+ };
+ function C() {
+ }
+ __name(C, "C");
+ C.prototype = B.prototype;
+ function D(a, b, e2) {
+ this.props = a;
+ this.context = b;
+ this.refs = A;
+ this.updater = e2 || z;
+ }
+ __name(D, "D");
+ var E = D.prototype = new C();
+ E.constructor = D;
+ l(E, B.prototype);
+ E.isPureReactComponent = true;
+ var F = Array.isArray, G = Object.prototype.hasOwnProperty, H = {
+ current: null
+ }, I = {
+ key: true,
+ ref: true,
+ __self: true,
+ __source: true
+ };
+ function J(a, b, e2) {
+ var d, c = {}, k = null, h = null;
+ if (null != b)
+ for (d in void 0 !== b.ref && (h = b.ref), void 0 !== b.key && (k = "" + b.key), b) {
+ G.call(b, d) && !I.hasOwnProperty(d) && (c[d] = b[d]);
+ }
+ var g = arguments.length - 2;
+ if (1 === g)
+ c.children = e2;
+ else if (1 < g) {
+ for (var f = Array(g), n = 0; n < g; n++) {
+ f[n] = arguments[n + 2];
+ }
+ c.children = f;
+ }
+ if (a && a.defaultProps)
+ for (d in g = a.defaultProps, g) {
+ void 0 === c[d] && (c[d] = g[d]);
+ }
+ return {
+ $$typeof: m,
+ type: a,
+ key: k,
+ ref: h,
+ props: c,
+ _owner: H.current
+ };
+ }
+ __name(J, "J");
+ function K(a, b) {
+ return {
+ $$typeof: m,
+ type: a.type,
+ key: b,
+ ref: a.ref,
+ props: a.props,
+ _owner: a._owner
+ };
+ }
+ __name(K, "K");
+ function L(a) {
+ return "object" === _typeof7(a) && null !== a && a.$$typeof === m;
+ }
+ __name(L, "L");
+ function escape2(a) {
+ var b = {
+ "=": "=0",
+ ":": "=2"
+ };
+ return "$" + a.replace(/[=:]/g, function(a2) {
+ return b[a2];
+ });
+ }
+ __name(escape2, "escape");
+ var M = /\/+/g;
+ function N(a, b) {
+ return "object" === _typeof7(a) && null !== a && null != a.key ? escape2("" + a.key) : b.toString(36);
+ }
+ __name(N, "N");
+ function O(a, b, e2, d, c) {
+ var k = _typeof7(a);
+ if ("undefined" === k || "boolean" === k)
+ a = null;
+ var h = false;
+ if (null === a)
+ h = true;
+ else
+ switch (k) {
+ case "string":
+ case "number":
+ h = true;
+ break;
+ case "object":
+ switch (a.$$typeof) {
+ case m:
+ case p:
+ h = true;
+ }
+ }
+ if (h)
+ return h = a, c = c(h), a = "" === d ? "." + N(h, 0) : d, F(c) ? (e2 = "", null != a && (e2 = a.replace(M, "$&/") + "/"), O(c, b, e2, "", function(a2) {
+ return a2;
+ })) : null != c && (L(c) && (c = K(c, e2 + (!c.key || h && h.key === c.key ? "" : ("" + c.key).replace(M, "$&/") + "/") + a)), b.push(c)), 1;
+ h = 0;
+ d = "" === d ? "." : d + ":";
+ if (F(a))
+ for (var g = 0; g < a.length; g++) {
+ k = a[g];
+ var f = d + N(k, g);
+ h += O(k, b, e2, f, c);
+ }
+ else if (f = y(a), "function" === typeof f)
+ for (a = f.call(a), g = 0; !(k = a.next()).done; ) {
+ k = k.value, f = d + N(k, g++), h += O(k, b, e2, f, c);
+ }
+ else if ("object" === k)
+ throw b = String(a), Error("Objects are not valid as a React child (found: " + ("[object Object]" === b ? "object with keys {" + Object.keys(a).join(", ") + "}" : b) + "). If you meant to render a collection of children, use an array instead.");
+ return h;
+ }
+ __name(O, "O");
+ function P(a, b, e2) {
+ if (null == a)
+ return a;
+ var d = [], c = 0;
+ O(a, d, "", "", function(a2) {
+ return b.call(e2, a2, c++);
+ });
+ return d;
+ }
+ __name(P, "P");
+ function Q(a) {
+ if (-1 === a._status) {
+ var b = a._result;
+ b = b();
+ b.then(function(b2) {
+ if (0 === a._status || -1 === a._status)
+ a._status = 1, a._result = b2;
+ }, function(b2) {
+ if (0 === a._status || -1 === a._status)
+ a._status = 2, a._result = b2;
+ });
+ -1 === a._status && (a._status = 0, a._result = b);
+ }
+ if (1 === a._status)
+ return a._result.default;
+ throw a._result;
+ }
+ __name(Q, "Q");
+ var R = {
+ current: null
+ }, S = {
+ transition: 0
+ }, T = {
+ ReactCurrentDispatcher: R,
+ ReactCurrentBatchConfig: S,
+ ReactCurrentOwner: H,
+ assign: l
+ };
+ exports3.Children = {
+ map: P,
+ forEach: /* @__PURE__ */ __name(function forEach(a, b, e2) {
+ P(a, function() {
+ b.apply(this, arguments);
+ }, e2);
+ }, "forEach"),
+ count: /* @__PURE__ */ __name(function count(a) {
+ var b = 0;
+ P(a, function() {
+ b++;
+ });
+ return b;
+ }, "count"),
+ toArray: /* @__PURE__ */ __name(function toArray(a) {
+ return P(a, function(a2) {
+ return a2;
+ }) || [];
+ }, "toArray"),
+ only: /* @__PURE__ */ __name(function only(a) {
+ if (!L(a))
+ throw Error("React.Children.only expected to receive a single React element child.");
+ return a;
+ }, "only")
+ };
+ exports3.Component = B;
+ exports3.PureComponent = D;
+ exports3.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = T;
+ exports3.cloneElement = function(a, b, e2) {
+ if (null === a || void 0 === a)
+ throw Error("React.cloneElement(...): The argument must be a React element, but you passed " + a + ".");
+ var d = l({}, a.props), c = a.key, k = a.ref, h = a._owner;
+ if (null != b) {
+ void 0 !== b.ref && (k = b.ref, h = H.current);
+ void 0 !== b.key && (c = "" + b.key);
+ if (a.type && a.type.defaultProps)
+ var g = a.type.defaultProps;
+ for (f in b) {
+ G.call(b, f) && !I.hasOwnProperty(f) && (d[f] = void 0 === b[f] && void 0 !== g ? g[f] : b[f]);
+ }
+ }
+ var f = arguments.length - 2;
+ if (1 === f)
+ d.children = e2;
+ else if (1 < f) {
+ g = Array(f);
+ for (var n = 0; n < f; n++) {
+ g[n] = arguments[n + 2];
+ }
+ d.children = g;
+ }
+ return {
+ $$typeof: m,
+ type: a.type,
+ key: c,
+ ref: k,
+ props: d,
+ _owner: h
+ };
+ };
+ exports3.createContext = function(a) {
+ a = {
+ $$typeof: r,
+ _currentValue: a,
+ _currentValue2: a,
+ _threadCount: 0,
+ Provider: null,
+ Consumer: null
+ };
+ a.Provider = {
+ $$typeof: q,
+ _context: a
+ };
+ return a.Consumer = a;
+ };
+ exports3.createElement = J;
+ exports3.createFactory = function(a) {
+ var b = J.bind(null, a);
+ b.type = a;
+ return b;
+ };
+ exports3.createRef = function() {
+ return {
+ current: null
+ };
+ };
+ exports3.forwardRef = function(a) {
+ return {
+ $$typeof: t2,
+ render: a
+ };
+ };
+ exports3.isValidElement = L;
+ exports3.lazy = function(a) {
+ return {
+ $$typeof: v,
+ _payload: {
+ _status: -1,
+ _result: a
+ },
+ _init: Q
+ };
+ };
+ exports3.memo = function(a, b) {
+ return {
+ $$typeof: u,
+ type: a,
+ compare: void 0 === b ? null : b
+ };
+ };
+ exports3.startTransition = function(a) {
+ var b = S.transition;
+ S.transition = 1;
+ try {
+ a();
+ } finally {
+ S.transition = b;
+ }
+ };
+ exports3.unstable_act = function() {
+ throw Error("act(...) is not supported in production builds of React.");
+ };
+ exports3.unstable_createMutableSource = function(a, b) {
+ return {
+ _getVersion: b,
+ _source: a,
+ _workInProgressVersionPrimary: null,
+ _workInProgressVersionSecondary: null
+ };
+ };
+ exports3.unstable_getCacheForType = function(a) {
+ return R.current.getCacheForType(a);
+ };
+ exports3.unstable_getCacheSignal = function() {
+ return R.current.getCacheSignal();
+ };
+ exports3.unstable_useCacheRefresh = function() {
+ return R.current.useCacheRefresh();
+ };
+ exports3.useCallback = function(a, b) {
+ return R.current.useCallback(a, b);
+ };
+ exports3.useContext = function(a) {
+ return R.current.useContext(a);
+ };
+ exports3.useDebugValue = function() {
+ };
+ exports3.useDeferredValue = function(a) {
+ return R.current.useDeferredValue(a);
+ };
+ exports3.useEffect = function(a, b) {
+ return R.current.useEffect(a, b);
+ };
+ exports3.useId = function() {
+ return R.current.useId();
+ };
+ exports3.useImperativeHandle = function(a, b, e2) {
+ return R.current.useImperativeHandle(a, b, e2);
+ };
+ exports3.useInsertionEffect = function(a, b) {
+ return R.current.useInsertionEffect(a, b);
+ };
+ exports3.useLayoutEffect = function(a, b) {
+ return R.current.useLayoutEffect(a, b);
+ };
+ exports3.useMemo = function(a, b) {
+ return R.current.useMemo(a, b);
+ };
+ exports3.useReducer = function(a, b, e2) {
+ return R.current.useReducer(a, b, e2);
+ };
+ exports3.useRef = function(a) {
+ return R.current.useRef(a);
+ };
+ exports3.useState = function(a) {
+ return R.current.useState(a);
+ };
+ exports3.useSyncExternalStore = function(a, b, e2) {
+ return R.current.useSyncExternalStore(a, b, e2);
+ };
+ exports3.useTransition = function() {
+ return R.current.useTransition();
+ };
+ exports3.version = "18.0.0-rc.0-experimental-13036bfbc-20220121";
+ },
+ /* 33 */
+ /***/
+ function(module3, __webpack_exports__, __webpack_require__) {
+ "use strict";
+ __webpack_require__.r(__webpack_exports__);
+ __webpack_require__.d(__webpack_exports__, "connectToDevTools", function() {
+ return (
+ /* binding */
+ connectToDevTools
+ );
+ });
+ function _classCallCheck5(instance, Constructor) {
+ if (!(instance instanceof Constructor)) {
+ throw new TypeError("Cannot call a class as a function");
+ }
+ }
+ __name(_classCallCheck5, "_classCallCheck");
+ function _defineProperties5(target, props) {
+ for (var i = 0; i < props.length; i++) {
+ var descriptor2 = props[i];
+ descriptor2.enumerable = descriptor2.enumerable || false;
+ descriptor2.configurable = true;
+ if ("value" in descriptor2)
+ descriptor2.writable = true;
+ Object.defineProperty(target, descriptor2.key, descriptor2);
+ }
+ }
+ __name(_defineProperties5, "_defineProperties");
+ function _createClass5(Constructor, protoProps, staticProps) {
+ if (protoProps)
+ _defineProperties5(Constructor.prototype, protoProps);
+ if (staticProps)
+ _defineProperties5(Constructor, staticProps);
+ return Constructor;
+ }
+ __name(_createClass5, "_createClass");
+ function _defineProperty11(obj, key, value) {
+ if (key in obj) {
+ Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
+ } else {
+ obj[key] = value;
+ }
+ return obj;
+ }
+ __name(_defineProperty11, "_defineProperty");
+ var EventEmitter3 = /* @__PURE__ */ function() {
+ function EventEmitter4() {
+ _classCallCheck5(this, EventEmitter4);
+ _defineProperty11(this, "listenersMap", /* @__PURE__ */ new Map());
+ }
+ __name(EventEmitter4, "EventEmitter");
+ _createClass5(EventEmitter4, [{
+ key: "addListener",
+ value: /* @__PURE__ */ __name(function addListener(event, listener) {
+ var listeners = this.listenersMap.get(event);
+ if (listeners === void 0) {
+ this.listenersMap.set(event, [listener]);
+ } else {
+ var index = listeners.indexOf(listener);
+ if (index < 0) {
+ listeners.push(listener);
+ }
+ }
+ }, "addListener")
+ }, {
+ key: "emit",
+ value: /* @__PURE__ */ __name(function emit(event) {
+ var listeners = this.listenersMap.get(event);
+ if (listeners !== void 0) {
+ for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+ args[_key - 1] = arguments[_key];
+ }
+ if (listeners.length === 1) {
+ var listener = listeners[0];
+ listener.apply(null, args);
+ } else {
+ var didThrow = false;
+ var caughtError = null;
+ var clonedListeners = Array.from(listeners);
+ for (var i = 0; i < clonedListeners.length; i++) {
+ var _listener = clonedListeners[i];
+ try {
+ _listener.apply(null, args);
+ } catch (error) {
+ if (caughtError === null) {
+ didThrow = true;
+ caughtError = error;
+ }
+ }
+ }
+ if (didThrow) {
+ throw caughtError;
+ }
+ }
+ }
+ }, "emit")
+ }, {
+ key: "removeAllListeners",
+ value: /* @__PURE__ */ __name(function removeAllListeners() {
+ this.listenersMap.clear();
+ }, "removeAllListeners")
+ }, {
+ key: "removeListener",
+ value: /* @__PURE__ */ __name(function removeListener(event, listener) {
+ var listeners = this.listenersMap.get(event);
+ if (listeners !== void 0) {
+ var index = listeners.indexOf(listener);
+ if (index >= 0) {
+ listeners.splice(index, 1);
+ }
+ }
+ }, "removeListener")
+ }]);
+ return EventEmitter4;
+ }();
+ var lodash_throttle = __webpack_require__(15);
+ var lodash_throttle_default = /* @__PURE__ */ __webpack_require__.n(lodash_throttle);
+ var constants3 = __webpack_require__(1);
+ var storage = __webpack_require__(5);
+ var simpleIsEqual = /* @__PURE__ */ __name(function simpleIsEqual2(a, b) {
+ return a === b;
+ }, "simpleIsEqual");
+ var esm = /* @__PURE__ */ __name(function(resultFn) {
+ var isEqual = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : simpleIsEqual;
+ var lastThis = void 0;
+ var lastArgs = [];
+ var lastResult = void 0;
+ var calledOnce = false;
+ var isNewArgEqualToLast = /* @__PURE__ */ __name(function isNewArgEqualToLast2(newArg, index) {
+ return isEqual(newArg, lastArgs[index]);
+ }, "isNewArgEqualToLast");
+ var result = /* @__PURE__ */ __name(function result2() {
+ for (var _len = arguments.length, newArgs = Array(_len), _key = 0; _key < _len; _key++) {
+ newArgs[_key] = arguments[_key];
+ }
+ if (calledOnce && lastThis === this && newArgs.length === lastArgs.length && newArgs.every(isNewArgEqualToLast)) {
+ return lastResult;
+ }
+ calledOnce = true;
+ lastThis = this;
+ lastArgs = newArgs;
+ lastResult = resultFn.apply(this, newArgs);
+ return lastResult;
+ }, "result");
+ return result;
+ }, "esm");
+ var object_assign = __webpack_require__(8);
+ var object_assign_default = /* @__PURE__ */ __webpack_require__.n(object_assign);
+ function getOwnerWindow(node) {
+ if (!node.ownerDocument) {
+ return null;
+ }
+ return node.ownerDocument.defaultView;
+ }
+ __name(getOwnerWindow, "getOwnerWindow");
+ function getOwnerIframe(node) {
+ var nodeWindow = getOwnerWindow(node);
+ if (nodeWindow) {
+ return nodeWindow.frameElement;
+ }
+ return null;
+ }
+ __name(getOwnerIframe, "getOwnerIframe");
+ function getBoundingClientRectWithBorderOffset(node) {
+ var dimensions = getElementDimensions(node);
+ return mergeRectOffsets([node.getBoundingClientRect(), {
+ top: dimensions.borderTop,
+ left: dimensions.borderLeft,
+ bottom: dimensions.borderBottom,
+ right: dimensions.borderRight,
+ // This width and height won't get used by mergeRectOffsets (since this
+ // is not the first rect in the array), but we set them so that this
+ // object type checks as a ClientRect.
+ width: 0,
+ height: 0
+ }]);
+ }
+ __name(getBoundingClientRectWithBorderOffset, "getBoundingClientRectWithBorderOffset");
+ function mergeRectOffsets(rects) {
+ return rects.reduce(function(previousRect, rect) {
+ if (previousRect == null) {
+ return rect;
+ }
+ return {
+ top: previousRect.top + rect.top,
+ left: previousRect.left + rect.left,
+ width: previousRect.width,
+ height: previousRect.height,
+ bottom: previousRect.bottom + rect.bottom,
+ right: previousRect.right + rect.right
+ };
+ });
+ }
+ __name(mergeRectOffsets, "mergeRectOffsets");
+ function getNestedBoundingClientRect(node, boundaryWindow) {
+ var ownerIframe = getOwnerIframe(node);
+ if (ownerIframe && ownerIframe !== boundaryWindow) {
+ var rects = [node.getBoundingClientRect()];
+ var currentIframe = ownerIframe;
+ var onlyOneMore = false;
+ while (currentIframe) {
+ var rect = getBoundingClientRectWithBorderOffset(currentIframe);
+ rects.push(rect);
+ currentIframe = getOwnerIframe(currentIframe);
+ if (onlyOneMore) {
+ break;
+ }
+ if (currentIframe && getOwnerWindow(currentIframe) === boundaryWindow) {
+ onlyOneMore = true;
+ }
+ }
+ return mergeRectOffsets(rects);
+ } else {
+ return node.getBoundingClientRect();
+ }
+ }
+ __name(getNestedBoundingClientRect, "getNestedBoundingClientRect");
+ function getElementDimensions(domElement) {
+ var calculatedStyle = window.getComputedStyle(domElement);
+ return {
+ borderLeft: parseInt(calculatedStyle.borderLeftWidth, 10),
+ borderRight: parseInt(calculatedStyle.borderRightWidth, 10),
+ borderTop: parseInt(calculatedStyle.borderTopWidth, 10),
+ borderBottom: parseInt(calculatedStyle.borderBottomWidth, 10),
+ marginLeft: parseInt(calculatedStyle.marginLeft, 10),
+ marginRight: parseInt(calculatedStyle.marginRight, 10),
+ marginTop: parseInt(calculatedStyle.marginTop, 10),
+ marginBottom: parseInt(calculatedStyle.marginBottom, 10),
+ paddingLeft: parseInt(calculatedStyle.paddingLeft, 10),
+ paddingRight: parseInt(calculatedStyle.paddingRight, 10),
+ paddingTop: parseInt(calculatedStyle.paddingTop, 10),
+ paddingBottom: parseInt(calculatedStyle.paddingBottom, 10)
+ };
+ }
+ __name(getElementDimensions, "getElementDimensions");
+ function _createForOfIteratorHelper(o, allowArrayLike) {
+ var it2;
+ if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) {
+ if (Array.isArray(o) || (it2 = _unsupportedIterableToArray4(o)) || allowArrayLike && o && typeof o.length === "number") {
+ if (it2)
+ o = it2;
+ var i = 0;
+ var F = /* @__PURE__ */ __name(function F2() {
+ }, "F");
+ return { s: F, n: /* @__PURE__ */ __name(function n() {
+ if (i >= o.length)
+ return { done: true };
+ return { done: false, value: o[i++] };
+ }, "n"), e: /* @__PURE__ */ __name(function e2(_e) {
+ throw _e;
+ }, "e"), f: F };
+ }
+ throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+ }
+ var normalCompletion = true, didErr = false, err;
+ return { s: /* @__PURE__ */ __name(function s() {
+ it2 = o[Symbol.iterator]();
+ }, "s"), n: /* @__PURE__ */ __name(function n() {
+ var step = it2.next();
+ normalCompletion = step.done;
+ return step;
+ }, "n"), e: /* @__PURE__ */ __name(function e2(_e2) {
+ didErr = true;
+ err = _e2;
+ }, "e"), f: /* @__PURE__ */ __name(function f() {
+ try {
+ if (!normalCompletion && it2.return != null)
+ it2.return();
+ } finally {
+ if (didErr)
+ throw err;
+ }
+ }, "f") };
+ }
+ __name(_createForOfIteratorHelper, "_createForOfIteratorHelper");
+ function _unsupportedIterableToArray4(o, minLen) {
+ if (!o)
+ return;
+ if (typeof o === "string")
+ return _arrayLikeToArray4(o, minLen);
+ var n = Object.prototype.toString.call(o).slice(8, -1);
+ if (n === "Object" && o.constructor)
+ n = o.constructor.name;
+ if (n === "Map" || n === "Set")
+ return Array.from(o);
+ if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))
+ return _arrayLikeToArray4(o, minLen);
+ }
+ __name(_unsupportedIterableToArray4, "_unsupportedIterableToArray");
+ function _arrayLikeToArray4(arr, len) {
+ if (len == null || len > arr.length)
+ len = arr.length;
+ for (var i = 0, arr2 = new Array(len); i < len; i++) {
+ arr2[i] = arr[i];
+ }
+ return arr2;
+ }
+ __name(_arrayLikeToArray4, "_arrayLikeToArray");
+ function Overlay_classCallCheck(instance, Constructor) {
+ if (!(instance instanceof Constructor)) {
+ throw new TypeError("Cannot call a class as a function");
+ }
+ }
+ __name(Overlay_classCallCheck, "Overlay_classCallCheck");
+ function Overlay_defineProperties(target, props) {
+ for (var i = 0; i < props.length; i++) {
+ var descriptor2 = props[i];
+ descriptor2.enumerable = descriptor2.enumerable || false;
+ descriptor2.configurable = true;
+ if ("value" in descriptor2)
+ descriptor2.writable = true;
+ Object.defineProperty(target, descriptor2.key, descriptor2);
+ }
+ }
+ __name(Overlay_defineProperties, "Overlay_defineProperties");
+ function Overlay_createClass(Constructor, protoProps, staticProps) {
+ if (protoProps)
+ Overlay_defineProperties(Constructor.prototype, protoProps);
+ if (staticProps)
+ Overlay_defineProperties(Constructor, staticProps);
+ return Constructor;
+ }
+ __name(Overlay_createClass, "Overlay_createClass");
+ var Overlay_OverlayRect = /* @__PURE__ */ function() {
+ function OverlayRect(doc, container) {
+ Overlay_classCallCheck(this, OverlayRect);
+ this.node = doc.createElement("div");
+ this.border = doc.createElement("div");
+ this.padding = doc.createElement("div");
+ this.content = doc.createElement("div");
+ this.border.style.borderColor = overlayStyles.border;
+ this.padding.style.borderColor = overlayStyles.padding;
+ this.content.style.backgroundColor = overlayStyles.background;
+ object_assign_default()(this.node.style, {
+ borderColor: overlayStyles.margin,
+ pointerEvents: "none",
+ position: "fixed"
+ });
+ this.node.style.zIndex = "10000000";
+ this.node.appendChild(this.border);
+ this.border.appendChild(this.padding);
+ this.padding.appendChild(this.content);
+ container.appendChild(this.node);
+ }
+ __name(OverlayRect, "OverlayRect");
+ Overlay_createClass(OverlayRect, [{
+ key: "remove",
+ value: /* @__PURE__ */ __name(function remove() {
+ if (this.node.parentNode) {
+ this.node.parentNode.removeChild(this.node);
+ }
+ }, "remove")
+ }, {
+ key: "update",
+ value: /* @__PURE__ */ __name(function update(box, dims) {
+ boxWrap(dims, "margin", this.node);
+ boxWrap(dims, "border", this.border);
+ boxWrap(dims, "padding", this.padding);
+ object_assign_default()(this.content.style, {
+ height: box.height - dims.borderTop - dims.borderBottom - dims.paddingTop - dims.paddingBottom + "px",
+ width: box.width - dims.borderLeft - dims.borderRight - dims.paddingLeft - dims.paddingRight + "px"
+ });
+ object_assign_default()(this.node.style, {
+ top: box.top - dims.marginTop + "px",
+ left: box.left - dims.marginLeft + "px"
+ });
+ }, "update")
+ }]);
+ return OverlayRect;
+ }();
+ var Overlay_OverlayTip = /* @__PURE__ */ function() {
+ function OverlayTip(doc, container) {
+ Overlay_classCallCheck(this, OverlayTip);
+ this.tip = doc.createElement("div");
+ object_assign_default()(this.tip.style, {
+ display: "flex",
+ flexFlow: "row nowrap",
+ backgroundColor: "#333740",
+ borderRadius: "2px",
+ fontFamily: '"SFMono-Regular", Consolas, "Liberation Mono", Menlo, Courier, monospace',
+ fontWeight: "bold",
+ padding: "3px 5px",
+ pointerEvents: "none",
+ position: "fixed",
+ fontSize: "12px",
+ whiteSpace: "nowrap"
+ });
+ this.nameSpan = doc.createElement("span");
+ this.tip.appendChild(this.nameSpan);
+ object_assign_default()(this.nameSpan.style, {
+ color: "#ee78e6",
+ borderRight: "1px solid #aaaaaa",
+ paddingRight: "0.5rem",
+ marginRight: "0.5rem"
+ });
+ this.dimSpan = doc.createElement("span");
+ this.tip.appendChild(this.dimSpan);
+ object_assign_default()(this.dimSpan.style, {
+ color: "#d7d7d7"
+ });
+ this.tip.style.zIndex = "10000000";
+ container.appendChild(this.tip);
+ }
+ __name(OverlayTip, "OverlayTip");
+ Overlay_createClass(OverlayTip, [{
+ key: "remove",
+ value: /* @__PURE__ */ __name(function remove() {
+ if (this.tip.parentNode) {
+ this.tip.parentNode.removeChild(this.tip);
+ }
+ }, "remove")
+ }, {
+ key: "updateText",
+ value: /* @__PURE__ */ __name(function updateText(name, width, height) {
+ this.nameSpan.textContent = name;
+ this.dimSpan.textContent = Math.round(width) + "px \xD7 " + Math.round(height) + "px";
+ }, "updateText")
+ }, {
+ key: "updatePosition",
+ value: /* @__PURE__ */ __name(function updatePosition(dims, bounds) {
+ var tipRect = this.tip.getBoundingClientRect();
+ var tipPos = findTipPos(dims, bounds, {
+ width: tipRect.width,
+ height: tipRect.height
+ });
+ object_assign_default()(this.tip.style, tipPos.style);
+ }, "updatePosition")
+ }]);
+ return OverlayTip;
+ }();
+ var Overlay_Overlay = /* @__PURE__ */ function() {
+ function Overlay() {
+ Overlay_classCallCheck(this, Overlay);
+ var currentWindow = window.__REACT_DEVTOOLS_TARGET_WINDOW__ || window;
+ this.window = currentWindow;
+ var tipBoundsWindow = window.__REACT_DEVTOOLS_TARGET_WINDOW__ || window;
+ this.tipBoundsWindow = tipBoundsWindow;
+ var doc = currentWindow.document;
+ this.container = doc.createElement("div");
+ this.container.style.zIndex = "10000000";
+ this.tip = new Overlay_OverlayTip(doc, this.container);
+ this.rects = [];
+ doc.body.appendChild(this.container);
+ }
+ __name(Overlay, "Overlay");
+ Overlay_createClass(Overlay, [{
+ key: "remove",
+ value: /* @__PURE__ */ __name(function remove() {
+ this.tip.remove();
+ this.rects.forEach(function(rect) {
+ rect.remove();
+ });
+ this.rects.length = 0;
+ if (this.container.parentNode) {
+ this.container.parentNode.removeChild(this.container);
+ }
+ }, "remove")
+ }, {
+ key: "inspect",
+ value: /* @__PURE__ */ __name(function inspect2(nodes, name) {
+ var _this = this;
+ var elements = nodes.filter(function(node2) {
+ return node2.nodeType === Node.ELEMENT_NODE;
+ });
+ while (this.rects.length > elements.length) {
+ var rect = this.rects.pop();
+ rect.remove();
+ }
+ if (elements.length === 0) {
+ return;
+ }
+ while (this.rects.length < elements.length) {
+ this.rects.push(new Overlay_OverlayRect(this.window.document, this.container));
+ }
+ var outerBox = {
+ top: Number.POSITIVE_INFINITY,
+ right: Number.NEGATIVE_INFINITY,
+ bottom: Number.NEGATIVE_INFINITY,
+ left: Number.POSITIVE_INFINITY
+ };
+ elements.forEach(function(element, index) {
+ var box = getNestedBoundingClientRect(element, _this.window);
+ var dims = getElementDimensions(element);
+ outerBox.top = Math.min(outerBox.top, box.top - dims.marginTop);
+ outerBox.right = Math.max(outerBox.right, box.left + box.width + dims.marginRight);
+ outerBox.bottom = Math.max(outerBox.bottom, box.top + box.height + dims.marginBottom);
+ outerBox.left = Math.min(outerBox.left, box.left - dims.marginLeft);
+ var rect2 = _this.rects[index];
+ rect2.update(box, dims);
+ });
+ if (!name) {
+ name = elements[0].nodeName.toLowerCase();
+ var node = elements[0];
+ var hook = node.ownerDocument.defaultView.__REACT_DEVTOOLS_GLOBAL_HOOK__;
+ if (hook != null && hook.rendererInterfaces != null) {
+ var ownerName = null;
+ var _iterator = _createForOfIteratorHelper(hook.rendererInterfaces.values()), _step;
+ try {
+ for (_iterator.s(); !(_step = _iterator.n()).done; ) {
+ var rendererInterface = _step.value;
+ var id = rendererInterface.getFiberIDForNative(node, true);
+ if (id !== null) {
+ ownerName = rendererInterface.getDisplayNameForFiberID(id, true);
+ break;
+ }
+ }
+ } catch (err) {
+ _iterator.e(err);
+ } finally {
+ _iterator.f();
+ }
+ if (ownerName) {
+ name += " (in " + ownerName + ")";
+ }
+ }
+ }
+ this.tip.updateText(name, outerBox.right - outerBox.left, outerBox.bottom - outerBox.top);
+ var tipBounds = getNestedBoundingClientRect(this.tipBoundsWindow.document.documentElement, this.window);
+ this.tip.updatePosition({
+ top: outerBox.top,
+ left: outerBox.left,
+ height: outerBox.bottom - outerBox.top,
+ width: outerBox.right - outerBox.left
+ }, {
+ top: tipBounds.top + this.tipBoundsWindow.scrollY,
+ left: tipBounds.left + this.tipBoundsWindow.scrollX,
+ height: this.tipBoundsWindow.innerHeight,
+ width: this.tipBoundsWindow.innerWidth
+ });
+ }, "inspect")
+ }]);
+ return Overlay;
+ }();
+ function findTipPos(dims, bounds, tipSize) {
+ var tipHeight = Math.max(tipSize.height, 20);
+ var tipWidth = Math.max(tipSize.width, 60);
+ var margin = 5;
+ var top2;
+ if (dims.top + dims.height + tipHeight <= bounds.top + bounds.height) {
+ if (dims.top + dims.height < bounds.top + 0) {
+ top2 = bounds.top + margin;
+ } else {
+ top2 = dims.top + dims.height + margin;
+ }
+ } else if (dims.top - tipHeight <= bounds.top + bounds.height) {
+ if (dims.top - tipHeight - margin < bounds.top + margin) {
+ top2 = bounds.top + margin;
+ } else {
+ top2 = dims.top - tipHeight - margin;
+ }
+ } else {
+ top2 = bounds.top + bounds.height - tipHeight - margin;
+ }
+ var left2 = dims.left + margin;
+ if (dims.left < bounds.left) {
+ left2 = bounds.left + margin;
+ }
+ if (dims.left + tipWidth > bounds.left + bounds.width) {
+ left2 = bounds.left + bounds.width - tipWidth - margin;
+ }
+ top2 += "px";
+ left2 += "px";
+ return {
+ style: {
+ top: top2,
+ left: left2
+ }
+ };
+ }
+ __name(findTipPos, "findTipPos");
+ function boxWrap(dims, what, node) {
+ object_assign_default()(node.style, {
+ borderTopWidth: dims[what + "Top"] + "px",
+ borderLeftWidth: dims[what + "Left"] + "px",
+ borderRightWidth: dims[what + "Right"] + "px",
+ borderBottomWidth: dims[what + "Bottom"] + "px",
+ borderStyle: "solid"
+ });
+ }
+ __name(boxWrap, "boxWrap");
+ var overlayStyles = {
+ background: "rgba(120, 170, 210, 0.7)",
+ padding: "rgba(77, 200, 0, 0.3)",
+ margin: "rgba(255, 155, 0, 0.3)",
+ border: "rgba(255, 200, 50, 0.3)"
+ };
+ var SHOW_DURATION = 2e3;
+ var timeoutID = null;
+ var overlay = null;
+ function hideOverlay() {
+ timeoutID = null;
+ if (overlay !== null) {
+ overlay.remove();
+ overlay = null;
+ }
+ }
+ __name(hideOverlay, "hideOverlay");
+ function showOverlay(elements, componentName, hideAfterTimeout) {
+ if (window.document == null) {
+ return;
+ }
+ if (timeoutID !== null) {
+ clearTimeout(timeoutID);
+ }
+ if (elements == null) {
+ return;
+ }
+ if (overlay === null) {
+ overlay = new Overlay_Overlay();
+ }
+ overlay.inspect(elements, componentName);
+ if (hideAfterTimeout) {
+ timeoutID = setTimeout(hideOverlay, SHOW_DURATION);
+ }
+ }
+ __name(showOverlay, "showOverlay");
+ var iframesListeningTo = /* @__PURE__ */ new Set();
+ function setupHighlighter(bridge, agent) {
+ bridge.addListener("clearNativeElementHighlight", clearNativeElementHighlight);
+ bridge.addListener("highlightNativeElement", highlightNativeElement);
+ bridge.addListener("shutdown", stopInspectingNative);
+ bridge.addListener("startInspectingNative", startInspectingNative);
+ bridge.addListener("stopInspectingNative", stopInspectingNative);
+ function startInspectingNative() {
+ registerListenersOnWindow(window);
+ }
+ __name(startInspectingNative, "startInspectingNative");
+ function registerListenersOnWindow(window2) {
+ if (window2 && typeof window2.addEventListener === "function") {
+ window2.addEventListener("click", onClick, true);
+ window2.addEventListener("mousedown", onMouseEvent, true);
+ window2.addEventListener("mouseover", onMouseEvent, true);
+ window2.addEventListener("mouseup", onMouseEvent, true);
+ window2.addEventListener("pointerdown", onPointerDown, true);
+ window2.addEventListener("pointerover", onPointerOver, true);
+ window2.addEventListener("pointerup", onPointerUp, true);
+ }
+ }
+ __name(registerListenersOnWindow, "registerListenersOnWindow");
+ function stopInspectingNative() {
+ hideOverlay();
+ removeListenersOnWindow(window);
+ iframesListeningTo.forEach(function(frame) {
+ try {
+ removeListenersOnWindow(frame.contentWindow);
+ } catch (error) {
+ }
+ });
+ iframesListeningTo = /* @__PURE__ */ new Set();
+ }
+ __name(stopInspectingNative, "stopInspectingNative");
+ function removeListenersOnWindow(window2) {
+ if (window2 && typeof window2.removeEventListener === "function") {
+ window2.removeEventListener("click", onClick, true);
+ window2.removeEventListener("mousedown", onMouseEvent, true);
+ window2.removeEventListener("mouseover", onMouseEvent, true);
+ window2.removeEventListener("mouseup", onMouseEvent, true);
+ window2.removeEventListener("pointerdown", onPointerDown, true);
+ window2.removeEventListener("pointerover", onPointerOver, true);
+ window2.removeEventListener("pointerup", onPointerUp, true);
+ }
+ }
+ __name(removeListenersOnWindow, "removeListenersOnWindow");
+ function clearNativeElementHighlight() {
+ hideOverlay();
+ }
+ __name(clearNativeElementHighlight, "clearNativeElementHighlight");
+ function highlightNativeElement(_ref) {
+ var displayName = _ref.displayName, hideAfterTimeout = _ref.hideAfterTimeout, id = _ref.id, openNativeElementsPanel = _ref.openNativeElementsPanel, rendererID = _ref.rendererID, scrollIntoView = _ref.scrollIntoView;
+ var renderer = agent.rendererInterfaces[rendererID];
+ if (renderer == null) {
+ console.warn('Invalid renderer id "'.concat(rendererID, '" for element "').concat(id, '"'));
+ }
+ var nodes = null;
+ if (renderer != null) {
+ nodes = renderer.findNativeNodesForFiberID(id);
+ }
+ if (nodes != null && nodes[0] != null) {
+ var node = nodes[0];
+ if (scrollIntoView && typeof node.scrollIntoView === "function") {
+ node.scrollIntoView({
+ block: "nearest",
+ inline: "nearest"
+ });
+ }
+ showOverlay(nodes, displayName, hideAfterTimeout);
+ if (openNativeElementsPanel) {
+ window.__REACT_DEVTOOLS_GLOBAL_HOOK__.$0 = node;
+ bridge.send("syncSelectionToNativeElementsPanel");
+ }
+ } else {
+ hideOverlay();
+ }
+ }
+ __name(highlightNativeElement, "highlightNativeElement");
+ function onClick(event) {
+ event.preventDefault();
+ event.stopPropagation();
+ stopInspectingNative();
+ bridge.send("stopInspectingNative", true);
+ }
+ __name(onClick, "onClick");
+ function onMouseEvent(event) {
+ event.preventDefault();
+ event.stopPropagation();
+ }
+ __name(onMouseEvent, "onMouseEvent");
+ function onPointerDown(event) {
+ event.preventDefault();
+ event.stopPropagation();
+ selectFiberForNode(event.target);
+ }
+ __name(onPointerDown, "onPointerDown");
+ function onPointerOver(event) {
+ event.preventDefault();
+ event.stopPropagation();
+ var target = event.target;
+ if (target.tagName === "IFRAME") {
+ var iframe = target;
+ try {
+ if (!iframesListeningTo.has(iframe)) {
+ var _window = iframe.contentWindow;
+ registerListenersOnWindow(_window);
+ iframesListeningTo.add(iframe);
+ }
+ } catch (error) {
+ }
+ }
+ showOverlay([target], null, false);
+ selectFiberForNode(target);
+ }
+ __name(onPointerOver, "onPointerOver");
+ function onPointerUp(event) {
+ event.preventDefault();
+ event.stopPropagation();
+ }
+ __name(onPointerUp, "onPointerUp");
+ var selectFiberForNode = lodash_throttle_default()(
+ esm(function(node) {
+ var id = agent.getIDForNode(node);
+ if (id !== null) {
+ bridge.send("selectFiber", id);
+ }
+ }),
+ 200,
+ // Don't change the selection in the very first 200ms
+ // because those are usually unintentional as you lift the cursor.
+ {
+ leading: false
+ }
+ );
+ }
+ __name(setupHighlighter, "setupHighlighter");
+ var OUTLINE_COLOR = "#f0f0f0";
+ var COLORS = ["#37afa9", "#63b19e", "#80b393", "#97b488", "#abb67d", "#beb771", "#cfb965", "#dfba57", "#efbb49", "#febc38"];
+ var canvas = null;
+ function draw(nodeToData2) {
+ if (canvas === null) {
+ initialize();
+ }
+ var canvasFlow = canvas;
+ canvasFlow.width = window.innerWidth;
+ canvasFlow.height = window.innerHeight;
+ var context2 = canvasFlow.getContext("2d");
+ context2.clearRect(0, 0, canvasFlow.width, canvasFlow.height);
+ nodeToData2.forEach(function(_ref) {
+ var count = _ref.count, rect = _ref.rect;
+ if (rect !== null) {
+ var colorIndex = Math.min(COLORS.length - 1, count - 1);
+ var color = COLORS[colorIndex];
+ drawBorder(context2, rect, color);
+ }
+ });
+ }
+ __name(draw, "draw");
+ function drawBorder(context2, rect, color) {
+ var height = rect.height, left2 = rect.left, top2 = rect.top, width = rect.width;
+ context2.lineWidth = 1;
+ context2.strokeStyle = OUTLINE_COLOR;
+ context2.strokeRect(left2 - 1, top2 - 1, width + 2, height + 2);
+ context2.lineWidth = 1;
+ context2.strokeStyle = OUTLINE_COLOR;
+ context2.strokeRect(left2 + 1, top2 + 1, width - 1, height - 1);
+ context2.strokeStyle = color;
+ context2.setLineDash([0]);
+ context2.lineWidth = 1;
+ context2.strokeRect(left2, top2, width - 1, height - 1);
+ context2.setLineDash([0]);
+ }
+ __name(drawBorder, "drawBorder");
+ function destroy() {
+ if (canvas !== null) {
+ if (canvas.parentNode != null) {
+ canvas.parentNode.removeChild(canvas);
+ }
+ canvas = null;
+ }
+ }
+ __name(destroy, "destroy");
+ function initialize() {
+ canvas = window.document.createElement("canvas");
+ canvas.style.cssText = "\n xx-background-color: red;\n xx-opacity: 0.5;\n bottom: 0;\n left: 0;\n pointer-events: none;\n position: fixed;\n right: 0;\n top: 0;\n z-index: 1000000000;\n ";
+ var root = window.document.documentElement;
+ root.insertBefore(canvas, root.firstChild);
+ }
+ __name(initialize, "initialize");
+ function _typeof7(obj) {
+ "@babel/helpers - typeof";
+ if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+ _typeof7 = /* @__PURE__ */ __name(function _typeof8(obj2) {
+ return typeof obj2;
+ }, "_typeof");
+ } else {
+ _typeof7 = /* @__PURE__ */ __name(function _typeof8(obj2) {
+ return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+ }, "_typeof");
+ }
+ return _typeof7(obj);
+ }
+ __name(_typeof7, "_typeof");
+ var DISPLAY_DURATION = 250;
+ var MAX_DISPLAY_DURATION = 3e3;
+ var REMEASUREMENT_AFTER_DURATION = 250;
+ var getCurrentTime = (typeof performance === "undefined" ? "undefined" : _typeof7(performance)) === "object" && typeof performance.now === "function" ? function() {
+ return performance.now();
+ } : function() {
+ return Date.now();
+ };
+ var nodeToData = /* @__PURE__ */ new Map();
+ var TraceUpdates_agent = null;
+ var drawAnimationFrameID = null;
+ var isEnabled = false;
+ var redrawTimeoutID = null;
+ function TraceUpdates_initialize(injectedAgent) {
+ TraceUpdates_agent = injectedAgent;
+ TraceUpdates_agent.addListener("traceUpdates", traceUpdates);
+ }
+ __name(TraceUpdates_initialize, "TraceUpdates_initialize");
+ function toggleEnabled(value) {
+ isEnabled = value;
+ if (!isEnabled) {
+ nodeToData.clear();
+ if (drawAnimationFrameID !== null) {
+ cancelAnimationFrame(drawAnimationFrameID);
+ drawAnimationFrameID = null;
+ }
+ if (redrawTimeoutID !== null) {
+ clearTimeout(redrawTimeoutID);
+ redrawTimeoutID = null;
+ }
+ destroy();
+ }
+ }
+ __name(toggleEnabled, "toggleEnabled");
+ function traceUpdates(nodes) {
+ if (!isEnabled) {
+ return;
+ }
+ nodes.forEach(function(node) {
+ var data = nodeToData.get(node);
+ var now = getCurrentTime();
+ var lastMeasuredAt = data != null ? data.lastMeasuredAt : 0;
+ var rect = data != null ? data.rect : null;
+ if (rect === null || lastMeasuredAt + REMEASUREMENT_AFTER_DURATION < now) {
+ lastMeasuredAt = now;
+ rect = measureNode(node);
+ }
+ nodeToData.set(node, {
+ count: data != null ? data.count + 1 : 1,
+ expirationTime: data != null ? Math.min(now + MAX_DISPLAY_DURATION, data.expirationTime + DISPLAY_DURATION) : now + DISPLAY_DURATION,
+ lastMeasuredAt,
+ rect
+ });
+ });
+ if (redrawTimeoutID !== null) {
+ clearTimeout(redrawTimeoutID);
+ redrawTimeoutID = null;
+ }
+ if (drawAnimationFrameID === null) {
+ drawAnimationFrameID = requestAnimationFrame(prepareToDraw);
+ }
+ }
+ __name(traceUpdates, "traceUpdates");
+ function prepareToDraw() {
+ drawAnimationFrameID = null;
+ redrawTimeoutID = null;
+ var now = getCurrentTime();
+ var earliestExpiration = Number.MAX_VALUE;
+ nodeToData.forEach(function(data, node) {
+ if (data.expirationTime < now) {
+ nodeToData.delete(node);
+ } else {
+ earliestExpiration = Math.min(earliestExpiration, data.expirationTime);
+ }
+ });
+ draw(nodeToData);
+ if (earliestExpiration !== Number.MAX_VALUE) {
+ redrawTimeoutID = setTimeout(prepareToDraw, earliestExpiration - now);
+ }
+ }
+ __name(prepareToDraw, "prepareToDraw");
+ function measureNode(node) {
+ if (!node || typeof node.getBoundingClientRect !== "function") {
+ return null;
+ }
+ var currentWindow = window.__REACT_DEVTOOLS_TARGET_WINDOW__ || window;
+ return getNestedBoundingClientRect(node, currentWindow);
+ }
+ __name(measureNode, "measureNode");
+ var backend_console = __webpack_require__(10);
+ function bridge_typeof(obj) {
+ "@babel/helpers - typeof";
+ if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+ bridge_typeof = /* @__PURE__ */ __name(function _typeof8(obj2) {
+ return typeof obj2;
+ }, "_typeof");
+ } else {
+ bridge_typeof = /* @__PURE__ */ __name(function _typeof8(obj2) {
+ return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+ }, "_typeof");
+ }
+ return bridge_typeof(obj);
+ }
+ __name(bridge_typeof, "bridge_typeof");
+ function _toConsumableArray(arr) {
+ return _arrayWithoutHoles(arr) || _iterableToArray(arr) || bridge_unsupportedIterableToArray(arr) || _nonIterableSpread();
+ }
+ __name(_toConsumableArray, "_toConsumableArray");
+ function _nonIterableSpread() {
+ throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+ }
+ __name(_nonIterableSpread, "_nonIterableSpread");
+ function bridge_unsupportedIterableToArray(o, minLen) {
+ if (!o)
+ return;
+ if (typeof o === "string")
+ return bridge_arrayLikeToArray(o, minLen);
+ var n = Object.prototype.toString.call(o).slice(8, -1);
+ if (n === "Object" && o.constructor)
+ n = o.constructor.name;
+ if (n === "Map" || n === "Set")
+ return Array.from(o);
+ if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))
+ return bridge_arrayLikeToArray(o, minLen);
+ }
+ __name(bridge_unsupportedIterableToArray, "bridge_unsupportedIterableToArray");
+ function _iterableToArray(iter) {
+ if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter))
+ return Array.from(iter);
+ }
+ __name(_iterableToArray, "_iterableToArray");
+ function _arrayWithoutHoles(arr) {
+ if (Array.isArray(arr))
+ return bridge_arrayLikeToArray(arr);
+ }
+ __name(_arrayWithoutHoles, "_arrayWithoutHoles");
+ function bridge_arrayLikeToArray(arr, len) {
+ if (len == null || len > arr.length)
+ len = arr.length;
+ for (var i = 0, arr2 = new Array(len); i < len; i++) {
+ arr2[i] = arr[i];
+ }
+ return arr2;
+ }
+ __name(bridge_arrayLikeToArray, "bridge_arrayLikeToArray");
+ function bridge_classCallCheck(instance, Constructor) {
+ if (!(instance instanceof Constructor)) {
+ throw new TypeError("Cannot call a class as a function");
+ }
+ }
+ __name(bridge_classCallCheck, "bridge_classCallCheck");
+ function bridge_defineProperties(target, props) {
+ for (var i = 0; i < props.length; i++) {
+ var descriptor2 = props[i];
+ descriptor2.enumerable = descriptor2.enumerable || false;
+ descriptor2.configurable = true;
+ if ("value" in descriptor2)
+ descriptor2.writable = true;
+ Object.defineProperty(target, descriptor2.key, descriptor2);
+ }
+ }
+ __name(bridge_defineProperties, "bridge_defineProperties");
+ function bridge_createClass(Constructor, protoProps, staticProps) {
+ if (protoProps)
+ bridge_defineProperties(Constructor.prototype, protoProps);
+ if (staticProps)
+ bridge_defineProperties(Constructor, staticProps);
+ return Constructor;
+ }
+ __name(bridge_createClass, "bridge_createClass");
+ function _inherits(subClass, superClass) {
+ if (typeof superClass !== "function" && superClass !== null) {
+ throw new TypeError("Super expression must either be null or a function");
+ }
+ subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } });
+ if (superClass)
+ _setPrototypeOf2(subClass, superClass);
+ }
+ __name(_inherits, "_inherits");
+ function _setPrototypeOf2(o, p) {
+ _setPrototypeOf2 = Object.setPrototypeOf || /* @__PURE__ */ __name(function _setPrototypeOf3(o2, p2) {
+ o2.__proto__ = p2;
+ return o2;
+ }, "_setPrototypeOf");
+ return _setPrototypeOf2(o, p);
+ }
+ __name(_setPrototypeOf2, "_setPrototypeOf");
+ function _createSuper(Derived) {
+ var hasNativeReflectConstruct = _isNativeReflectConstruct();
+ return /* @__PURE__ */ __name(function _createSuperInternal() {
+ var Super = _getPrototypeOf(Derived), result;
+ if (hasNativeReflectConstruct) {
+ var NewTarget = _getPrototypeOf(this).constructor;
+ result = Reflect.construct(Super, arguments, NewTarget);
+ } else {
+ result = Super.apply(this, arguments);
+ }
+ return _possibleConstructorReturn(this, result);
+ }, "_createSuperInternal");
+ }
+ __name(_createSuper, "_createSuper");
+ function _possibleConstructorReturn(self2, call) {
+ if (call && (bridge_typeof(call) === "object" || typeof call === "function")) {
+ return call;
+ }
+ return _assertThisInitialized(self2);
+ }
+ __name(_possibleConstructorReturn, "_possibleConstructorReturn");
+ function _assertThisInitialized(self2) {
+ if (self2 === void 0) {
+ throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+ }
+ return self2;
+ }
+ __name(_assertThisInitialized, "_assertThisInitialized");
+ function _isNativeReflectConstruct() {
+ if (typeof Reflect === "undefined" || !Reflect.construct)
+ return false;
+ if (Reflect.construct.sham)
+ return false;
+ if (typeof Proxy === "function")
+ return true;
+ try {
+ Date.prototype.toString.call(Reflect.construct(Date, [], function() {
+ }));
+ return true;
+ } catch (e2) {
+ return false;
+ }
+ }
+ __name(_isNativeReflectConstruct, "_isNativeReflectConstruct");
+ function _getPrototypeOf(o) {
+ _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : /* @__PURE__ */ __name(function _getPrototypeOf2(o2) {
+ return o2.__proto__ || Object.getPrototypeOf(o2);
+ }, "_getPrototypeOf");
+ return _getPrototypeOf(o);
+ }
+ __name(_getPrototypeOf, "_getPrototypeOf");
+ function bridge_defineProperty(obj, key, value) {
+ if (key in obj) {
+ Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
+ } else {
+ obj[key] = value;
+ }
+ return obj;
+ }
+ __name(bridge_defineProperty, "bridge_defineProperty");
+ var BATCH_DURATION = 100;
+ var BRIDGE_PROTOCOL = [
+ // This version technically never existed,
+ // but a backwards breaking change was added in 4.11,
+ // so the safest guess to downgrade the frontend would be to version 4.10.
+ {
+ version: 0,
+ minNpmVersion: '"<4.11.0"',
+ maxNpmVersion: '"<4.11.0"'
+ },
+ {
+ version: 1,
+ minNpmVersion: "4.13.0",
+ maxNpmVersion: "4.21.0"
+ },
+ // Version 2 adds a StrictMode-enabled and supports-StrictMode bits to add-root operation.
+ {
+ version: 2,
+ minNpmVersion: "4.22.0",
+ maxNpmVersion: null
+ }
+ ];
+ var currentBridgeProtocol = BRIDGE_PROTOCOL[BRIDGE_PROTOCOL.length - 1];
+ var Bridge = /* @__PURE__ */ function(_EventEmitter) {
+ _inherits(Bridge2, _EventEmitter);
+ var _super = _createSuper(Bridge2);
+ function Bridge2(wall) {
+ var _this;
+ bridge_classCallCheck(this, Bridge2);
+ _this = _super.call(this);
+ bridge_defineProperty(_assertThisInitialized(_this), "_isShutdown", false);
+ bridge_defineProperty(_assertThisInitialized(_this), "_messageQueue", []);
+ bridge_defineProperty(_assertThisInitialized(_this), "_timeoutID", null);
+ bridge_defineProperty(_assertThisInitialized(_this), "_wallUnlisten", null);
+ bridge_defineProperty(_assertThisInitialized(_this), "_flush", function() {
+ if (_this._timeoutID !== null) {
+ clearTimeout(_this._timeoutID);
+ _this._timeoutID = null;
+ }
+ if (_this._messageQueue.length) {
+ for (var i = 0; i < _this._messageQueue.length; i += 2) {
+ var _this$_wall;
+ (_this$_wall = _this._wall).send.apply(_this$_wall, [_this._messageQueue[i]].concat(_toConsumableArray(_this._messageQueue[i + 1])));
+ }
+ _this._messageQueue.length = 0;
+ _this._timeoutID = setTimeout(_this._flush, BATCH_DURATION);
+ }
+ });
+ bridge_defineProperty(_assertThisInitialized(_this), "overrideValueAtPath", function(_ref) {
+ var id = _ref.id, path45 = _ref.path, rendererID = _ref.rendererID, type = _ref.type, value = _ref.value;
+ switch (type) {
+ case "context":
+ _this.send("overrideContext", {
+ id,
+ path: path45,
+ rendererID,
+ wasForwarded: true,
+ value
+ });
+ break;
+ case "hooks":
+ _this.send("overrideHookState", {
+ id,
+ path: path45,
+ rendererID,
+ wasForwarded: true,
+ value
+ });
+ break;
+ case "props":
+ _this.send("overrideProps", {
+ id,
+ path: path45,
+ rendererID,
+ wasForwarded: true,
+ value
+ });
+ break;
+ case "state":
+ _this.send("overrideState", {
+ id,
+ path: path45,
+ rendererID,
+ wasForwarded: true,
+ value
+ });
+ break;
+ }
+ });
+ _this._wall = wall;
+ _this._wallUnlisten = wall.listen(function(message) {
+ if (message && message.event) {
+ _assertThisInitialized(_this).emit(message.event, message.payload);
+ }
+ }) || null;
+ _this.addListener("overrideValueAtPath", _this.overrideValueAtPath);
+ return _this;
+ }
+ __name(Bridge2, "Bridge");
+ bridge_createClass(Bridge2, [{
+ key: "send",
+ value: /* @__PURE__ */ __name(function send(event) {
+ if (this._isShutdown) {
+ console.warn('Cannot send message "'.concat(event, '" through a Bridge that has been shutdown.'));
+ return;
+ }
+ for (var _len = arguments.length, payload = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+ payload[_key - 1] = arguments[_key];
+ }
+ this._messageQueue.push(event, payload);
+ if (!this._timeoutID) {
+ this._timeoutID = setTimeout(this._flush, 0);
+ }
+ }, "send")
+ }, {
+ key: "shutdown",
+ value: /* @__PURE__ */ __name(function shutdown() {
+ if (this._isShutdown) {
+ console.warn("Bridge was already shutdown.");
+ return;
+ }
+ this.send("shutdown");
+ this._isShutdown = true;
+ this.addListener = function() {
+ };
+ this.emit = function() {
+ };
+ this.removeAllListeners();
+ var wallUnlisten = this._wallUnlisten;
+ if (wallUnlisten) {
+ wallUnlisten();
+ }
+ do {
+ this._flush();
+ } while (this._messageQueue.length);
+ if (this._timeoutID !== null) {
+ clearTimeout(this._timeoutID);
+ this._timeoutID = null;
+ }
+ }, "shutdown")
+ }, {
+ key: "wall",
+ get: /* @__PURE__ */ __name(function get() {
+ return this._wall;
+ }, "get")
+ }]);
+ return Bridge2;
+ }(EventEmitter3);
+ var src_bridge = Bridge;
+ var utils = __webpack_require__(4);
+ function agent_typeof(obj) {
+ "@babel/helpers - typeof";
+ if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+ agent_typeof = /* @__PURE__ */ __name(function _typeof8(obj2) {
+ return typeof obj2;
+ }, "_typeof");
+ } else {
+ agent_typeof = /* @__PURE__ */ __name(function _typeof8(obj2) {
+ return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+ }, "_typeof");
+ }
+ return agent_typeof(obj);
+ }
+ __name(agent_typeof, "agent_typeof");
+ function agent_classCallCheck(instance, Constructor) {
+ if (!(instance instanceof Constructor)) {
+ throw new TypeError("Cannot call a class as a function");
+ }
+ }
+ __name(agent_classCallCheck, "agent_classCallCheck");
+ function agent_defineProperties(target, props) {
+ for (var i = 0; i < props.length; i++) {
+ var descriptor2 = props[i];
+ descriptor2.enumerable = descriptor2.enumerable || false;
+ descriptor2.configurable = true;
+ if ("value" in descriptor2)
+ descriptor2.writable = true;
+ Object.defineProperty(target, descriptor2.key, descriptor2);
+ }
+ }
+ __name(agent_defineProperties, "agent_defineProperties");
+ function agent_createClass(Constructor, protoProps, staticProps) {
+ if (protoProps)
+ agent_defineProperties(Constructor.prototype, protoProps);
+ if (staticProps)
+ agent_defineProperties(Constructor, staticProps);
+ return Constructor;
+ }
+ __name(agent_createClass, "agent_createClass");
+ function agent_inherits(subClass, superClass) {
+ if (typeof superClass !== "function" && superClass !== null) {
+ throw new TypeError("Super expression must either be null or a function");
+ }
+ subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } });
+ if (superClass)
+ agent_setPrototypeOf(subClass, superClass);
+ }
+ __name(agent_inherits, "agent_inherits");
+ function agent_setPrototypeOf(o, p) {
+ agent_setPrototypeOf = Object.setPrototypeOf || /* @__PURE__ */ __name(function _setPrototypeOf3(o2, p2) {
+ o2.__proto__ = p2;
+ return o2;
+ }, "_setPrototypeOf");
+ return agent_setPrototypeOf(o, p);
+ }
+ __name(agent_setPrototypeOf, "agent_setPrototypeOf");
+ function agent_createSuper(Derived) {
+ var hasNativeReflectConstruct = agent_isNativeReflectConstruct();
+ return /* @__PURE__ */ __name(function _createSuperInternal() {
+ var Super = agent_getPrototypeOf(Derived), result;
+ if (hasNativeReflectConstruct) {
+ var NewTarget = agent_getPrototypeOf(this).constructor;
+ result = Reflect.construct(Super, arguments, NewTarget);
+ } else {
+ result = Super.apply(this, arguments);
+ }
+ return agent_possibleConstructorReturn(this, result);
+ }, "_createSuperInternal");
+ }
+ __name(agent_createSuper, "agent_createSuper");
+ function agent_possibleConstructorReturn(self2, call) {
+ if (call && (agent_typeof(call) === "object" || typeof call === "function")) {
+ return call;
+ }
+ return agent_assertThisInitialized(self2);
+ }
+ __name(agent_possibleConstructorReturn, "agent_possibleConstructorReturn");
+ function agent_assertThisInitialized(self2) {
+ if (self2 === void 0) {
+ throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+ }
+ return self2;
+ }
+ __name(agent_assertThisInitialized, "agent_assertThisInitialized");
+ function agent_isNativeReflectConstruct() {
+ if (typeof Reflect === "undefined" || !Reflect.construct)
+ return false;
+ if (Reflect.construct.sham)
+ return false;
+ if (typeof Proxy === "function")
+ return true;
+ try {
+ Date.prototype.toString.call(Reflect.construct(Date, [], function() {
+ }));
+ return true;
+ } catch (e2) {
+ return false;
+ }
+ }
+ __name(agent_isNativeReflectConstruct, "agent_isNativeReflectConstruct");
+ function agent_getPrototypeOf(o) {
+ agent_getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : /* @__PURE__ */ __name(function _getPrototypeOf2(o2) {
+ return o2.__proto__ || Object.getPrototypeOf(o2);
+ }, "_getPrototypeOf");
+ return agent_getPrototypeOf(o);
+ }
+ __name(agent_getPrototypeOf, "agent_getPrototypeOf");
+ function agent_defineProperty(obj, key, value) {
+ if (key in obj) {
+ Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
+ } else {
+ obj[key] = value;
+ }
+ return obj;
+ }
+ __name(agent_defineProperty, "agent_defineProperty");
+ var agent_debug = /* @__PURE__ */ __name(function debug(methodName) {
+ if (constants3[
+ "q"
+ /* __DEBUG__ */
+ ]) {
+ var _console;
+ for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+ args[_key - 1] = arguments[_key];
+ }
+ (_console = console).log.apply(_console, ["%cAgent %c".concat(methodName), "color: purple; font-weight: bold;", "font-weight: bold;"].concat(args));
+ }
+ }, "debug");
+ var agent_Agent = /* @__PURE__ */ function(_EventEmitter) {
+ agent_inherits(Agent, _EventEmitter);
+ var _super = agent_createSuper(Agent);
+ function Agent(bridge) {
+ var _this;
+ agent_classCallCheck(this, Agent);
+ _this = _super.call(this);
+ agent_defineProperty(agent_assertThisInitialized(_this), "_isProfiling", false);
+ agent_defineProperty(agent_assertThisInitialized(_this), "_recordChangeDescriptions", false);
+ agent_defineProperty(agent_assertThisInitialized(_this), "_rendererInterfaces", {});
+ agent_defineProperty(agent_assertThisInitialized(_this), "_persistedSelection", null);
+ agent_defineProperty(agent_assertThisInitialized(_this), "_persistedSelectionMatch", null);
+ agent_defineProperty(agent_assertThisInitialized(_this), "_traceUpdatesEnabled", false);
+ agent_defineProperty(agent_assertThisInitialized(_this), "clearErrorsAndWarnings", function(_ref) {
+ var rendererID = _ref.rendererID;
+ var renderer = _this._rendererInterfaces[rendererID];
+ if (renderer == null) {
+ console.warn('Invalid renderer id "'.concat(rendererID, '"'));
+ } else {
+ renderer.clearErrorsAndWarnings();
+ }
+ });
+ agent_defineProperty(agent_assertThisInitialized(_this), "clearErrorsForFiberID", function(_ref2) {
+ var id = _ref2.id, rendererID = _ref2.rendererID;
+ var renderer = _this._rendererInterfaces[rendererID];
+ if (renderer == null) {
+ console.warn('Invalid renderer id "'.concat(rendererID, '"'));
+ } else {
+ renderer.clearErrorsForFiberID(id);
+ }
+ });
+ agent_defineProperty(agent_assertThisInitialized(_this), "clearWarningsForFiberID", function(_ref3) {
+ var id = _ref3.id, rendererID = _ref3.rendererID;
+ var renderer = _this._rendererInterfaces[rendererID];
+ if (renderer == null) {
+ console.warn('Invalid renderer id "'.concat(rendererID, '"'));
+ } else {
+ renderer.clearWarningsForFiberID(id);
+ }
+ });
+ agent_defineProperty(agent_assertThisInitialized(_this), "copyElementPath", function(_ref4) {
+ var id = _ref4.id, path45 = _ref4.path, rendererID = _ref4.rendererID;
+ var renderer = _this._rendererInterfaces[rendererID];
+ if (renderer == null) {
+ console.warn('Invalid renderer id "'.concat(rendererID, '" for element "').concat(id, '"'));
+ } else {
+ renderer.copyElementPath(id, path45);
+ }
+ });
+ agent_defineProperty(agent_assertThisInitialized(_this), "deletePath", function(_ref5) {
+ var hookID = _ref5.hookID, id = _ref5.id, path45 = _ref5.path, rendererID = _ref5.rendererID, type = _ref5.type;
+ var renderer = _this._rendererInterfaces[rendererID];
+ if (renderer == null) {
+ console.warn('Invalid renderer id "'.concat(rendererID, '" for element "').concat(id, '"'));
+ } else {
+ renderer.deletePath(type, id, hookID, path45);
+ }
+ });
+ agent_defineProperty(agent_assertThisInitialized(_this), "getBridgeProtocol", function() {
+ _this._bridge.send("bridgeProtocol", currentBridgeProtocol);
+ });
+ agent_defineProperty(agent_assertThisInitialized(_this), "getProfilingData", function(_ref6) {
+ var rendererID = _ref6.rendererID;
+ var renderer = _this._rendererInterfaces[rendererID];
+ if (renderer == null) {
+ console.warn('Invalid renderer id "'.concat(rendererID, '"'));
+ }
+ _this._bridge.send("profilingData", renderer.getProfilingData());
+ });
+ agent_defineProperty(agent_assertThisInitialized(_this), "getProfilingStatus", function() {
+ _this._bridge.send("profilingStatus", _this._isProfiling);
+ });
+ agent_defineProperty(agent_assertThisInitialized(_this), "getOwnersList", function(_ref7) {
+ var id = _ref7.id, rendererID = _ref7.rendererID;
+ var renderer = _this._rendererInterfaces[rendererID];
+ if (renderer == null) {
+ console.warn('Invalid renderer id "'.concat(rendererID, '" for element "').concat(id, '"'));
+ } else {
+ var owners = renderer.getOwnersList(id);
+ _this._bridge.send("ownersList", {
+ id,
+ owners
+ });
+ }
+ });
+ agent_defineProperty(agent_assertThisInitialized(_this), "inspectElement", function(_ref8) {
+ var forceFullData = _ref8.forceFullData, id = _ref8.id, path45 = _ref8.path, rendererID = _ref8.rendererID, requestID = _ref8.requestID;
+ var renderer = _this._rendererInterfaces[rendererID];
+ if (renderer == null) {
+ console.warn('Invalid renderer id "'.concat(rendererID, '" for element "').concat(id, '"'));
+ } else {
+ _this._bridge.send("inspectedElement", renderer.inspectElement(requestID, id, path45, forceFullData));
+ if (_this._persistedSelectionMatch === null || _this._persistedSelectionMatch.id !== id) {
+ _this._persistedSelection = null;
+ _this._persistedSelectionMatch = null;
+ renderer.setTrackedPath(null);
+ _this._throttledPersistSelection(rendererID, id);
+ }
+ }
+ });
+ agent_defineProperty(agent_assertThisInitialized(_this), "logElementToConsole", function(_ref9) {
+ var id = _ref9.id, rendererID = _ref9.rendererID;
+ var renderer = _this._rendererInterfaces[rendererID];
+ if (renderer == null) {
+ console.warn('Invalid renderer id "'.concat(rendererID, '" for element "').concat(id, '"'));
+ } else {
+ renderer.logElementToConsole(id);
+ }
+ });
+ agent_defineProperty(agent_assertThisInitialized(_this), "overrideError", function(_ref10) {
+ var id = _ref10.id, rendererID = _ref10.rendererID, forceError = _ref10.forceError;
+ var renderer = _this._rendererInterfaces[rendererID];
+ if (renderer == null) {
+ console.warn('Invalid renderer id "'.concat(rendererID, '" for element "').concat(id, '"'));
+ } else {
+ renderer.overrideError(id, forceError);
+ }
+ });
+ agent_defineProperty(agent_assertThisInitialized(_this), "overrideSuspense", function(_ref11) {
+ var id = _ref11.id, rendererID = _ref11.rendererID, forceFallback = _ref11.forceFallback;
+ var renderer = _this._rendererInterfaces[rendererID];
+ if (renderer == null) {
+ console.warn('Invalid renderer id "'.concat(rendererID, '" for element "').concat(id, '"'));
+ } else {
+ renderer.overrideSuspense(id, forceFallback);
+ }
+ });
+ agent_defineProperty(agent_assertThisInitialized(_this), "overrideValueAtPath", function(_ref12) {
+ var hookID = _ref12.hookID, id = _ref12.id, path45 = _ref12.path, rendererID = _ref12.rendererID, type = _ref12.type, value = _ref12.value;
+ var renderer = _this._rendererInterfaces[rendererID];
+ if (renderer == null) {
+ console.warn('Invalid renderer id "'.concat(rendererID, '" for element "').concat(id, '"'));
+ } else {
+ renderer.overrideValueAtPath(type, id, hookID, path45, value);
+ }
+ });
+ agent_defineProperty(agent_assertThisInitialized(_this), "overrideContext", function(_ref13) {
+ var id = _ref13.id, path45 = _ref13.path, rendererID = _ref13.rendererID, wasForwarded = _ref13.wasForwarded, value = _ref13.value;
+ if (!wasForwarded) {
+ _this.overrideValueAtPath({
+ id,
+ path: path45,
+ rendererID,
+ type: "context",
+ value
+ });
+ }
+ });
+ agent_defineProperty(agent_assertThisInitialized(_this), "overrideHookState", function(_ref14) {
+ var id = _ref14.id, hookID = _ref14.hookID, path45 = _ref14.path, rendererID = _ref14.rendererID, wasForwarded = _ref14.wasForwarded, value = _ref14.value;
+ if (!wasForwarded) {
+ _this.overrideValueAtPath({
+ id,
+ path: path45,
+ rendererID,
+ type: "hooks",
+ value
+ });
+ }
+ });
+ agent_defineProperty(agent_assertThisInitialized(_this), "overrideProps", function(_ref15) {
+ var id = _ref15.id, path45 = _ref15.path, rendererID = _ref15.rendererID, wasForwarded = _ref15.wasForwarded, value = _ref15.value;
+ if (!wasForwarded) {
+ _this.overrideValueAtPath({
+ id,
+ path: path45,
+ rendererID,
+ type: "props",
+ value
+ });
+ }
+ });
+ agent_defineProperty(agent_assertThisInitialized(_this), "overrideState", function(_ref16) {
+ var id = _ref16.id, path45 = _ref16.path, rendererID = _ref16.rendererID, wasForwarded = _ref16.wasForwarded, value = _ref16.value;
+ if (!wasForwarded) {
+ _this.overrideValueAtPath({
+ id,
+ path: path45,
+ rendererID,
+ type: "state",
+ value
+ });
+ }
+ });
+ agent_defineProperty(agent_assertThisInitialized(_this), "reloadAndProfile", function(recordChangeDescriptions) {
+ Object(storage[
+ "e"
+ /* sessionStorageSetItem */
+ ])(constants3[
+ "i"
+ /* SESSION_STORAGE_RELOAD_AND_PROFILE_KEY */
+ ], "true");
+ Object(storage[
+ "e"
+ /* sessionStorageSetItem */
+ ])(constants3[
+ "h"
+ /* SESSION_STORAGE_RECORD_CHANGE_DESCRIPTIONS_KEY */
+ ], recordChangeDescriptions ? "true" : "false");
+ _this._bridge.send("reloadAppForProfiling");
+ });
+ agent_defineProperty(agent_assertThisInitialized(_this), "renamePath", function(_ref17) {
+ var hookID = _ref17.hookID, id = _ref17.id, newPath = _ref17.newPath, oldPath = _ref17.oldPath, rendererID = _ref17.rendererID, type = _ref17.type;
+ var renderer = _this._rendererInterfaces[rendererID];
+ if (renderer == null) {
+ console.warn('Invalid renderer id "'.concat(rendererID, '" for element "').concat(id, '"'));
+ } else {
+ renderer.renamePath(type, id, hookID, oldPath, newPath);
+ }
+ });
+ agent_defineProperty(agent_assertThisInitialized(_this), "setTraceUpdatesEnabled", function(traceUpdatesEnabled) {
+ _this._traceUpdatesEnabled = traceUpdatesEnabled;
+ toggleEnabled(traceUpdatesEnabled);
+ for (var rendererID in _this._rendererInterfaces) {
+ var renderer = _this._rendererInterfaces[rendererID];
+ renderer.setTraceUpdatesEnabled(traceUpdatesEnabled);
+ }
+ });
+ agent_defineProperty(agent_assertThisInitialized(_this), "syncSelectionFromNativeElementsPanel", function() {
+ var target = window.__REACT_DEVTOOLS_GLOBAL_HOOK__.$0;
+ if (target == null) {
+ return;
+ }
+ _this.selectNode(target);
+ });
+ agent_defineProperty(agent_assertThisInitialized(_this), "shutdown", function() {
+ _this.emit("shutdown");
+ });
+ agent_defineProperty(agent_assertThisInitialized(_this), "startProfiling", function(recordChangeDescriptions) {
+ _this._recordChangeDescriptions = recordChangeDescriptions;
+ _this._isProfiling = true;
+ for (var rendererID in _this._rendererInterfaces) {
+ var renderer = _this._rendererInterfaces[rendererID];
+ renderer.startProfiling(recordChangeDescriptions);
+ }
+ _this._bridge.send("profilingStatus", _this._isProfiling);
+ });
+ agent_defineProperty(agent_assertThisInitialized(_this), "stopProfiling", function() {
+ _this._isProfiling = false;
+ _this._recordChangeDescriptions = false;
+ for (var rendererID in _this._rendererInterfaces) {
+ var renderer = _this._rendererInterfaces[rendererID];
+ renderer.stopProfiling();
+ }
+ _this._bridge.send("profilingStatus", _this._isProfiling);
+ });
+ agent_defineProperty(agent_assertThisInitialized(_this), "storeAsGlobal", function(_ref18) {
+ var count = _ref18.count, id = _ref18.id, path45 = _ref18.path, rendererID = _ref18.rendererID;
+ var renderer = _this._rendererInterfaces[rendererID];
+ if (renderer == null) {
+ console.warn('Invalid renderer id "'.concat(rendererID, '" for element "').concat(id, '"'));
+ } else {
+ renderer.storeAsGlobal(id, path45, count);
+ }
+ });
+ agent_defineProperty(agent_assertThisInitialized(_this), "updateConsolePatchSettings", function(_ref19) {
+ var appendComponentStack = _ref19.appendComponentStack, breakOnConsoleErrors = _ref19.breakOnConsoleErrors, showInlineWarningsAndErrors = _ref19.showInlineWarningsAndErrors, hideConsoleLogsInStrictMode = _ref19.hideConsoleLogsInStrictMode, browserTheme = _ref19.browserTheme;
+ Object(backend_console[
+ "a"
+ /* patch */
+ ])({
+ appendComponentStack,
+ breakOnConsoleErrors,
+ showInlineWarningsAndErrors,
+ hideConsoleLogsInStrictMode,
+ browserTheme
+ });
+ });
+ agent_defineProperty(agent_assertThisInitialized(_this), "updateComponentFilters", function(componentFilters) {
+ for (var rendererID in _this._rendererInterfaces) {
+ var renderer = _this._rendererInterfaces[rendererID];
+ renderer.updateComponentFilters(componentFilters);
+ }
+ });
+ agent_defineProperty(agent_assertThisInitialized(_this), "viewAttributeSource", function(_ref20) {
+ var id = _ref20.id, path45 = _ref20.path, rendererID = _ref20.rendererID;
+ var renderer = _this._rendererInterfaces[rendererID];
+ if (renderer == null) {
+ console.warn('Invalid renderer id "'.concat(rendererID, '" for element "').concat(id, '"'));
+ } else {
+ renderer.prepareViewAttributeSource(id, path45);
+ }
+ });
+ agent_defineProperty(agent_assertThisInitialized(_this), "viewElementSource", function(_ref21) {
+ var id = _ref21.id, rendererID = _ref21.rendererID;
+ var renderer = _this._rendererInterfaces[rendererID];
+ if (renderer == null) {
+ console.warn('Invalid renderer id "'.concat(rendererID, '" for element "').concat(id, '"'));
+ } else {
+ renderer.prepareViewElementSource(id);
+ }
+ });
+ agent_defineProperty(agent_assertThisInitialized(_this), "onTraceUpdates", function(nodes) {
+ _this.emit("traceUpdates", nodes);
+ });
+ agent_defineProperty(agent_assertThisInitialized(_this), "onFastRefreshScheduled", function() {
+ if (constants3[
+ "q"
+ /* __DEBUG__ */
+ ]) {
+ agent_debug("onFastRefreshScheduled");
+ }
+ _this._bridge.send("fastRefreshScheduled");
+ });
+ agent_defineProperty(agent_assertThisInitialized(_this), "onHookOperations", function(operations) {
+ if (constants3[
+ "q"
+ /* __DEBUG__ */
+ ]) {
+ agent_debug("onHookOperations", "(".concat(operations.length, ") [").concat(operations.join(", "), "]"));
+ }
+ _this._bridge.send("operations", operations);
+ if (_this._persistedSelection !== null) {
+ var rendererID = operations[0];
+ if (_this._persistedSelection.rendererID === rendererID) {
+ var renderer = _this._rendererInterfaces[rendererID];
+ if (renderer == null) {
+ console.warn('Invalid renderer id "'.concat(rendererID, '"'));
+ } else {
+ var prevMatch = _this._persistedSelectionMatch;
+ var nextMatch = renderer.getBestMatchForTrackedPath();
+ _this._persistedSelectionMatch = nextMatch;
+ var prevMatchID = prevMatch !== null ? prevMatch.id : null;
+ var nextMatchID = nextMatch !== null ? nextMatch.id : null;
+ if (prevMatchID !== nextMatchID) {
+ if (nextMatchID !== null) {
+ _this._bridge.send("selectFiber", nextMatchID);
+ }
+ }
+ if (nextMatch !== null && nextMatch.isFullMatch) {
+ _this._persistedSelection = null;
+ _this._persistedSelectionMatch = null;
+ renderer.setTrackedPath(null);
+ }
+ }
+ }
+ }
+ });
+ agent_defineProperty(agent_assertThisInitialized(_this), "_throttledPersistSelection", lodash_throttle_default()(function(rendererID, id) {
+ var renderer = _this._rendererInterfaces[rendererID];
+ var path45 = renderer != null ? renderer.getPathForElement(id) : null;
+ if (path45 !== null) {
+ Object(storage[
+ "e"
+ /* sessionStorageSetItem */
+ ])(constants3[
+ "g"
+ /* SESSION_STORAGE_LAST_SELECTION_KEY */
+ ], JSON.stringify({
+ rendererID,
+ path: path45
+ }));
+ } else {
+ Object(storage[
+ "d"
+ /* sessionStorageRemoveItem */
+ ])(constants3[
+ "g"
+ /* SESSION_STORAGE_LAST_SELECTION_KEY */
+ ]);
+ }
+ }, 1e3));
+ if (Object(storage[
+ "c"
+ /* sessionStorageGetItem */
+ ])(constants3[
+ "i"
+ /* SESSION_STORAGE_RELOAD_AND_PROFILE_KEY */
+ ]) === "true") {
+ _this._recordChangeDescriptions = Object(storage[
+ "c"
+ /* sessionStorageGetItem */
+ ])(constants3[
+ "h"
+ /* SESSION_STORAGE_RECORD_CHANGE_DESCRIPTIONS_KEY */
+ ]) === "true";
+ _this._isProfiling = true;
+ Object(storage[
+ "d"
+ /* sessionStorageRemoveItem */
+ ])(constants3[
+ "h"
+ /* SESSION_STORAGE_RECORD_CHANGE_DESCRIPTIONS_KEY */
+ ]);
+ Object(storage[
+ "d"
+ /* sessionStorageRemoveItem */
+ ])(constants3[
+ "i"
+ /* SESSION_STORAGE_RELOAD_AND_PROFILE_KEY */
+ ]);
+ }
+ var persistedSelectionString = Object(storage[
+ "c"
+ /* sessionStorageGetItem */
+ ])(constants3[
+ "g"
+ /* SESSION_STORAGE_LAST_SELECTION_KEY */
+ ]);
+ if (persistedSelectionString != null) {
+ _this._persistedSelection = JSON.parse(persistedSelectionString);
+ }
+ _this._bridge = bridge;
+ bridge.addListener("clearErrorsAndWarnings", _this.clearErrorsAndWarnings);
+ bridge.addListener("clearErrorsForFiberID", _this.clearErrorsForFiberID);
+ bridge.addListener("clearWarningsForFiberID", _this.clearWarningsForFiberID);
+ bridge.addListener("copyElementPath", _this.copyElementPath);
+ bridge.addListener("deletePath", _this.deletePath);
+ bridge.addListener("getBridgeProtocol", _this.getBridgeProtocol);
+ bridge.addListener("getProfilingData", _this.getProfilingData);
+ bridge.addListener("getProfilingStatus", _this.getProfilingStatus);
+ bridge.addListener("getOwnersList", _this.getOwnersList);
+ bridge.addListener("inspectElement", _this.inspectElement);
+ bridge.addListener("logElementToConsole", _this.logElementToConsole);
+ bridge.addListener("overrideError", _this.overrideError);
+ bridge.addListener("overrideSuspense", _this.overrideSuspense);
+ bridge.addListener("overrideValueAtPath", _this.overrideValueAtPath);
+ bridge.addListener("reloadAndProfile", _this.reloadAndProfile);
+ bridge.addListener("renamePath", _this.renamePath);
+ bridge.addListener("setTraceUpdatesEnabled", _this.setTraceUpdatesEnabled);
+ bridge.addListener("startProfiling", _this.startProfiling);
+ bridge.addListener("stopProfiling", _this.stopProfiling);
+ bridge.addListener("storeAsGlobal", _this.storeAsGlobal);
+ bridge.addListener("syncSelectionFromNativeElementsPanel", _this.syncSelectionFromNativeElementsPanel);
+ bridge.addListener("shutdown", _this.shutdown);
+ bridge.addListener("updateConsolePatchSettings", _this.updateConsolePatchSettings);
+ bridge.addListener("updateComponentFilters", _this.updateComponentFilters);
+ bridge.addListener("viewAttributeSource", _this.viewAttributeSource);
+ bridge.addListener("viewElementSource", _this.viewElementSource);
+ bridge.addListener("overrideContext", _this.overrideContext);
+ bridge.addListener("overrideHookState", _this.overrideHookState);
+ bridge.addListener("overrideProps", _this.overrideProps);
+ bridge.addListener("overrideState", _this.overrideState);
+ if (_this._isProfiling) {
+ bridge.send("profilingStatus", true);
+ }
+ _this._bridge.send("bridgeProtocol", currentBridgeProtocol);
+ var isBackendStorageAPISupported = false;
+ try {
+ localStorage.getItem("test");
+ isBackendStorageAPISupported = true;
+ } catch (error) {
+ }
+ bridge.send("isBackendStorageAPISupported", isBackendStorageAPISupported);
+ bridge.send("isSynchronousXHRSupported", Object(utils[
+ "h"
+ /* isSynchronousXHRSupported */
+ ])());
+ setupHighlighter(bridge, agent_assertThisInitialized(_this));
+ TraceUpdates_initialize(agent_assertThisInitialized(_this));
+ return _this;
+ }
+ __name(Agent, "Agent");
+ agent_createClass(Agent, [{
+ key: "getInstanceAndStyle",
+ value: /* @__PURE__ */ __name(function getInstanceAndStyle(_ref22) {
+ var id = _ref22.id, rendererID = _ref22.rendererID;
+ var renderer = this._rendererInterfaces[rendererID];
+ if (renderer == null) {
+ console.warn('Invalid renderer id "'.concat(rendererID, '"'));
+ return null;
+ }
+ return renderer.getInstanceAndStyle(id);
+ }, "getInstanceAndStyle")
+ }, {
+ key: "getIDForNode",
+ value: /* @__PURE__ */ __name(function getIDForNode(node) {
+ for (var rendererID in this._rendererInterfaces) {
+ var renderer = this._rendererInterfaces[rendererID];
+ try {
+ var id = renderer.getFiberIDForNative(node, true);
+ if (id !== null) {
+ return id;
+ }
+ } catch (error) {
+ }
+ }
+ return null;
+ }, "getIDForNode")
+ }, {
+ key: "selectNode",
+ value: /* @__PURE__ */ __name(function selectNode(target) {
+ var id = this.getIDForNode(target);
+ if (id !== null) {
+ this._bridge.send("selectFiber", id);
+ }
+ }, "selectNode")
+ }, {
+ key: "setRendererInterface",
+ value: /* @__PURE__ */ __name(function setRendererInterface(rendererID, rendererInterface) {
+ this._rendererInterfaces[rendererID] = rendererInterface;
+ if (this._isProfiling) {
+ rendererInterface.startProfiling(this._recordChangeDescriptions);
+ }
+ rendererInterface.setTraceUpdatesEnabled(this._traceUpdatesEnabled);
+ var selection = this._persistedSelection;
+ if (selection !== null && selection.rendererID === rendererID) {
+ rendererInterface.setTrackedPath(selection.path);
+ }
+ }, "setRendererInterface")
+ }, {
+ key: "onUnsupportedRenderer",
+ value: /* @__PURE__ */ __name(function onUnsupportedRenderer(rendererID) {
+ this._bridge.send("unsupportedRendererVersion", rendererID);
+ }, "onUnsupportedRenderer")
+ }, {
+ key: "rendererInterfaces",
+ get: /* @__PURE__ */ __name(function get() {
+ return this._rendererInterfaces;
+ }, "get")
+ }]);
+ return Agent;
+ }(EventEmitter3);
+ function installHook(target) {
+ if (target.hasOwnProperty("__REACT_DEVTOOLS_GLOBAL_HOOK__")) {
+ return null;
+ }
+ var targetConsole = console;
+ var targetConsoleMethods = {};
+ for (var method in console) {
+ targetConsoleMethods[method] = console[method];
+ }
+ function dangerous_setTargetConsoleForTesting(targetConsoleForTesting) {
+ targetConsole = targetConsoleForTesting;
+ targetConsoleMethods = {};
+ for (var _method in targetConsole) {
+ targetConsoleMethods[_method] = console[_method];
+ }
+ }
+ __name(dangerous_setTargetConsoleForTesting, "dangerous_setTargetConsoleForTesting");
+ function detectReactBuildType(renderer) {
+ try {
+ if (typeof renderer.version === "string") {
+ if (renderer.bundleType > 0) {
+ return "development";
+ }
+ return "production";
+ }
+ var _toString = Function.prototype.toString;
+ if (renderer.Mount && renderer.Mount._renderNewRootComponent) {
+ var renderRootCode = _toString.call(renderer.Mount._renderNewRootComponent);
+ if (renderRootCode.indexOf("function") !== 0) {
+ return "production";
+ }
+ if (renderRootCode.indexOf("storedMeasure") !== -1) {
+ return "development";
+ }
+ if (renderRootCode.indexOf("should be a pure function") !== -1) {
+ if (renderRootCode.indexOf("NODE_ENV") !== -1) {
+ return "development";
+ }
+ if (renderRootCode.indexOf("development") !== -1) {
+ return "development";
+ }
+ if (renderRootCode.indexOf("true") !== -1) {
+ return "development";
+ }
+ if (
+ // 0.13 to 15
+ renderRootCode.indexOf("nextElement") !== -1 || // 0.12
+ renderRootCode.indexOf("nextComponent") !== -1
+ ) {
+ return "unminified";
+ } else {
+ return "development";
+ }
+ }
+ if (
+ // 0.13 to 15
+ renderRootCode.indexOf("nextElement") !== -1 || // 0.12
+ renderRootCode.indexOf("nextComponent") !== -1
+ ) {
+ return "unminified";
+ }
+ return "outdated";
+ }
+ } catch (err) {
+ }
+ return "production";
+ }
+ __name(detectReactBuildType, "detectReactBuildType");
+ function checkDCE(fn2) {
+ try {
+ var _toString2 = Function.prototype.toString;
+ var code = _toString2.call(fn2);
+ if (code.indexOf("^_^") > -1) {
+ hasDetectedBadDCE = true;
+ setTimeout(function() {
+ throw new Error("React is running in production mode, but dead code elimination has not been applied. Read how to correctly configure React for production: https://reactjs.org/link/perf-use-production-build");
+ });
+ }
+ } catch (err) {
+ }
+ }
+ __name(checkDCE, "checkDCE");
+ function format8(maybeMessage) {
+ for (var _len = arguments.length, inputArgs = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+ inputArgs[_key - 1] = arguments[_key];
+ }
+ var args = inputArgs.slice();
+ var formatted = String(maybeMessage);
+ if (typeof maybeMessage === "string") {
+ if (args.length) {
+ var REGEXP = /(%?)(%([jds]))/g;
+ formatted = formatted.replace(REGEXP, function(match, escaped, ptn, flag) {
+ var arg = args.shift();
+ switch (flag) {
+ case "s":
+ arg += "";
+ break;
+ case "d":
+ case "i":
+ arg = parseInt(arg, 10).toString();
+ break;
+ case "f":
+ arg = parseFloat(arg).toString();
+ break;
+ }
+ if (!escaped) {
+ return arg;
+ }
+ args.unshift(arg);
+ return match;
+ });
+ }
+ }
+ if (args.length) {
+ for (var i = 0; i < args.length; i++) {
+ formatted += " " + String(args[i]);
+ }
+ }
+ formatted = formatted.replace(/%{2,2}/g, "%");
+ return String(formatted);
+ }
+ __name(format8, "format");
+ var unpatchFn = null;
+ function patchConsoleForInitialRenderInStrictMode(_ref) {
+ var hideConsoleLogsInStrictMode = _ref.hideConsoleLogsInStrictMode, browserTheme = _ref.browserTheme;
+ var overrideConsoleMethods = ["error", "trace", "warn", "log"];
+ if (unpatchFn !== null) {
+ return;
+ }
+ var originalConsoleMethods = {};
+ unpatchFn = /* @__PURE__ */ __name(function unpatchFn2() {
+ for (var _method2 in originalConsoleMethods) {
+ try {
+ targetConsole[_method2] = originalConsoleMethods[_method2];
+ } catch (error) {
+ }
+ }
+ }, "unpatchFn");
+ overrideConsoleMethods.forEach(function(method2) {
+ try {
+ var originalMethod = originalConsoleMethods[method2] = targetConsole[method2].__REACT_DEVTOOLS_STRICT_MODE_ORIGINAL_METHOD__ ? targetConsole[method2].__REACT_DEVTOOLS_STRICT_MODE_ORIGINAL_METHOD__ : targetConsole[method2];
+ var overrideMethod = /* @__PURE__ */ __name(function overrideMethod2() {
+ if (!hideConsoleLogsInStrictMode) {
+ var color;
+ switch (method2) {
+ case "warn":
+ color = browserTheme === "light" ? "rgba(250, 180, 50, 0.75)" : "rgba(250, 180, 50, 0.5)";
+ break;
+ case "error":
+ color = browserTheme === "light" ? "rgba(250, 123, 130, 0.75)" : "rgba(250, 123, 130, 0.5)";
+ break;
+ case "log":
+ default:
+ color = browserTheme === "light" ? "rgba(125, 125, 125, 0.75)" : "rgba(125, 125, 125, 0.5)";
+ break;
+ }
+ if (color) {
+ originalMethod("%c".concat(format8.apply(void 0, arguments)), "color: ".concat(color));
+ } else {
+ throw Error("Console color is not defined");
+ }
+ }
+ }, "overrideMethod");
+ overrideMethod.__REACT_DEVTOOLS_STRICT_MODE_ORIGINAL_METHOD__ = originalMethod;
+ originalMethod.__REACT_DEVTOOLS_STRICT_MODE_OVERRIDE_METHOD__ = overrideMethod;
+ targetConsole[method2] = overrideMethod;
+ } catch (error) {
+ }
+ });
+ }
+ __name(patchConsoleForInitialRenderInStrictMode, "patchConsoleForInitialRenderInStrictMode");
+ function unpatchConsoleForInitialRenderInStrictMode() {
+ if (unpatchFn !== null) {
+ unpatchFn();
+ unpatchFn = null;
+ }
+ }
+ __name(unpatchConsoleForInitialRenderInStrictMode, "unpatchConsoleForInitialRenderInStrictMode");
+ var uidCounter = 0;
+ function inject(renderer) {
+ var id = ++uidCounter;
+ renderers.set(id, renderer);
+ var reactBuildType = hasDetectedBadDCE ? "deadcode" : detectReactBuildType(renderer);
+ if (true) {
+ try {
+ var appendComponentStack = window.__REACT_DEVTOOLS_APPEND_COMPONENT_STACK__ !== false;
+ var breakOnConsoleErrors = window.__REACT_DEVTOOLS_BREAK_ON_CONSOLE_ERRORS__ === true;
+ var showInlineWarningsAndErrors = window.__REACT_DEVTOOLS_SHOW_INLINE_WARNINGS_AND_ERRORS__ !== false;
+ var hideConsoleLogsInStrictMode = window.__REACT_DEVTOOLS_HIDE_CONSOLE_LOGS_IN_STRICT_MODE__ === true;
+ var browserTheme = window.__REACT_DEVTOOLS_BROWSER_THEME__;
+ Object(backend_console[
+ "c"
+ /* registerRenderer */
+ ])(renderer);
+ Object(backend_console[
+ "a"
+ /* patch */
+ ])({
+ appendComponentStack,
+ breakOnConsoleErrors,
+ showInlineWarningsAndErrors,
+ hideConsoleLogsInStrictMode,
+ browserTheme
+ });
+ } catch (error) {
+ }
+ }
+ var attach = target.__REACT_DEVTOOLS_ATTACH__;
+ if (typeof attach === "function") {
+ var rendererInterface = attach(hook, id, renderer, target);
+ hook.rendererInterfaces.set(id, rendererInterface);
+ }
+ hook.emit("renderer", {
+ id,
+ renderer,
+ reactBuildType
+ });
+ return id;
+ }
+ __name(inject, "inject");
+ var hasDetectedBadDCE = false;
+ function sub(event, fn2) {
+ hook.on(event, fn2);
+ return function() {
+ return hook.off(event, fn2);
+ };
+ }
+ __name(sub, "sub");
+ function on(event, fn2) {
+ if (!listeners[event]) {
+ listeners[event] = [];
+ }
+ listeners[event].push(fn2);
+ }
+ __name(on, "on");
+ function off(event, fn2) {
+ if (!listeners[event]) {
+ return;
+ }
+ var index = listeners[event].indexOf(fn2);
+ if (index !== -1) {
+ listeners[event].splice(index, 1);
+ }
+ if (!listeners[event].length) {
+ delete listeners[event];
+ }
+ }
+ __name(off, "off");
+ function emit(event, data) {
+ if (listeners[event]) {
+ listeners[event].map(function(fn2) {
+ return fn2(data);
+ });
+ }
+ }
+ __name(emit, "emit");
+ function getFiberRoots(rendererID) {
+ var roots = fiberRoots;
+ if (!roots[rendererID]) {
+ roots[rendererID] = /* @__PURE__ */ new Set();
+ }
+ return roots[rendererID];
+ }
+ __name(getFiberRoots, "getFiberRoots");
+ function onCommitFiberUnmount(rendererID, fiber) {
+ var rendererInterface = rendererInterfaces.get(rendererID);
+ if (rendererInterface != null) {
+ rendererInterface.handleCommitFiberUnmount(fiber);
+ }
+ }
+ __name(onCommitFiberUnmount, "onCommitFiberUnmount");
+ function onCommitFiberRoot(rendererID, root, priorityLevel) {
+ var mountedRoots = hook.getFiberRoots(rendererID);
+ var current = root.current;
+ var isKnownRoot = mountedRoots.has(root);
+ var isUnmounting = current.memoizedState == null || current.memoizedState.element == null;
+ if (!isKnownRoot && !isUnmounting) {
+ mountedRoots.add(root);
+ } else if (isKnownRoot && isUnmounting) {
+ mountedRoots.delete(root);
+ }
+ var rendererInterface = rendererInterfaces.get(rendererID);
+ if (rendererInterface != null) {
+ rendererInterface.handleCommitFiberRoot(root, priorityLevel);
+ }
+ }
+ __name(onCommitFiberRoot, "onCommitFiberRoot");
+ function onPostCommitFiberRoot(rendererID, root) {
+ var rendererInterface = rendererInterfaces.get(rendererID);
+ if (rendererInterface != null) {
+ rendererInterface.handlePostCommitFiberRoot(root);
+ }
+ }
+ __name(onPostCommitFiberRoot, "onPostCommitFiberRoot");
+ function setStrictMode(rendererID, isStrictMode) {
+ var rendererInterface = rendererInterfaces.get(rendererID);
+ if (rendererInterface != null) {
+ if (isStrictMode) {
+ rendererInterface.patchConsoleForStrictMode();
+ } else {
+ rendererInterface.unpatchConsoleForStrictMode();
+ }
+ } else {
+ if (isStrictMode) {
+ var hideConsoleLogsInStrictMode = window.__REACT_DEVTOOLS_HIDE_CONSOLE_LOGS_IN_STRICT_MODE__ === true;
+ var browserTheme = window.__REACT_DEVTOOLS_BROWSER_THEME__;
+ patchConsoleForInitialRenderInStrictMode({
+ hideConsoleLogsInStrictMode,
+ browserTheme
+ });
+ } else {
+ unpatchConsoleForInitialRenderInStrictMode();
+ }
+ }
+ }
+ __name(setStrictMode, "setStrictMode");
+ var openModuleRangesStack = [];
+ var moduleRanges = [];
+ function getTopStackFrameString(error) {
+ var frames = error.stack.split("\n");
+ var frame = frames.length > 1 ? frames[1] : null;
+ return frame;
+ }
+ __name(getTopStackFrameString, "getTopStackFrameString");
+ function getInternalModuleRanges() {
+ return moduleRanges;
+ }
+ __name(getInternalModuleRanges, "getInternalModuleRanges");
+ function registerInternalModuleStart(error) {
+ var startStackFrame = getTopStackFrameString(error);
+ if (startStackFrame !== null) {
+ openModuleRangesStack.push(startStackFrame);
+ }
+ }
+ __name(registerInternalModuleStart, "registerInternalModuleStart");
+ function registerInternalModuleStop(error) {
+ if (openModuleRangesStack.length > 0) {
+ var startStackFrame = openModuleRangesStack.pop();
+ var stopStackFrame = getTopStackFrameString(error);
+ if (stopStackFrame !== null) {
+ moduleRanges.push([startStackFrame, stopStackFrame]);
+ }
+ }
+ }
+ __name(registerInternalModuleStop, "registerInternalModuleStop");
+ var fiberRoots = {};
+ var rendererInterfaces = /* @__PURE__ */ new Map();
+ var listeners = {};
+ var renderers = /* @__PURE__ */ new Map();
+ var hook = {
+ rendererInterfaces,
+ listeners,
+ // Fast Refresh for web relies on this.
+ renderers,
+ emit,
+ getFiberRoots,
+ inject,
+ on,
+ off,
+ sub,
+ // This is a legacy flag.
+ // React v16 checks the hook for this to ensure DevTools is new enough.
+ supportsFiber: true,
+ // React calls these methods.
+ checkDCE,
+ onCommitFiberUnmount,
+ onCommitFiberRoot,
+ onPostCommitFiberRoot,
+ setStrictMode,
+ // Schedule Profiler runtime helpers.
+ // These internal React modules to report their own boundaries
+ // which in turn enables the profiler to dim or filter internal frames.
+ getInternalModuleRanges,
+ registerInternalModuleStart,
+ registerInternalModuleStop
+ };
+ if (false) {
+ }
+ Object.defineProperty(target, "__REACT_DEVTOOLS_GLOBAL_HOOK__", {
+ // This property needs to be configurable for the test environment,
+ // else we won't be able to delete and recreate it between tests.
+ configurable: false,
+ enumerable: false,
+ get: /* @__PURE__ */ __name(function get() {
+ return hook;
+ }, "get")
+ });
+ return hook;
+ }
+ __name(installHook, "installHook");
+ var backend_renderer = __webpack_require__(16);
+ var types = __webpack_require__(0);
+ var src_utils = __webpack_require__(2);
+ function decorate(object, attr, fn2) {
+ var old = object[attr];
+ object[attr] = function(instance) {
+ return fn2.call(this, old, arguments);
+ };
+ return old;
+ }
+ __name(decorate, "decorate");
+ function decorateMany(source, fns) {
+ var olds = {};
+ for (var name in fns) {
+ olds[name] = decorate(source, name, fns[name]);
+ }
+ return olds;
+ }
+ __name(decorateMany, "decorateMany");
+ function restoreMany(source, olds) {
+ for (var name in olds) {
+ source[name] = olds[name];
+ }
+ }
+ __name(restoreMany, "restoreMany");
+ function forceUpdate(instance) {
+ if (typeof instance.forceUpdate === "function") {
+ instance.forceUpdate();
+ } else if (instance.updater != null && typeof instance.updater.enqueueForceUpdate === "function") {
+ instance.updater.enqueueForceUpdate(this, function() {
+ }, "forceUpdate");
+ }
+ }
+ __name(forceUpdate, "forceUpdate");
+ function ownKeys11(object, enumerableOnly) {
+ var keys = Object.keys(object);
+ if (Object.getOwnPropertySymbols) {
+ var symbols = Object.getOwnPropertySymbols(object);
+ if (enumerableOnly)
+ symbols = symbols.filter(function(sym) {
+ return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+ });
+ keys.push.apply(keys, symbols);
+ }
+ return keys;
+ }
+ __name(ownKeys11, "ownKeys");
+ function _objectSpread11(target) {
+ for (var i = 1; i < arguments.length; i++) {
+ var source = arguments[i] != null ? arguments[i] : {};
+ if (i % 2) {
+ ownKeys11(Object(source), true).forEach(function(key) {
+ renderer_defineProperty(target, key, source[key]);
+ });
+ } else if (Object.getOwnPropertyDescriptors) {
+ Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+ } else {
+ ownKeys11(Object(source)).forEach(function(key) {
+ Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+ });
+ }
+ }
+ return target;
+ }
+ __name(_objectSpread11, "_objectSpread");
+ function renderer_defineProperty(obj, key, value) {
+ if (key in obj) {
+ Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
+ } else {
+ obj[key] = value;
+ }
+ return obj;
+ }
+ __name(renderer_defineProperty, "renderer_defineProperty");
+ function renderer_typeof(obj) {
+ "@babel/helpers - typeof";
+ if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+ renderer_typeof = /* @__PURE__ */ __name(function _typeof8(obj2) {
+ return typeof obj2;
+ }, "_typeof");
+ } else {
+ renderer_typeof = /* @__PURE__ */ __name(function _typeof8(obj2) {
+ return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+ }, "_typeof");
+ }
+ return renderer_typeof(obj);
+ }
+ __name(renderer_typeof, "renderer_typeof");
+ function getData(internalInstance) {
+ var displayName = null;
+ var key = null;
+ if (internalInstance._currentElement != null) {
+ if (internalInstance._currentElement.key) {
+ key = String(internalInstance._currentElement.key);
+ }
+ var elementType = internalInstance._currentElement.type;
+ if (typeof elementType === "string") {
+ displayName = elementType;
+ } else if (typeof elementType === "function") {
+ displayName = Object(src_utils[
+ "f"
+ /* getDisplayName */
+ ])(elementType);
+ }
+ }
+ return {
+ displayName,
+ key
+ };
+ }
+ __name(getData, "getData");
+ function getElementType(internalInstance) {
+ if (internalInstance._currentElement != null) {
+ var elementType = internalInstance._currentElement.type;
+ if (typeof elementType === "function") {
+ var publicInstance = internalInstance.getPublicInstance();
+ if (publicInstance !== null) {
+ return types[
+ "e"
+ /* ElementTypeClass */
+ ];
+ } else {
+ return types[
+ "h"
+ /* ElementTypeFunction */
+ ];
+ }
+ } else if (typeof elementType === "string") {
+ return types[
+ "i"
+ /* ElementTypeHostComponent */
+ ];
+ }
+ }
+ return types[
+ "k"
+ /* ElementTypeOtherOrUnknown */
+ ];
+ }
+ __name(getElementType, "getElementType");
+ function getChildren(internalInstance) {
+ var children = [];
+ if (renderer_typeof(internalInstance) !== "object") {
+ } else if (internalInstance._currentElement === null || internalInstance._currentElement === false) {
+ } else if (internalInstance._renderedComponent) {
+ var child = internalInstance._renderedComponent;
+ if (getElementType(child) !== types[
+ "k"
+ /* ElementTypeOtherOrUnknown */
+ ]) {
+ children.push(child);
+ }
+ } else if (internalInstance._renderedChildren) {
+ var renderedChildren = internalInstance._renderedChildren;
+ for (var name in renderedChildren) {
+ var _child = renderedChildren[name];
+ if (getElementType(_child) !== types[
+ "k"
+ /* ElementTypeOtherOrUnknown */
+ ]) {
+ children.push(_child);
+ }
+ }
+ }
+ return children;
+ }
+ __name(getChildren, "getChildren");
+ function renderer_attach(hook, rendererID, renderer, global2) {
+ var idToInternalInstanceMap = /* @__PURE__ */ new Map();
+ var internalInstanceToIDMap = /* @__PURE__ */ new WeakMap();
+ var internalInstanceToRootIDMap = /* @__PURE__ */ new WeakMap();
+ var getInternalIDForNative = null;
+ var findNativeNodeForInternalID;
+ if (renderer.ComponentTree) {
+ getInternalIDForNative = /* @__PURE__ */ __name(function getInternalIDForNative2(node, findNearestUnfilteredAncestor) {
+ var internalInstance = renderer.ComponentTree.getClosestInstanceFromNode(node);
+ return internalInstanceToIDMap.get(internalInstance) || null;
+ }, "getInternalIDForNative");
+ findNativeNodeForInternalID = /* @__PURE__ */ __name(function findNativeNodeForInternalID2(id) {
+ var internalInstance = idToInternalInstanceMap.get(id);
+ return renderer.ComponentTree.getNodeFromInstance(internalInstance);
+ }, "findNativeNodeForInternalID");
+ } else if (renderer.Mount.getID && renderer.Mount.getNode) {
+ getInternalIDForNative = /* @__PURE__ */ __name(function getInternalIDForNative2(node, findNearestUnfilteredAncestor) {
+ return null;
+ }, "getInternalIDForNative");
+ findNativeNodeForInternalID = /* @__PURE__ */ __name(function findNativeNodeForInternalID2(id) {
+ return null;
+ }, "findNativeNodeForInternalID");
+ }
+ function getDisplayNameForFiberID(id) {
+ var internalInstance = idToInternalInstanceMap.get(id);
+ return internalInstance ? getData(internalInstance).displayName : null;
+ }
+ __name(getDisplayNameForFiberID, "getDisplayNameForFiberID");
+ function getID(internalInstance) {
+ if (renderer_typeof(internalInstance) !== "object" || internalInstance === null) {
+ throw new Error("Invalid internal instance: " + internalInstance);
+ }
+ if (!internalInstanceToIDMap.has(internalInstance)) {
+ var _id = Object(src_utils[
+ "i"
+ /* getUID */
+ ])();
+ internalInstanceToIDMap.set(internalInstance, _id);
+ idToInternalInstanceMap.set(_id, internalInstance);
+ }
+ return internalInstanceToIDMap.get(internalInstance);
+ }
+ __name(getID, "getID");
+ function areEqualArrays(a, b) {
+ if (a.length !== b.length) {
+ return false;
+ }
+ for (var i = 0; i < a.length; i++) {
+ if (a[i] !== b[i]) {
+ return false;
+ }
+ }
+ return true;
+ }
+ __name(areEqualArrays, "areEqualArrays");
+ var parentIDStack = [];
+ var oldReconcilerMethods = null;
+ if (renderer.Reconciler) {
+ oldReconcilerMethods = decorateMany(renderer.Reconciler, {
+ mountComponent: /* @__PURE__ */ __name(function mountComponent(fn2, args) {
+ var internalInstance = args[0];
+ var hostContainerInfo = args[3];
+ if (getElementType(internalInstance) === types[
+ "k"
+ /* ElementTypeOtherOrUnknown */
+ ]) {
+ return fn2.apply(this, args);
+ }
+ if (hostContainerInfo._topLevelWrapper === void 0) {
+ return fn2.apply(this, args);
+ }
+ var id = getID(internalInstance);
+ var parentID = parentIDStack.length > 0 ? parentIDStack[parentIDStack.length - 1] : 0;
+ recordMount(internalInstance, id, parentID);
+ parentIDStack.push(id);
+ internalInstanceToRootIDMap.set(internalInstance, getID(hostContainerInfo._topLevelWrapper));
+ try {
+ var result = fn2.apply(this, args);
+ parentIDStack.pop();
+ return result;
+ } catch (err) {
+ parentIDStack = [];
+ throw err;
+ } finally {
+ if (parentIDStack.length === 0) {
+ var rootID = internalInstanceToRootIDMap.get(internalInstance);
+ if (rootID === void 0) {
+ throw new Error("Expected to find root ID.");
+ }
+ flushPendingEvents(rootID);
+ }
+ }
+ }, "mountComponent"),
+ performUpdateIfNecessary: /* @__PURE__ */ __name(function performUpdateIfNecessary(fn2, args) {
+ var internalInstance = args[0];
+ if (getElementType(internalInstance) === types[
+ "k"
+ /* ElementTypeOtherOrUnknown */
+ ]) {
+ return fn2.apply(this, args);
+ }
+ var id = getID(internalInstance);
+ parentIDStack.push(id);
+ var prevChildren = getChildren(internalInstance);
+ try {
+ var result = fn2.apply(this, args);
+ var nextChildren = getChildren(internalInstance);
+ if (!areEqualArrays(prevChildren, nextChildren)) {
+ recordReorder(internalInstance, id, nextChildren);
+ }
+ parentIDStack.pop();
+ return result;
+ } catch (err) {
+ parentIDStack = [];
+ throw err;
+ } finally {
+ if (parentIDStack.length === 0) {
+ var rootID = internalInstanceToRootIDMap.get(internalInstance);
+ if (rootID === void 0) {
+ throw new Error("Expected to find root ID.");
+ }
+ flushPendingEvents(rootID);
+ }
+ }
+ }, "performUpdateIfNecessary"),
+ receiveComponent: /* @__PURE__ */ __name(function receiveComponent(fn2, args) {
+ var internalInstance = args[0];
+ if (getElementType(internalInstance) === types[
+ "k"
+ /* ElementTypeOtherOrUnknown */
+ ]) {
+ return fn2.apply(this, args);
+ }
+ var id = getID(internalInstance);
+ parentIDStack.push(id);
+ var prevChildren = getChildren(internalInstance);
+ try {
+ var result = fn2.apply(this, args);
+ var nextChildren = getChildren(internalInstance);
+ if (!areEqualArrays(prevChildren, nextChildren)) {
+ recordReorder(internalInstance, id, nextChildren);
+ }
+ parentIDStack.pop();
+ return result;
+ } catch (err) {
+ parentIDStack = [];
+ throw err;
+ } finally {
+ if (parentIDStack.length === 0) {
+ var rootID = internalInstanceToRootIDMap.get(internalInstance);
+ if (rootID === void 0) {
+ throw new Error("Expected to find root ID.");
+ }
+ flushPendingEvents(rootID);
+ }
+ }
+ }, "receiveComponent"),
+ unmountComponent: /* @__PURE__ */ __name(function unmountComponent(fn2, args) {
+ var internalInstance = args[0];
+ if (getElementType(internalInstance) === types[
+ "k"
+ /* ElementTypeOtherOrUnknown */
+ ]) {
+ return fn2.apply(this, args);
+ }
+ var id = getID(internalInstance);
+ parentIDStack.push(id);
+ try {
+ var result = fn2.apply(this, args);
+ parentIDStack.pop();
+ recordUnmount(internalInstance, id);
+ return result;
+ } catch (err) {
+ parentIDStack = [];
+ throw err;
+ } finally {
+ if (parentIDStack.length === 0) {
+ var rootID = internalInstanceToRootIDMap.get(internalInstance);
+ if (rootID === void 0) {
+ throw new Error("Expected to find root ID.");
+ }
+ flushPendingEvents(rootID);
+ }
+ }
+ }, "unmountComponent")
+ });
+ }
+ function cleanup() {
+ if (oldReconcilerMethods !== null) {
+ if (renderer.Component) {
+ restoreMany(renderer.Component.Mixin, oldReconcilerMethods);
+ } else {
+ restoreMany(renderer.Reconciler, oldReconcilerMethods);
+ }
+ }
+ oldReconcilerMethods = null;
+ }
+ __name(cleanup, "cleanup");
+ function recordMount(internalInstance, id, parentID) {
+ var isRoot = parentID === 0;
+ if (constants3[
+ "q"
+ /* __DEBUG__ */
+ ]) {
+ console.log("%crecordMount()", "color: green; font-weight: bold;", id, getData(internalInstance).displayName);
+ }
+ if (isRoot) {
+ var hasOwnerMetadata = internalInstance._currentElement != null && internalInstance._currentElement._owner != null;
+ pushOperation(constants3[
+ "j"
+ /* TREE_OPERATION_ADD */
+ ]);
+ pushOperation(id);
+ pushOperation(types[
+ "m"
+ /* ElementTypeRoot */
+ ]);
+ pushOperation(0);
+ pushOperation(0);
+ pushOperation(0);
+ pushOperation(hasOwnerMetadata ? 1 : 0);
+ } else {
+ var type = getElementType(internalInstance);
+ var _getData = getData(internalInstance), displayName = _getData.displayName, key = _getData.key;
+ var ownerID = internalInstance._currentElement != null && internalInstance._currentElement._owner != null ? getID(internalInstance._currentElement._owner) : 0;
+ var displayNameStringID = getStringID(displayName);
+ var keyStringID = getStringID(key);
+ pushOperation(constants3[
+ "j"
+ /* TREE_OPERATION_ADD */
+ ]);
+ pushOperation(id);
+ pushOperation(type);
+ pushOperation(parentID);
+ pushOperation(ownerID);
+ pushOperation(displayNameStringID);
+ pushOperation(keyStringID);
+ }
+ }
+ __name(recordMount, "recordMount");
+ function recordReorder(internalInstance, id, nextChildren) {
+ pushOperation(constants3[
+ "m"
+ /* TREE_OPERATION_REORDER_CHILDREN */
+ ]);
+ pushOperation(id);
+ var nextChildIDs = nextChildren.map(getID);
+ pushOperation(nextChildIDs.length);
+ for (var i = 0; i < nextChildIDs.length; i++) {
+ pushOperation(nextChildIDs[i]);
+ }
+ }
+ __name(recordReorder, "recordReorder");
+ function recordUnmount(internalInstance, id) {
+ pendingUnmountedIDs.push(id);
+ idToInternalInstanceMap.delete(id);
+ }
+ __name(recordUnmount, "recordUnmount");
+ function crawlAndRecordInitialMounts(id, parentID, rootID) {
+ if (constants3[
+ "q"
+ /* __DEBUG__ */
+ ]) {
+ console.group("crawlAndRecordInitialMounts() id:", id);
+ }
+ var internalInstance = idToInternalInstanceMap.get(id);
+ if (internalInstance != null) {
+ internalInstanceToRootIDMap.set(internalInstance, rootID);
+ recordMount(internalInstance, id, parentID);
+ getChildren(internalInstance).forEach(function(child) {
+ return crawlAndRecordInitialMounts(getID(child), id, rootID);
+ });
+ }
+ if (constants3[
+ "q"
+ /* __DEBUG__ */
+ ]) {
+ console.groupEnd();
+ }
+ }
+ __name(crawlAndRecordInitialMounts, "crawlAndRecordInitialMounts");
+ function flushInitialOperations() {
+ var roots = renderer.Mount._instancesByReactRootID || renderer.Mount._instancesByContainerID;
+ for (var key in roots) {
+ var internalInstance = roots[key];
+ var _id2 = getID(internalInstance);
+ crawlAndRecordInitialMounts(_id2, 0, _id2);
+ flushPendingEvents(_id2);
+ }
+ }
+ __name(flushInitialOperations, "flushInitialOperations");
+ var pendingOperations = [];
+ var pendingStringTable = /* @__PURE__ */ new Map();
+ var pendingUnmountedIDs = [];
+ var pendingStringTableLength = 0;
+ var pendingUnmountedRootID = null;
+ function flushPendingEvents(rootID) {
+ if (pendingOperations.length === 0 && pendingUnmountedIDs.length === 0 && pendingUnmountedRootID === null) {
+ return;
+ }
+ var numUnmountIDs = pendingUnmountedIDs.length + (pendingUnmountedRootID === null ? 0 : 1);
+ var operations = new Array(
+ // Identify which renderer this update is coming from.
+ 2 + // [rendererID, rootFiberID]
+ // How big is the string table?
+ 1 + // [stringTableLength]
+ // Then goes the actual string table.
+ pendingStringTableLength + // All unmounts are batched in a single message.
+ // [TREE_OPERATION_REMOVE, removedIDLength, ...ids]
+ (numUnmountIDs > 0 ? 2 + numUnmountIDs : 0) + // Mount operations
+ pendingOperations.length
+ );
+ var i = 0;
+ operations[i++] = rendererID;
+ operations[i++] = rootID;
+ operations[i++] = pendingStringTableLength;
+ pendingStringTable.forEach(function(value, key) {
+ operations[i++] = key.length;
+ var encodedKey = Object(src_utils[
+ "m"
+ /* utfEncodeString */
+ ])(key);
+ for (var j2 = 0; j2 < encodedKey.length; j2++) {
+ operations[i + j2] = encodedKey[j2];
+ }
+ i += key.length;
+ });
+ if (numUnmountIDs > 0) {
+ operations[i++] = constants3[
+ "k"
+ /* TREE_OPERATION_REMOVE */
+ ];
+ operations[i++] = numUnmountIDs;
+ for (var j = 0; j < pendingUnmountedIDs.length; j++) {
+ operations[i++] = pendingUnmountedIDs[j];
+ }
+ if (pendingUnmountedRootID !== null) {
+ operations[i] = pendingUnmountedRootID;
+ i++;
+ }
+ }
+ for (var _j = 0; _j < pendingOperations.length; _j++) {
+ operations[i + _j] = pendingOperations[_j];
+ }
+ i += pendingOperations.length;
+ if (constants3[
+ "q"
+ /* __DEBUG__ */
+ ]) {
+ Object(src_utils[
+ "j"
+ /* printOperationsArray */
+ ])(operations);
+ }
+ hook.emit("operations", operations);
+ pendingOperations.length = 0;
+ pendingUnmountedIDs = [];
+ pendingUnmountedRootID = null;
+ pendingStringTable.clear();
+ pendingStringTableLength = 0;
+ }
+ __name(flushPendingEvents, "flushPendingEvents");
+ function pushOperation(op) {
+ if (false) {
+ }
+ pendingOperations.push(op);
+ }
+ __name(pushOperation, "pushOperation");
+ function getStringID(str) {
+ if (str === null) {
+ return 0;
+ }
+ var existingID = pendingStringTable.get(str);
+ if (existingID !== void 0) {
+ return existingID;
+ }
+ var stringID = pendingStringTable.size + 1;
+ pendingStringTable.set(str, stringID);
+ pendingStringTableLength += str.length + 1;
+ return stringID;
+ }
+ __name(getStringID, "getStringID");
+ var currentlyInspectedElementID = null;
+ var currentlyInspectedPaths = {};
+ function mergeInspectedPaths(path45) {
+ var current = currentlyInspectedPaths;
+ path45.forEach(function(key) {
+ if (!current[key]) {
+ current[key] = {};
+ }
+ current = current[key];
+ });
+ }
+ __name(mergeInspectedPaths, "mergeInspectedPaths");
+ function createIsPathAllowed(key) {
+ return /* @__PURE__ */ __name(function isPathAllowed(path45) {
+ var current = currentlyInspectedPaths[key];
+ if (!current) {
+ return false;
+ }
+ for (var i = 0; i < path45.length; i++) {
+ current = current[path45[i]];
+ if (!current) {
+ return false;
+ }
+ }
+ return true;
+ }, "isPathAllowed");
+ }
+ __name(createIsPathAllowed, "createIsPathAllowed");
+ function getInstanceAndStyle(id) {
+ var instance = null;
+ var style = null;
+ var internalInstance = idToInternalInstanceMap.get(id);
+ if (internalInstance != null) {
+ instance = internalInstance._instance || null;
+ var element = internalInstance._currentElement;
+ if (element != null && element.props != null) {
+ style = element.props.style || null;
+ }
+ }
+ return {
+ instance,
+ style
+ };
+ }
+ __name(getInstanceAndStyle, "getInstanceAndStyle");
+ function updateSelectedElement(id) {
+ var internalInstance = idToInternalInstanceMap.get(id);
+ if (internalInstance == null) {
+ console.warn('Could not find instance with id "'.concat(id, '"'));
+ return;
+ }
+ switch (getElementType(internalInstance)) {
+ case types[
+ "e"
+ /* ElementTypeClass */
+ ]:
+ global2.$r = internalInstance._instance;
+ break;
+ case types[
+ "h"
+ /* ElementTypeFunction */
+ ]:
+ var element = internalInstance._currentElement;
+ if (element == null) {
+ console.warn('Could not find element with id "'.concat(id, '"'));
+ return;
+ }
+ global2.$r = {
+ props: element.props,
+ type: element.type
+ };
+ break;
+ default:
+ global2.$r = null;
+ break;
+ }
+ }
+ __name(updateSelectedElement, "updateSelectedElement");
+ function storeAsGlobal(id, path45, count) {
+ var inspectedElement = inspectElementRaw(id);
+ if (inspectedElement !== null) {
+ var value = Object(src_utils[
+ "h"
+ /* getInObject */
+ ])(inspectedElement, path45);
+ var key = "$reactTemp".concat(count);
+ window[key] = value;
+ console.log(key);
+ console.log(value);
+ }
+ }
+ __name(storeAsGlobal, "storeAsGlobal");
+ function copyElementPath(id, path45) {
+ var inspectedElement = inspectElementRaw(id);
+ if (inspectedElement !== null) {
+ Object(utils[
+ "b"
+ /* copyToClipboard */
+ ])(Object(src_utils[
+ "h"
+ /* getInObject */
+ ])(inspectedElement, path45));
+ }
+ }
+ __name(copyElementPath, "copyElementPath");
+ function inspectElement(requestID, id, path45, forceFullData) {
+ if (forceFullData || currentlyInspectedElementID !== id) {
+ currentlyInspectedElementID = id;
+ currentlyInspectedPaths = {};
+ }
+ var inspectedElement = inspectElementRaw(id);
+ if (inspectedElement === null) {
+ return {
+ id,
+ responseID: requestID,
+ type: "not-found"
+ };
+ }
+ if (path45 !== null) {
+ mergeInspectedPaths(path45);
+ }
+ updateSelectedElement(id);
+ inspectedElement.context = Object(utils[
+ "a"
+ /* cleanForBridge */
+ ])(inspectedElement.context, createIsPathAllowed("context"));
+ inspectedElement.props = Object(utils[
+ "a"
+ /* cleanForBridge */
+ ])(inspectedElement.props, createIsPathAllowed("props"));
+ inspectedElement.state = Object(utils[
+ "a"
+ /* cleanForBridge */
+ ])(inspectedElement.state, createIsPathAllowed("state"));
+ return {
+ id,
+ responseID: requestID,
+ type: "full-data",
+ value: inspectedElement
+ };
+ }
+ __name(inspectElement, "inspectElement");
+ function inspectElementRaw(id) {
+ var internalInstance = idToInternalInstanceMap.get(id);
+ if (internalInstance == null) {
+ return null;
+ }
+ var _getData2 = getData(internalInstance), displayName = _getData2.displayName, key = _getData2.key;
+ var type = getElementType(internalInstance);
+ var context2 = null;
+ var owners = null;
+ var props = null;
+ var state = null;
+ var source = null;
+ var element = internalInstance._currentElement;
+ if (element !== null) {
+ props = element.props;
+ source = element._source != null ? element._source : null;
+ var owner = element._owner;
+ if (owner) {
+ owners = [];
+ while (owner != null) {
+ owners.push({
+ displayName: getData(owner).displayName || "Unknown",
+ id: getID(owner),
+ key: element.key,
+ type: getElementType(owner)
+ });
+ if (owner._currentElement) {
+ owner = owner._currentElement._owner;
+ }
+ }
+ }
+ }
+ var publicInstance = internalInstance._instance;
+ if (publicInstance != null) {
+ context2 = publicInstance.context || null;
+ state = publicInstance.state || null;
+ }
+ var errors = [];
+ var warnings = [];
+ return {
+ id,
+ // Does the current renderer support editable hooks and function props?
+ canEditHooks: false,
+ canEditFunctionProps: false,
+ // Does the current renderer support advanced editing interface?
+ canEditHooksAndDeletePaths: false,
+ canEditHooksAndRenamePaths: false,
+ canEditFunctionPropsDeletePaths: false,
+ canEditFunctionPropsRenamePaths: false,
+ // Toggle error boundary did not exist in legacy versions
+ canToggleError: false,
+ isErrored: false,
+ targetErrorBoundaryID: null,
+ // Suspense did not exist in legacy versions
+ canToggleSuspense: false,
+ // Can view component source location.
+ canViewSource: type === types[
+ "e"
+ /* ElementTypeClass */
+ ] || type === types[
+ "h"
+ /* ElementTypeFunction */
+ ],
+ // Only legacy context exists in legacy versions.
+ hasLegacyContext: true,
+ displayName,
+ type,
+ key: key != null ? key : null,
+ // Inspectable properties.
+ context: context2,
+ hooks: null,
+ props,
+ state,
+ errors,
+ warnings,
+ // List of owners
+ owners,
+ // Location of component in source code.
+ source,
+ rootType: null,
+ rendererPackageName: null,
+ rendererVersion: null,
+ plugins: {
+ stylex: null
+ }
+ };
+ }
+ __name(inspectElementRaw, "inspectElementRaw");
+ function logElementToConsole(id) {
+ var result = inspectElementRaw(id);
+ if (result === null) {
+ console.warn('Could not find element with id "'.concat(id, '"'));
+ return;
+ }
+ var supportsGroup = typeof console.groupCollapsed === "function";
+ if (supportsGroup) {
+ console.groupCollapsed(
+ "[Click to expand] %c<".concat(result.displayName || "Component", " />"),
+ // --dom-tag-name-color is the CSS variable Chrome styles HTML elements with in the console.
+ "color: var(--dom-tag-name-color); font-weight: normal;"
+ );
+ }
+ if (result.props !== null) {
+ console.log("Props:", result.props);
+ }
+ if (result.state !== null) {
+ console.log("State:", result.state);
+ }
+ if (result.context !== null) {
+ console.log("Context:", result.context);
+ }
+ var nativeNode = findNativeNodeForInternalID(id);
+ if (nativeNode !== null) {
+ console.log("Node:", nativeNode);
+ }
+ if (window.chrome || /firefox/i.test(navigator.userAgent)) {
+ console.log("Right-click any value to save it as a global variable for further inspection.");
+ }
+ if (supportsGroup) {
+ console.groupEnd();
+ }
+ }
+ __name(logElementToConsole, "logElementToConsole");
+ function prepareViewAttributeSource(id, path45) {
+ var inspectedElement = inspectElementRaw(id);
+ if (inspectedElement !== null) {
+ window.$attribute = Object(src_utils[
+ "h"
+ /* getInObject */
+ ])(inspectedElement, path45);
+ }
+ }
+ __name(prepareViewAttributeSource, "prepareViewAttributeSource");
+ function prepareViewElementSource(id) {
+ var internalInstance = idToInternalInstanceMap.get(id);
+ if (internalInstance == null) {
+ console.warn('Could not find instance with id "'.concat(id, '"'));
+ return;
+ }
+ var element = internalInstance._currentElement;
+ if (element == null) {
+ console.warn('Could not find element with id "'.concat(id, '"'));
+ return;
+ }
+ global2.$type = element.type;
+ }
+ __name(prepareViewElementSource, "prepareViewElementSource");
+ function deletePath(type, id, hookID, path45) {
+ var internalInstance = idToInternalInstanceMap.get(id);
+ if (internalInstance != null) {
+ var publicInstance = internalInstance._instance;
+ if (publicInstance != null) {
+ switch (type) {
+ case "context":
+ Object(src_utils[
+ "a"
+ /* deletePathInObject */
+ ])(publicInstance.context, path45);
+ forceUpdate(publicInstance);
+ break;
+ case "hooks":
+ throw new Error("Hooks not supported by this renderer");
+ case "props":
+ var element = internalInstance._currentElement;
+ internalInstance._currentElement = _objectSpread11(_objectSpread11({}, element), {}, {
+ props: Object(utils[
+ "c"
+ /* copyWithDelete */
+ ])(element.props, path45)
+ });
+ forceUpdate(publicInstance);
+ break;
+ case "state":
+ Object(src_utils[
+ "a"
+ /* deletePathInObject */
+ ])(publicInstance.state, path45);
+ forceUpdate(publicInstance);
+ break;
+ }
+ }
+ }
+ }
+ __name(deletePath, "deletePath");
+ function renamePath(type, id, hookID, oldPath, newPath) {
+ var internalInstance = idToInternalInstanceMap.get(id);
+ if (internalInstance != null) {
+ var publicInstance = internalInstance._instance;
+ if (publicInstance != null) {
+ switch (type) {
+ case "context":
+ Object(src_utils[
+ "k"
+ /* renamePathInObject */
+ ])(publicInstance.context, oldPath, newPath);
+ forceUpdate(publicInstance);
+ break;
+ case "hooks":
+ throw new Error("Hooks not supported by this renderer");
+ case "props":
+ var element = internalInstance._currentElement;
+ internalInstance._currentElement = _objectSpread11(_objectSpread11({}, element), {}, {
+ props: Object(utils[
+ "d"
+ /* copyWithRename */
+ ])(element.props, oldPath, newPath)
+ });
+ forceUpdate(publicInstance);
+ break;
+ case "state":
+ Object(src_utils[
+ "k"
+ /* renamePathInObject */
+ ])(publicInstance.state, oldPath, newPath);
+ forceUpdate(publicInstance);
+ break;
+ }
+ }
+ }
+ }
+ __name(renamePath, "renamePath");
+ function overrideValueAtPath(type, id, hookID, path45, value) {
+ var internalInstance = idToInternalInstanceMap.get(id);
+ if (internalInstance != null) {
+ var publicInstance = internalInstance._instance;
+ if (publicInstance != null) {
+ switch (type) {
+ case "context":
+ Object(src_utils[
+ "l"
+ /* setInObject */
+ ])(publicInstance.context, path45, value);
+ forceUpdate(publicInstance);
+ break;
+ case "hooks":
+ throw new Error("Hooks not supported by this renderer");
+ case "props":
+ var element = internalInstance._currentElement;
+ internalInstance._currentElement = _objectSpread11(_objectSpread11({}, element), {}, {
+ props: Object(utils[
+ "e"
+ /* copyWithSet */
+ ])(element.props, path45, value)
+ });
+ forceUpdate(publicInstance);
+ break;
+ case "state":
+ Object(src_utils[
+ "l"
+ /* setInObject */
+ ])(publicInstance.state, path45, value);
+ forceUpdate(publicInstance);
+ break;
+ }
+ }
+ }
+ }
+ __name(overrideValueAtPath, "overrideValueAtPath");
+ var getProfilingData = /* @__PURE__ */ __name(function getProfilingData2() {
+ throw new Error("getProfilingData not supported by this renderer");
+ }, "getProfilingData");
+ var handleCommitFiberRoot = /* @__PURE__ */ __name(function handleCommitFiberRoot2() {
+ throw new Error("handleCommitFiberRoot not supported by this renderer");
+ }, "handleCommitFiberRoot");
+ var handleCommitFiberUnmount = /* @__PURE__ */ __name(function handleCommitFiberUnmount2() {
+ throw new Error("handleCommitFiberUnmount not supported by this renderer");
+ }, "handleCommitFiberUnmount");
+ var handlePostCommitFiberRoot = /* @__PURE__ */ __name(function handlePostCommitFiberRoot2() {
+ throw new Error("handlePostCommitFiberRoot not supported by this renderer");
+ }, "handlePostCommitFiberRoot");
+ var overrideError = /* @__PURE__ */ __name(function overrideError2() {
+ throw new Error("overrideError not supported by this renderer");
+ }, "overrideError");
+ var overrideSuspense = /* @__PURE__ */ __name(function overrideSuspense2() {
+ throw new Error("overrideSuspense not supported by this renderer");
+ }, "overrideSuspense");
+ var startProfiling = /* @__PURE__ */ __name(function startProfiling2() {
+ }, "startProfiling");
+ var stopProfiling = /* @__PURE__ */ __name(function stopProfiling2() {
+ }, "stopProfiling");
+ function getBestMatchForTrackedPath() {
+ return null;
+ }
+ __name(getBestMatchForTrackedPath, "getBestMatchForTrackedPath");
+ function getPathForElement(id) {
+ return null;
+ }
+ __name(getPathForElement, "getPathForElement");
+ function updateComponentFilters(componentFilters) {
+ }
+ __name(updateComponentFilters, "updateComponentFilters");
+ function setTraceUpdatesEnabled(enabled) {
+ }
+ __name(setTraceUpdatesEnabled, "setTraceUpdatesEnabled");
+ function setTrackedPath(path45) {
+ }
+ __name(setTrackedPath, "setTrackedPath");
+ function getOwnersList(id) {
+ return null;
+ }
+ __name(getOwnersList, "getOwnersList");
+ function clearErrorsAndWarnings() {
+ }
+ __name(clearErrorsAndWarnings, "clearErrorsAndWarnings");
+ function clearErrorsForFiberID(id) {
+ }
+ __name(clearErrorsForFiberID, "clearErrorsForFiberID");
+ function clearWarningsForFiberID(id) {
+ }
+ __name(clearWarningsForFiberID, "clearWarningsForFiberID");
+ function patchConsoleForStrictMode() {
+ }
+ __name(patchConsoleForStrictMode, "patchConsoleForStrictMode");
+ function unpatchConsoleForStrictMode() {
+ }
+ __name(unpatchConsoleForStrictMode, "unpatchConsoleForStrictMode");
+ return {
+ clearErrorsAndWarnings,
+ clearErrorsForFiberID,
+ clearWarningsForFiberID,
+ cleanup,
+ copyElementPath,
+ deletePath,
+ flushInitialOperations,
+ getBestMatchForTrackedPath,
+ getDisplayNameForFiberID,
+ getFiberIDForNative: getInternalIDForNative,
+ getInstanceAndStyle,
+ findNativeNodesForFiberID: /* @__PURE__ */ __name(function findNativeNodesForFiberID(id) {
+ var nativeNode = findNativeNodeForInternalID(id);
+ return nativeNode == null ? null : [nativeNode];
+ }, "findNativeNodesForFiberID"),
+ getOwnersList,
+ getPathForElement,
+ getProfilingData,
+ handleCommitFiberRoot,
+ handleCommitFiberUnmount,
+ handlePostCommitFiberRoot,
+ inspectElement,
+ logElementToConsole,
+ overrideError,
+ overrideSuspense,
+ overrideValueAtPath,
+ renamePath,
+ patchConsoleForStrictMode,
+ prepareViewAttributeSource,
+ prepareViewElementSource,
+ renderer,
+ setTraceUpdatesEnabled,
+ setTrackedPath,
+ startProfiling,
+ stopProfiling,
+ storeAsGlobal,
+ unpatchConsoleForStrictMode,
+ updateComponentFilters
+ };
+ }
+ __name(renderer_attach, "renderer_attach");
+ function initBackend(hook, agent, global2) {
+ if (hook == null) {
+ return function() {
+ };
+ }
+ var subs = [
+ hook.sub("renderer-attached", function(_ref) {
+ var id = _ref.id, renderer = _ref.renderer, rendererInterface = _ref.rendererInterface;
+ agent.setRendererInterface(id, rendererInterface);
+ rendererInterface.flushInitialOperations();
+ }),
+ hook.sub("unsupported-renderer-version", function(id) {
+ agent.onUnsupportedRenderer(id);
+ }),
+ hook.sub("fastRefreshScheduled", agent.onFastRefreshScheduled),
+ hook.sub("operations", agent.onHookOperations),
+ hook.sub("traceUpdates", agent.onTraceUpdates)
+ // TODO Add additional subscriptions required for profiling mode
+ ];
+ var attachRenderer = /* @__PURE__ */ __name(function attachRenderer2(id, renderer) {
+ var rendererInterface = hook.rendererInterfaces.get(id);
+ if (rendererInterface == null) {
+ if (typeof renderer.findFiberByHostInstance === "function") {
+ rendererInterface = Object(backend_renderer[
+ "a"
+ /* attach */
+ ])(hook, id, renderer, global2);
+ } else if (renderer.ComponentTree) {
+ rendererInterface = renderer_attach(hook, id, renderer, global2);
+ } else {
+ }
+ if (rendererInterface != null) {
+ hook.rendererInterfaces.set(id, rendererInterface);
+ }
+ }
+ if (rendererInterface != null) {
+ hook.emit("renderer-attached", {
+ id,
+ renderer,
+ rendererInterface
+ });
+ } else {
+ hook.emit("unsupported-renderer-version", id);
+ }
+ }, "attachRenderer");
+ hook.renderers.forEach(function(renderer, id) {
+ attachRenderer(id, renderer);
+ });
+ subs.push(hook.sub("renderer", function(_ref2) {
+ var id = _ref2.id, renderer = _ref2.renderer;
+ attachRenderer(id, renderer);
+ }));
+ hook.emit("react-devtools", agent);
+ hook.reactDevtoolsAgent = agent;
+ var onAgentShutdown = /* @__PURE__ */ __name(function onAgentShutdown2() {
+ subs.forEach(function(fn2) {
+ return fn2();
+ });
+ hook.rendererInterfaces.forEach(function(rendererInterface) {
+ rendererInterface.cleanup();
+ });
+ hook.reactDevtoolsAgent = null;
+ }, "onAgentShutdown");
+ agent.addListener("shutdown", onAgentShutdown);
+ subs.push(function() {
+ agent.removeListener("shutdown", onAgentShutdown);
+ });
+ return function() {
+ subs.forEach(function(fn2) {
+ return fn2();
+ });
+ };
+ }
+ __name(initBackend, "initBackend");
+ function resolveBoxStyle(prefix, style) {
+ var hasParts = false;
+ var result = {
+ bottom: 0,
+ left: 0,
+ right: 0,
+ top: 0
+ };
+ var styleForAll = style[prefix];
+ if (styleForAll != null) {
+ for (var _i = 0, _Object$keys = Object.keys(result); _i < _Object$keys.length; _i++) {
+ var key = _Object$keys[_i];
+ result[key] = styleForAll;
+ }
+ hasParts = true;
+ }
+ var styleForHorizontal = style[prefix + "Horizontal"];
+ if (styleForHorizontal != null) {
+ result.left = styleForHorizontal;
+ result.right = styleForHorizontal;
+ hasParts = true;
+ } else {
+ var styleForLeft = style[prefix + "Left"];
+ if (styleForLeft != null) {
+ result.left = styleForLeft;
+ hasParts = true;
+ }
+ var styleForRight = style[prefix + "Right"];
+ if (styleForRight != null) {
+ result.right = styleForRight;
+ hasParts = true;
+ }
+ var styleForEnd = style[prefix + "End"];
+ if (styleForEnd != null) {
+ result.right = styleForEnd;
+ hasParts = true;
+ }
+ var styleForStart = style[prefix + "Start"];
+ if (styleForStart != null) {
+ result.left = styleForStart;
+ hasParts = true;
+ }
+ }
+ var styleForVertical = style[prefix + "Vertical"];
+ if (styleForVertical != null) {
+ result.bottom = styleForVertical;
+ result.top = styleForVertical;
+ hasParts = true;
+ } else {
+ var styleForBottom = style[prefix + "Bottom"];
+ if (styleForBottom != null) {
+ result.bottom = styleForBottom;
+ hasParts = true;
+ }
+ var styleForTop = style[prefix + "Top"];
+ if (styleForTop != null) {
+ result.top = styleForTop;
+ hasParts = true;
+ }
+ }
+ return hasParts ? result : null;
+ }
+ __name(resolveBoxStyle, "resolveBoxStyle");
+ var isArray = __webpack_require__(6);
+ function setupNativeStyleEditor_typeof(obj) {
+ "@babel/helpers - typeof";
+ if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+ setupNativeStyleEditor_typeof = /* @__PURE__ */ __name(function _typeof8(obj2) {
+ return typeof obj2;
+ }, "_typeof");
+ } else {
+ setupNativeStyleEditor_typeof = /* @__PURE__ */ __name(function _typeof8(obj2) {
+ return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+ }, "_typeof");
+ }
+ return setupNativeStyleEditor_typeof(obj);
+ }
+ __name(setupNativeStyleEditor_typeof, "setupNativeStyleEditor_typeof");
+ function setupNativeStyleEditor_defineProperty(obj, key, value) {
+ if (key in obj) {
+ Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
+ } else {
+ obj[key] = value;
+ }
+ return obj;
+ }
+ __name(setupNativeStyleEditor_defineProperty, "setupNativeStyleEditor_defineProperty");
+ function setupNativeStyleEditor(bridge, agent, resolveNativeStyle, validAttributes) {
+ bridge.addListener("NativeStyleEditor_measure", function(_ref) {
+ var id = _ref.id, rendererID = _ref.rendererID;
+ measureStyle(agent, bridge, resolveNativeStyle, id, rendererID);
+ });
+ bridge.addListener("NativeStyleEditor_renameAttribute", function(_ref2) {
+ var id = _ref2.id, rendererID = _ref2.rendererID, oldName = _ref2.oldName, newName = _ref2.newName, value = _ref2.value;
+ renameStyle(agent, id, rendererID, oldName, newName, value);
+ setTimeout(function() {
+ return measureStyle(agent, bridge, resolveNativeStyle, id, rendererID);
+ });
+ });
+ bridge.addListener("NativeStyleEditor_setValue", function(_ref3) {
+ var id = _ref3.id, rendererID = _ref3.rendererID, name = _ref3.name, value = _ref3.value;
+ setStyle(agent, id, rendererID, name, value);
+ setTimeout(function() {
+ return measureStyle(agent, bridge, resolveNativeStyle, id, rendererID);
+ });
+ });
+ bridge.send("isNativeStyleEditorSupported", {
+ isSupported: true,
+ validAttributes
+ });
+ }
+ __name(setupNativeStyleEditor, "setupNativeStyleEditor");
+ var EMPTY_BOX_STYLE = {
+ top: 0,
+ left: 0,
+ right: 0,
+ bottom: 0
+ };
+ var componentIDToStyleOverrides = /* @__PURE__ */ new Map();
+ function measureStyle(agent, bridge, resolveNativeStyle, id, rendererID) {
+ var data = agent.getInstanceAndStyle({
+ id,
+ rendererID
+ });
+ if (!data || !data.style) {
+ bridge.send("NativeStyleEditor_styleAndLayout", {
+ id,
+ layout: null,
+ style: null
+ });
+ return;
+ }
+ var instance = data.instance, style = data.style;
+ var resolvedStyle = resolveNativeStyle(style);
+ var styleOverrides = componentIDToStyleOverrides.get(id);
+ if (styleOverrides != null) {
+ resolvedStyle = Object.assign({}, resolvedStyle, styleOverrides);
+ }
+ if (!instance || typeof instance.measure !== "function") {
+ bridge.send("NativeStyleEditor_styleAndLayout", {
+ id,
+ layout: null,
+ style: resolvedStyle || null
+ });
+ return;
+ }
+ instance.measure(function(x, y, width, height, left2, top2) {
+ if (typeof x !== "number") {
+ bridge.send("NativeStyleEditor_styleAndLayout", {
+ id,
+ layout: null,
+ style: resolvedStyle || null
+ });
+ return;
+ }
+ var margin = resolvedStyle != null && resolveBoxStyle("margin", resolvedStyle) || EMPTY_BOX_STYLE;
+ var padding = resolvedStyle != null && resolveBoxStyle("padding", resolvedStyle) || EMPTY_BOX_STYLE;
+ bridge.send("NativeStyleEditor_styleAndLayout", {
+ id,
+ layout: {
+ x,
+ y,
+ width,
+ height,
+ left: left2,
+ top: top2,
+ margin,
+ padding
+ },
+ style: resolvedStyle || null
+ });
+ });
+ }
+ __name(measureStyle, "measureStyle");
+ function shallowClone(object) {
+ var cloned = {};
+ for (var n in object) {
+ cloned[n] = object[n];
+ }
+ return cloned;
+ }
+ __name(shallowClone, "shallowClone");
+ function renameStyle(agent, id, rendererID, oldName, newName, value) {
+ var _ref4;
+ var data = agent.getInstanceAndStyle({
+ id,
+ rendererID
+ });
+ if (!data || !data.style) {
+ return;
+ }
+ var instance = data.instance, style = data.style;
+ var newStyle = newName ? (_ref4 = {}, setupNativeStyleEditor_defineProperty(_ref4, oldName, void 0), setupNativeStyleEditor_defineProperty(_ref4, newName, value), _ref4) : setupNativeStyleEditor_defineProperty({}, oldName, void 0);
+ var customStyle;
+ if (instance !== null && typeof instance.setNativeProps === "function") {
+ var styleOverrides = componentIDToStyleOverrides.get(id);
+ if (!styleOverrides) {
+ componentIDToStyleOverrides.set(id, newStyle);
+ } else {
+ Object.assign(styleOverrides, newStyle);
+ }
+ instance.setNativeProps({
+ style: newStyle
+ });
+ } else if (Object(isArray[
+ "a"
+ /* default */
+ ])(style)) {
+ var lastIndex = style.length - 1;
+ if (setupNativeStyleEditor_typeof(style[lastIndex]) === "object" && !Object(isArray[
+ "a"
+ /* default */
+ ])(style[lastIndex])) {
+ customStyle = shallowClone(style[lastIndex]);
+ delete customStyle[oldName];
+ if (newName) {
+ customStyle[newName] = value;
+ } else {
+ customStyle[oldName] = void 0;
+ }
+ agent.overrideValueAtPath({
+ type: "props",
+ id,
+ rendererID,
+ path: ["style", lastIndex],
+ value: customStyle
+ });
+ } else {
+ agent.overrideValueAtPath({
+ type: "props",
+ id,
+ rendererID,
+ path: ["style"],
+ value: style.concat([newStyle])
+ });
+ }
+ } else if (setupNativeStyleEditor_typeof(style) === "object") {
+ customStyle = shallowClone(style);
+ delete customStyle[oldName];
+ if (newName) {
+ customStyle[newName] = value;
+ } else {
+ customStyle[oldName] = void 0;
+ }
+ agent.overrideValueAtPath({
+ type: "props",
+ id,
+ rendererID,
+ path: ["style"],
+ value: customStyle
+ });
+ } else {
+ agent.overrideValueAtPath({
+ type: "props",
+ id,
+ rendererID,
+ path: ["style"],
+ value: [style, newStyle]
+ });
+ }
+ agent.emit("hideNativeHighlight");
+ }
+ __name(renameStyle, "renameStyle");
+ function setStyle(agent, id, rendererID, name, value) {
+ var data = agent.getInstanceAndStyle({
+ id,
+ rendererID
+ });
+ if (!data || !data.style) {
+ return;
+ }
+ var instance = data.instance, style = data.style;
+ var newStyle = setupNativeStyleEditor_defineProperty({}, name, value);
+ if (instance !== null && typeof instance.setNativeProps === "function") {
+ var styleOverrides = componentIDToStyleOverrides.get(id);
+ if (!styleOverrides) {
+ componentIDToStyleOverrides.set(id, newStyle);
+ } else {
+ Object.assign(styleOverrides, newStyle);
+ }
+ instance.setNativeProps({
+ style: newStyle
+ });
+ } else if (Object(isArray[
+ "a"
+ /* default */
+ ])(style)) {
+ var lastLength = style.length - 1;
+ if (setupNativeStyleEditor_typeof(style[lastLength]) === "object" && !Object(isArray[
+ "a"
+ /* default */
+ ])(style[lastLength])) {
+ agent.overrideValueAtPath({
+ type: "props",
+ id,
+ rendererID,
+ path: ["style", lastLength, name],
+ value
+ });
+ } else {
+ agent.overrideValueAtPath({
+ type: "props",
+ id,
+ rendererID,
+ path: ["style"],
+ value: style.concat([newStyle])
+ });
+ }
+ } else {
+ agent.overrideValueAtPath({
+ type: "props",
+ id,
+ rendererID,
+ path: ["style"],
+ value: [style, newStyle]
+ });
+ }
+ agent.emit("hideNativeHighlight");
+ }
+ __name(setStyle, "setStyle");
+ installHook(window);
+ var backend_hook = window.__REACT_DEVTOOLS_GLOBAL_HOOK__;
+ var savedComponentFilters = Object(src_utils[
+ "e"
+ /* getDefaultComponentFilters */
+ ])();
+ function backend_debug(methodName) {
+ if (constants3[
+ "q"
+ /* __DEBUG__ */
+ ]) {
+ var _console;
+ for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+ args[_key - 1] = arguments[_key];
+ }
+ (_console = console).log.apply(_console, ["%c[core/backend] %c".concat(methodName), "color: teal; font-weight: bold;", "font-weight: bold;"].concat(args));
+ }
+ }
+ __name(backend_debug, "backend_debug");
+ function connectToDevTools(options14) {
+ if (backend_hook == null) {
+ return;
+ }
+ var _ref = options14 || {}, _ref$host = _ref.host, host = _ref$host === void 0 ? "localhost" : _ref$host, nativeStyleEditorValidAttributes = _ref.nativeStyleEditorValidAttributes, _ref$useHttps = _ref.useHttps, useHttps = _ref$useHttps === void 0 ? false : _ref$useHttps, _ref$port = _ref.port, port2 = _ref$port === void 0 ? 8097 : _ref$port, websocket = _ref.websocket, _ref$resolveRNStyle = _ref.resolveRNStyle, resolveRNStyle = _ref$resolveRNStyle === void 0 ? null : _ref$resolveRNStyle, _ref$retryConnectionD = _ref.retryConnectionDelay, retryConnectionDelay = _ref$retryConnectionD === void 0 ? 2e3 : _ref$retryConnectionD, _ref$isAppActive = _ref.isAppActive, isAppActive = _ref$isAppActive === void 0 ? function() {
+ return true;
+ } : _ref$isAppActive;
+ var protocol = useHttps ? "wss" : "ws";
+ var retryTimeoutID = null;
+ function scheduleRetry() {
+ if (retryTimeoutID === null) {
+ retryTimeoutID = setTimeout(function() {
+ return connectToDevTools(options14);
+ }, retryConnectionDelay);
+ }
+ }
+ __name(scheduleRetry, "scheduleRetry");
+ if (!isAppActive()) {
+ scheduleRetry();
+ return;
+ }
+ var bridge = null;
+ var messageListeners = [];
+ var uri = protocol + "://" + host + ":" + port2;
+ var ws = websocket ? websocket : new window.WebSocket(uri);
+ ws.onclose = handleClose;
+ ws.onerror = handleFailed;
+ ws.onmessage = handleMessage;
+ ws.onopen = function() {
+ bridge = new src_bridge({
+ listen: /* @__PURE__ */ __name(function listen(fn2) {
+ messageListeners.push(fn2);
+ return function() {
+ var index = messageListeners.indexOf(fn2);
+ if (index >= 0) {
+ messageListeners.splice(index, 1);
+ }
+ };
+ }, "listen"),
+ send: /* @__PURE__ */ __name(function send(event, payload, transferable) {
+ if (ws.readyState === ws.OPEN) {
+ if (constants3[
+ "q"
+ /* __DEBUG__ */
+ ]) {
+ backend_debug("wall.send()", event, payload);
+ }
+ ws.send(JSON.stringify({
+ event,
+ payload
+ }));
+ } else {
+ if (constants3[
+ "q"
+ /* __DEBUG__ */
+ ]) {
+ backend_debug("wall.send()", "Shutting down bridge because of closed WebSocket connection");
+ }
+ if (bridge !== null) {
+ bridge.shutdown();
+ }
+ scheduleRetry();
+ }
+ }, "send")
+ });
+ bridge.addListener("inspectElement", function(_ref2) {
+ var id = _ref2.id, rendererID = _ref2.rendererID;
+ var renderer = agent.rendererInterfaces[rendererID];
+ if (renderer != null) {
+ var nodes = renderer.findNativeNodesForFiberID(id);
+ if (nodes != null && nodes[0] != null) {
+ agent.emit("showNativeHighlight", nodes[0]);
+ }
+ }
+ });
+ bridge.addListener("updateComponentFilters", function(componentFilters) {
+ savedComponentFilters = componentFilters;
+ });
+ if (window.__REACT_DEVTOOLS_COMPONENT_FILTERS__ == null) {
+ bridge.send("overrideComponentFilters", savedComponentFilters);
+ }
+ var agent = new agent_Agent(bridge);
+ agent.addListener("shutdown", function() {
+ backend_hook.emit("shutdown");
+ });
+ initBackend(backend_hook, agent, window);
+ if (resolveRNStyle != null || backend_hook.resolveRNStyle != null) {
+ setupNativeStyleEditor(bridge, agent, resolveRNStyle || backend_hook.resolveRNStyle, nativeStyleEditorValidAttributes || backend_hook.nativeStyleEditorValidAttributes || null);
+ } else {
+ var lazyResolveRNStyle;
+ var lazyNativeStyleEditorValidAttributes;
+ var initAfterTick = /* @__PURE__ */ __name(function initAfterTick2() {
+ if (bridge !== null) {
+ setupNativeStyleEditor(bridge, agent, lazyResolveRNStyle, lazyNativeStyleEditorValidAttributes);
+ }
+ }, "initAfterTick");
+ if (!backend_hook.hasOwnProperty("resolveRNStyle")) {
+ Object.defineProperty(backend_hook, "resolveRNStyle", {
+ enumerable: false,
+ get: /* @__PURE__ */ __name(function get() {
+ return lazyResolveRNStyle;
+ }, "get"),
+ set: /* @__PURE__ */ __name(function set(value) {
+ lazyResolveRNStyle = value;
+ initAfterTick();
+ }, "set")
+ });
+ }
+ if (!backend_hook.hasOwnProperty("nativeStyleEditorValidAttributes")) {
+ Object.defineProperty(backend_hook, "nativeStyleEditorValidAttributes", {
+ enumerable: false,
+ get: /* @__PURE__ */ __name(function get() {
+ return lazyNativeStyleEditorValidAttributes;
+ }, "get"),
+ set: /* @__PURE__ */ __name(function set(value) {
+ lazyNativeStyleEditorValidAttributes = value;
+ initAfterTick();
+ }, "set")
+ });
+ }
+ }
+ };
+ function handleClose() {
+ if (constants3[
+ "q"
+ /* __DEBUG__ */
+ ]) {
+ backend_debug("WebSocket.onclose");
+ }
+ if (bridge !== null) {
+ bridge.emit("shutdown");
+ }
+ scheduleRetry();
+ }
+ __name(handleClose, "handleClose");
+ function handleFailed() {
+ if (constants3[
+ "q"
+ /* __DEBUG__ */
+ ]) {
+ backend_debug("WebSocket.onerror");
+ }
+ scheduleRetry();
+ }
+ __name(handleFailed, "handleFailed");
+ function handleMessage(event) {
+ var data;
+ try {
+ if (typeof event.data === "string") {
+ data = JSON.parse(event.data);
+ if (constants3[
+ "q"
+ /* __DEBUG__ */
+ ]) {
+ backend_debug("WebSocket.onmessage", data);
+ }
+ } else {
+ throw Error();
+ }
+ } catch (e2) {
+ console.error("[React DevTools] Failed to parse JSON: " + event.data);
+ return;
+ }
+ messageListeners.forEach(function(fn2) {
+ try {
+ fn2(data);
+ } catch (error) {
+ console.log("[React DevTools] Error calling listener", data);
+ console.log("error:", error);
+ throw error;
+ }
+ });
+ }
+ __name(handleMessage, "handleMessage");
+ }
+ __name(connectToDevTools, "connectToDevTools");
+ }
+ /******/
+ ])
+ );
+ });
+ }
+});
+
+// ../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/devtools.js
+var require_devtools = __commonJS({
+ "../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/devtools.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ Object.defineProperty(exports2, "__esModule", { value: true });
+ require_devtools_window_polyfill();
+ var react_devtools_core_1 = require_backend();
+ react_devtools_core_1.connectToDevTools();
+ }
+});
+
+// ../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/reconciler.js
+var require_reconciler = __commonJS({
+ "../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/reconciler.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ var __importDefault = exports2 && exports2.__importDefault || function(mod) {
+ return mod && mod.__esModule ? mod : { "default": mod };
+ };
+ Object.defineProperty(exports2, "__esModule", { value: true });
+ var scheduler_1 = require_scheduler();
+ var react_reconciler_1 = __importDefault(require_react_reconciler());
+ var yoga_layout_prebuilt_1 = __importDefault(require_wasm_sync2());
+ var dom_1 = require_dom();
+ if (process.env.DEV === "true") {
+ require_devtools();
+ }
+ var cleanupYogaNode = /* @__PURE__ */ __name((node) => {
+ node === null || node === void 0 ? void 0 : node.unsetMeasureFunc();
+ node === null || node === void 0 ? void 0 : node.freeRecursive();
+ }, "cleanupYogaNode");
+ exports2.default = react_reconciler_1.default({
+ // @ts-ignore
+ schedulePassiveEffects: scheduler_1.unstable_scheduleCallback,
+ cancelPassiveEffects: scheduler_1.unstable_cancelCallback,
+ now: Date.now,
+ getRootHostContext: () => ({
+ isInsideText: false
+ }),
+ prepareForCommit: () => null,
+ preparePortalMount: () => null,
+ clearContainer: () => false,
+ shouldDeprioritizeSubtree: () => false,
+ resetAfterCommit: (rootNode) => {
+ if (rootNode.isStaticDirty) {
+ rootNode.isStaticDirty = false;
+ if (typeof rootNode.onImmediateRender === "function") {
+ rootNode.onImmediateRender();
+ }
+ return;
+ }
+ if (typeof rootNode.onRender === "function") {
+ rootNode.onRender();
+ }
+ },
+ getChildHostContext: (parentHostContext, type) => {
+ const previousIsInsideText = parentHostContext.isInsideText;
+ const isInsideText = type === "ink-text" || type === "ink-virtual-text";
+ if (previousIsInsideText === isInsideText) {
+ return parentHostContext;
+ }
+ return { isInsideText };
+ },
+ shouldSetTextContent: () => false,
+ createInstance: (originalType, newProps, _root, hostContext) => {
+ if (hostContext.isInsideText && originalType === "ink-box") {
+ throw new Error(` can\u2019t be nested inside component`);
+ }
+ const type = originalType === "ink-text" && hostContext.isInsideText ? "ink-virtual-text" : originalType;
+ const node = dom_1.createNode(type);
+ for (const [key, value] of Object.entries(newProps)) {
+ if (key === "children") {
+ continue;
+ } else if (key === "style") {
+ dom_1.setStyle(node, value);
+ } else if (key === "internal_transform") {
+ node.internal_transform = value;
+ } else if (key === "internal_static") {
+ node.internal_static = true;
+ } else {
+ dom_1.setAttribute(node, key, value);
+ }
+ }
+ return node;
+ },
+ createTextInstance: (text, _root, hostContext) => {
+ if (!hostContext.isInsideText) {
+ throw new Error(`Text string "${text}" must be rendered inside component`);
+ }
+ return dom_1.createTextNode(text);
+ },
+ resetTextContent: () => {
+ },
+ hideTextInstance: (node) => {
+ dom_1.setTextNodeValue(node, "");
+ },
+ unhideTextInstance: (node, text) => {
+ dom_1.setTextNodeValue(node, text);
+ },
+ getPublicInstance: (instance) => instance,
+ hideInstance: (node) => {
+ var _a2;
+ (_a2 = node.yogaNode) === null || _a2 === void 0 ? void 0 : _a2.setDisplay(yoga_layout_prebuilt_1.default.DISPLAY_NONE);
+ },
+ unhideInstance: (node) => {
+ var _a2;
+ (_a2 = node.yogaNode) === null || _a2 === void 0 ? void 0 : _a2.setDisplay(yoga_layout_prebuilt_1.default.DISPLAY_FLEX);
+ },
+ appendInitialChild: dom_1.appendChildNode,
+ appendChild: dom_1.appendChildNode,
+ insertBefore: dom_1.insertBeforeNode,
+ finalizeInitialChildren: (node, _type2, _props, rootNode) => {
+ if (node.internal_static) {
+ rootNode.isStaticDirty = true;
+ rootNode.staticNode = node;
+ }
+ return false;
+ },
+ supportsMutation: true,
+ appendChildToContainer: dom_1.appendChildNode,
+ insertInContainerBefore: dom_1.insertBeforeNode,
+ removeChildFromContainer: (node, removeNode) => {
+ dom_1.removeChildNode(node, removeNode);
+ cleanupYogaNode(removeNode.yogaNode);
+ },
+ prepareUpdate: (node, _type2, oldProps, newProps, rootNode) => {
+ if (node.internal_static) {
+ rootNode.isStaticDirty = true;
+ }
+ const updatePayload = {};
+ const keys = Object.keys(newProps);
+ for (const key of keys) {
+ if (newProps[key] !== oldProps[key]) {
+ const isStyle2 = key === "style" && typeof newProps.style === "object" && typeof oldProps.style === "object";
+ if (isStyle2) {
+ const newStyle = newProps.style;
+ const oldStyle = oldProps.style;
+ const styleKeys = Object.keys(newStyle);
+ for (const styleKey of styleKeys) {
+ if (styleKey === "borderStyle" || styleKey === "borderColor") {
+ if (typeof updatePayload.style !== "object") {
+ const style = {};
+ updatePayload.style = style;
+ }
+ updatePayload.style.borderStyle = newStyle.borderStyle;
+ updatePayload.style.borderColor = newStyle.borderColor;
+ }
+ if (newStyle[styleKey] !== oldStyle[styleKey]) {
+ if (typeof updatePayload.style !== "object") {
+ const style = {};
+ updatePayload.style = style;
+ }
+ updatePayload.style[styleKey] = newStyle[styleKey];
+ }
+ }
+ continue;
+ }
+ updatePayload[key] = newProps[key];
+ }
+ }
+ return updatePayload;
+ },
+ commitUpdate: (node, updatePayload) => {
+ for (const [key, value] of Object.entries(updatePayload)) {
+ if (key === "children") {
+ continue;
+ } else if (key === "style") {
+ dom_1.setStyle(node, value);
+ } else if (key === "internal_transform") {
+ node.internal_transform = value;
+ } else if (key === "internal_static") {
+ node.internal_static = true;
+ } else {
+ dom_1.setAttribute(node, key, value);
+ }
+ }
+ },
+ commitTextUpdate: (node, _oldText, newText) => {
+ dom_1.setTextNodeValue(node, newText);
+ },
+ removeChild: (node, removeNode) => {
+ dom_1.removeChildNode(node, removeNode);
+ cleanupYogaNode(removeNode.yogaNode);
+ }
+ });
+ }
+});
+
+// ../../node_modules/.pnpm/indent-string@4.0.0/node_modules/indent-string/index.js
+var require_indent_string = __commonJS({
+ "../../node_modules/.pnpm/indent-string@4.0.0/node_modules/indent-string/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ module2.exports = (string, count = 1, options14) => {
+ options14 = {
+ indent: " ",
+ includeEmptyLines: false,
+ ...options14
+ };
+ if (typeof string !== "string") {
+ throw new TypeError(
+ `Expected \`input\` to be a \`string\`, got \`${typeof string}\``
+ );
+ }
+ if (typeof count !== "number") {
+ throw new TypeError(
+ `Expected \`count\` to be a \`number\`, got \`${typeof count}\``
+ );
+ }
+ if (typeof options14.indent !== "string") {
+ throw new TypeError(
+ `Expected \`options.indent\` to be a \`string\`, got \`${typeof options14.indent}\``
+ );
+ }
+ if (count === 0) {
+ return string;
+ }
+ const regex = options14.includeEmptyLines ? /^/gm : /^(?!\s*$)/gm;
+ return string.replace(regex, options14.indent.repeat(count));
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/get-max-width.js
+var require_get_max_width = __commonJS({
+ "../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/get-max-width.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ var __importDefault = exports2 && exports2.__importDefault || function(mod) {
+ return mod && mod.__esModule ? mod : { "default": mod };
+ };
+ Object.defineProperty(exports2, "__esModule", { value: true });
+ var yoga_layout_prebuilt_1 = __importDefault(require_wasm_sync2());
+ exports2.default = (yogaNode) => {
+ return yogaNode.getComputedWidth() - yogaNode.getComputedPadding(yoga_layout_prebuilt_1.default.EDGE_LEFT) - yogaNode.getComputedPadding(yoga_layout_prebuilt_1.default.EDGE_RIGHT) - yogaNode.getComputedBorder(yoga_layout_prebuilt_1.default.EDGE_LEFT) - yogaNode.getComputedBorder(yoga_layout_prebuilt_1.default.EDGE_RIGHT);
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/cli-boxes@2.2.1/node_modules/cli-boxes/boxes.json
+var require_boxes = __commonJS({
+ "../../node_modules/.pnpm/cli-boxes@2.2.1/node_modules/cli-boxes/boxes.json"(exports2, module2) {
+ module2.exports = {
+ single: {
+ topLeft: "\u250C",
+ topRight: "\u2510",
+ bottomRight: "\u2518",
+ bottomLeft: "\u2514",
+ vertical: "\u2502",
+ horizontal: "\u2500"
+ },
+ double: {
+ topLeft: "\u2554",
+ topRight: "\u2557",
+ bottomRight: "\u255D",
+ bottomLeft: "\u255A",
+ vertical: "\u2551",
+ horizontal: "\u2550"
+ },
+ round: {
+ topLeft: "\u256D",
+ topRight: "\u256E",
+ bottomRight: "\u256F",
+ bottomLeft: "\u2570",
+ vertical: "\u2502",
+ horizontal: "\u2500"
+ },
+ bold: {
+ topLeft: "\u250F",
+ topRight: "\u2513",
+ bottomRight: "\u251B",
+ bottomLeft: "\u2517",
+ vertical: "\u2503",
+ horizontal: "\u2501"
+ },
+ singleDouble: {
+ topLeft: "\u2553",
+ topRight: "\u2556",
+ bottomRight: "\u255C",
+ bottomLeft: "\u2559",
+ vertical: "\u2551",
+ horizontal: "\u2500"
+ },
+ doubleSingle: {
+ topLeft: "\u2552",
+ topRight: "\u2555",
+ bottomRight: "\u255B",
+ bottomLeft: "\u2558",
+ vertical: "\u2502",
+ horizontal: "\u2550"
+ },
+ classic: {
+ topLeft: "+",
+ topRight: "+",
+ bottomRight: "+",
+ bottomLeft: "+",
+ vertical: "|",
+ horizontal: "-"
+ }
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/cli-boxes@2.2.1/node_modules/cli-boxes/index.js
+var require_cli_boxes = __commonJS({
+ "../../node_modules/.pnpm/cli-boxes@2.2.1/node_modules/cli-boxes/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var cliBoxes = require_boxes();
+ module2.exports = cliBoxes;
+ module2.exports.default = cliBoxes;
+ }
+});
+
+// ../../node_modules/.pnpm/has-flag@4.0.0/node_modules/has-flag/index.js
+var require_has_flag2 = __commonJS({
+ "../../node_modules/.pnpm/has-flag@4.0.0/node_modules/has-flag/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ 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);
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/supports-color@7.2.0/node_modules/supports-color/index.js
+var require_supports_color2 = __commonJS({
+ "../../node_modules/.pnpm/supports-color@7.2.0/node_modules/supports-color/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var os9 = require("os");
+ var tty2 = require("tty");
+ var hasFlag2 = require_has_flag2();
+ var { env: env5 } = 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 env5) {
+ if (env5.FORCE_COLOR === "true") {
+ forceColor = 1;
+ } else if (env5.FORCE_COLOR === "false") {
+ forceColor = 0;
+ } else {
+ forceColor = env5.FORCE_COLOR.length === 0 ? 1 : Math.min(parseInt(env5.FORCE_COLOR, 10), 3);
+ }
+ }
+ function translateLevel2(level) {
+ if (level === 0) {
+ return false;
+ }
+ return {
+ level,
+ hasBasic: true,
+ has256: level >= 2,
+ has16m: level >= 3
+ };
+ }
+ __name(translateLevel2, "translateLevel");
+ 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 (env5.TERM === "dumb") {
+ return min;
+ }
+ if (process.platform === "win32") {
+ const osRelease = os9.release().split(".");
+ if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
+ return Number(osRelease[2]) >= 14931 ? 3 : 2;
+ }
+ return 1;
+ }
+ if ("CI" in env5) {
+ if (["TRAVIS", "CIRCLECI", "APPVEYOR", "GITLAB_CI", "GITHUB_ACTIONS", "BUILDKITE"].some((sign) => sign in env5) || env5.CI_NAME === "codeship") {
+ return 1;
+ }
+ return min;
+ }
+ if ("TEAMCITY_VERSION" in env5) {
+ return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env5.TEAMCITY_VERSION) ? 1 : 0;
+ }
+ if (env5.COLORTERM === "truecolor") {
+ return 3;
+ }
+ if ("TERM_PROGRAM" in env5) {
+ const version2 = parseInt((env5.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+ switch (env5.TERM_PROGRAM) {
+ case "iTerm.app":
+ return version2 >= 3 ? 3 : 2;
+ case "Apple_Terminal":
+ return 2;
+ }
+ }
+ if (/-256(color)?$/i.test(env5.TERM)) {
+ return 2;
+ }
+ if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env5.TERM)) {
+ return 1;
+ }
+ if ("COLORTERM" in env5) {
+ return 1;
+ }
+ return min;
+ }
+ __name(supportsColor2, "supportsColor");
+ function getSupportLevel(stream2) {
+ const level = supportsColor2(stream2, stream2 && stream2.isTTY);
+ return translateLevel2(level);
+ }
+ __name(getSupportLevel, "getSupportLevel");
+ module2.exports = {
+ supportsColor: getSupportLevel,
+ stdout: translateLevel2(supportsColor2(true, tty2.isatty(1))),
+ stderr: translateLevel2(supportsColor2(true, tty2.isatty(2)))
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/chalk@4.1.2/node_modules/chalk/source/util.js
+var require_util6 = __commonJS({
+ "../../node_modules/.pnpm/chalk@4.1.2/node_modules/chalk/source/util.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var stringReplaceAll = /* @__PURE__ */ __name((string, substring, replacer2) => {
+ 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 + replacer2;
+ endIndex = index + substringLength;
+ index = string.indexOf(substring, endIndex);
+ } while (index !== -1);
+ returnValue += string.substr(endIndex);
+ return returnValue;
+ }, "stringReplaceAll");
+ var stringEncaseCRLFWithFirstIndex = /* @__PURE__ */ __name((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;
+ }, "stringEncaseCRLFWithFirstIndex");
+ module2.exports = {
+ stringReplaceAll,
+ stringEncaseCRLFWithFirstIndex
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/chalk@4.1.2/node_modules/chalk/source/templates.js
+var require_templates2 = __commonJS({
+ "../../node_modules/.pnpm/chalk@4.1.2/node_modules/chalk/source/templates.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var TEMPLATE_REGEX2 = /(?:\\(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;
+ }
+ __name(unescape2, "unescape");
+ 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;
+ }
+ __name(parseArguments, "parseArguments");
+ 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;
+ }
+ __name(parseStyle, "parseStyle");
+ function buildStyle(chalk17, styles) {
+ const enabled = {};
+ for (const layer of styles) {
+ for (const style of layer.styles) {
+ enabled[style[0]] = layer.inverse ? null : style.slice(1);
+ }
+ }
+ let current = chalk17;
+ for (const [styleName, styles2] of Object.entries(enabled)) {
+ if (!Array.isArray(styles2)) {
+ continue;
+ }
+ if (!(styleName in current)) {
+ throw new Error(`Unknown Chalk style: ${styleName}`);
+ }
+ current = styles2.length > 0 ? current[styleName](...styles2) : current[styleName];
+ }
+ return current;
+ }
+ __name(buildStyle, "buildStyle");
+ module2.exports = (chalk17, temporary) => {
+ const styles = [];
+ const chunks = [];
+ let chunk = [];
+ temporary.replace(TEMPLATE_REGEX2, (m, escapeCharacter, inverse, style, close, character) => {
+ if (escapeCharacter) {
+ chunk.push(unescape2(escapeCharacter));
+ } else if (style) {
+ const string = chunk.join("");
+ chunk = [];
+ chunks.push(styles.length === 0 ? string : buildStyle(chalk17, styles)(string));
+ styles.push({ inverse, styles: parseStyle(style) });
+ } else if (close) {
+ if (styles.length === 0) {
+ throw new Error("Found extraneous } in Chalk template literal");
+ }
+ chunks.push(buildStyle(chalk17, styles)(chunk.join("")));
+ chunk = [];
+ styles.pop();
+ } else {
+ chunk.push(character);
+ }
+ });
+ chunks.push(chunk.join(""));
+ if (styles.length > 0) {
+ const errMessage = `Chalk template literal is missing ${styles.length} closing bracket${styles.length === 1 ? "" : "s"} (\`}\`)`;
+ throw new Error(errMessage);
+ }
+ return chunks.join("");
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/chalk@4.1.2/node_modules/chalk/source/index.js
+var require_source = __commonJS({
+ "../../node_modules/.pnpm/chalk@4.1.2/node_modules/chalk/source/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var ansiStyles = require_ansi_styles2();
+ var { stdout: stdoutColor, stderr: stderrColor } = require_supports_color2();
+ var {
+ stringReplaceAll,
+ stringEncaseCRLFWithFirstIndex
+ } = require_util6();
+ var { isArray } = Array;
+ var levelMapping = [
+ "ansi",
+ "ansi",
+ "ansi256",
+ "ansi16m"
+ ];
+ var styles = /* @__PURE__ */ Object.create(null);
+ var applyOptions = /* @__PURE__ */ __name((object, options14 = {}) => {
+ if (options14.level && !(Number.isInteger(options14.level) && options14.level >= 0 && options14.level <= 3)) {
+ throw new Error("The `level` option should be an integer from 0 to 3");
+ }
+ const colorLevel = stdoutColor ? stdoutColor.level : 0;
+ object.level = options14.level === void 0 ? colorLevel : options14.level;
+ }, "applyOptions");
+ var ChalkClass = class {
+ constructor(options14) {
+ return chalkFactory(options14);
+ }
+ };
+ __name(ChalkClass, "ChalkClass");
+ var chalkFactory = /* @__PURE__ */ __name((options14) => {
+ const chalk18 = {};
+ applyOptions(chalk18, options14);
+ chalk18.template = (...arguments_) => chalkTag(chalk18.template, ...arguments_);
+ Object.setPrototypeOf(chalk18, Chalk.prototype);
+ Object.setPrototypeOf(chalk18.template, chalk18);
+ chalk18.template.constructor = () => {
+ throw new Error("`chalk.constructor()` is deprecated. Use `new chalk.Instance()` instead.");
+ };
+ chalk18.template.Instance = ChalkClass;
+ return chalk18.template;
+ }, "chalkFactory");
+ function Chalk(options14) {
+ return chalkFactory(options14);
+ }
+ __name(Chalk, "Chalk");
+ for (const [styleName, style] of Object.entries(ansiStyles)) {
+ styles[styleName] = {
+ get() {
+ const builder = createBuilder(this, createStyler(style.open, style.close, this._styler), this._isEmpty);
+ Object.defineProperty(this, styleName, { value: builder });
+ return builder;
+ }
+ };
+ }
+ styles.visible = {
+ get() {
+ const builder = createBuilder(this, this._styler, true);
+ Object.defineProperty(this, "visible", { value: builder });
+ return builder;
+ }
+ };
+ var usedModels = ["rgb", "hex", "keyword", "hsl", "hsv", "hwb", "ansi", "ansi256"];
+ for (const model of usedModels) {
+ styles[model] = {
+ get() {
+ const { level } = this;
+ return function(...arguments_) {
+ const styler = createStyler(ansiStyles.color[levelMapping[level]][model](...arguments_), ansiStyles.color.close, this._styler);
+ return createBuilder(this, styler, this._isEmpty);
+ };
+ }
+ };
+ }
+ for (const model of usedModels) {
+ const bgModel = "bg" + model[0].toUpperCase() + model.slice(1);
+ styles[bgModel] = {
+ get() {
+ const { level } = this;
+ return function(...arguments_) {
+ const styler = createStyler(ansiStyles.bgColor[levelMapping[level]][model](...arguments_), ansiStyles.bgColor.close, this._styler);
+ return createBuilder(this, styler, this._isEmpty);
+ };
+ }
+ };
+ }
+ var proto = Object.defineProperties(() => {
+ }, {
+ ...styles,
+ level: {
+ enumerable: true,
+ get() {
+ return this._generator.level;
+ },
+ set(level) {
+ this._generator.level = level;
+ }
+ }
+ });
+ var createStyler = /* @__PURE__ */ __name((open3, close, parent) => {
+ let openAll;
+ let closeAll;
+ if (parent === void 0) {
+ openAll = open3;
+ closeAll = close;
+ } else {
+ openAll = parent.openAll + open3;
+ closeAll = close + parent.closeAll;
+ }
+ return {
+ open: open3,
+ close,
+ openAll,
+ closeAll,
+ parent
+ };
+ }, "createStyler");
+ var createBuilder = /* @__PURE__ */ __name((self2, _styler, _isEmpty) => {
+ const builder = /* @__PURE__ */ __name((...arguments_) => {
+ if (isArray(arguments_[0]) && isArray(arguments_[0].raw)) {
+ return applyStyle(builder, chalkTag(builder, ...arguments_));
+ }
+ return applyStyle(builder, arguments_.length === 1 ? "" + arguments_[0] : arguments_.join(" "));
+ }, "builder");
+ Object.setPrototypeOf(builder, proto);
+ builder._generator = self2;
+ builder._styler = _styler;
+ builder._isEmpty = _isEmpty;
+ return builder;
+ }, "createBuilder");
+ var applyStyle = /* @__PURE__ */ __name((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 = 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;
+ }, "applyStyle");
+ var template;
+ var chalkTag = /* @__PURE__ */ __name((chalk18, ...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_templates2();
+ }
+ return template(chalk18, parts.join(""));
+ }, "chalkTag");
+ Object.defineProperties(Chalk.prototype, styles);
+ var chalk17 = Chalk();
+ chalk17.supportsColor = stdoutColor;
+ chalk17.stderr = Chalk({ level: stderrColor ? stderrColor.level : 0 });
+ chalk17.stderr.supportsColor = stderrColor;
+ module2.exports = chalk17;
+ }
+});
+
+// ../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/colorize.js
+var require_colorize = __commonJS({
+ "../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/colorize.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ var __importDefault = exports2 && exports2.__importDefault || function(mod) {
+ return mod && mod.__esModule ? mod : { "default": mod };
+ };
+ Object.defineProperty(exports2, "__esModule", { value: true });
+ var chalk_1 = __importDefault(require_source());
+ var RGB_LIKE_REGEX = /^(rgb|hsl|hsv|hwb)\(\s?(\d+),\s?(\d+),\s?(\d+)\s?\)$/;
+ var ANSI_REGEX = /^(ansi|ansi256)\(\s?(\d+)\s?\)$/;
+ var getMethod = /* @__PURE__ */ __name((name, type) => {
+ if (type === "foreground") {
+ return name;
+ }
+ return "bg" + name[0].toUpperCase() + name.slice(1);
+ }, "getMethod");
+ exports2.default = (str, color, type) => {
+ if (!color) {
+ return str;
+ }
+ if (color in chalk_1.default) {
+ const method = getMethod(color, type);
+ return chalk_1.default[method](str);
+ }
+ if (color.startsWith("#")) {
+ const method = getMethod("hex", type);
+ return chalk_1.default[method](color)(str);
+ }
+ if (color.startsWith("ansi")) {
+ const matches = ANSI_REGEX.exec(color);
+ if (!matches) {
+ return str;
+ }
+ const method = getMethod(matches[1], type);
+ const value = Number(matches[2]);
+ return chalk_1.default[method](value)(str);
+ }
+ const isRgbLike = color.startsWith("rgb") || color.startsWith("hsl") || color.startsWith("hsv") || color.startsWith("hwb");
+ if (isRgbLike) {
+ const matches = RGB_LIKE_REGEX.exec(color);
+ if (!matches) {
+ return str;
+ }
+ const method = getMethod(matches[1], type);
+ const firstValue = Number(matches[2]);
+ const secondValue = Number(matches[3]);
+ const thirdValue = Number(matches[4]);
+ return chalk_1.default[method](firstValue, secondValue, thirdValue)(str);
+ }
+ return str;
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/render-border.js
+var require_render_border = __commonJS({
+ "../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/render-border.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ var __importDefault = exports2 && exports2.__importDefault || function(mod) {
+ return mod && mod.__esModule ? mod : { "default": mod };
+ };
+ Object.defineProperty(exports2, "__esModule", { value: true });
+ var cli_boxes_1 = __importDefault(require_cli_boxes());
+ var colorize_1 = __importDefault(require_colorize());
+ exports2.default = (x, y, node, output) => {
+ if (typeof node.style.borderStyle === "string") {
+ const width = node.yogaNode.getComputedWidth();
+ const height = node.yogaNode.getComputedHeight();
+ const color = node.style.borderColor;
+ const box = cli_boxes_1.default[node.style.borderStyle];
+ const topBorder = colorize_1.default(box.topLeft + box.horizontal.repeat(width - 2) + box.topRight, color, "foreground");
+ const verticalBorder = (colorize_1.default(box.vertical, color, "foreground") + "\n").repeat(height - 2);
+ const bottomBorder = colorize_1.default(box.bottomLeft + box.horizontal.repeat(width - 2) + box.bottomRight, color, "foreground");
+ output.write(x, y, topBorder, { transformers: [] });
+ output.write(x, y + 1, verticalBorder, { transformers: [] });
+ output.write(x + width - 1, y + 1, verticalBorder, { transformers: [] });
+ output.write(x, y + height - 1, bottomBorder, { transformers: [] });
+ }
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/render-node-to-output.js
+var require_render_node_to_output = __commonJS({
+ "../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/render-node-to-output.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ var __importDefault = exports2 && exports2.__importDefault || function(mod) {
+ return mod && mod.__esModule ? mod : { "default": mod };
+ };
+ Object.defineProperty(exports2, "__esModule", { value: true });
+ var yoga_layout_prebuilt_1 = __importDefault(require_wasm_sync2());
+ var widest_line_1 = __importDefault(require_widest_line());
+ var indent_string_1 = __importDefault(require_indent_string());
+ var wrap_text_1 = __importDefault(require_wrap_text());
+ var get_max_width_1 = __importDefault(require_get_max_width());
+ var squash_text_nodes_1 = __importDefault(require_squash_text_nodes());
+ var render_border_1 = __importDefault(require_render_border());
+ var applyPaddingToText = /* @__PURE__ */ __name((node, text) => {
+ var _a2;
+ const yogaNode = (_a2 = node.childNodes[0]) === null || _a2 === void 0 ? void 0 : _a2.yogaNode;
+ if (yogaNode) {
+ const offsetX = yogaNode.getComputedLeft();
+ const offsetY = yogaNode.getComputedTop();
+ text = "\n".repeat(offsetY) + indent_string_1.default(text, offsetX);
+ }
+ return text;
+ }, "applyPaddingToText");
+ var renderNodeToOutput = /* @__PURE__ */ __name((node, output, options14) => {
+ var _a2;
+ const { offsetX = 0, offsetY = 0, transformers = [], skipStaticElements } = options14;
+ if (skipStaticElements && node.internal_static) {
+ return;
+ }
+ const { yogaNode } = node;
+ if (yogaNode) {
+ if (yogaNode.getDisplay() === yoga_layout_prebuilt_1.default.DISPLAY_NONE) {
+ return;
+ }
+ const x = offsetX + yogaNode.getComputedLeft();
+ const y = offsetY + yogaNode.getComputedTop();
+ let newTransformers = transformers;
+ if (typeof node.internal_transform === "function") {
+ newTransformers = [node.internal_transform, ...transformers];
+ }
+ if (node.nodeName === "ink-text") {
+ let text = squash_text_nodes_1.default(node);
+ if (text.length > 0) {
+ const currentWidth = widest_line_1.default(text);
+ const maxWidth = get_max_width_1.default(yogaNode);
+ if (currentWidth > maxWidth) {
+ const textWrap = (_a2 = node.style.textWrap) !== null && _a2 !== void 0 ? _a2 : "wrap";
+ text = wrap_text_1.default(text, maxWidth, textWrap);
+ }
+ text = applyPaddingToText(node, text);
+ output.write(x, y, text, { transformers: newTransformers });
+ }
+ return;
+ }
+ if (node.nodeName === "ink-box") {
+ render_border_1.default(x, y, node, output);
+ }
+ if (node.nodeName === "ink-root" || node.nodeName === "ink-box") {
+ for (const childNode of node.childNodes) {
+ renderNodeToOutput(childNode, output, {
+ offsetX: x,
+ offsetY: y,
+ transformers: newTransformers,
+ skipStaticElements
+ });
+ }
+ }
+ }
+ }, "renderNodeToOutput");
+ exports2.default = renderNodeToOutput;
+ }
+});
+
+// ../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/output.js
+var require_output = __commonJS({
+ "../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/output.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ var __importDefault = exports2 && exports2.__importDefault || function(mod) {
+ return mod && mod.__esModule ? mod : { "default": mod };
+ };
+ Object.defineProperty(exports2, "__esModule", { value: true });
+ var slice_ansi_1 = __importDefault(require_slice_ansi());
+ var string_width_1 = __importDefault(require_string_width());
+ var Output = class {
+ constructor(options14) {
+ this.writes = [];
+ const { width, height } = options14;
+ this.width = width;
+ this.height = height;
+ }
+ write(x, y, text, options14) {
+ const { transformers } = options14;
+ if (!text) {
+ return;
+ }
+ this.writes.push({ x, y, text, transformers });
+ }
+ get() {
+ const output = [];
+ for (let y = 0; y < this.height; y++) {
+ output.push(" ".repeat(this.width));
+ }
+ for (const write of this.writes) {
+ const { x, y, text, transformers } = write;
+ const lines = text.split("\n");
+ let offsetY = 0;
+ for (let line of lines) {
+ const currentLine = output[y + offsetY];
+ if (!currentLine) {
+ continue;
+ }
+ const width = string_width_1.default(line);
+ for (const transformer of transformers) {
+ line = transformer(line);
+ }
+ output[y + offsetY] = slice_ansi_1.default(currentLine, 0, x) + line + slice_ansi_1.default(currentLine, x + width);
+ offsetY++;
+ }
+ }
+ const generatedOutput = output.map((line) => line.trimRight()).join("\n");
+ return {
+ output: generatedOutput,
+ height: output.length
+ };
+ }
+ };
+ __name(Output, "Output");
+ exports2.default = Output;
+ }
+});
+
+// ../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/renderer.js
+var require_renderer = __commonJS({
+ "../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/renderer.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ var __importDefault = exports2 && exports2.__importDefault || function(mod) {
+ return mod && mod.__esModule ? mod : { "default": mod };
+ };
+ Object.defineProperty(exports2, "__esModule", { value: true });
+ var yoga_layout_prebuilt_1 = __importDefault(require_wasm_sync2());
+ var render_node_to_output_1 = __importDefault(require_render_node_to_output());
+ var output_1 = __importDefault(require_output());
+ exports2.default = (node, terminalWidth) => {
+ var _a2;
+ node.yogaNode.setWidth(terminalWidth);
+ if (node.yogaNode) {
+ node.yogaNode.calculateLayout(void 0, void 0, yoga_layout_prebuilt_1.default.DIRECTION_LTR);
+ const output = new output_1.default({
+ width: node.yogaNode.getComputedWidth(),
+ height: node.yogaNode.getComputedHeight()
+ });
+ render_node_to_output_1.default(node, output, { skipStaticElements: true });
+ let staticOutput;
+ if ((_a2 = node.staticNode) === null || _a2 === void 0 ? void 0 : _a2.yogaNode) {
+ staticOutput = new output_1.default({
+ width: node.staticNode.yogaNode.getComputedWidth(),
+ height: node.staticNode.yogaNode.getComputedHeight()
+ });
+ render_node_to_output_1.default(node.staticNode, staticOutput, {
+ skipStaticElements: false
+ });
+ }
+ const { output: generatedOutput, height: outputHeight } = output.get();
+ return {
+ output: generatedOutput,
+ outputHeight,
+ // Newline at the end is needed, because static output doesn't have one, so
+ // interactive output will override last line of static output
+ staticOutput: staticOutput ? `${staticOutput.get().output}
+` : ""
+ };
+ }
+ return {
+ output: "",
+ outputHeight: 0,
+ staticOutput: ""
+ };
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/patch-console@1.0.0/node_modules/patch-console/build/index.js
+var require_build = __commonJS({
+ "../../node_modules/.pnpm/patch-console@1.0.0/node_modules/patch-console/build/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var stream_1 = require("stream");
+ var CONSOLE_METHODS = [
+ "assert",
+ "count",
+ "countReset",
+ "debug",
+ "dir",
+ "dirxml",
+ "error",
+ "group",
+ "groupCollapsed",
+ "groupEnd",
+ "info",
+ "log",
+ "table",
+ "time",
+ "timeEnd",
+ "timeLog",
+ "trace",
+ "warn"
+ ];
+ var originalMethods = {};
+ var patchConsole = /* @__PURE__ */ __name((callback) => {
+ const stdout = new stream_1.PassThrough();
+ const stderr = new stream_1.PassThrough();
+ stdout.write = (data) => callback("stdout", data);
+ stderr.write = (data) => callback("stderr", data);
+ const internalConsole = new console.Console(stdout, stderr);
+ for (const method of CONSOLE_METHODS) {
+ originalMethods[method] = console[method];
+ console[method] = internalConsole[method];
+ }
+ return () => {
+ for (const method of CONSOLE_METHODS) {
+ console[method] = originalMethods[method];
+ }
+ originalMethods = {};
+ };
+ }, "patchConsole");
+ module2.exports = patchConsole;
+ }
+});
+
+// ../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/instances.js
+var require_instances = __commonJS({
+ "../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/instances.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ Object.defineProperty(exports2, "__esModule", { value: true });
+ exports2.default = /* @__PURE__ */ new WeakMap();
+ }
+});
+
+// ../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/components/AppContext.js
+var require_AppContext = __commonJS({
+ "../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/components/AppContext.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ Object.defineProperty(exports2, "__esModule", { value: true });
+ var react_1 = require_react();
+ var AppContext = react_1.createContext({
+ exit: () => {
+ }
+ });
+ AppContext.displayName = "InternalAppContext";
+ exports2.default = AppContext;
+ }
+});
+
+// ../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/components/StdinContext.js
+var require_StdinContext = __commonJS({
+ "../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/components/StdinContext.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ Object.defineProperty(exports2, "__esModule", { value: true });
+ var react_1 = require_react();
+ var StdinContext = react_1.createContext({
+ stdin: void 0,
+ setRawMode: () => {
+ },
+ isRawModeSupported: false,
+ internal_exitOnCtrlC: true
+ });
+ StdinContext.displayName = "InternalStdinContext";
+ exports2.default = StdinContext;
+ }
+});
+
+// ../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/components/StdoutContext.js
+var require_StdoutContext = __commonJS({
+ "../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/components/StdoutContext.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ Object.defineProperty(exports2, "__esModule", { value: true });
+ var react_1 = require_react();
+ var StdoutContext = react_1.createContext({
+ stdout: void 0,
+ write: () => {
+ }
+ });
+ StdoutContext.displayName = "InternalStdoutContext";
+ exports2.default = StdoutContext;
+ }
+});
+
+// ../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/components/StderrContext.js
+var require_StderrContext = __commonJS({
+ "../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/components/StderrContext.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ Object.defineProperty(exports2, "__esModule", { value: true });
+ var react_1 = require_react();
+ var StderrContext = react_1.createContext({
+ stderr: void 0,
+ write: () => {
+ }
+ });
+ StderrContext.displayName = "InternalStderrContext";
+ exports2.default = StderrContext;
+ }
+});
+
+// ../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/components/FocusContext.js
+var require_FocusContext = __commonJS({
+ "../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/components/FocusContext.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ Object.defineProperty(exports2, "__esModule", { value: true });
+ var react_1 = require_react();
+ var FocusContext = react_1.createContext({
+ activeId: void 0,
+ add: () => {
+ },
+ remove: () => {
+ },
+ activate: () => {
+ },
+ deactivate: () => {
+ },
+ enableFocus: () => {
+ },
+ disableFocus: () => {
+ },
+ focusNext: () => {
+ },
+ focusPrevious: () => {
+ },
+ focus: () => {
+ }
+ });
+ FocusContext.displayName = "InternalFocusContext";
+ exports2.default = FocusContext;
+ }
+});
+
+// ../../node_modules/.pnpm/escape-string-regexp@2.0.0/node_modules/escape-string-regexp/index.js
+var require_escape_string_regexp2 = __commonJS({
+ "../../node_modules/.pnpm/escape-string-regexp@2.0.0/node_modules/escape-string-regexp/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var matchOperatorsRegex = /[|\\{}()[\]^$+*?.-]/g;
+ module2.exports = (string) => {
+ if (typeof string !== "string") {
+ throw new TypeError("Expected a string");
+ }
+ return string.replace(matchOperatorsRegex, "\\$&");
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/stack-utils@2.0.5/node_modules/stack-utils/index.js
+var require_stack_utils = __commonJS({
+ "../../node_modules/.pnpm/stack-utils@2.0.5/node_modules/stack-utils/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var escapeStringRegexp = require_escape_string_regexp2();
+ var cwd2 = typeof process === "object" && process && typeof process.cwd === "function" ? process.cwd() : ".";
+ var natives = [].concat(
+ require("module").builtinModules,
+ "bootstrap_node",
+ "node"
+ ).map((n) => new RegExp(`(?:\\((?:node:)?${n}(?:\\.js)?:\\d+:\\d+\\)$|^\\s*at (?:node:)?${n}(?:\\.js)?:\\d+:\\d+$)`));
+ natives.push(
+ /\((?:node:)?internal\/[^:]+:\d+:\d+\)$/,
+ /\s*at (?:node:)?internal\/[^:]+:\d+:\d+$/,
+ /\/\.node-spawn-wrap-\w+-\w+\/node:\d+:\d+\)?$/
+ );
+ var StackUtils = class {
+ constructor(opts) {
+ opts = {
+ ignoredPackages: [],
+ ...opts
+ };
+ if ("internals" in opts === false) {
+ opts.internals = StackUtils.nodeInternals();
+ }
+ if ("cwd" in opts === false) {
+ opts.cwd = cwd2;
+ }
+ this._cwd = opts.cwd.replace(/\\/g, "/");
+ this._internals = [].concat(
+ opts.internals,
+ ignoredPackagesRegExp(opts.ignoredPackages)
+ );
+ this._wrapCallSite = opts.wrapCallSite || false;
+ }
+ static nodeInternals() {
+ return [...natives];
+ }
+ clean(stack, indent = 0) {
+ indent = " ".repeat(indent);
+ if (!Array.isArray(stack)) {
+ stack = stack.split("\n");
+ }
+ if (!/^\s*at /.test(stack[0]) && /^\s*at /.test(stack[1])) {
+ stack = stack.slice(1);
+ }
+ let outdent = false;
+ let lastNonAtLine = null;
+ const result = [];
+ stack.forEach((st) => {
+ st = st.replace(/\\/g, "/");
+ if (this._internals.some((internal) => internal.test(st))) {
+ return;
+ }
+ const isAtLine = /^\s*at /.test(st);
+ if (outdent) {
+ st = st.trimEnd().replace(/^(\s+)at /, "$1");
+ } else {
+ st = st.trim();
+ if (isAtLine) {
+ st = st.slice(3);
+ }
+ }
+ st = st.replace(`${this._cwd}/`, "");
+ if (st) {
+ if (isAtLine) {
+ if (lastNonAtLine) {
+ result.push(lastNonAtLine);
+ lastNonAtLine = null;
+ }
+ result.push(st);
+ } else {
+ outdent = true;
+ lastNonAtLine = st;
+ }
+ }
+ });
+ return result.map((line) => `${indent}${line}
+`).join("");
+ }
+ captureString(limit, fn2 = this.captureString) {
+ if (typeof limit === "function") {
+ fn2 = limit;
+ limit = Infinity;
+ }
+ const { stackTraceLimit } = Error;
+ if (limit) {
+ Error.stackTraceLimit = limit;
+ }
+ const obj = {};
+ Error.captureStackTrace(obj, fn2);
+ const { stack } = obj;
+ Error.stackTraceLimit = stackTraceLimit;
+ return this.clean(stack);
+ }
+ capture(limit, fn2 = this.capture) {
+ if (typeof limit === "function") {
+ fn2 = limit;
+ limit = Infinity;
+ }
+ const { prepareStackTrace, stackTraceLimit } = Error;
+ Error.prepareStackTrace = (obj2, site) => {
+ if (this._wrapCallSite) {
+ return site.map(this._wrapCallSite);
+ }
+ return site;
+ };
+ if (limit) {
+ Error.stackTraceLimit = limit;
+ }
+ const obj = {};
+ Error.captureStackTrace(obj, fn2);
+ const { stack } = obj;
+ Object.assign(Error, { prepareStackTrace, stackTraceLimit });
+ return stack;
+ }
+ at(fn2 = this.at) {
+ const [site] = this.capture(1, fn2);
+ if (!site) {
+ return {};
+ }
+ const res = {
+ line: site.getLineNumber(),
+ column: site.getColumnNumber()
+ };
+ setFile(res, site.getFileName(), this._cwd);
+ if (site.isConstructor()) {
+ res.constructor = true;
+ }
+ if (site.isEval()) {
+ res.evalOrigin = site.getEvalOrigin();
+ }
+ if (site.isNative()) {
+ res.native = true;
+ }
+ let typename;
+ try {
+ typename = site.getTypeName();
+ } catch (_2) {
+ }
+ if (typename && typename !== "Object" && typename !== "[object Object]") {
+ res.type = typename;
+ }
+ const fname = site.getFunctionName();
+ if (fname) {
+ res.function = fname;
+ }
+ const meth = site.getMethodName();
+ if (meth && fname !== meth) {
+ res.method = meth;
+ }
+ return res;
+ }
+ parseLine(line) {
+ const match = line && line.match(re);
+ if (!match) {
+ return null;
+ }
+ const ctor = match[1] === "new";
+ let fname = match[2];
+ const evalOrigin = match[3];
+ const evalFile = match[4];
+ const evalLine = Number(match[5]);
+ const evalCol = Number(match[6]);
+ let file = match[7];
+ const lnum = match[8];
+ const col = match[9];
+ const native = match[10] === "native";
+ const closeParen = match[11] === ")";
+ let method;
+ const res = {};
+ if (lnum) {
+ res.line = Number(lnum);
+ }
+ if (col) {
+ res.column = Number(col);
+ }
+ if (closeParen && file) {
+ let closes = 0;
+ for (let i = file.length - 1; i > 0; i--) {
+ if (file.charAt(i) === ")") {
+ closes++;
+ } else if (file.charAt(i) === "(" && file.charAt(i - 1) === " ") {
+ closes--;
+ if (closes === -1 && file.charAt(i - 1) === " ") {
+ const before = file.slice(0, i - 1);
+ const after = file.slice(i + 1);
+ file = after;
+ fname += ` (${before}`;
+ break;
+ }
+ }
+ }
+ }
+ if (fname) {
+ const methodMatch = fname.match(methodRe);
+ if (methodMatch) {
+ fname = methodMatch[1];
+ method = methodMatch[2];
+ }
+ }
+ setFile(res, file, this._cwd);
+ if (ctor) {
+ res.constructor = true;
+ }
+ if (evalOrigin) {
+ res.evalOrigin = evalOrigin;
+ res.evalLine = evalLine;
+ res.evalColumn = evalCol;
+ res.evalFile = evalFile && evalFile.replace(/\\/g, "/");
+ }
+ if (native) {
+ res.native = true;
+ }
+ if (fname) {
+ res.function = fname;
+ }
+ if (method && fname !== method) {
+ res.method = method;
+ }
+ return res;
+ }
+ };
+ __name(StackUtils, "StackUtils");
+ function setFile(result, filename, cwd3) {
+ if (filename) {
+ filename = filename.replace(/\\/g, "/");
+ if (filename.startsWith(`${cwd3}/`)) {
+ filename = filename.slice(cwd3.length + 1);
+ }
+ result.file = filename;
+ }
+ }
+ __name(setFile, "setFile");
+ function ignoredPackagesRegExp(ignoredPackages) {
+ if (ignoredPackages.length === 0) {
+ return [];
+ }
+ const packages = ignoredPackages.map((mod) => escapeStringRegexp(mod));
+ return new RegExp(`[/\\\\]node_modules[/\\\\](?:${packages.join("|")})[/\\\\][^:]+:\\d+:\\d+`);
+ }
+ __name(ignoredPackagesRegExp, "ignoredPackagesRegExp");
+ var re = new RegExp(
+ "^(?:\\s*at )?(?:(new) )?(?:(.*?) \\()?(?:eval at ([^ ]+) \\((.+?):(\\d+):(\\d+)\\), )?(?:(.+?):(\\d+):(\\d+)|(native))(\\)?)$"
+ );
+ var methodRe = /^(.*?) \[as (.*?)\]$/;
+ module2.exports = StackUtils;
+ }
+});
+
+// ../../node_modules/.pnpm/convert-to-spaces@1.0.2/node_modules/convert-to-spaces/index.js
+var require_convert_to_spaces = __commonJS({
+ "../../node_modules/.pnpm/convert-to-spaces@1.0.2/node_modules/convert-to-spaces/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ module2.exports = (str, spaces) => {
+ return str.replace(/^\t+/gm, ($1) => " ".repeat($1.length * (spaces || 2)));
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/code-excerpt@3.0.0/node_modules/code-excerpt/index.js
+var require_code_excerpt = __commonJS({
+ "../../node_modules/.pnpm/code-excerpt@3.0.0/node_modules/code-excerpt/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var tabsToSpaces = require_convert_to_spaces();
+ var generateLineNumbers = /* @__PURE__ */ __name((line, around) => {
+ const lineNumbers = [];
+ const min = line - around;
+ const max = line + around;
+ for (let lineNumber = min; lineNumber <= max; lineNumber++) {
+ lineNumbers.push(lineNumber);
+ }
+ return lineNumbers;
+ }, "generateLineNumbers");
+ module2.exports = (source, line, options14) => {
+ if (typeof source !== "string") {
+ throw new TypeError("Source code is missing.");
+ }
+ if (!line || line < 1) {
+ throw new TypeError("Line number must start from `1`.");
+ }
+ source = tabsToSpaces(source).split(/\r?\n/);
+ if (line > source.length) {
+ return;
+ }
+ options14 = {
+ around: 3,
+ ...options14
+ };
+ return generateLineNumbers(line, options14.around).filter((line2) => source[line2 - 1] !== void 0).map((line2) => ({ line: line2, value: source[line2 - 1] }));
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/components/Box.js
+var require_Box = __commonJS({
+ "../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/components/Box.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
+ if (k2 === void 0)
+ k2 = k;
+ Object.defineProperty(o, k2, { enumerable: true, get: function() {
+ return m[k];
+ } });
+ } : function(o, m, k, k2) {
+ if (k2 === void 0)
+ k2 = k;
+ o[k2] = m[k];
+ });
+ var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) {
+ Object.defineProperty(o, "default", { enumerable: true, value: v });
+ } : function(o, v) {
+ o["default"] = v;
+ });
+ var __importStar = exports2 && exports2.__importStar || function(mod) {
+ if (mod && mod.__esModule)
+ return mod;
+ var result = {};
+ if (mod != null) {
+ for (var k in mod)
+ if (k !== "default" && Object.hasOwnProperty.call(mod, k))
+ __createBinding(result, mod, k);
+ }
+ __setModuleDefault(result, mod);
+ return result;
+ };
+ var __rest = exports2 && exports2.__rest || function(s, e2) {
+ var t2 = {};
+ for (var p in s)
+ if (Object.prototype.hasOwnProperty.call(s, p) && e2.indexOf(p) < 0)
+ t2[p] = s[p];
+ if (s != null && typeof Object.getOwnPropertySymbols === "function")
+ for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+ if (e2.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+ t2[p[i]] = s[p[i]];
+ }
+ return t2;
+ };
+ Object.defineProperty(exports2, "__esModule", { value: true });
+ var react_1 = __importStar(require_react());
+ var Box6 = react_1.forwardRef((_a2, ref) => {
+ var { children } = _a2, style = __rest(_a2, ["children"]);
+ const transformedStyle = Object.assign(Object.assign({}, style), { marginLeft: style.marginLeft || style.marginX || style.margin || 0, marginRight: style.marginRight || style.marginX || style.margin || 0, marginTop: style.marginTop || style.marginY || style.margin || 0, marginBottom: style.marginBottom || style.marginY || style.margin || 0, paddingLeft: style.paddingLeft || style.paddingX || style.padding || 0, paddingRight: style.paddingRight || style.paddingX || style.padding || 0, paddingTop: style.paddingTop || style.paddingY || style.padding || 0, paddingBottom: style.paddingBottom || style.paddingY || style.padding || 0 });
+ return react_1.default.createElement("ink-box", { ref, style: transformedStyle }, children);
+ });
+ Box6.displayName = "Box";
+ Box6.defaultProps = {
+ flexDirection: "row",
+ flexGrow: 0,
+ flexShrink: 1
+ };
+ exports2.default = Box6;
+ }
+});
+
+// ../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/components/Text.js
+var require_Text = __commonJS({
+ "../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/components/Text.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ var __importDefault = exports2 && exports2.__importDefault || function(mod) {
+ return mod && mod.__esModule ? mod : { "default": mod };
+ };
+ Object.defineProperty(exports2, "__esModule", { value: true });
+ var react_1 = __importDefault(require_react());
+ var chalk_1 = __importDefault(require_source());
+ var colorize_1 = __importDefault(require_colorize());
+ var Text11 = /* @__PURE__ */ __name(({ color, backgroundColor, dimColor, bold, italic, underline, strikethrough, inverse, wrap: wrap2, children }) => {
+ if (children === void 0 || children === null) {
+ return null;
+ }
+ const transform = /* @__PURE__ */ __name((children2) => {
+ if (dimColor) {
+ children2 = chalk_1.default.dim(children2);
+ }
+ if (color) {
+ children2 = colorize_1.default(children2, color, "foreground");
+ }
+ if (backgroundColor) {
+ children2 = colorize_1.default(children2, backgroundColor, "background");
+ }
+ if (bold) {
+ children2 = chalk_1.default.bold(children2);
+ }
+ if (italic) {
+ children2 = chalk_1.default.italic(children2);
+ }
+ if (underline) {
+ children2 = chalk_1.default.underline(children2);
+ }
+ if (strikethrough) {
+ children2 = chalk_1.default.strikethrough(children2);
+ }
+ if (inverse) {
+ children2 = chalk_1.default.inverse(children2);
+ }
+ return children2;
+ }, "transform");
+ return react_1.default.createElement("ink-text", { style: { flexGrow: 0, flexShrink: 1, flexDirection: "row", textWrap: wrap2 }, internal_transform: transform }, children);
+ }, "Text");
+ Text11.displayName = "Text";
+ Text11.defaultProps = {
+ dimColor: false,
+ bold: false,
+ italic: false,
+ underline: false,
+ strikethrough: false,
+ wrap: "wrap"
+ };
+ exports2.default = Text11;
+ }
+});
+
+// ../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/components/ErrorOverview.js
+var require_ErrorOverview = __commonJS({
+ "../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/components/ErrorOverview.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
+ if (k2 === void 0)
+ k2 = k;
+ Object.defineProperty(o, k2, { enumerable: true, get: function() {
+ return m[k];
+ } });
+ } : function(o, m, k, k2) {
+ if (k2 === void 0)
+ k2 = k;
+ o[k2] = m[k];
+ });
+ var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) {
+ Object.defineProperty(o, "default", { enumerable: true, value: v });
+ } : function(o, v) {
+ o["default"] = v;
+ });
+ var __importStar = exports2 && exports2.__importStar || function(mod) {
+ if (mod && mod.__esModule)
+ return mod;
+ var result = {};
+ if (mod != null) {
+ for (var k in mod)
+ if (k !== "default" && Object.hasOwnProperty.call(mod, k))
+ __createBinding(result, mod, k);
+ }
+ __setModuleDefault(result, mod);
+ return result;
+ };
+ var __importDefault = exports2 && exports2.__importDefault || function(mod) {
+ return mod && mod.__esModule ? mod : { "default": mod };
+ };
+ Object.defineProperty(exports2, "__esModule", { value: true });
+ var fs20 = __importStar(require("fs"));
+ var react_1 = __importDefault(require_react());
+ var stack_utils_1 = __importDefault(require_stack_utils());
+ var code_excerpt_1 = __importDefault(require_code_excerpt());
+ var Box_1 = __importDefault(require_Box());
+ var Text_1 = __importDefault(require_Text());
+ var stackUtils = new stack_utils_1.default({
+ cwd: process.cwd(),
+ internals: stack_utils_1.default.nodeInternals()
+ });
+ var ErrorOverview = /* @__PURE__ */ __name(({ error }) => {
+ const stack = error.stack ? error.stack.split("\n").slice(1) : void 0;
+ const origin = stack ? stackUtils.parseLine(stack[0]) : void 0;
+ let excerpt;
+ let lineWidth = 0;
+ if ((origin === null || origin === void 0 ? void 0 : origin.file) && (origin === null || origin === void 0 ? void 0 : origin.line) && fs20.existsSync(origin.file)) {
+ const sourceCode = fs20.readFileSync(origin.file, "utf8");
+ excerpt = code_excerpt_1.default(sourceCode, origin.line);
+ if (excerpt) {
+ for (const { line } of excerpt) {
+ lineWidth = Math.max(lineWidth, String(line).length);
+ }
+ }
+ }
+ return react_1.default.createElement(
+ Box_1.default,
+ { flexDirection: "column", padding: 1 },
+ react_1.default.createElement(
+ Box_1.default,
+ null,
+ react_1.default.createElement(
+ Text_1.default,
+ { backgroundColor: "red", color: "white" },
+ " ",
+ "ERROR",
+ " "
+ ),
+ react_1.default.createElement(
+ Text_1.default,
+ null,
+ " ",
+ error.message
+ )
+ ),
+ origin && react_1.default.createElement(
+ Box_1.default,
+ { marginTop: 1 },
+ react_1.default.createElement(
+ Text_1.default,
+ { dimColor: true },
+ origin.file,
+ ":",
+ origin.line,
+ ":",
+ origin.column
+ )
+ ),
+ origin && excerpt && react_1.default.createElement(Box_1.default, { marginTop: 1, flexDirection: "column" }, excerpt.map(({ line, value }) => react_1.default.createElement(
+ Box_1.default,
+ { key: line },
+ react_1.default.createElement(
+ Box_1.default,
+ { width: lineWidth + 1 },
+ react_1.default.createElement(
+ Text_1.default,
+ { dimColor: line !== origin.line, backgroundColor: line === origin.line ? "red" : void 0, color: line === origin.line ? "white" : void 0 },
+ String(line).padStart(lineWidth, " "),
+ ":"
+ )
+ ),
+ react_1.default.createElement(Text_1.default, { key: line, backgroundColor: line === origin.line ? "red" : void 0, color: line === origin.line ? "white" : void 0 }, " " + value)
+ ))),
+ error.stack && react_1.default.createElement(Box_1.default, { marginTop: 1, flexDirection: "column" }, error.stack.split("\n").slice(1).map((line) => {
+ const parsedLine = stackUtils.parseLine(line);
+ if (!parsedLine) {
+ return react_1.default.createElement(
+ Box_1.default,
+ { key: line },
+ react_1.default.createElement(Text_1.default, { dimColor: true }, "- "),
+ react_1.default.createElement(Text_1.default, { dimColor: true, bold: true }, line)
+ );
+ }
+ return react_1.default.createElement(
+ Box_1.default,
+ { key: line },
+ react_1.default.createElement(Text_1.default, { dimColor: true }, "- "),
+ react_1.default.createElement(Text_1.default, { dimColor: true, bold: true }, parsedLine.function),
+ react_1.default.createElement(
+ Text_1.default,
+ { dimColor: true, color: "gray" },
+ " ",
+ "(",
+ parsedLine.file,
+ ":",
+ parsedLine.line,
+ ":",
+ parsedLine.column,
+ ")"
+ )
+ );
+ }))
+ );
+ }, "ErrorOverview");
+ exports2.default = ErrorOverview;
+ }
+});
+
+// ../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/components/App.js
+var require_App = __commonJS({
+ "../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/components/App.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
+ if (k2 === void 0)
+ k2 = k;
+ Object.defineProperty(o, k2, { enumerable: true, get: function() {
+ return m[k];
+ } });
+ } : function(o, m, k, k2) {
+ if (k2 === void 0)
+ k2 = k;
+ o[k2] = m[k];
+ });
+ var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) {
+ Object.defineProperty(o, "default", { enumerable: true, value: v });
+ } : function(o, v) {
+ o["default"] = v;
+ });
+ var __importStar = exports2 && exports2.__importStar || function(mod) {
+ if (mod && mod.__esModule)
+ return mod;
+ var result = {};
+ if (mod != null) {
+ for (var k in mod)
+ if (k !== "default" && Object.hasOwnProperty.call(mod, k))
+ __createBinding(result, mod, k);
+ }
+ __setModuleDefault(result, mod);
+ return result;
+ };
+ var __importDefault = exports2 && exports2.__importDefault || function(mod) {
+ return mod && mod.__esModule ? mod : { "default": mod };
+ };
+ Object.defineProperty(exports2, "__esModule", { value: true });
+ var react_1 = __importStar(require_react());
+ var cli_cursor_1 = __importDefault(require_cli_cursor());
+ var AppContext_1 = __importDefault(require_AppContext());
+ var StdinContext_1 = __importDefault(require_StdinContext());
+ var StdoutContext_1 = __importDefault(require_StdoutContext());
+ var StderrContext_1 = __importDefault(require_StderrContext());
+ var FocusContext_1 = __importDefault(require_FocusContext());
+ var ErrorOverview_1 = __importDefault(require_ErrorOverview());
+ var TAB = " ";
+ var SHIFT_TAB = "\x1B[Z";
+ var ESC = "\x1B";
+ var App = class extends react_1.PureComponent {
+ constructor() {
+ super(...arguments);
+ this.state = {
+ isFocusEnabled: true,
+ activeFocusId: void 0,
+ focusables: [],
+ error: void 0
+ };
+ this.rawModeEnabledCount = 0;
+ this.handleSetRawMode = (isEnabled) => {
+ const { stdin } = this.props;
+ if (!this.isRawModeSupported()) {
+ if (stdin === process.stdin) {
+ throw new Error("Raw mode is not supported on the current process.stdin, which Ink uses as input stream by default.\nRead about how to prevent this error on https://github.com/vadimdemedes/ink/#israwmodesupported");
+ } else {
+ throw new Error("Raw mode is not supported on the stdin provided to Ink.\nRead about how to prevent this error on https://github.com/vadimdemedes/ink/#israwmodesupported");
+ }
+ }
+ stdin.setEncoding("utf8");
+ if (isEnabled) {
+ if (this.rawModeEnabledCount === 0) {
+ stdin.addListener("data", this.handleInput);
+ stdin.resume();
+ stdin.setRawMode(true);
+ }
+ this.rawModeEnabledCount++;
+ return;
+ }
+ if (--this.rawModeEnabledCount === 0) {
+ stdin.setRawMode(false);
+ stdin.removeListener("data", this.handleInput);
+ stdin.pause();
+ }
+ };
+ this.handleInput = (input) => {
+ if (input === "" && this.props.exitOnCtrlC) {
+ this.handleExit();
+ }
+ if (input === ESC && this.state.activeFocusId) {
+ this.setState({
+ activeFocusId: void 0
+ });
+ }
+ if (this.state.isFocusEnabled && this.state.focusables.length > 0) {
+ if (input === TAB) {
+ this.focusNext();
+ }
+ if (input === SHIFT_TAB) {
+ this.focusPrevious();
+ }
+ }
+ };
+ this.handleExit = (error) => {
+ if (this.isRawModeSupported()) {
+ this.handleSetRawMode(false);
+ }
+ this.props.onExit(error);
+ };
+ this.enableFocus = () => {
+ this.setState({
+ isFocusEnabled: true
+ });
+ };
+ this.disableFocus = () => {
+ this.setState({
+ isFocusEnabled: false
+ });
+ };
+ this.focus = (id) => {
+ this.setState((previousState) => {
+ const hasFocusableId = previousState.focusables.some((focusable) => (focusable === null || focusable === void 0 ? void 0 : focusable.id) === id);
+ if (!hasFocusableId) {
+ return previousState;
+ }
+ return { activeFocusId: id };
+ });
+ };
+ this.focusNext = () => {
+ this.setState((previousState) => {
+ var _a2;
+ const firstFocusableId = (_a2 = previousState.focusables[0]) === null || _a2 === void 0 ? void 0 : _a2.id;
+ const nextFocusableId = this.findNextFocusable(previousState);
+ return {
+ activeFocusId: nextFocusableId || firstFocusableId
+ };
+ });
+ };
+ this.focusPrevious = () => {
+ this.setState((previousState) => {
+ var _a2;
+ const lastFocusableId = (_a2 = previousState.focusables[previousState.focusables.length - 1]) === null || _a2 === void 0 ? void 0 : _a2.id;
+ const previousFocusableId = this.findPreviousFocusable(previousState);
+ return {
+ activeFocusId: previousFocusableId || lastFocusableId
+ };
+ });
+ };
+ this.addFocusable = (id, { autoFocus }) => {
+ this.setState((previousState) => {
+ let nextFocusId = previousState.activeFocusId;
+ if (!nextFocusId && autoFocus) {
+ nextFocusId = id;
+ }
+ return {
+ activeFocusId: nextFocusId,
+ focusables: [
+ ...previousState.focusables,
+ {
+ id,
+ isActive: true
+ }
+ ]
+ };
+ });
+ };
+ this.removeFocusable = (id) => {
+ this.setState((previousState) => ({
+ activeFocusId: previousState.activeFocusId === id ? void 0 : previousState.activeFocusId,
+ focusables: previousState.focusables.filter((focusable) => {
+ return focusable.id !== id;
+ })
+ }));
+ };
+ this.activateFocusable = (id) => {
+ this.setState((previousState) => ({
+ focusables: previousState.focusables.map((focusable) => {
+ if (focusable.id !== id) {
+ return focusable;
+ }
+ return {
+ id,
+ isActive: true
+ };
+ })
+ }));
+ };
+ this.deactivateFocusable = (id) => {
+ this.setState((previousState) => ({
+ activeFocusId: previousState.activeFocusId === id ? void 0 : previousState.activeFocusId,
+ focusables: previousState.focusables.map((focusable) => {
+ if (focusable.id !== id) {
+ return focusable;
+ }
+ return {
+ id,
+ isActive: false
+ };
+ })
+ }));
+ };
+ this.findNextFocusable = (state) => {
+ var _a2;
+ const activeIndex = state.focusables.findIndex((focusable) => {
+ return focusable.id === state.activeFocusId;
+ });
+ for (let index = activeIndex + 1; index < state.focusables.length; index++) {
+ if ((_a2 = state.focusables[index]) === null || _a2 === void 0 ? void 0 : _a2.isActive) {
+ return state.focusables[index].id;
+ }
+ }
+ return void 0;
+ };
+ this.findPreviousFocusable = (state) => {
+ var _a2;
+ const activeIndex = state.focusables.findIndex((focusable) => {
+ return focusable.id === state.activeFocusId;
+ });
+ for (let index = activeIndex - 1; index >= 0; index--) {
+ if ((_a2 = state.focusables[index]) === null || _a2 === void 0 ? void 0 : _a2.isActive) {
+ return state.focusables[index].id;
+ }
+ }
+ return void 0;
+ };
+ }
+ static getDerivedStateFromError(error) {
+ return { error };
+ }
+ // Determines if TTY is supported on the provided stdin
+ isRawModeSupported() {
+ return this.props.stdin.isTTY;
+ }
+ render() {
+ return react_1.default.createElement(
+ AppContext_1.default.Provider,
+ { value: {
+ exit: this.handleExit
+ } },
+ react_1.default.createElement(
+ StdinContext_1.default.Provider,
+ { value: {
+ stdin: this.props.stdin,
+ setRawMode: this.handleSetRawMode,
+ isRawModeSupported: this.isRawModeSupported(),
+ internal_exitOnCtrlC: this.props.exitOnCtrlC
+ } },
+ react_1.default.createElement(
+ StdoutContext_1.default.Provider,
+ { value: {
+ stdout: this.props.stdout,
+ write: this.props.writeToStdout
+ } },
+ react_1.default.createElement(
+ StderrContext_1.default.Provider,
+ { value: {
+ stderr: this.props.stderr,
+ write: this.props.writeToStderr
+ } },
+ react_1.default.createElement(FocusContext_1.default.Provider, { value: {
+ activeId: this.state.activeFocusId,
+ add: this.addFocusable,
+ remove: this.removeFocusable,
+ activate: this.activateFocusable,
+ deactivate: this.deactivateFocusable,
+ enableFocus: this.enableFocus,
+ disableFocus: this.disableFocus,
+ focusNext: this.focusNext,
+ focusPrevious: this.focusPrevious,
+ focus: this.focus
+ } }, this.state.error ? react_1.default.createElement(ErrorOverview_1.default, { error: this.state.error }) : this.props.children)
+ )
+ )
+ )
+ );
+ }
+ componentDidMount() {
+ cli_cursor_1.default.hide(this.props.stdout);
+ }
+ componentWillUnmount() {
+ cli_cursor_1.default.show(this.props.stdout);
+ if (this.isRawModeSupported()) {
+ this.handleSetRawMode(false);
+ }
+ }
+ componentDidCatch(error) {
+ this.handleExit(error);
+ }
+ };
+ __name(App, "App");
+ exports2.default = App;
+ App.displayName = "InternalApp";
+ }
+});
+
+// ../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/ink.js
+var require_ink = __commonJS({
+ "../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/ink.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
+ if (k2 === void 0)
+ k2 = k;
+ Object.defineProperty(o, k2, { enumerable: true, get: function() {
+ return m[k];
+ } });
+ } : function(o, m, k, k2) {
+ if (k2 === void 0)
+ k2 = k;
+ o[k2] = m[k];
+ });
+ var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) {
+ Object.defineProperty(o, "default", { enumerable: true, value: v });
+ } : function(o, v) {
+ o["default"] = v;
+ });
+ var __importStar = exports2 && exports2.__importStar || function(mod) {
+ if (mod && mod.__esModule)
+ return mod;
+ var result = {};
+ if (mod != null) {
+ for (var k in mod)
+ if (k !== "default" && Object.hasOwnProperty.call(mod, k))
+ __createBinding(result, mod, k);
+ }
+ __setModuleDefault(result, mod);
+ return result;
+ };
+ var __importDefault = exports2 && exports2.__importDefault || function(mod) {
+ return mod && mod.__esModule ? mod : { "default": mod };
+ };
+ Object.defineProperty(exports2, "__esModule", { value: true });
+ var react_1 = __importDefault(require_react());
+ var lodash_1 = require_lodash();
+ var log_update_1 = __importDefault(require_log_update());
+ var ansi_escapes_1 = __importDefault(require_ansi_escapes());
+ var is_ci_1 = __importDefault(require_is_ci());
+ var auto_bind_1 = __importDefault(require_auto_bind());
+ var reconciler_1 = __importDefault(require_reconciler());
+ var renderer_1 = __importDefault(require_renderer());
+ var signal_exit_1 = __importDefault(require_signal_exit());
+ var patch_console_1 = __importDefault(require_build());
+ var dom = __importStar(require_dom());
+ var instances_1 = __importDefault(require_instances());
+ var App_1 = __importDefault(require_App());
+ var isCI2 = process.env.CI === "false" ? false : is_ci_1.default;
+ var noop = /* @__PURE__ */ __name(() => {
+ }, "noop");
+ var Ink = class {
+ constructor(options14) {
+ this.resolveExitPromise = () => {
+ };
+ this.rejectExitPromise = () => {
+ };
+ this.unsubscribeExit = () => {
+ };
+ this.onRender = () => {
+ if (this.isUnmounted) {
+ return;
+ }
+ const { output, outputHeight, staticOutput } = renderer_1.default(
+ this.rootNode,
+ // The 'columns' property can be undefined or 0 when not using a TTY.
+ // In that case we fall back to 80.
+ this.options.stdout.columns || 80
+ );
+ const hasStaticOutput = staticOutput && staticOutput !== "\n";
+ if (this.options.debug) {
+ if (hasStaticOutput) {
+ this.fullStaticOutput += staticOutput;
+ }
+ this.options.stdout.write(this.fullStaticOutput + output);
+ return;
+ }
+ if (isCI2) {
+ if (hasStaticOutput) {
+ this.options.stdout.write(staticOutput);
+ }
+ this.lastOutput = output;
+ return;
+ }
+ if (hasStaticOutput) {
+ this.fullStaticOutput += staticOutput;
+ }
+ if (outputHeight >= this.options.stdout.rows) {
+ this.options.stdout.write(ansi_escapes_1.default.clearTerminal + this.fullStaticOutput + output);
+ this.lastOutput = output;
+ return;
+ }
+ if (hasStaticOutput) {
+ this.log.clear();
+ this.options.stdout.write(staticOutput);
+ this.log(output);
+ }
+ if (!hasStaticOutput && output !== this.lastOutput) {
+ this.throttledLog(output);
+ }
+ this.lastOutput = output;
+ };
+ auto_bind_1.default(this);
+ this.options = options14;
+ this.rootNode = dom.createNode("ink-root");
+ this.rootNode.onRender = options14.debug ? this.onRender : lodash_1.throttle(this.onRender, 32, {
+ leading: true,
+ trailing: true
+ });
+ this.rootNode.onImmediateRender = this.onRender;
+ this.log = log_update_1.default.create(options14.stdout);
+ this.throttledLog = options14.debug ? this.log : lodash_1.throttle(this.log, void 0, {
+ leading: true,
+ trailing: true
+ });
+ this.isUnmounted = false;
+ this.lastOutput = "";
+ this.fullStaticOutput = "";
+ this.container = reconciler_1.default.createContainer(
+ this.rootNode,
+ // Legacy mode
+ 0,
+ false,
+ null
+ );
+ this.unsubscribeExit = signal_exit_1.default(this.unmount, { alwaysLast: false });
+ if (process.env.DEV === "true") {
+ reconciler_1.default.injectIntoDevTools({
+ bundleType: 0,
+ // Reporting React DOM's version, not Ink's
+ // See https://github.com/facebook/react/issues/16666#issuecomment-532639905
+ version: "16.13.1",
+ rendererPackageName: "ink"
+ });
+ }
+ if (options14.patchConsole) {
+ this.patchConsole();
+ }
+ if (!isCI2) {
+ options14.stdout.on("resize", this.onRender);
+ this.unsubscribeResize = () => {
+ options14.stdout.off("resize", this.onRender);
+ };
+ }
+ }
+ render(node) {
+ const tree = react_1.default.createElement(App_1.default, { stdin: this.options.stdin, stdout: this.options.stdout, stderr: this.options.stderr, writeToStdout: this.writeToStdout, writeToStderr: this.writeToStderr, exitOnCtrlC: this.options.exitOnCtrlC, onExit: this.unmount }, node);
+ reconciler_1.default.updateContainer(tree, this.container, null, noop);
+ }
+ writeToStdout(data) {
+ if (this.isUnmounted) {
+ return;
+ }
+ if (this.options.debug) {
+ this.options.stdout.write(data + this.fullStaticOutput + this.lastOutput);
+ return;
+ }
+ if (isCI2) {
+ this.options.stdout.write(data);
+ return;
+ }
+ this.log.clear();
+ this.options.stdout.write(data);
+ this.log(this.lastOutput);
+ }
+ writeToStderr(data) {
+ if (this.isUnmounted) {
+ return;
+ }
+ if (this.options.debug) {
+ this.options.stderr.write(data);
+ this.options.stdout.write(this.fullStaticOutput + this.lastOutput);
+ return;
+ }
+ if (isCI2) {
+ this.options.stderr.write(data);
+ return;
+ }
+ this.log.clear();
+ this.options.stderr.write(data);
+ this.log(this.lastOutput);
+ }
+ unmount(error) {
+ if (this.isUnmounted) {
+ return;
+ }
+ this.onRender();
+ this.unsubscribeExit();
+ if (typeof this.restoreConsole === "function") {
+ this.restoreConsole();
+ }
+ if (typeof this.unsubscribeResize === "function") {
+ this.unsubscribeResize();
+ }
+ if (isCI2) {
+ this.options.stdout.write(this.lastOutput + "\n");
+ } else if (!this.options.debug) {
+ this.log.done();
+ }
+ this.isUnmounted = true;
+ reconciler_1.default.updateContainer(null, this.container, null, noop);
+ instances_1.default.delete(this.options.stdout);
+ if (error instanceof Error) {
+ this.rejectExitPromise(error);
+ } else {
+ this.resolveExitPromise();
+ }
+ }
+ waitUntilExit() {
+ if (!this.exitPromise) {
+ this.exitPromise = new Promise((resolve18, reject) => {
+ this.resolveExitPromise = resolve18;
+ this.rejectExitPromise = reject;
+ });
+ }
+ return this.exitPromise;
+ }
+ clear() {
+ if (!isCI2 && !this.options.debug) {
+ this.log.clear();
+ }
+ }
+ patchConsole() {
+ if (this.options.debug) {
+ return;
+ }
+ this.restoreConsole = patch_console_1.default((stream2, data) => {
+ if (stream2 === "stdout") {
+ this.writeToStdout(data);
+ }
+ if (stream2 === "stderr") {
+ const isReactMessage = data.startsWith("The above error occurred");
+ if (!isReactMessage) {
+ this.writeToStderr(data);
+ }
+ }
+ });
+ }
+ };
+ __name(Ink, "Ink");
+ exports2.default = Ink;
+ }
+});
+
+// ../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/render.js
+var require_render = __commonJS({
+ "../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/render.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ var __importDefault = exports2 && exports2.__importDefault || function(mod) {
+ return mod && mod.__esModule ? mod : { "default": mod };
+ };
+ Object.defineProperty(exports2, "__esModule", { value: true });
+ var ink_1 = __importDefault(require_ink());
+ var instances_1 = __importDefault(require_instances());
+ var stream_1 = require("stream");
+ var render7 = /* @__PURE__ */ __name((node, options14) => {
+ const inkOptions = Object.assign({ stdout: process.stdout, stdin: process.stdin, stderr: process.stderr, debug: false, exitOnCtrlC: true, patchConsole: true }, getOptions(options14));
+ const instance = getInstance(inkOptions.stdout, () => new ink_1.default(inkOptions));
+ instance.render(node);
+ return {
+ rerender: instance.render,
+ unmount: () => instance.unmount(),
+ waitUntilExit: instance.waitUntilExit,
+ cleanup: () => instances_1.default.delete(inkOptions.stdout),
+ clear: instance.clear
+ };
+ }, "render");
+ exports2.default = render7;
+ var getOptions = /* @__PURE__ */ __name((stdout = {}) => {
+ if (stdout instanceof stream_1.Stream) {
+ return {
+ stdout,
+ stdin: process.stdin
+ };
+ }
+ return stdout;
+ }, "getOptions");
+ var getInstance = /* @__PURE__ */ __name((stdout, createInstance) => {
+ let instance;
+ if (instances_1.default.has(stdout)) {
+ instance = instances_1.default.get(stdout);
+ } else {
+ instance = createInstance();
+ instances_1.default.set(stdout, instance);
+ }
+ return instance;
+ }, "getInstance");
+ }
+});
+
+// ../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/components/Static.js
+var require_Static = __commonJS({
+ "../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/components/Static.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
+ if (k2 === void 0)
+ k2 = k;
+ Object.defineProperty(o, k2, { enumerable: true, get: function() {
+ return m[k];
+ } });
+ } : function(o, m, k, k2) {
+ if (k2 === void 0)
+ k2 = k;
+ o[k2] = m[k];
+ });
+ var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) {
+ Object.defineProperty(o, "default", { enumerable: true, value: v });
+ } : function(o, v) {
+ o["default"] = v;
+ });
+ var __importStar = exports2 && exports2.__importStar || function(mod) {
+ if (mod && mod.__esModule)
+ return mod;
+ var result = {};
+ if (mod != null) {
+ for (var k in mod)
+ if (k !== "default" && Object.hasOwnProperty.call(mod, k))
+ __createBinding(result, mod, k);
+ }
+ __setModuleDefault(result, mod);
+ return result;
+ };
+ Object.defineProperty(exports2, "__esModule", { value: true });
+ var react_1 = __importStar(require_react());
+ var Static2 = /* @__PURE__ */ __name((props) => {
+ const { items, children: render7, style: customStyle } = props;
+ const [index, setIndex] = react_1.useState(0);
+ const itemsToRender = react_1.useMemo(() => {
+ return items.slice(index);
+ }, [items, index]);
+ react_1.useLayoutEffect(() => {
+ setIndex(items.length);
+ }, [items.length]);
+ const children = itemsToRender.map((item, itemIndex) => {
+ return render7(item, index + itemIndex);
+ });
+ const style = react_1.useMemo(() => Object.assign({ position: "absolute", flexDirection: "column" }, customStyle), [customStyle]);
+ return react_1.default.createElement("ink-box", {
+ // @ts-ignore
+ internal_static: true,
+ style
+ }, children);
+ }, "Static");
+ Static2.displayName = "Static";
+ exports2.default = Static2;
+ }
+});
+
+// ../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/components/Transform.js
+var require_Transform = __commonJS({
+ "../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/components/Transform.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ var __importDefault = exports2 && exports2.__importDefault || function(mod) {
+ return mod && mod.__esModule ? mod : { "default": mod };
+ };
+ Object.defineProperty(exports2, "__esModule", { value: true });
+ var react_1 = __importDefault(require_react());
+ var Transform = /* @__PURE__ */ __name(({ children, transform }) => {
+ if (children === void 0 || children === null) {
+ return null;
+ }
+ return react_1.default.createElement("ink-text", { style: { flexGrow: 0, flexShrink: 1, flexDirection: "row" }, internal_transform: transform }, children);
+ }, "Transform");
+ Transform.displayName = "Transform";
+ exports2.default = Transform;
+ }
+});
+
+// ../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/components/Newline.js
+var require_Newline = __commonJS({
+ "../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/components/Newline.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ var __importDefault = exports2 && exports2.__importDefault || function(mod) {
+ return mod && mod.__esModule ? mod : { "default": mod };
+ };
+ Object.defineProperty(exports2, "__esModule", { value: true });
+ var react_1 = __importDefault(require_react());
+ var Newline = /* @__PURE__ */ __name(({ count = 1 }) => react_1.default.createElement("ink-text", null, "\n".repeat(count)), "Newline");
+ Newline.displayName = "Newline";
+ exports2.default = Newline;
+ }
+});
+
+// ../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/components/Spacer.js
+var require_Spacer = __commonJS({
+ "../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/components/Spacer.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ var __importDefault = exports2 && exports2.__importDefault || function(mod) {
+ return mod && mod.__esModule ? mod : { "default": mod };
+ };
+ Object.defineProperty(exports2, "__esModule", { value: true });
+ var react_1 = __importDefault(require_react());
+ var Box_1 = __importDefault(require_Box());
+ var Spacer = /* @__PURE__ */ __name(() => react_1.default.createElement(Box_1.default, { flexGrow: 1 }), "Spacer");
+ Spacer.displayName = "Spacer";
+ exports2.default = Spacer;
+ }
+});
+
+// ../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/hooks/use-stdin.js
+var require_use_stdin = __commonJS({
+ "../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/hooks/use-stdin.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ var __importDefault = exports2 && exports2.__importDefault || function(mod) {
+ return mod && mod.__esModule ? mod : { "default": mod };
+ };
+ Object.defineProperty(exports2, "__esModule", { value: true });
+ var react_1 = require_react();
+ var StdinContext_1 = __importDefault(require_StdinContext());
+ var useStdin2 = /* @__PURE__ */ __name(() => react_1.useContext(StdinContext_1.default), "useStdin");
+ exports2.default = useStdin2;
+ }
+});
+
+// ../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/hooks/use-input.js
+var require_use_input = __commonJS({
+ "../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/hooks/use-input.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ var __importDefault = exports2 && exports2.__importDefault || function(mod) {
+ return mod && mod.__esModule ? mod : { "default": mod };
+ };
+ Object.defineProperty(exports2, "__esModule", { value: true });
+ var react_1 = require_react();
+ var use_stdin_1 = __importDefault(require_use_stdin());
+ var useInput2 = /* @__PURE__ */ __name((inputHandler, options14 = {}) => {
+ const { stdin, setRawMode, internal_exitOnCtrlC } = use_stdin_1.default();
+ react_1.useEffect(() => {
+ if (options14.isActive === false) {
+ return;
+ }
+ setRawMode(true);
+ return () => {
+ setRawMode(false);
+ };
+ }, [options14.isActive, setRawMode]);
+ react_1.useEffect(() => {
+ if (options14.isActive === false) {
+ return;
+ }
+ const handleData = /* @__PURE__ */ __name((data) => {
+ let input = String(data);
+ const key = {
+ upArrow: input === "\x1B[A",
+ downArrow: input === "\x1B[B",
+ leftArrow: input === "\x1B[D",
+ rightArrow: input === "\x1B[C",
+ pageDown: input === "\x1B[6~",
+ pageUp: input === "\x1B[5~",
+ return: input === "\r",
+ escape: input === "\x1B",
+ ctrl: false,
+ shift: false,
+ tab: input === " " || input === "\x1B[Z",
+ backspace: input === "\b",
+ delete: input === "\x7F" || input === "\x1B[3~",
+ meta: false
+ };
+ if (input <= "" && !key.return) {
+ input = String.fromCharCode(input.charCodeAt(0) + "a".charCodeAt(0) - 1);
+ key.ctrl = true;
+ }
+ if (input.startsWith("\x1B")) {
+ input = input.slice(1);
+ key.meta = true;
+ }
+ const isLatinUppercase = input >= "A" && input <= "Z";
+ const isCyrillicUppercase = input >= "\u0410" && input <= "\u042F";
+ if (input.length === 1 && (isLatinUppercase || isCyrillicUppercase)) {
+ key.shift = true;
+ }
+ if (key.tab && input === "[Z") {
+ key.shift = true;
+ }
+ if (key.tab || key.backspace || key.delete) {
+ input = "";
+ }
+ if (!(input === "c" && key.ctrl) || !internal_exitOnCtrlC) {
+ inputHandler(input, key);
+ }
+ }, "handleData");
+ stdin === null || stdin === void 0 ? void 0 : stdin.on("data", handleData);
+ return () => {
+ stdin === null || stdin === void 0 ? void 0 : stdin.off("data", handleData);
+ };
+ }, [options14.isActive, stdin, internal_exitOnCtrlC, inputHandler]);
+ }, "useInput");
+ exports2.default = useInput2;
+ }
+});
+
+// ../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/hooks/use-app.js
+var require_use_app = __commonJS({
+ "../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/hooks/use-app.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ var __importDefault = exports2 && exports2.__importDefault || function(mod) {
+ return mod && mod.__esModule ? mod : { "default": mod };
+ };
+ Object.defineProperty(exports2, "__esModule", { value: true });
+ var react_1 = require_react();
+ var AppContext_1 = __importDefault(require_AppContext());
+ var useApp3 = /* @__PURE__ */ __name(() => react_1.useContext(AppContext_1.default), "useApp");
+ exports2.default = useApp3;
+ }
+});
+
+// ../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/hooks/use-stdout.js
+var require_use_stdout = __commonJS({
+ "../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/hooks/use-stdout.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ var __importDefault = exports2 && exports2.__importDefault || function(mod) {
+ return mod && mod.__esModule ? mod : { "default": mod };
+ };
+ Object.defineProperty(exports2, "__esModule", { value: true });
+ var react_1 = require_react();
+ var StdoutContext_1 = __importDefault(require_StdoutContext());
+ var useStdout = /* @__PURE__ */ __name(() => react_1.useContext(StdoutContext_1.default), "useStdout");
+ exports2.default = useStdout;
+ }
+});
+
+// ../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/hooks/use-stderr.js
+var require_use_stderr = __commonJS({
+ "../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/hooks/use-stderr.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ var __importDefault = exports2 && exports2.__importDefault || function(mod) {
+ return mod && mod.__esModule ? mod : { "default": mod };
+ };
+ Object.defineProperty(exports2, "__esModule", { value: true });
+ var react_1 = require_react();
+ var StderrContext_1 = __importDefault(require_StderrContext());
+ var useStderr = /* @__PURE__ */ __name(() => react_1.useContext(StderrContext_1.default), "useStderr");
+ exports2.default = useStderr;
+ }
+});
+
+// ../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/hooks/use-focus.js
+var require_use_focus = __commonJS({
+ "../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/hooks/use-focus.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ var __importDefault = exports2 && exports2.__importDefault || function(mod) {
+ return mod && mod.__esModule ? mod : { "default": mod };
+ };
+ Object.defineProperty(exports2, "__esModule", { value: true });
+ var react_1 = require_react();
+ var FocusContext_1 = __importDefault(require_FocusContext());
+ var use_stdin_1 = __importDefault(require_use_stdin());
+ var useFocus = /* @__PURE__ */ __name(({ isActive = true, autoFocus = false, id: customId } = {}) => {
+ const { isRawModeSupported, setRawMode } = use_stdin_1.default();
+ const { activeId, add, remove, activate, deactivate, focus } = react_1.useContext(FocusContext_1.default);
+ const id = react_1.useMemo(() => {
+ return customId !== null && customId !== void 0 ? customId : Math.random().toString().slice(2, 7);
+ }, [customId]);
+ react_1.useEffect(() => {
+ add(id, { autoFocus });
+ return () => {
+ remove(id);
+ };
+ }, [id, autoFocus]);
+ react_1.useEffect(() => {
+ if (isActive) {
+ activate(id);
+ } else {
+ deactivate(id);
+ }
+ }, [isActive, id]);
+ react_1.useEffect(() => {
+ if (!isRawModeSupported || !isActive) {
+ return;
+ }
+ setRawMode(true);
+ return () => {
+ setRawMode(false);
+ };
+ }, [isActive]);
+ return {
+ isFocused: Boolean(id) && activeId === id,
+ focus
+ };
+ }, "useFocus");
+ exports2.default = useFocus;
+ }
+});
+
+// ../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/hooks/use-focus-manager.js
+var require_use_focus_manager = __commonJS({
+ "../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/hooks/use-focus-manager.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ var __importDefault = exports2 && exports2.__importDefault || function(mod) {
+ return mod && mod.__esModule ? mod : { "default": mod };
+ };
+ Object.defineProperty(exports2, "__esModule", { value: true });
+ var react_1 = require_react();
+ var FocusContext_1 = __importDefault(require_FocusContext());
+ var useFocusManager = /* @__PURE__ */ __name(() => {
+ const focusContext = react_1.useContext(FocusContext_1.default);
+ return {
+ enableFocus: focusContext.enableFocus,
+ disableFocus: focusContext.disableFocus,
+ focusNext: focusContext.focusNext,
+ focusPrevious: focusContext.focusPrevious,
+ focus: focusContext.focus
+ };
+ }, "useFocusManager");
+ exports2.default = useFocusManager;
+ }
+});
+
+// ../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/measure-element.js
+var require_measure_element = __commonJS({
+ "../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/measure-element.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ Object.defineProperty(exports2, "__esModule", { value: true });
+ exports2.default = (node) => {
+ var _a2, _b2, _c2, _d;
+ return {
+ width: (_b2 = (_a2 = node.yogaNode) === null || _a2 === void 0 ? void 0 : _a2.getComputedWidth()) !== null && _b2 !== void 0 ? _b2 : 0,
+ height: (_d = (_c2 = node.yogaNode) === null || _c2 === void 0 ? void 0 : _c2.getComputedHeight()) !== null && _d !== void 0 ? _d : 0
+ };
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/index.js
+var require_build2 = __commonJS({
+ "../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/index.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ Object.defineProperty(exports2, "__esModule", { value: true });
+ var render_1 = require_render();
+ Object.defineProperty(exports2, "render", { enumerable: true, get: function() {
+ return render_1.default;
+ } });
+ var Box_1 = require_Box();
+ Object.defineProperty(exports2, "Box", { enumerable: true, get: function() {
+ return Box_1.default;
+ } });
+ var Text_1 = require_Text();
+ Object.defineProperty(exports2, "Text", { enumerable: true, get: function() {
+ return Text_1.default;
+ } });
+ var Static_1 = require_Static();
+ Object.defineProperty(exports2, "Static", { enumerable: true, get: function() {
+ return Static_1.default;
+ } });
+ var Transform_1 = require_Transform();
+ Object.defineProperty(exports2, "Transform", { enumerable: true, get: function() {
+ return Transform_1.default;
+ } });
+ var Newline_1 = require_Newline();
+ Object.defineProperty(exports2, "Newline", { enumerable: true, get: function() {
+ return Newline_1.default;
+ } });
+ var Spacer_1 = require_Spacer();
+ Object.defineProperty(exports2, "Spacer", { enumerable: true, get: function() {
+ return Spacer_1.default;
+ } });
+ var use_input_1 = require_use_input();
+ Object.defineProperty(exports2, "useInput", { enumerable: true, get: function() {
+ return use_input_1.default;
+ } });
+ var use_app_1 = require_use_app();
+ Object.defineProperty(exports2, "useApp", { enumerable: true, get: function() {
+ return use_app_1.default;
+ } });
+ var use_stdin_1 = require_use_stdin();
+ Object.defineProperty(exports2, "useStdin", { enumerable: true, get: function() {
+ return use_stdin_1.default;
+ } });
+ var use_stdout_1 = require_use_stdout();
+ Object.defineProperty(exports2, "useStdout", { enumerable: true, get: function() {
+ return use_stdout_1.default;
+ } });
+ var use_stderr_1 = require_use_stderr();
+ Object.defineProperty(exports2, "useStderr", { enumerable: true, get: function() {
+ return use_stderr_1.default;
+ } });
+ var use_focus_1 = require_use_focus();
+ Object.defineProperty(exports2, "useFocus", { enumerable: true, get: function() {
+ return use_focus_1.default;
+ } });
+ var use_focus_manager_1 = require_use_focus_manager();
+ Object.defineProperty(exports2, "useFocusManager", { enumerable: true, get: function() {
+ return use_focus_manager_1.default;
+ } });
+ var measure_element_1 = require_measure_element();
+ Object.defineProperty(exports2, "measureElement", { enumerable: true, get: function() {
+ return measure_element_1.default;
+ } });
+ }
+});
+
+// ../../node_modules/.pnpm/dotenv@16.0.0/node_modules/dotenv/lib/main.js
+var require_main = __commonJS({
+ "../../node_modules/.pnpm/dotenv@16.0.0/node_modules/dotenv/lib/main.js"(exports2, module2) {
+ init_import_meta_url();
+ var fs20 = require("fs");
+ var path45 = require("path");
+ var os9 = require("os");
+ var LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/mg;
+ function parse4(src) {
+ const obj = {};
+ let lines = src.toString();
+ lines = lines.replace(/\r\n?/mg, "\n");
+ let match;
+ while ((match = LINE.exec(lines)) != null) {
+ const key = match[1];
+ let value = match[2] || "";
+ value = value.trim();
+ const maybeQuote = value[0];
+ value = value.replace(/^(['"`])([\s\S]*)\1$/mg, "$2");
+ if (maybeQuote === '"') {
+ value = value.replace(/\\n/g, "\n");
+ value = value.replace(/\\r/g, "\r");
+ }
+ obj[key] = value;
+ }
+ return obj;
+ }
+ __name(parse4, "parse");
+ function _log(message) {
+ console.log(`[dotenv][DEBUG] ${message}`);
+ }
+ __name(_log, "_log");
+ function _resolveHome(envPath) {
+ return envPath[0] === "~" ? path45.join(os9.homedir(), envPath.slice(1)) : envPath;
+ }
+ __name(_resolveHome, "_resolveHome");
+ function config(options14) {
+ let dotenvPath = path45.resolve(process.cwd(), ".env");
+ let encoding = "utf8";
+ const debug = Boolean(options14 && options14.debug);
+ const override = Boolean(options14 && options14.override);
+ if (options14) {
+ if (options14.path != null) {
+ dotenvPath = _resolveHome(options14.path);
+ }
+ if (options14.encoding != null) {
+ encoding = options14.encoding;
+ }
+ }
+ try {
+ const parsed = DotenvModule.parse(fs20.readFileSync(dotenvPath, { encoding }));
+ Object.keys(parsed).forEach(function(key) {
+ if (!Object.prototype.hasOwnProperty.call(process.env, key)) {
+ process.env[key] = parsed[key];
+ } else {
+ if (override === true) {
+ process.env[key] = parsed[key];
+ }
+ if (debug) {
+ if (override === true) {
+ _log(`"${key}" is already defined in \`process.env\` and WAS overwritten`);
+ } else {
+ _log(`"${key}" is already defined in \`process.env\` and was NOT overwritten`);
+ }
+ }
+ }
+ });
+ return { parsed };
+ } catch (e2) {
+ if (debug) {
+ _log(`Failed to load ${dotenvPath} ${e2.message}`);
+ }
+ return { error: e2 };
+ }
+ }
+ __name(config, "config");
+ var DotenvModule = {
+ config,
+ parse: parse4
+ };
+ module2.exports.config = DotenvModule.config;
+ module2.exports.parse = DotenvModule.parse;
+ module2.exports = DotenvModule;
+ }
+});
+
+// ../../node_modules/.pnpm/cli-table3@0.6.3/node_modules/cli-table3/src/debug.js
+var require_debug = __commonJS({
+ "../../node_modules/.pnpm/cli-table3@0.6.3/node_modules/cli-table3/src/debug.js"(exports2, module2) {
+ init_import_meta_url();
+ var messages = [];
+ var level = 0;
+ var debug = /* @__PURE__ */ __name((msg, min) => {
+ if (level >= min) {
+ messages.push(msg);
+ }
+ }, "debug");
+ debug.WARN = 1;
+ debug.INFO = 2;
+ debug.DEBUG = 3;
+ debug.reset = () => {
+ messages = [];
+ };
+ debug.setDebugLevel = (v) => {
+ level = v;
+ };
+ debug.warn = (msg) => debug(msg, debug.WARN);
+ debug.info = (msg) => debug(msg, debug.INFO);
+ debug.debug = (msg) => debug(msg, debug.DEBUG);
+ debug.debugMessages = () => messages;
+ module2.exports = debug;
+ }
+});
+
+// ../../node_modules/.pnpm/cli-table3@0.6.3/node_modules/cli-table3/src/utils.js
+var require_utils3 = __commonJS({
+ "../../node_modules/.pnpm/cli-table3@0.6.3/node_modules/cli-table3/src/utils.js"(exports2, module2) {
+ init_import_meta_url();
+ var stringWidth = require_string_width();
+ function codeRegex(capture) {
+ return capture ? /\u001b\[((?:\d*;){0,5}\d*)m/g : /\u001b\[(?:\d*;){0,5}\d*m/g;
+ }
+ __name(codeRegex, "codeRegex");
+ function strlen(str) {
+ let code = codeRegex();
+ let stripped = ("" + str).replace(code, "");
+ let split = stripped.split("\n");
+ return split.reduce(function(memo, s) {
+ return stringWidth(s) > memo ? stringWidth(s) : memo;
+ }, 0);
+ }
+ __name(strlen, "strlen");
+ function repeat(str, times) {
+ return Array(times + 1).join(str);
+ }
+ __name(repeat, "repeat");
+ function pad2(str, len, pad3, dir) {
+ let length = strlen(str);
+ if (len + 1 >= length) {
+ let padlen = len - length;
+ switch (dir) {
+ case "right": {
+ str = repeat(pad3, padlen) + str;
+ break;
+ }
+ case "center": {
+ let right2 = Math.ceil(padlen / 2);
+ let left2 = padlen - right2;
+ str = repeat(pad3, left2) + str + repeat(pad3, right2);
+ break;
+ }
+ default: {
+ str = str + repeat(pad3, padlen);
+ break;
+ }
+ }
+ }
+ return str;
+ }
+ __name(pad2, "pad");
+ var codeCache = {};
+ function addToCodeCache(name, on, off) {
+ on = "\x1B[" + on + "m";
+ off = "\x1B[" + off + "m";
+ codeCache[on] = { set: name, to: true };
+ codeCache[off] = { set: name, to: false };
+ codeCache[name] = { on, off };
+ }
+ __name(addToCodeCache, "addToCodeCache");
+ addToCodeCache("bold", 1, 22);
+ addToCodeCache("italics", 3, 23);
+ addToCodeCache("underline", 4, 24);
+ addToCodeCache("inverse", 7, 27);
+ addToCodeCache("strikethrough", 9, 29);
+ function updateState(state, controlChars) {
+ let controlCode = controlChars[1] ? parseInt(controlChars[1].split(";")[0]) : 0;
+ if (controlCode >= 30 && controlCode <= 39 || controlCode >= 90 && controlCode <= 97) {
+ state.lastForegroundAdded = controlChars[0];
+ return;
+ }
+ if (controlCode >= 40 && controlCode <= 49 || controlCode >= 100 && controlCode <= 107) {
+ state.lastBackgroundAdded = controlChars[0];
+ return;
+ }
+ if (controlCode === 0) {
+ for (let i in state) {
+ if (Object.prototype.hasOwnProperty.call(state, i)) {
+ delete state[i];
+ }
+ }
+ return;
+ }
+ let info = codeCache[controlChars[0]];
+ if (info) {
+ state[info.set] = info.to;
+ }
+ }
+ __name(updateState, "updateState");
+ function readState(line) {
+ let code = codeRegex(true);
+ let controlChars = code.exec(line);
+ let state = {};
+ while (controlChars !== null) {
+ updateState(state, controlChars);
+ controlChars = code.exec(line);
+ }
+ return state;
+ }
+ __name(readState, "readState");
+ function unwindState(state, ret) {
+ let lastBackgroundAdded = state.lastBackgroundAdded;
+ let lastForegroundAdded = state.lastForegroundAdded;
+ delete state.lastBackgroundAdded;
+ delete state.lastForegroundAdded;
+ Object.keys(state).forEach(function(key) {
+ if (state[key]) {
+ ret += codeCache[key].off;
+ }
+ });
+ if (lastBackgroundAdded && lastBackgroundAdded != "\x1B[49m") {
+ ret += "\x1B[49m";
+ }
+ if (lastForegroundAdded && lastForegroundAdded != "\x1B[39m") {
+ ret += "\x1B[39m";
+ }
+ return ret;
+ }
+ __name(unwindState, "unwindState");
+ function rewindState(state, ret) {
+ let lastBackgroundAdded = state.lastBackgroundAdded;
+ let lastForegroundAdded = state.lastForegroundAdded;
+ delete state.lastBackgroundAdded;
+ delete state.lastForegroundAdded;
+ Object.keys(state).forEach(function(key) {
+ if (state[key]) {
+ ret = codeCache[key].on + ret;
+ }
+ });
+ if (lastBackgroundAdded && lastBackgroundAdded != "\x1B[49m") {
+ ret = lastBackgroundAdded + ret;
+ }
+ if (lastForegroundAdded && lastForegroundAdded != "\x1B[39m") {
+ ret = lastForegroundAdded + ret;
+ }
+ return ret;
+ }
+ __name(rewindState, "rewindState");
+ function truncateWidth(str, desiredLength) {
+ if (str.length === strlen(str)) {
+ return str.substr(0, desiredLength);
+ }
+ while (strlen(str) > desiredLength) {
+ str = str.slice(0, -1);
+ }
+ return str;
+ }
+ __name(truncateWidth, "truncateWidth");
+ function truncateWidthWithAnsi(str, desiredLength) {
+ let code = codeRegex(true);
+ let split = str.split(codeRegex());
+ let splitIndex = 0;
+ let retLen = 0;
+ let ret = "";
+ let myArray;
+ let state = {};
+ while (retLen < desiredLength) {
+ myArray = code.exec(str);
+ let toAdd = split[splitIndex];
+ splitIndex++;
+ if (retLen + strlen(toAdd) > desiredLength) {
+ toAdd = truncateWidth(toAdd, desiredLength - retLen);
+ }
+ ret += toAdd;
+ retLen += strlen(toAdd);
+ if (retLen < desiredLength) {
+ if (!myArray) {
+ break;
+ }
+ ret += myArray[0];
+ updateState(state, myArray);
+ }
+ }
+ return unwindState(state, ret);
+ }
+ __name(truncateWidthWithAnsi, "truncateWidthWithAnsi");
+ function truncate2(str, desiredLength, truncateChar) {
+ truncateChar = truncateChar || "\u2026";
+ let lengthOfStr = strlen(str);
+ if (lengthOfStr <= desiredLength) {
+ return str;
+ }
+ desiredLength -= strlen(truncateChar);
+ let ret = truncateWidthWithAnsi(str, desiredLength);
+ return ret + truncateChar;
+ }
+ __name(truncate2, "truncate");
+ function defaultOptions() {
+ return {
+ chars: {
+ top: "\u2500",
+ "top-mid": "\u252C",
+ "top-left": "\u250C",
+ "top-right": "\u2510",
+ bottom: "\u2500",
+ "bottom-mid": "\u2534",
+ "bottom-left": "\u2514",
+ "bottom-right": "\u2518",
+ left: "\u2502",
+ "left-mid": "\u251C",
+ mid: "\u2500",
+ "mid-mid": "\u253C",
+ right: "\u2502",
+ "right-mid": "\u2524",
+ middle: "\u2502"
+ },
+ truncate: "\u2026",
+ colWidths: [],
+ rowHeights: [],
+ colAligns: [],
+ rowAligns: [],
+ style: {
+ "padding-left": 1,
+ "padding-right": 1,
+ head: ["red"],
+ border: ["grey"],
+ compact: false
+ },
+ head: []
+ };
+ }
+ __name(defaultOptions, "defaultOptions");
+ function mergeOptions(options14, defaults) {
+ options14 = options14 || {};
+ defaults = defaults || defaultOptions();
+ let ret = Object.assign({}, defaults, options14);
+ ret.chars = Object.assign({}, defaults.chars, options14.chars);
+ ret.style = Object.assign({}, defaults.style, options14.style);
+ return ret;
+ }
+ __name(mergeOptions, "mergeOptions");
+ function wordWrap(maxLength, input) {
+ let lines = [];
+ let split = input.split(/(\s+)/g);
+ let line = [];
+ let lineLength = 0;
+ let whitespace;
+ for (let i = 0; i < split.length; i += 2) {
+ let word = split[i];
+ let newLength = lineLength + strlen(word);
+ if (lineLength > 0 && whitespace) {
+ newLength += whitespace.length;
+ }
+ if (newLength > maxLength) {
+ if (lineLength !== 0) {
+ lines.push(line.join(""));
+ }
+ line = [word];
+ lineLength = strlen(word);
+ } else {
+ line.push(whitespace || "", word);
+ lineLength = newLength;
+ }
+ whitespace = split[i + 1];
+ }
+ if (lineLength) {
+ lines.push(line.join(""));
+ }
+ return lines;
+ }
+ __name(wordWrap, "wordWrap");
+ function textWrap(maxLength, input) {
+ let lines = [];
+ let line = "";
+ function pushLine(str, ws) {
+ if (line.length && ws)
+ line += ws;
+ line += str;
+ while (line.length > maxLength) {
+ lines.push(line.slice(0, maxLength));
+ line = line.slice(maxLength);
+ }
+ }
+ __name(pushLine, "pushLine");
+ let split = input.split(/(\s+)/g);
+ for (let i = 0; i < split.length; i += 2) {
+ pushLine(split[i], i && split[i - 1]);
+ }
+ if (line.length)
+ lines.push(line);
+ return lines;
+ }
+ __name(textWrap, "textWrap");
+ function multiLineWordWrap(maxLength, input, wrapOnWordBoundary = true) {
+ let output = [];
+ input = input.split("\n");
+ const handler15 = wrapOnWordBoundary ? wordWrap : textWrap;
+ for (let i = 0; i < input.length; i++) {
+ output.push.apply(output, handler15(maxLength, input[i]));
+ }
+ return output;
+ }
+ __name(multiLineWordWrap, "multiLineWordWrap");
+ function colorizeLines(input) {
+ let state = {};
+ let output = [];
+ for (let i = 0; i < input.length; i++) {
+ let line = rewindState(state, input[i]);
+ state = readState(line);
+ let temp = Object.assign({}, state);
+ output.push(unwindState(temp, line));
+ }
+ return output;
+ }
+ __name(colorizeLines, "colorizeLines");
+ function hyperlink(url3, text) {
+ const OSC = "\x1B]";
+ const BEL = "\x07";
+ const SEP = ";";
+ return [OSC, "8", SEP, SEP, url3 || text, BEL, text, OSC, "8", SEP, SEP, BEL].join("");
+ }
+ __name(hyperlink, "hyperlink");
+ module2.exports = {
+ strlen,
+ repeat,
+ pad: pad2,
+ truncate: truncate2,
+ mergeOptions,
+ wordWrap: multiLineWordWrap,
+ colorizeLines,
+ hyperlink
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/@colors+colors@1.5.0/node_modules/@colors/colors/lib/styles.js
+var require_styles2 = __commonJS({
+ "../../node_modules/.pnpm/@colors+colors@1.5.0/node_modules/@colors/colors/lib/styles.js"(exports2, module2) {
+ init_import_meta_url();
+ var styles = {};
+ module2["exports"] = styles;
+ var codes = {
+ reset: [0, 0],
+ bold: [1, 22],
+ dim: [2, 22],
+ italic: [3, 23],
+ underline: [4, 24],
+ inverse: [7, 27],
+ hidden: [8, 28],
+ strikethrough: [9, 29],
+ black: [30, 39],
+ red: [31, 39],
+ green: [32, 39],
+ yellow: [33, 39],
+ blue: [34, 39],
+ magenta: [35, 39],
+ cyan: [36, 39],
+ white: [37, 39],
+ gray: [90, 39],
+ grey: [90, 39],
+ brightRed: [91, 39],
+ brightGreen: [92, 39],
+ brightYellow: [93, 39],
+ brightBlue: [94, 39],
+ brightMagenta: [95, 39],
+ brightCyan: [96, 39],
+ brightWhite: [97, 39],
+ bgBlack: [40, 49],
+ bgRed: [41, 49],
+ bgGreen: [42, 49],
+ bgYellow: [43, 49],
+ bgBlue: [44, 49],
+ bgMagenta: [45, 49],
+ bgCyan: [46, 49],
+ bgWhite: [47, 49],
+ bgGray: [100, 49],
+ bgGrey: [100, 49],
+ bgBrightRed: [101, 49],
+ bgBrightGreen: [102, 49],
+ bgBrightYellow: [103, 49],
+ bgBrightBlue: [104, 49],
+ bgBrightMagenta: [105, 49],
+ bgBrightCyan: [106, 49],
+ bgBrightWhite: [107, 49],
+ // legacy styles for colors pre v1.0.0
+ blackBG: [40, 49],
+ redBG: [41, 49],
+ greenBG: [42, 49],
+ yellowBG: [43, 49],
+ blueBG: [44, 49],
+ magentaBG: [45, 49],
+ cyanBG: [46, 49],
+ whiteBG: [47, 49]
+ };
+ Object.keys(codes).forEach(function(key) {
+ var val = codes[key];
+ var style = styles[key] = [];
+ style.open = "\x1B[" + val[0] + "m";
+ style.close = "\x1B[" + val[1] + "m";
+ });
+ }
+});
+
+// ../../node_modules/.pnpm/@colors+colors@1.5.0/node_modules/@colors/colors/lib/system/has-flag.js
+var require_has_flag3 = __commonJS({
+ "../../node_modules/.pnpm/@colors+colors@1.5.0/node_modules/@colors/colors/lib/system/has-flag.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ module2.exports = function(flag, argv) {
+ argv = argv || process.argv;
+ var terminatorPos = argv.indexOf("--");
+ var prefix = /^-{1,2}/.test(flag) ? "" : "--";
+ var pos = argv.indexOf(prefix + flag);
+ return pos !== -1 && (terminatorPos === -1 ? true : pos < terminatorPos);
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/@colors+colors@1.5.0/node_modules/@colors/colors/lib/system/supports-colors.js
+var require_supports_colors = __commonJS({
+ "../../node_modules/.pnpm/@colors+colors@1.5.0/node_modules/@colors/colors/lib/system/supports-colors.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var os9 = require("os");
+ var hasFlag2 = require_has_flag3();
+ var env5 = process.env;
+ var forceColor = void 0;
+ if (hasFlag2("no-color") || hasFlag2("no-colors") || hasFlag2("color=false")) {
+ forceColor = false;
+ } else if (hasFlag2("color") || hasFlag2("colors") || hasFlag2("color=true") || hasFlag2("color=always")) {
+ forceColor = true;
+ }
+ if ("FORCE_COLOR" in env5) {
+ forceColor = env5.FORCE_COLOR.length === 0 || parseInt(env5.FORCE_COLOR, 10) !== 0;
+ }
+ function translateLevel2(level) {
+ if (level === 0) {
+ return false;
+ }
+ return {
+ level,
+ hasBasic: true,
+ has256: level >= 2,
+ has16m: level >= 3
+ };
+ }
+ __name(translateLevel2, "translateLevel");
+ function supportsColor2(stream2) {
+ if (forceColor === false) {
+ return 0;
+ }
+ if (hasFlag2("color=16m") || hasFlag2("color=full") || hasFlag2("color=truecolor")) {
+ return 3;
+ }
+ if (hasFlag2("color=256")) {
+ return 2;
+ }
+ if (stream2 && !stream2.isTTY && forceColor !== true) {
+ return 0;
+ }
+ var min = forceColor ? 1 : 0;
+ if (process.platform === "win32") {
+ var osRelease = os9.release().split(".");
+ if (Number(process.versions.node.split(".")[0]) >= 8 && Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
+ return Number(osRelease[2]) >= 14931 ? 3 : 2;
+ }
+ return 1;
+ }
+ if ("CI" in env5) {
+ if (["TRAVIS", "CIRCLECI", "APPVEYOR", "GITLAB_CI"].some(function(sign) {
+ return sign in env5;
+ }) || env5.CI_NAME === "codeship") {
+ return 1;
+ }
+ return min;
+ }
+ if ("TEAMCITY_VERSION" in env5) {
+ return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env5.TEAMCITY_VERSION) ? 1 : 0;
+ }
+ if ("TERM_PROGRAM" in env5) {
+ var version2 = parseInt((env5.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+ switch (env5.TERM_PROGRAM) {
+ case "iTerm.app":
+ return version2 >= 3 ? 3 : 2;
+ case "Hyper":
+ return 3;
+ case "Apple_Terminal":
+ return 2;
+ }
+ }
+ if (/-256(color)?$/i.test(env5.TERM)) {
+ return 2;
+ }
+ if (/^screen|^xterm|^vt100|^rxvt|color|ansi|cygwin|linux/i.test(env5.TERM)) {
+ return 1;
+ }
+ if ("COLORTERM" in env5) {
+ return 1;
+ }
+ if (env5.TERM === "dumb") {
+ return min;
+ }
+ return min;
+ }
+ __name(supportsColor2, "supportsColor");
+ function getSupportLevel(stream2) {
+ var level = supportsColor2(stream2);
+ return translateLevel2(level);
+ }
+ __name(getSupportLevel, "getSupportLevel");
+ module2.exports = {
+ supportsColor: getSupportLevel,
+ stdout: getSupportLevel(process.stdout),
+ stderr: getSupportLevel(process.stderr)
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/@colors+colors@1.5.0/node_modules/@colors/colors/lib/custom/trap.js
+var require_trap = __commonJS({
+ "../../node_modules/.pnpm/@colors+colors@1.5.0/node_modules/@colors/colors/lib/custom/trap.js"(exports2, module2) {
+ init_import_meta_url();
+ module2["exports"] = /* @__PURE__ */ __name(function runTheTrap(text, options14) {
+ var result = "";
+ text = text || "Run the trap, drop the bass";
+ text = text.split("");
+ var trap = {
+ a: ["@", "\u0104", "\u023A", "\u0245", "\u0394", "\u039B", "\u0414"],
+ b: ["\xDF", "\u0181", "\u0243", "\u026E", "\u03B2", "\u0E3F"],
+ c: ["\xA9", "\u023B", "\u03FE"],
+ d: ["\xD0", "\u018A", "\u0500", "\u0501", "\u0502", "\u0503"],
+ e: [
+ "\xCB",
+ "\u0115",
+ "\u018E",
+ "\u0258",
+ "\u03A3",
+ "\u03BE",
+ "\u04BC",
+ "\u0A6C"
+ ],
+ f: ["\u04FA"],
+ g: ["\u0262"],
+ h: ["\u0126", "\u0195", "\u04A2", "\u04BA", "\u04C7", "\u050A"],
+ i: ["\u0F0F"],
+ j: ["\u0134"],
+ k: ["\u0138", "\u04A0", "\u04C3", "\u051E"],
+ l: ["\u0139"],
+ m: ["\u028D", "\u04CD", "\u04CE", "\u0520", "\u0521", "\u0D69"],
+ n: ["\xD1", "\u014B", "\u019D", "\u0376", "\u03A0", "\u048A"],
+ o: [
+ "\xD8",
+ "\xF5",
+ "\xF8",
+ "\u01FE",
+ "\u0298",
+ "\u047A",
+ "\u05DD",
+ "\u06DD",
+ "\u0E4F"
+ ],
+ p: ["\u01F7", "\u048E"],
+ q: ["\u09CD"],
+ r: ["\xAE", "\u01A6", "\u0210", "\u024C", "\u0280", "\u042F"],
+ s: ["\xA7", "\u03DE", "\u03DF", "\u03E8"],
+ t: ["\u0141", "\u0166", "\u0373"],
+ u: ["\u01B1", "\u054D"],
+ v: ["\u05D8"],
+ w: ["\u0428", "\u0460", "\u047C", "\u0D70"],
+ x: ["\u04B2", "\u04FE", "\u04FC", "\u04FD"],
+ y: ["\xA5", "\u04B0", "\u04CB"],
+ z: ["\u01B5", "\u0240"]
+ };
+ text.forEach(function(c) {
+ c = c.toLowerCase();
+ var chars = trap[c] || [" "];
+ var rand = Math.floor(Math.random() * chars.length);
+ if (typeof trap[c] !== "undefined") {
+ result += trap[c][rand];
+ } else {
+ result += c;
+ }
+ });
+ return result;
+ }, "runTheTrap");
+ }
+});
+
+// ../../node_modules/.pnpm/@colors+colors@1.5.0/node_modules/@colors/colors/lib/custom/zalgo.js
+var require_zalgo = __commonJS({
+ "../../node_modules/.pnpm/@colors+colors@1.5.0/node_modules/@colors/colors/lib/custom/zalgo.js"(exports2, module2) {
+ init_import_meta_url();
+ module2["exports"] = /* @__PURE__ */ __name(function zalgo(text, options14) {
+ text = text || " he is here ";
+ var soul = {
+ "up": [
+ "\u030D",
+ "\u030E",
+ "\u0304",
+ "\u0305",
+ "\u033F",
+ "\u0311",
+ "\u0306",
+ "\u0310",
+ "\u0352",
+ "\u0357",
+ "\u0351",
+ "\u0307",
+ "\u0308",
+ "\u030A",
+ "\u0342",
+ "\u0313",
+ "\u0308",
+ "\u034A",
+ "\u034B",
+ "\u034C",
+ "\u0303",
+ "\u0302",
+ "\u030C",
+ "\u0350",
+ "\u0300",
+ "\u0301",
+ "\u030B",
+ "\u030F",
+ "\u0312",
+ "\u0313",
+ "\u0314",
+ "\u033D",
+ "\u0309",
+ "\u0363",
+ "\u0364",
+ "\u0365",
+ "\u0366",
+ "\u0367",
+ "\u0368",
+ "\u0369",
+ "\u036A",
+ "\u036B",
+ "\u036C",
+ "\u036D",
+ "\u036E",
+ "\u036F",
+ "\u033E",
+ "\u035B",
+ "\u0346",
+ "\u031A"
+ ],
+ "down": [
+ "\u0316",
+ "\u0317",
+ "\u0318",
+ "\u0319",
+ "\u031C",
+ "\u031D",
+ "\u031E",
+ "\u031F",
+ "\u0320",
+ "\u0324",
+ "\u0325",
+ "\u0326",
+ "\u0329",
+ "\u032A",
+ "\u032B",
+ "\u032C",
+ "\u032D",
+ "\u032E",
+ "\u032F",
+ "\u0330",
+ "\u0331",
+ "\u0332",
+ "\u0333",
+ "\u0339",
+ "\u033A",
+ "\u033B",
+ "\u033C",
+ "\u0345",
+ "\u0347",
+ "\u0348",
+ "\u0349",
+ "\u034D",
+ "\u034E",
+ "\u0353",
+ "\u0354",
+ "\u0355",
+ "\u0356",
+ "\u0359",
+ "\u035A",
+ "\u0323"
+ ],
+ "mid": [
+ "\u0315",
+ "\u031B",
+ "\u0300",
+ "\u0301",
+ "\u0358",
+ "\u0321",
+ "\u0322",
+ "\u0327",
+ "\u0328",
+ "\u0334",
+ "\u0335",
+ "\u0336",
+ "\u035C",
+ "\u035D",
+ "\u035E",
+ "\u035F",
+ "\u0360",
+ "\u0362",
+ "\u0338",
+ "\u0337",
+ "\u0361",
+ " \u0489"
+ ]
+ };
+ var all2 = [].concat(soul.up, soul.down, soul.mid);
+ function randomNumber(range) {
+ var r = Math.floor(Math.random() * range);
+ return r;
+ }
+ __name(randomNumber, "randomNumber");
+ function isChar(character) {
+ var bool = false;
+ all2.filter(function(i) {
+ bool = i === character;
+ });
+ return bool;
+ }
+ __name(isChar, "isChar");
+ function heComes(text2, options15) {
+ var result = "";
+ var counts;
+ var l;
+ options15 = options15 || {};
+ options15["up"] = typeof options15["up"] !== "undefined" ? options15["up"] : true;
+ options15["mid"] = typeof options15["mid"] !== "undefined" ? options15["mid"] : true;
+ options15["down"] = typeof options15["down"] !== "undefined" ? options15["down"] : true;
+ options15["size"] = typeof options15["size"] !== "undefined" ? options15["size"] : "maxi";
+ text2 = text2.split("");
+ for (l in text2) {
+ if (isChar(l)) {
+ continue;
+ }
+ result = result + text2[l];
+ counts = { "up": 0, "down": 0, "mid": 0 };
+ switch (options15.size) {
+ case "mini":
+ counts.up = randomNumber(8);
+ counts.mid = randomNumber(2);
+ counts.down = randomNumber(8);
+ break;
+ case "maxi":
+ counts.up = randomNumber(16) + 3;
+ counts.mid = randomNumber(4) + 1;
+ counts.down = randomNumber(64) + 3;
+ break;
+ default:
+ counts.up = randomNumber(8) + 1;
+ counts.mid = randomNumber(6) / 2;
+ counts.down = randomNumber(8) + 1;
+ break;
+ }
+ var arr = ["up", "mid", "down"];
+ for (var d in arr) {
+ var index = arr[d];
+ for (var i = 0; i <= counts[index]; i++) {
+ if (options15[index]) {
+ result = result + soul[index][randomNumber(soul[index].length)];
+ }
+ }
+ }
+ }
+ return result;
+ }
+ __name(heComes, "heComes");
+ return heComes(text, options14);
+ }, "zalgo");
+ }
+});
+
+// ../../node_modules/.pnpm/@colors+colors@1.5.0/node_modules/@colors/colors/lib/maps/america.js
+var require_america = __commonJS({
+ "../../node_modules/.pnpm/@colors+colors@1.5.0/node_modules/@colors/colors/lib/maps/america.js"(exports2, module2) {
+ init_import_meta_url();
+ module2["exports"] = function(colors) {
+ return function(letter, i, exploded) {
+ if (letter === " ")
+ return letter;
+ switch (i % 3) {
+ case 0:
+ return colors.red(letter);
+ case 1:
+ return colors.white(letter);
+ case 2:
+ return colors.blue(letter);
+ }
+ };
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/@colors+colors@1.5.0/node_modules/@colors/colors/lib/maps/zebra.js
+var require_zebra = __commonJS({
+ "../../node_modules/.pnpm/@colors+colors@1.5.0/node_modules/@colors/colors/lib/maps/zebra.js"(exports2, module2) {
+ init_import_meta_url();
+ module2["exports"] = function(colors) {
+ return function(letter, i, exploded) {
+ return i % 2 === 0 ? letter : colors.inverse(letter);
+ };
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/@colors+colors@1.5.0/node_modules/@colors/colors/lib/maps/rainbow.js
+var require_rainbow = __commonJS({
+ "../../node_modules/.pnpm/@colors+colors@1.5.0/node_modules/@colors/colors/lib/maps/rainbow.js"(exports2, module2) {
+ init_import_meta_url();
+ module2["exports"] = function(colors) {
+ var rainbowColors = ["red", "yellow", "green", "blue", "magenta"];
+ return function(letter, i, exploded) {
+ if (letter === " ") {
+ return letter;
+ } else {
+ return colors[rainbowColors[i++ % rainbowColors.length]](letter);
+ }
+ };
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/@colors+colors@1.5.0/node_modules/@colors/colors/lib/maps/random.js
+var require_random = __commonJS({
+ "../../node_modules/.pnpm/@colors+colors@1.5.0/node_modules/@colors/colors/lib/maps/random.js"(exports2, module2) {
+ init_import_meta_url();
+ module2["exports"] = function(colors) {
+ var available = [
+ "underline",
+ "inverse",
+ "grey",
+ "yellow",
+ "red",
+ "green",
+ "blue",
+ "white",
+ "cyan",
+ "magenta",
+ "brightYellow",
+ "brightRed",
+ "brightGreen",
+ "brightBlue",
+ "brightWhite",
+ "brightCyan",
+ "brightMagenta"
+ ];
+ return function(letter, i, exploded) {
+ return letter === " " ? letter : colors[available[Math.round(Math.random() * (available.length - 2))]](letter);
+ };
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/@colors+colors@1.5.0/node_modules/@colors/colors/lib/colors.js
+var require_colors = __commonJS({
+ "../../node_modules/.pnpm/@colors+colors@1.5.0/node_modules/@colors/colors/lib/colors.js"(exports2, module2) {
+ init_import_meta_url();
+ var colors = {};
+ module2["exports"] = colors;
+ colors.themes = {};
+ var util3 = require("util");
+ var ansiStyles = colors.styles = require_styles2();
+ var defineProps = Object.defineProperties;
+ var newLineRegex = new RegExp(/[\r\n]+/g);
+ colors.supportsColor = require_supports_colors().supportsColor;
+ if (typeof colors.enabled === "undefined") {
+ colors.enabled = colors.supportsColor() !== false;
+ }
+ colors.enable = function() {
+ colors.enabled = true;
+ };
+ colors.disable = function() {
+ colors.enabled = false;
+ };
+ colors.stripColors = colors.strip = function(str) {
+ return ("" + str).replace(/\x1B\[\d+m/g, "");
+ };
+ var stylize = colors.stylize = /* @__PURE__ */ __name(function stylize2(str, style) {
+ if (!colors.enabled) {
+ return str + "";
+ }
+ var styleMap = ansiStyles[style];
+ if (!styleMap && style in colors) {
+ return colors[style](str);
+ }
+ return styleMap.open + str + styleMap.close;
+ }, "stylize");
+ var matchOperatorsRe = /[|\\{}()[\]^$+*?.]/g;
+ var escapeStringRegexp = /* @__PURE__ */ __name(function(str) {
+ if (typeof str !== "string") {
+ throw new TypeError("Expected a string");
+ }
+ return str.replace(matchOperatorsRe, "\\$&");
+ }, "escapeStringRegexp");
+ function build5(_styles) {
+ var builder = /* @__PURE__ */ __name(function builder2() {
+ return applyStyle.apply(builder2, arguments);
+ }, "builder");
+ builder._styles = _styles;
+ builder.__proto__ = proto;
+ return builder;
+ }
+ __name(build5, "build");
+ var styles = function() {
+ var ret = {};
+ ansiStyles.grey = ansiStyles.gray;
+ Object.keys(ansiStyles).forEach(function(key) {
+ ansiStyles[key].closeRe = new RegExp(escapeStringRegexp(ansiStyles[key].close), "g");
+ ret[key] = {
+ get: function() {
+ return build5(this._styles.concat(key));
+ }
+ };
+ });
+ return ret;
+ }();
+ var proto = defineProps(/* @__PURE__ */ __name(function colors2() {
+ }, "colors"), styles);
+ function applyStyle() {
+ var args = Array.prototype.slice.call(arguments);
+ var str = args.map(function(arg) {
+ if (arg != null && arg.constructor === String) {
+ return arg;
+ } else {
+ return util3.inspect(arg);
+ }
+ }).join(" ");
+ if (!colors.enabled || !str) {
+ return str;
+ }
+ var newLinesPresent = str.indexOf("\n") != -1;
+ var nestedStyles = this._styles;
+ var i = nestedStyles.length;
+ while (i--) {
+ var code = ansiStyles[nestedStyles[i]];
+ str = code.open + str.replace(code.closeRe, code.open) + code.close;
+ if (newLinesPresent) {
+ str = str.replace(newLineRegex, function(match) {
+ return code.close + match + code.open;
+ });
+ }
+ }
+ return str;
+ }
+ __name(applyStyle, "applyStyle");
+ colors.setTheme = function(theme) {
+ if (typeof theme === "string") {
+ console.log("colors.setTheme now only accepts an object, not a string. If you are trying to set a theme from a file, it is now your (the caller's) responsibility to require the file. The old syntax looked like colors.setTheme(__dirname + '/../themes/generic-logging.js'); The new syntax looks like colors.setTheme(require(__dirname + '/../themes/generic-logging.js'));");
+ return;
+ }
+ for (var style in theme) {
+ (function(style2) {
+ colors[style2] = function(str) {
+ if (typeof theme[style2] === "object") {
+ var out = str;
+ for (var i in theme[style2]) {
+ out = colors[theme[style2][i]](out);
+ }
+ return out;
+ }
+ return colors[theme[style2]](str);
+ };
+ })(style);
+ }
+ };
+ function init() {
+ var ret = {};
+ Object.keys(styles).forEach(function(name) {
+ ret[name] = {
+ get: function() {
+ return build5([name]);
+ }
+ };
+ });
+ return ret;
+ }
+ __name(init, "init");
+ var sequencer = /* @__PURE__ */ __name(function sequencer2(map2, str) {
+ var exploded = str.split("");
+ exploded = exploded.map(map2);
+ return exploded.join("");
+ }, "sequencer");
+ colors.trap = require_trap();
+ colors.zalgo = require_zalgo();
+ colors.maps = {};
+ colors.maps.america = require_america()(colors);
+ colors.maps.zebra = require_zebra()(colors);
+ colors.maps.rainbow = require_rainbow()(colors);
+ colors.maps.random = require_random()(colors);
+ for (map in colors.maps) {
+ (function(map2) {
+ colors[map2] = function(str) {
+ return sequencer(colors.maps[map2], str);
+ };
+ })(map);
+ }
+ var map;
+ defineProps(colors, init());
+ }
+});
+
+// ../../node_modules/.pnpm/@colors+colors@1.5.0/node_modules/@colors/colors/safe.js
+var require_safe = __commonJS({
+ "../../node_modules/.pnpm/@colors+colors@1.5.0/node_modules/@colors/colors/safe.js"(exports2, module2) {
+ init_import_meta_url();
+ var colors = require_colors();
+ module2["exports"] = colors;
+ }
+});
+
+// ../../node_modules/.pnpm/cli-table3@0.6.3/node_modules/cli-table3/src/cell.js
+var require_cell = __commonJS({
+ "../../node_modules/.pnpm/cli-table3@0.6.3/node_modules/cli-table3/src/cell.js"(exports2, module2) {
+ init_import_meta_url();
+ var { info, debug } = require_debug();
+ var utils = require_utils3();
+ var Cell = class {
+ /**
+ * A representation of a cell within the table.
+ * Implementations must have `init` and `draw` methods,
+ * as well as `colSpan`, `rowSpan`, `desiredHeight` and `desiredWidth` properties.
+ * @param options
+ * @constructor
+ */
+ constructor(options14) {
+ this.setOptions(options14);
+ this.x = null;
+ this.y = null;
+ }
+ setOptions(options14) {
+ if (["boolean", "number", "string"].indexOf(typeof options14) !== -1) {
+ options14 = { content: "" + options14 };
+ }
+ options14 = options14 || {};
+ this.options = options14;
+ let content = options14.content;
+ if (["boolean", "number", "string"].indexOf(typeof content) !== -1) {
+ this.content = String(content);
+ } else if (!content) {
+ this.content = this.options.href || "";
+ } else {
+ throw new Error("Content needs to be a primitive, got: " + typeof content);
+ }
+ this.colSpan = options14.colSpan || 1;
+ this.rowSpan = options14.rowSpan || 1;
+ if (this.options.href) {
+ Object.defineProperty(this, "href", {
+ get() {
+ return this.options.href;
+ }
+ });
+ }
+ }
+ mergeTableOptions(tableOptions, cells) {
+ this.cells = cells;
+ let optionsChars = this.options.chars || {};
+ let tableChars = tableOptions.chars;
+ let chars = this.chars = {};
+ CHAR_NAMES.forEach(function(name) {
+ setOption(optionsChars, tableChars, name, chars);
+ });
+ this.truncate = this.options.truncate || tableOptions.truncate;
+ let style = this.options.style = this.options.style || {};
+ let tableStyle = tableOptions.style;
+ setOption(style, tableStyle, "padding-left", this);
+ setOption(style, tableStyle, "padding-right", this);
+ this.head = style.head || tableStyle.head;
+ this.border = style.border || tableStyle.border;
+ this.fixedWidth = tableOptions.colWidths[this.x];
+ this.lines = this.computeLines(tableOptions);
+ this.desiredWidth = utils.strlen(this.content) + this.paddingLeft + this.paddingRight;
+ this.desiredHeight = this.lines.length;
+ }
+ computeLines(tableOptions) {
+ const tableWordWrap = tableOptions.wordWrap || tableOptions.textWrap;
+ const { wordWrap = tableWordWrap } = this.options;
+ if (this.fixedWidth && wordWrap) {
+ this.fixedWidth -= this.paddingLeft + this.paddingRight;
+ if (this.colSpan) {
+ let i = 1;
+ while (i < this.colSpan) {
+ this.fixedWidth += tableOptions.colWidths[this.x + i];
+ i++;
+ }
+ }
+ const { wrapOnWordBoundary: tableWrapOnWordBoundary = true } = tableOptions;
+ const { wrapOnWordBoundary = tableWrapOnWordBoundary } = this.options;
+ return this.wrapLines(utils.wordWrap(this.fixedWidth, this.content, wrapOnWordBoundary));
+ }
+ return this.wrapLines(this.content.split("\n"));
+ }
+ wrapLines(computedLines) {
+ const lines = utils.colorizeLines(computedLines);
+ if (this.href) {
+ return lines.map((line) => utils.hyperlink(this.href, line));
+ }
+ return lines;
+ }
+ /**
+ * Initializes the Cells data structure.
+ *
+ * @param tableOptions - A fully populated set of tableOptions.
+ * In addition to the standard default values, tableOptions must have fully populated the
+ * `colWidths` and `rowWidths` arrays. Those arrays must have lengths equal to the number
+ * of columns or rows (respectively) in this table, and each array item must be a Number.
+ *
+ */
+ init(tableOptions) {
+ let x = this.x;
+ let y = this.y;
+ this.widths = tableOptions.colWidths.slice(x, x + this.colSpan);
+ this.heights = tableOptions.rowHeights.slice(y, y + this.rowSpan);
+ this.width = this.widths.reduce(sumPlusOne, -1);
+ this.height = this.heights.reduce(sumPlusOne, -1);
+ this.hAlign = this.options.hAlign || tableOptions.colAligns[x];
+ this.vAlign = this.options.vAlign || tableOptions.rowAligns[y];
+ this.drawRight = x + this.colSpan == tableOptions.colWidths.length;
+ }
+ /**
+ * Draws the given line of the cell.
+ * This default implementation defers to methods `drawTop`, `drawBottom`, `drawLine` and `drawEmpty`.
+ * @param lineNum - can be `top`, `bottom` or a numerical line number.
+ * @param spanningCell - will be a number if being called from a RowSpanCell, and will represent how
+ * many rows below it's being called from. Otherwise it's undefined.
+ * @returns {String} The representation of this line.
+ */
+ draw(lineNum, spanningCell) {
+ if (lineNum == "top")
+ return this.drawTop(this.drawRight);
+ if (lineNum == "bottom")
+ return this.drawBottom(this.drawRight);
+ let content = utils.truncate(this.content, 10, this.truncate);
+ if (!lineNum) {
+ info(`${this.y}-${this.x}: ${this.rowSpan - lineNum}x${this.colSpan} Cell ${content}`);
+ } else {
+ }
+ let padLen = Math.max(this.height - this.lines.length, 0);
+ let padTop;
+ switch (this.vAlign) {
+ case "center":
+ padTop = Math.ceil(padLen / 2);
+ break;
+ case "bottom":
+ padTop = padLen;
+ break;
+ default:
+ padTop = 0;
+ }
+ if (lineNum < padTop || lineNum >= padTop + this.lines.length) {
+ return this.drawEmpty(this.drawRight, spanningCell);
+ }
+ let forceTruncation = this.lines.length > this.height && lineNum + 1 >= this.height;
+ return this.drawLine(lineNum - padTop, this.drawRight, forceTruncation, spanningCell);
+ }
+ /**
+ * Renders the top line of the cell.
+ * @param drawRight - true if this method should render the right edge of the cell.
+ * @returns {String}
+ */
+ drawTop(drawRight) {
+ let content = [];
+ if (this.cells) {
+ this.widths.forEach(function(width, index) {
+ content.push(this._topLeftChar(index));
+ content.push(utils.repeat(this.chars[this.y == 0 ? "top" : "mid"], width));
+ }, this);
+ } else {
+ content.push(this._topLeftChar(0));
+ content.push(utils.repeat(this.chars[this.y == 0 ? "top" : "mid"], this.width));
+ }
+ if (drawRight) {
+ content.push(this.chars[this.y == 0 ? "topRight" : "rightMid"]);
+ }
+ return this.wrapWithStyleColors("border", content.join(""));
+ }
+ _topLeftChar(offset) {
+ let x = this.x + offset;
+ let leftChar;
+ if (this.y == 0) {
+ leftChar = x == 0 ? "topLeft" : offset == 0 ? "topMid" : "top";
+ } else {
+ if (x == 0) {
+ leftChar = "leftMid";
+ } else {
+ leftChar = offset == 0 ? "midMid" : "bottomMid";
+ if (this.cells) {
+ let spanAbove = this.cells[this.y - 1][x] instanceof Cell.ColSpanCell;
+ if (spanAbove) {
+ leftChar = offset == 0 ? "topMid" : "mid";
+ }
+ if (offset == 0) {
+ let i = 1;
+ while (this.cells[this.y][x - i] instanceof Cell.ColSpanCell) {
+ i++;
+ }
+ if (this.cells[this.y][x - i] instanceof Cell.RowSpanCell) {
+ leftChar = "leftMid";
+ }
+ }
+ }
+ }
+ }
+ return this.chars[leftChar];
+ }
+ wrapWithStyleColors(styleProperty, content) {
+ if (this[styleProperty] && this[styleProperty].length) {
+ try {
+ let colors = require_safe();
+ for (let i = this[styleProperty].length - 1; i >= 0; i--) {
+ colors = colors[this[styleProperty][i]];
+ }
+ return colors(content);
+ } catch (e2) {
+ return content;
+ }
+ } else {
+ return content;
+ }
+ }
+ /**
+ * Renders a line of text.
+ * @param lineNum - Which line of text to render. This is not necessarily the line within the cell.
+ * There may be top-padding above the first line of text.
+ * @param drawRight - true if this method should render the right edge of the cell.
+ * @param forceTruncationSymbol - `true` if the rendered text should end with the truncation symbol even
+ * if the text fits. This is used when the cell is vertically truncated. If `false` the text should
+ * only include the truncation symbol if the text will not fit horizontally within the cell width.
+ * @param spanningCell - a number of if being called from a RowSpanCell. (how many rows below). otherwise undefined.
+ * @returns {String}
+ */
+ drawLine(lineNum, drawRight, forceTruncationSymbol, spanningCell) {
+ let left2 = this.chars[this.x == 0 ? "left" : "middle"];
+ if (this.x && spanningCell && this.cells) {
+ let cellLeft = this.cells[this.y + spanningCell][this.x - 1];
+ while (cellLeft instanceof ColSpanCell) {
+ cellLeft = this.cells[cellLeft.y][cellLeft.x - 1];
+ }
+ if (!(cellLeft instanceof RowSpanCell)) {
+ left2 = this.chars["rightMid"];
+ }
+ }
+ let leftPadding = utils.repeat(" ", this.paddingLeft);
+ let right2 = drawRight ? this.chars["right"] : "";
+ let rightPadding = utils.repeat(" ", this.paddingRight);
+ let line = this.lines[lineNum];
+ let len = this.width - (this.paddingLeft + this.paddingRight);
+ if (forceTruncationSymbol)
+ line += this.truncate || "\u2026";
+ let content = utils.truncate(line, len, this.truncate);
+ content = utils.pad(content, len, " ", this.hAlign);
+ content = leftPadding + content + rightPadding;
+ return this.stylizeLine(left2, content, right2);
+ }
+ stylizeLine(left2, content, right2) {
+ left2 = this.wrapWithStyleColors("border", left2);
+ right2 = this.wrapWithStyleColors("border", right2);
+ if (this.y === 0) {
+ content = this.wrapWithStyleColors("head", content);
+ }
+ return left2 + content + right2;
+ }
+ /**
+ * Renders the bottom line of the cell.
+ * @param drawRight - true if this method should render the right edge of the cell.
+ * @returns {String}
+ */
+ drawBottom(drawRight) {
+ let left2 = this.chars[this.x == 0 ? "bottomLeft" : "bottomMid"];
+ let content = utils.repeat(this.chars.bottom, this.width);
+ let right2 = drawRight ? this.chars["bottomRight"] : "";
+ return this.wrapWithStyleColors("border", left2 + content + right2);
+ }
+ /**
+ * Renders a blank line of text within the cell. Used for top and/or bottom padding.
+ * @param drawRight - true if this method should render the right edge of the cell.
+ * @param spanningCell - a number of if being called from a RowSpanCell. (how many rows below). otherwise undefined.
+ * @returns {String}
+ */
+ drawEmpty(drawRight, spanningCell) {
+ let left2 = this.chars[this.x == 0 ? "left" : "middle"];
+ if (this.x && spanningCell && this.cells) {
+ let cellLeft = this.cells[this.y + spanningCell][this.x - 1];
+ while (cellLeft instanceof ColSpanCell) {
+ cellLeft = this.cells[cellLeft.y][cellLeft.x - 1];
+ }
+ if (!(cellLeft instanceof RowSpanCell)) {
+ left2 = this.chars["rightMid"];
+ }
+ }
+ let right2 = drawRight ? this.chars["right"] : "";
+ let content = utils.repeat(" ", this.width);
+ return this.stylizeLine(left2, content, right2);
+ }
+ };
+ __name(Cell, "Cell");
+ var ColSpanCell = class {
+ /**
+ * A Cell that doesn't do anything. It just draws empty lines.
+ * Used as a placeholder in column spanning.
+ * @constructor
+ */
+ constructor() {
+ }
+ draw(lineNum) {
+ if (typeof lineNum === "number") {
+ debug(`${this.y}-${this.x}: 1x1 ColSpanCell`);
+ }
+ return "";
+ }
+ init() {
+ }
+ mergeTableOptions() {
+ }
+ };
+ __name(ColSpanCell, "ColSpanCell");
+ var RowSpanCell = class {
+ /**
+ * A placeholder Cell for a Cell that spans multiple rows.
+ * It delegates rendering to the original cell, but adds the appropriate offset.
+ * @param originalCell
+ * @constructor
+ */
+ constructor(originalCell) {
+ this.originalCell = originalCell;
+ }
+ init(tableOptions) {
+ let y = this.y;
+ let originalY = this.originalCell.y;
+ this.cellOffset = y - originalY;
+ this.offset = findDimension(tableOptions.rowHeights, originalY, this.cellOffset);
+ }
+ draw(lineNum) {
+ if (lineNum == "top") {
+ return this.originalCell.draw(this.offset, this.cellOffset);
+ }
+ if (lineNum == "bottom") {
+ return this.originalCell.draw("bottom");
+ }
+ debug(`${this.y}-${this.x}: 1x${this.colSpan} RowSpanCell for ${this.originalCell.content}`);
+ return this.originalCell.draw(this.offset + 1 + lineNum);
+ }
+ mergeTableOptions() {
+ }
+ };
+ __name(RowSpanCell, "RowSpanCell");
+ function firstDefined(...args) {
+ return args.filter((v) => v !== void 0 && v !== null).shift();
+ }
+ __name(firstDefined, "firstDefined");
+ function setOption(objA, objB, nameB, targetObj) {
+ let nameA = nameB.split("-");
+ if (nameA.length > 1) {
+ nameA[1] = nameA[1].charAt(0).toUpperCase() + nameA[1].substr(1);
+ nameA = nameA.join("");
+ targetObj[nameA] = firstDefined(objA[nameA], objA[nameB], objB[nameA], objB[nameB]);
+ } else {
+ targetObj[nameB] = firstDefined(objA[nameB], objB[nameB]);
+ }
+ }
+ __name(setOption, "setOption");
+ function findDimension(dimensionTable, startingIndex, span) {
+ let ret = dimensionTable[startingIndex];
+ for (let i = 1; i < span; i++) {
+ ret += 1 + dimensionTable[startingIndex + i];
+ }
+ return ret;
+ }
+ __name(findDimension, "findDimension");
+ function sumPlusOne(a, b) {
+ return a + b + 1;
+ }
+ __name(sumPlusOne, "sumPlusOne");
+ var CHAR_NAMES = [
+ "top",
+ "top-mid",
+ "top-left",
+ "top-right",
+ "bottom",
+ "bottom-mid",
+ "bottom-left",
+ "bottom-right",
+ "left",
+ "left-mid",
+ "mid",
+ "mid-mid",
+ "right",
+ "right-mid",
+ "middle"
+ ];
+ module2.exports = Cell;
+ module2.exports.ColSpanCell = ColSpanCell;
+ module2.exports.RowSpanCell = RowSpanCell;
+ }
+});
+
+// ../../node_modules/.pnpm/cli-table3@0.6.3/node_modules/cli-table3/src/layout-manager.js
+var require_layout_manager = __commonJS({
+ "../../node_modules/.pnpm/cli-table3@0.6.3/node_modules/cli-table3/src/layout-manager.js"(exports2, module2) {
+ init_import_meta_url();
+ var { warn, debug } = require_debug();
+ var Cell = require_cell();
+ var { ColSpanCell, RowSpanCell } = Cell;
+ (function() {
+ function next(alloc, col) {
+ if (alloc[col] > 0) {
+ return next(alloc, col + 1);
+ }
+ return col;
+ }
+ __name(next, "next");
+ function layoutTable(table) {
+ let alloc = {};
+ table.forEach(function(row, rowIndex) {
+ let col = 0;
+ row.forEach(function(cell) {
+ cell.y = rowIndex;
+ cell.x = rowIndex ? next(alloc, col) : col;
+ const rowSpan = cell.rowSpan || 1;
+ const colSpan = cell.colSpan || 1;
+ if (rowSpan > 1) {
+ for (let cs2 = 0; cs2 < colSpan; cs2++) {
+ alloc[cell.x + cs2] = rowSpan;
+ }
+ }
+ col = cell.x + colSpan;
+ });
+ Object.keys(alloc).forEach((idx) => {
+ alloc[idx]--;
+ if (alloc[idx] < 1)
+ delete alloc[idx];
+ });
+ });
+ }
+ __name(layoutTable, "layoutTable");
+ function maxWidth(table) {
+ let mw = 0;
+ table.forEach(function(row) {
+ row.forEach(function(cell) {
+ mw = Math.max(mw, cell.x + (cell.colSpan || 1));
+ });
+ });
+ return mw;
+ }
+ __name(maxWidth, "maxWidth");
+ function maxHeight(table) {
+ return table.length;
+ }
+ __name(maxHeight, "maxHeight");
+ function cellsConflict(cell1, cell2) {
+ let yMin1 = cell1.y;
+ let yMax1 = cell1.y - 1 + (cell1.rowSpan || 1);
+ let yMin2 = cell2.y;
+ let yMax2 = cell2.y - 1 + (cell2.rowSpan || 1);
+ let yConflict = !(yMin1 > yMax2 || yMin2 > yMax1);
+ let xMin1 = cell1.x;
+ let xMax1 = cell1.x - 1 + (cell1.colSpan || 1);
+ let xMin2 = cell2.x;
+ let xMax2 = cell2.x - 1 + (cell2.colSpan || 1);
+ let xConflict = !(xMin1 > xMax2 || xMin2 > xMax1);
+ return yConflict && xConflict;
+ }
+ __name(cellsConflict, "cellsConflict");
+ function conflictExists(rows, x, y) {
+ let i_max = Math.min(rows.length - 1, y);
+ let cell = { x, y };
+ for (let i = 0; i <= i_max; i++) {
+ let row = rows[i];
+ for (let j = 0; j < row.length; j++) {
+ if (cellsConflict(cell, row[j])) {
+ return true;
+ }
+ }
+ }
+ return false;
+ }
+ __name(conflictExists, "conflictExists");
+ function allBlank(rows, y, xMin, xMax) {
+ for (let x = xMin; x < xMax; x++) {
+ if (conflictExists(rows, x, y)) {
+ return false;
+ }
+ }
+ return true;
+ }
+ __name(allBlank, "allBlank");
+ function addRowSpanCells(table) {
+ table.forEach(function(row, rowIndex) {
+ row.forEach(function(cell) {
+ for (let i = 1; i < cell.rowSpan; i++) {
+ let rowSpanCell = new RowSpanCell(cell);
+ rowSpanCell.x = cell.x;
+ rowSpanCell.y = cell.y + i;
+ rowSpanCell.colSpan = cell.colSpan;
+ insertCell(rowSpanCell, table[rowIndex + i]);
+ }
+ });
+ });
+ }
+ __name(addRowSpanCells, "addRowSpanCells");
+ function addColSpanCells(cellRows) {
+ for (let rowIndex = cellRows.length - 1; rowIndex >= 0; rowIndex--) {
+ let cellColumns = cellRows[rowIndex];
+ for (let columnIndex = 0; columnIndex < cellColumns.length; columnIndex++) {
+ let cell = cellColumns[columnIndex];
+ for (let k = 1; k < cell.colSpan; k++) {
+ let colSpanCell = new ColSpanCell();
+ colSpanCell.x = cell.x + k;
+ colSpanCell.y = cell.y;
+ cellColumns.splice(columnIndex + 1, 0, colSpanCell);
+ }
+ }
+ }
+ }
+ __name(addColSpanCells, "addColSpanCells");
+ function insertCell(cell, row) {
+ let x = 0;
+ while (x < row.length && row[x].x < cell.x) {
+ x++;
+ }
+ row.splice(x, 0, cell);
+ }
+ __name(insertCell, "insertCell");
+ function fillInTable(table) {
+ let h_max = maxHeight(table);
+ let w_max = maxWidth(table);
+ debug(`Max rows: ${h_max}; Max cols: ${w_max}`);
+ for (let y = 0; y < h_max; y++) {
+ for (let x = 0; x < w_max; x++) {
+ if (!conflictExists(table, x, y)) {
+ let opts = { x, y, colSpan: 1, rowSpan: 1 };
+ x++;
+ while (x < w_max && !conflictExists(table, x, y)) {
+ opts.colSpan++;
+ x++;
+ }
+ let y2 = y + 1;
+ while (y2 < h_max && allBlank(table, y2, opts.x, opts.x + opts.colSpan)) {
+ opts.rowSpan++;
+ y2++;
+ }
+ let cell = new Cell(opts);
+ cell.x = opts.x;
+ cell.y = opts.y;
+ warn(`Missing cell at ${cell.y}-${cell.x}.`);
+ insertCell(cell, table[y]);
+ }
+ }
+ }
+ }
+ __name(fillInTable, "fillInTable");
+ function generateCells(rows) {
+ return rows.map(function(row) {
+ if (!Array.isArray(row)) {
+ let key = Object.keys(row)[0];
+ row = row[key];
+ if (Array.isArray(row)) {
+ row = row.slice();
+ row.unshift(key);
+ } else {
+ row = [key, row];
+ }
+ }
+ return row.map(function(cell) {
+ return new Cell(cell);
+ });
+ });
+ }
+ __name(generateCells, "generateCells");
+ function makeTableLayout(rows) {
+ let cellRows = generateCells(rows);
+ layoutTable(cellRows);
+ fillInTable(cellRows);
+ addRowSpanCells(cellRows);
+ addColSpanCells(cellRows);
+ return cellRows;
+ }
+ __name(makeTableLayout, "makeTableLayout");
+ module2.exports = {
+ makeTableLayout,
+ layoutTable,
+ addRowSpanCells,
+ maxWidth,
+ fillInTable,
+ computeWidths: makeComputeWidths("colSpan", "desiredWidth", "x", 1),
+ computeHeights: makeComputeWidths("rowSpan", "desiredHeight", "y", 1)
+ };
+ })();
+ function makeComputeWidths(colSpan, desiredWidth, x, forcedMin) {
+ return function(vals, table) {
+ let result = [];
+ let spanners = [];
+ let auto = {};
+ table.forEach(function(row) {
+ row.forEach(function(cell) {
+ if ((cell[colSpan] || 1) > 1) {
+ spanners.push(cell);
+ } else {
+ result[cell[x]] = Math.max(result[cell[x]] || 0, cell[desiredWidth] || 0, forcedMin);
+ }
+ });
+ });
+ vals.forEach(function(val, index) {
+ if (typeof val === "number") {
+ result[index] = val;
+ }
+ });
+ for (let k = spanners.length - 1; k >= 0; k--) {
+ let cell = spanners[k];
+ let span = cell[colSpan];
+ let col = cell[x];
+ let existingWidth = result[col];
+ let editableCols = typeof vals[col] === "number" ? 0 : 1;
+ if (typeof existingWidth === "number") {
+ for (let i = 1; i < span; i++) {
+ existingWidth += 1 + result[col + i];
+ if (typeof vals[col + i] !== "number") {
+ editableCols++;
+ }
+ }
+ } else {
+ existingWidth = desiredWidth === "desiredWidth" ? cell.desiredWidth - 1 : 1;
+ if (!auto[col] || auto[col] < existingWidth) {
+ auto[col] = existingWidth;
+ }
+ }
+ if (cell[desiredWidth] > existingWidth) {
+ let i = 0;
+ while (editableCols > 0 && cell[desiredWidth] > existingWidth) {
+ if (typeof vals[col + i] !== "number") {
+ let dif = Math.round((cell[desiredWidth] - existingWidth) / editableCols);
+ existingWidth += dif;
+ result[col + i] += dif;
+ editableCols--;
+ }
+ i++;
+ }
+ }
+ }
+ Object.assign(vals, result, auto);
+ for (let j = 0; j < vals.length; j++) {
+ vals[j] = Math.max(forcedMin, vals[j] || 0);
+ }
+ };
+ }
+ __name(makeComputeWidths, "makeComputeWidths");
+ }
+});
+
+// ../../node_modules/.pnpm/cli-table3@0.6.3/node_modules/cli-table3/src/table.js
+var require_table = __commonJS({
+ "../../node_modules/.pnpm/cli-table3@0.6.3/node_modules/cli-table3/src/table.js"(exports2, module2) {
+ init_import_meta_url();
+ var debug = require_debug();
+ var utils = require_utils3();
+ var tableLayout = require_layout_manager();
+ var Table10 = class extends Array {
+ constructor(opts) {
+ super();
+ const options14 = utils.mergeOptions(opts);
+ Object.defineProperty(this, "options", {
+ value: options14,
+ enumerable: options14.debug
+ });
+ if (options14.debug) {
+ switch (typeof options14.debug) {
+ case "boolean":
+ debug.setDebugLevel(debug.WARN);
+ break;
+ case "number":
+ debug.setDebugLevel(options14.debug);
+ break;
+ case "string":
+ debug.setDebugLevel(parseInt(options14.debug, 10));
+ break;
+ default:
+ debug.setDebugLevel(debug.WARN);
+ debug.warn(`Debug option is expected to be boolean, number, or string. Received a ${typeof options14.debug}`);
+ }
+ Object.defineProperty(this, "messages", {
+ get() {
+ return debug.debugMessages();
+ }
+ });
+ }
+ }
+ toString() {
+ let array = this;
+ let headersPresent = this.options.head && this.options.head.length;
+ if (headersPresent) {
+ array = [this.options.head];
+ if (this.length) {
+ array.push.apply(array, this);
+ }
+ } else {
+ this.options.style.head = [];
+ }
+ let cells = tableLayout.makeTableLayout(array);
+ cells.forEach(function(row) {
+ row.forEach(function(cell) {
+ cell.mergeTableOptions(this.options, cells);
+ }, this);
+ }, this);
+ tableLayout.computeWidths(this.options.colWidths, cells);
+ tableLayout.computeHeights(this.options.rowHeights, cells);
+ cells.forEach(function(row) {
+ row.forEach(function(cell) {
+ cell.init(this.options);
+ }, this);
+ }, this);
+ let result = [];
+ for (let rowIndex = 0; rowIndex < cells.length; rowIndex++) {
+ let row = cells[rowIndex];
+ let heightOfRow = this.options.rowHeights[rowIndex];
+ if (rowIndex === 0 || !this.options.style.compact || rowIndex == 1 && headersPresent) {
+ doDraw(row, "top", result);
+ }
+ for (let lineNum = 0; lineNum < heightOfRow; lineNum++) {
+ doDraw(row, lineNum, result);
+ }
+ if (rowIndex + 1 == cells.length) {
+ doDraw(row, "bottom", result);
+ }
+ }
+ return result.join("\n");
+ }
+ get width() {
+ let str = this.toString().split("\n");
+ return str[0].length;
+ }
+ };
+ __name(Table10, "Table");
+ Table10.reset = () => debug.reset();
+ function doDraw(row, lineNum, result) {
+ let line = [];
+ row.forEach(function(cell) {
+ line.push(cell.draw(lineNum));
+ });
+ let str = line.join("");
+ if (str.length)
+ result.push(str);
+ }
+ __name(doDraw, "doDraw");
+ module2.exports = Table10;
+ }
+});
+
+// ../../node_modules/.pnpm/cli-table3@0.6.3/node_modules/cli-table3/index.js
+var require_cli_table3 = __commonJS({
+ "../../node_modules/.pnpm/cli-table3@0.6.3/node_modules/cli-table3/index.js"(exports2, module2) {
+ init_import_meta_url();
+ module2.exports = require_table();
+ }
+});
+
+// ../../node_modules/.pnpm/@iarna+toml@3.0.0/node_modules/@iarna/toml/lib/parser.js
+var require_parser = __commonJS({
+ "../../node_modules/.pnpm/@iarna+toml@3.0.0/node_modules/@iarna/toml/lib/parser.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var ParserEND = 1114112;
+ var ParserError = class extends Error {
+ /* istanbul ignore next */
+ constructor(msg, filename, linenumber) {
+ super("[ParserError] " + msg, filename, linenumber);
+ this.name = "ParserError";
+ this.code = "ParserError";
+ if (Error.captureStackTrace)
+ Error.captureStackTrace(this, ParserError);
+ }
+ };
+ __name(ParserError, "ParserError");
+ var State = class {
+ constructor(parser2) {
+ this.parser = parser2;
+ this.buf = "";
+ this.returned = null;
+ this.result = null;
+ this.resultTable = null;
+ this.resultArr = null;
+ }
+ };
+ __name(State, "State");
+ var Parser2 = class {
+ constructor() {
+ this.pos = 0;
+ this.col = 0;
+ this.line = 0;
+ this.obj = {};
+ this.ctx = this.obj;
+ this.stack = [];
+ this._buf = "";
+ this.char = null;
+ this.ii = 0;
+ this.state = new State(this.parseStart);
+ }
+ parse(str) {
+ if (str.length === 0 || str.length == null)
+ return;
+ this._buf = String(str);
+ this.ii = -1;
+ this.char = -1;
+ let getNext;
+ while (getNext === false || this.nextChar()) {
+ getNext = this.runOne();
+ }
+ this._buf = null;
+ }
+ nextChar() {
+ if (this.char === 10) {
+ ++this.line;
+ this.col = -1;
+ }
+ ++this.ii;
+ this.char = this._buf.codePointAt(this.ii);
+ ++this.pos;
+ ++this.col;
+ return this.haveBuffer();
+ }
+ haveBuffer() {
+ return this.ii < this._buf.length;
+ }
+ runOne() {
+ return this.state.parser.call(this, this.state.returned);
+ }
+ finish() {
+ this.char = ParserEND;
+ let last;
+ do {
+ last = this.state.parser;
+ this.runOne();
+ } while (this.state.parser !== last);
+ this.ctx = null;
+ this.state = null;
+ this._buf = null;
+ return this.obj;
+ }
+ next(fn2) {
+ if (typeof fn2 !== "function")
+ throw new ParserError("Tried to set state to non-existent state: " + JSON.stringify(fn2));
+ this.state.parser = fn2;
+ }
+ goto(fn2) {
+ this.next(fn2);
+ return this.runOne();
+ }
+ call(fn2, returnWith) {
+ if (returnWith)
+ this.next(returnWith);
+ this.stack.push(this.state);
+ this.state = new State(fn2);
+ }
+ callNow(fn2, returnWith) {
+ this.call(fn2, returnWith);
+ return this.runOne();
+ }
+ return(value) {
+ if (this.stack.length === 0)
+ throw this.error(new ParserError("Stack underflow"));
+ if (value === void 0)
+ value = this.state.buf;
+ this.state = this.stack.pop();
+ this.state.returned = value;
+ }
+ returnNow(value) {
+ this.return(value);
+ return this.runOne();
+ }
+ consume() {
+ if (this.char === ParserEND)
+ throw this.error(new ParserError("Unexpected end-of-buffer"));
+ this.state.buf += this._buf[this.ii];
+ }
+ error(err) {
+ err.line = this.line;
+ err.col = this.col;
+ err.pos = this.pos;
+ return err;
+ }
+ /* istanbul ignore next */
+ parseStart() {
+ throw new ParserError("Must declare a parseStart method");
+ }
+ };
+ __name(Parser2, "Parser");
+ Parser2.END = ParserEND;
+ Parser2.Error = ParserError;
+ module2.exports = Parser2;
+ }
+});
+
+// ../../node_modules/.pnpm/@iarna+toml@3.0.0/node_modules/@iarna/toml/lib/create-datetime.js
+var require_create_datetime = __commonJS({
+ "../../node_modules/.pnpm/@iarna+toml@3.0.0/node_modules/@iarna/toml/lib/create-datetime.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ module2.exports = (value) => {
+ const date = new Date(value);
+ if (isNaN(date)) {
+ throw new TypeError("Invalid Datetime");
+ } else {
+ return date;
+ }
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/@iarna+toml@3.0.0/node_modules/@iarna/toml/lib/format-num.js
+var require_format_num = __commonJS({
+ "../../node_modules/.pnpm/@iarna+toml@3.0.0/node_modules/@iarna/toml/lib/format-num.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ module2.exports = (d, num) => {
+ num = String(num);
+ while (num.length < d)
+ num = "0" + num;
+ return num;
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/@iarna+toml@3.0.0/node_modules/@iarna/toml/lib/create-datetime-float.js
+var require_create_datetime_float = __commonJS({
+ "../../node_modules/.pnpm/@iarna+toml@3.0.0/node_modules/@iarna/toml/lib/create-datetime-float.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var f = require_format_num();
+ var FloatingDateTime = class extends Date {
+ constructor(value) {
+ super(value + "Z");
+ this.isFloating = true;
+ }
+ toISOString() {
+ const date = `${this.getUTCFullYear()}-${f(2, this.getUTCMonth() + 1)}-${f(2, this.getUTCDate())}`;
+ const time = `${f(2, this.getUTCHours())}:${f(2, this.getUTCMinutes())}:${f(2, this.getUTCSeconds())}.${f(3, this.getUTCMilliseconds())}`;
+ return `${date}T${time}`;
+ }
+ };
+ __name(FloatingDateTime, "FloatingDateTime");
+ module2.exports = (value) => {
+ const date = new FloatingDateTime(value);
+ if (isNaN(date)) {
+ throw new TypeError("Invalid Datetime");
+ } else {
+ return date;
+ }
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/@iarna+toml@3.0.0/node_modules/@iarna/toml/lib/create-date.js
+var require_create_date = __commonJS({
+ "../../node_modules/.pnpm/@iarna+toml@3.0.0/node_modules/@iarna/toml/lib/create-date.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var f = require_format_num();
+ var DateTime = global.Date;
+ var Date2 = class extends DateTime {
+ constructor(value) {
+ super(value);
+ this.isDate = true;
+ }
+ toISOString() {
+ return `${this.getUTCFullYear()}-${f(2, this.getUTCMonth() + 1)}-${f(2, this.getUTCDate())}`;
+ }
+ };
+ __name(Date2, "Date");
+ module2.exports = (value) => {
+ const date = new Date2(value);
+ if (isNaN(date)) {
+ throw new TypeError("Invalid Datetime");
+ } else {
+ return date;
+ }
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/@iarna+toml@3.0.0/node_modules/@iarna/toml/lib/create-time.js
+var require_create_time = __commonJS({
+ "../../node_modules/.pnpm/@iarna+toml@3.0.0/node_modules/@iarna/toml/lib/create-time.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var f = require_format_num();
+ var Time = class extends Date {
+ constructor(value) {
+ super(`0000-01-01T${value}Z`);
+ this.isTime = true;
+ }
+ toISOString() {
+ return `${f(2, this.getUTCHours())}:${f(2, this.getUTCMinutes())}:${f(2, this.getUTCSeconds())}.${f(3, this.getUTCMilliseconds())}`;
+ }
+ };
+ __name(Time, "Time");
+ module2.exports = (value) => {
+ const date = new Time(value);
+ if (isNaN(date)) {
+ throw new TypeError("Invalid Datetime");
+ } else {
+ return date;
+ }
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/@iarna+toml@3.0.0/node_modules/@iarna/toml/lib/toml-parser.js
+var require_toml_parser = __commonJS({
+ "../../node_modules/.pnpm/@iarna+toml@3.0.0/node_modules/@iarna/toml/lib/toml-parser.js"(exports, module) {
+ "use strict";
+ init_import_meta_url();
+ module.exports = makeParserClass(require_parser());
+ module.exports.makeParserClass = makeParserClass;
+ var TomlError = class extends Error {
+ constructor(msg) {
+ super(msg);
+ this.name = "TomlError";
+ if (Error.captureStackTrace)
+ Error.captureStackTrace(this, TomlError);
+ this.fromTOML = true;
+ this.wrapped = null;
+ }
+ };
+ __name(TomlError, "TomlError");
+ TomlError.wrap = (err) => {
+ const terr = new TomlError(err.message);
+ terr.code = err.code;
+ terr.wrapped = err;
+ return terr;
+ };
+ module.exports.TomlError = TomlError;
+ var createDateTime = require_create_datetime();
+ var createDateTimeFloat = require_create_datetime_float();
+ var createDate = require_create_date();
+ var createTime = require_create_time();
+ var CTRL_I = 9;
+ var CTRL_J = 10;
+ var CTRL_M = 13;
+ var CTRL_CHAR_BOUNDARY = 31;
+ var CHAR_SP = 32;
+ var CHAR_QUOT = 34;
+ var CHAR_NUM = 35;
+ var CHAR_APOS = 39;
+ var CHAR_PLUS = 43;
+ var CHAR_COMMA = 44;
+ var CHAR_HYPHEN = 45;
+ var CHAR_PERIOD = 46;
+ var CHAR_0 = 48;
+ var CHAR_1 = 49;
+ var CHAR_7 = 55;
+ var CHAR_9 = 57;
+ var CHAR_COLON = 58;
+ var CHAR_EQUALS = 61;
+ var CHAR_A = 65;
+ var CHAR_E = 69;
+ var CHAR_F = 70;
+ var CHAR_T = 84;
+ var CHAR_U = 85;
+ var CHAR_Z = 90;
+ var CHAR_LOWBAR = 95;
+ var CHAR_a = 97;
+ var CHAR_b = 98;
+ var CHAR_e = 101;
+ var CHAR_f = 102;
+ var CHAR_i = 105;
+ var CHAR_l = 108;
+ var CHAR_n = 110;
+ var CHAR_o = 111;
+ var CHAR_r = 114;
+ var CHAR_s = 115;
+ var CHAR_t = 116;
+ var CHAR_u = 117;
+ var CHAR_x = 120;
+ var CHAR_z = 122;
+ var CHAR_LCUB = 123;
+ var CHAR_RCUB = 125;
+ var CHAR_LSQB = 91;
+ var CHAR_BSOL = 92;
+ var CHAR_RSQB = 93;
+ var CHAR_DEL = 127;
+ var SURROGATE_FIRST = 55296;
+ var SURROGATE_LAST = 57343;
+ var escapes = {
+ [CHAR_b]: "\b",
+ [CHAR_t]: " ",
+ [CHAR_n]: "\n",
+ [CHAR_f]: "\f",
+ [CHAR_r]: "\r",
+ [CHAR_QUOT]: '"',
+ [CHAR_BSOL]: "\\"
+ };
+ function isDigit(cp2) {
+ return cp2 >= CHAR_0 && cp2 <= CHAR_9;
+ }
+ __name(isDigit, "isDigit");
+ function isHexit(cp2) {
+ return cp2 >= CHAR_A && cp2 <= CHAR_F || cp2 >= CHAR_a && cp2 <= CHAR_f || cp2 >= CHAR_0 && cp2 <= CHAR_9;
+ }
+ __name(isHexit, "isHexit");
+ function isBit(cp2) {
+ return cp2 === CHAR_1 || cp2 === CHAR_0;
+ }
+ __name(isBit, "isBit");
+ function isOctit(cp2) {
+ return cp2 >= CHAR_0 && cp2 <= CHAR_7;
+ }
+ __name(isOctit, "isOctit");
+ function isAlphaNumQuoteHyphen(cp2) {
+ return cp2 >= CHAR_A && cp2 <= CHAR_Z || cp2 >= CHAR_a && cp2 <= CHAR_z || cp2 >= CHAR_0 && cp2 <= CHAR_9 || cp2 === CHAR_APOS || cp2 === CHAR_QUOT || cp2 === CHAR_LOWBAR || cp2 === CHAR_HYPHEN;
+ }
+ __name(isAlphaNumQuoteHyphen, "isAlphaNumQuoteHyphen");
+ function isAlphaNumHyphen(cp2) {
+ return cp2 >= CHAR_A && cp2 <= CHAR_Z || cp2 >= CHAR_a && cp2 <= CHAR_z || cp2 >= CHAR_0 && cp2 <= CHAR_9 || cp2 === CHAR_LOWBAR || cp2 === CHAR_HYPHEN;
+ }
+ __name(isAlphaNumHyphen, "isAlphaNumHyphen");
+ var _type = Symbol("type");
+ var _declared = Symbol("declared");
+ var hasOwnProperty = Object.prototype.hasOwnProperty;
+ var defineProperty = Object.defineProperty;
+ var descriptor = { configurable: true, enumerable: true, writable: true, value: void 0 };
+ function hasKey(obj, key) {
+ if (hasOwnProperty.call(obj, key))
+ return true;
+ if (key === "__proto__")
+ defineProperty(obj, "__proto__", descriptor);
+ return false;
+ }
+ __name(hasKey, "hasKey");
+ var INLINE_TABLE = Symbol("inline-table");
+ function InlineTable() {
+ return Object.defineProperties({}, {
+ [_type]: { value: INLINE_TABLE }
+ });
+ }
+ __name(InlineTable, "InlineTable");
+ function isInlineTable(obj) {
+ if (obj === null || typeof obj !== "object")
+ return false;
+ return obj[_type] === INLINE_TABLE;
+ }
+ __name(isInlineTable, "isInlineTable");
+ var TABLE = Symbol("table");
+ function Table() {
+ return Object.defineProperties({}, {
+ [_type]: { value: TABLE },
+ [_declared]: { value: false, writable: true }
+ });
+ }
+ __name(Table, "Table");
+ function isTable(obj) {
+ if (obj === null || typeof obj !== "object")
+ return false;
+ return obj[_type] === TABLE;
+ }
+ __name(isTable, "isTable");
+ var _contentType = Symbol("content-type");
+ var INLINE_LIST = Symbol("inline-list");
+ function InlineList(type) {
+ return Object.defineProperties([], {
+ [_type]: { value: INLINE_LIST },
+ [_contentType]: { value: type }
+ });
+ }
+ __name(InlineList, "InlineList");
+ function isInlineList(obj) {
+ if (obj === null || typeof obj !== "object")
+ return false;
+ return obj[_type] === INLINE_LIST;
+ }
+ __name(isInlineList, "isInlineList");
+ var LIST = Symbol("list");
+ function List() {
+ return Object.defineProperties([], {
+ [_type]: { value: LIST }
+ });
+ }
+ __name(List, "List");
+ function isList(obj) {
+ if (obj === null || typeof obj !== "object")
+ return false;
+ return obj[_type] === LIST;
+ }
+ __name(isList, "isList");
+ var _custom;
+ try {
+ const utilInspect = eval("require('util').inspect");
+ _custom = utilInspect.custom;
+ } catch (_2) {
+ }
+ var _inspect = _custom || "inspect";
+ var BoxedBigInt = class {
+ constructor(value) {
+ try {
+ this.value = global.BigInt.asIntN(64, value);
+ } catch (_2) {
+ this.value = null;
+ }
+ Object.defineProperty(this, _type, { value: INTEGER });
+ }
+ isNaN() {
+ return this.value === null;
+ }
+ /* istanbul ignore next */
+ toString() {
+ return String(this.value);
+ }
+ /* istanbul ignore next */
+ [_inspect]() {
+ return `[BigInt: ${this.toString()}]}`;
+ }
+ valueOf() {
+ return this.value;
+ }
+ };
+ __name(BoxedBigInt, "BoxedBigInt");
+ var INTEGER = Symbol("integer");
+ function Integer(value) {
+ let num = Number(value);
+ if (Object.is(num, -0))
+ num = 0;
+ if (global.BigInt && !Number.isSafeInteger(num)) {
+ return new BoxedBigInt(value);
+ } else {
+ return Object.defineProperties(new Number(num), {
+ isNaN: { value: function() {
+ return isNaN(this);
+ } },
+ [_type]: { value: INTEGER },
+ [_inspect]: { value: () => `[Integer: ${value}]` }
+ });
+ }
+ }
+ __name(Integer, "Integer");
+ function isInteger(obj) {
+ if (obj === null || typeof obj !== "object")
+ return false;
+ return obj[_type] === INTEGER;
+ }
+ __name(isInteger, "isInteger");
+ var FLOAT = Symbol("float");
+ function Float(value) {
+ return Object.defineProperties(new Number(value), {
+ [_type]: { value: FLOAT },
+ [_inspect]: { value: () => `[Float: ${value}]` }
+ });
+ }
+ __name(Float, "Float");
+ function isFloat(obj) {
+ if (obj === null || typeof obj !== "object")
+ return false;
+ return obj[_type] === FLOAT;
+ }
+ __name(isFloat, "isFloat");
+ function tomlType(value) {
+ const type = typeof value;
+ if (type === "object") {
+ if (value === null)
+ return "null";
+ if (value instanceof Date)
+ return "datetime";
+ if (_type in value) {
+ switch (value[_type]) {
+ case INLINE_TABLE:
+ return "inline-table";
+ case INLINE_LIST:
+ return "inline-list";
+ case TABLE:
+ return "table";
+ case LIST:
+ return "list";
+ case FLOAT:
+ return "float";
+ case INTEGER:
+ return "integer";
+ }
+ }
+ }
+ return type;
+ }
+ __name(tomlType, "tomlType");
+ function makeParserClass(Parser2) {
+ class TOMLParser extends Parser2 {
+ constructor() {
+ super();
+ this.ctx = this.obj = Table();
+ }
+ /* MATCH HELPER */
+ atEndOfWord() {
+ return this.char === CHAR_NUM || this.char === CTRL_I || this.char === CHAR_SP || this.atEndOfLine();
+ }
+ atEndOfLine() {
+ return this.char === Parser2.END || this.char === CTRL_J || this.char === CTRL_M;
+ }
+ parseStart() {
+ if (this.char === Parser2.END) {
+ return null;
+ } else if (this.char === CHAR_LSQB) {
+ return this.call(this.parseTableOrList);
+ } else if (this.char === CHAR_NUM) {
+ return this.call(this.parseComment);
+ } else if (this.char === CTRL_J || this.char === CHAR_SP || this.char === CTRL_I || this.char === CTRL_M) {
+ return null;
+ } else if (isAlphaNumQuoteHyphen(this.char)) {
+ return this.callNow(this.parseAssignStatement);
+ } else {
+ throw this.error(new TomlError(`Unknown character "${this.char}"`));
+ }
+ }
+ // HELPER, this strips any whitespace and comments to the end of the line
+ // then RETURNS. Last state in a production.
+ parseWhitespaceToEOL() {
+ if (this.char === CHAR_SP || this.char === CTRL_I || this.char === CTRL_M) {
+ return null;
+ } else if (this.char === CHAR_NUM) {
+ return this.goto(this.parseComment);
+ } else if (this.char === Parser2.END || this.char === CTRL_J) {
+ return this.return();
+ } else {
+ throw this.error(new TomlError("Unexpected character, expected only whitespace or comments till end of line"));
+ }
+ }
+ /* ASSIGNMENT: key = value */
+ parseAssignStatement() {
+ return this.callNow(this.parseAssign, this.recordAssignStatement);
+ }
+ recordAssignStatement(kv) {
+ let target = this.ctx;
+ let finalKey = kv.key.pop();
+ for (let kw of kv.key) {
+ if (hasKey(target, kw) && !isTable(target[kw])) {
+ throw this.error(new TomlError("Can't redefine existing key"));
+ }
+ target = target[kw] = target[kw] || Table();
+ }
+ if (hasKey(target, finalKey)) {
+ throw this.error(new TomlError("Can't redefine existing key"));
+ }
+ target[_declared] = true;
+ if (isInteger(kv.value) || isFloat(kv.value)) {
+ target[finalKey] = kv.value.valueOf();
+ } else {
+ target[finalKey] = kv.value;
+ }
+ return this.goto(this.parseWhitespaceToEOL);
+ }
+ /* ASSSIGNMENT expression, key = value possibly inside an inline table */
+ parseAssign() {
+ return this.callNow(this.parseKeyword, this.recordAssignKeyword);
+ }
+ recordAssignKeyword(key) {
+ if (this.state.resultTable) {
+ this.state.resultTable.push(key);
+ } else {
+ this.state.resultTable = [key];
+ }
+ return this.goto(this.parseAssignKeywordPreDot);
+ }
+ parseAssignKeywordPreDot() {
+ if (this.char === CHAR_PERIOD) {
+ return this.next(this.parseAssignKeywordPostDot);
+ } else if (this.char !== CHAR_SP && this.char !== CTRL_I) {
+ return this.goto(this.parseAssignEqual);
+ }
+ }
+ parseAssignKeywordPostDot() {
+ if (this.char !== CHAR_SP && this.char !== CTRL_I) {
+ return this.callNow(this.parseKeyword, this.recordAssignKeyword);
+ }
+ }
+ parseAssignEqual() {
+ if (this.char === CHAR_EQUALS) {
+ return this.next(this.parseAssignPreValue);
+ } else {
+ throw this.error(new TomlError('Invalid character, expected "="'));
+ }
+ }
+ parseAssignPreValue() {
+ if (this.char === CHAR_SP || this.char === CTRL_I) {
+ return null;
+ } else {
+ return this.callNow(this.parseValue, this.recordAssignValue);
+ }
+ }
+ recordAssignValue(value) {
+ return this.returnNow({ key: this.state.resultTable, value });
+ }
+ /* COMMENTS: #...eol */
+ parseComment() {
+ do {
+ if (this.char === Parser2.END || this.char === CTRL_J) {
+ return this.return();
+ } else if (this.char === CHAR_DEL || this.char <= CTRL_CHAR_BOUNDARY && this.char !== CTRL_I) {
+ throw this.errorControlCharIn("comments");
+ }
+ } while (this.nextChar());
+ }
+ /* TABLES AND LISTS, [foo] and [[foo]] */
+ parseTableOrList() {
+ if (this.char === CHAR_LSQB) {
+ this.next(this.parseList);
+ } else {
+ return this.goto(this.parseTable);
+ }
+ }
+ /* TABLE [foo.bar.baz] */
+ parseTable() {
+ this.ctx = this.obj;
+ return this.goto(this.parseTableNext);
+ }
+ parseTableNext() {
+ if (this.char === CHAR_SP || this.char === CTRL_I) {
+ return null;
+ } else {
+ return this.callNow(this.parseKeyword, this.parseTableMore);
+ }
+ }
+ parseTableMore(keyword) {
+ if (this.char === CHAR_SP || this.char === CTRL_I) {
+ return null;
+ } else if (this.char === CHAR_RSQB) {
+ if (hasKey(this.ctx, keyword) && (!isTable(this.ctx[keyword]) || this.ctx[keyword][_declared])) {
+ throw this.error(new TomlError("Can't redefine existing key"));
+ } else {
+ this.ctx = this.ctx[keyword] = this.ctx[keyword] || Table();
+ this.ctx[_declared] = true;
+ }
+ return this.next(this.parseWhitespaceToEOL);
+ } else if (this.char === CHAR_PERIOD) {
+ if (!hasKey(this.ctx, keyword)) {
+ this.ctx = this.ctx[keyword] = Table();
+ } else if (isTable(this.ctx[keyword])) {
+ this.ctx = this.ctx[keyword];
+ } else if (isList(this.ctx[keyword])) {
+ this.ctx = this.ctx[keyword][this.ctx[keyword].length - 1];
+ } else {
+ throw this.error(new TomlError("Can't redefine existing key"));
+ }
+ return this.next(this.parseTableNext);
+ } else {
+ throw this.error(new TomlError("Unexpected character, expected whitespace, . or ]"));
+ }
+ }
+ /* LIST [[a.b.c]] */
+ parseList() {
+ this.ctx = this.obj;
+ return this.goto(this.parseListNext);
+ }
+ parseListNext() {
+ if (this.char === CHAR_SP || this.char === CTRL_I) {
+ return null;
+ } else {
+ return this.callNow(this.parseKeyword, this.parseListMore);
+ }
+ }
+ parseListMore(keyword) {
+ if (this.char === CHAR_SP || this.char === CTRL_I) {
+ return null;
+ } else if (this.char === CHAR_RSQB) {
+ if (!hasKey(this.ctx, keyword)) {
+ this.ctx[keyword] = List();
+ }
+ if (isInlineList(this.ctx[keyword])) {
+ throw this.error(new TomlError("Can't extend an inline array"));
+ } else if (isList(this.ctx[keyword])) {
+ const next = Table();
+ this.ctx[keyword].push(next);
+ this.ctx = next;
+ } else {
+ throw this.error(new TomlError("Can't redefine an existing key"));
+ }
+ return this.next(this.parseListEnd);
+ } else if (this.char === CHAR_PERIOD) {
+ if (!hasKey(this.ctx, keyword)) {
+ this.ctx = this.ctx[keyword] = Table();
+ } else if (isInlineList(this.ctx[keyword])) {
+ throw this.error(new TomlError("Can't extend an inline array"));
+ } else if (isInlineTable(this.ctx[keyword])) {
+ throw this.error(new TomlError("Can't extend an inline table"));
+ } else if (isList(this.ctx[keyword])) {
+ this.ctx = this.ctx[keyword][this.ctx[keyword].length - 1];
+ } else if (isTable(this.ctx[keyword])) {
+ this.ctx = this.ctx[keyword];
+ } else {
+ throw this.error(new TomlError("Can't redefine an existing key"));
+ }
+ return this.next(this.parseListNext);
+ } else {
+ throw this.error(new TomlError("Unexpected character, expected whitespace, . or ]"));
+ }
+ }
+ parseListEnd(keyword) {
+ if (this.char === CHAR_RSQB) {
+ return this.next(this.parseWhitespaceToEOL);
+ } else {
+ throw this.error(new TomlError("Unexpected character, expected whitespace, . or ]"));
+ }
+ }
+ /* VALUE string, number, boolean, inline list, inline object */
+ parseValue() {
+ if (this.char === Parser2.END) {
+ throw this.error(new TomlError("Key without value"));
+ } else if (this.char === CHAR_QUOT) {
+ return this.next(this.parseDoubleString);
+ }
+ if (this.char === CHAR_APOS) {
+ return this.next(this.parseSingleString);
+ } else if (this.char === CHAR_HYPHEN || this.char === CHAR_PLUS) {
+ return this.goto(this.parseNumberSign);
+ } else if (this.char === CHAR_i) {
+ return this.next(this.parseInf);
+ } else if (this.char === CHAR_n) {
+ return this.next(this.parseNan);
+ } else if (isDigit(this.char)) {
+ return this.goto(this.parseNumberOrDateTime);
+ } else if (this.char === CHAR_t || this.char === CHAR_f) {
+ return this.goto(this.parseBoolean);
+ } else if (this.char === CHAR_LSQB) {
+ return this.call(this.parseInlineList, this.recordValue);
+ } else if (this.char === CHAR_LCUB) {
+ return this.call(this.parseInlineTable, this.recordValue);
+ } else {
+ throw this.error(new TomlError("Unexpected character, expecting string, number, datetime, boolean, inline array or inline table"));
+ }
+ }
+ recordValue(value) {
+ return this.returnNow(value);
+ }
+ parseInf() {
+ if (this.char === CHAR_n) {
+ return this.next(this.parseInf2);
+ } else {
+ throw this.error(new TomlError('Unexpected character, expected "inf", "+inf" or "-inf"'));
+ }
+ }
+ parseInf2() {
+ if (this.char === CHAR_f) {
+ if (this.state.buf === "-") {
+ return this.return(-Infinity);
+ } else {
+ return this.return(Infinity);
+ }
+ } else {
+ throw this.error(new TomlError('Unexpected character, expected "inf", "+inf" or "-inf"'));
+ }
+ }
+ parseNan() {
+ if (this.char === CHAR_a) {
+ return this.next(this.parseNan2);
+ } else {
+ throw this.error(new TomlError('Unexpected character, expected "nan"'));
+ }
+ }
+ parseNan2() {
+ if (this.char === CHAR_n) {
+ return this.return(NaN);
+ } else {
+ throw this.error(new TomlError('Unexpected character, expected "nan"'));
+ }
+ }
+ /* KEYS, barewords or basic, literal, or dotted */
+ parseKeyword() {
+ if (this.char === CHAR_QUOT) {
+ return this.next(this.parseBasicString);
+ } else if (this.char === CHAR_APOS) {
+ return this.next(this.parseLiteralString);
+ } else {
+ return this.goto(this.parseBareKey);
+ }
+ }
+ /* KEYS: barewords */
+ parseBareKey() {
+ do {
+ if (this.char === Parser2.END) {
+ throw this.error(new TomlError("Key ended without value"));
+ } else if (isAlphaNumHyphen(this.char)) {
+ this.consume();
+ } else if (this.state.buf.length === 0) {
+ throw this.error(new TomlError("Empty bare keys are not allowed"));
+ } else {
+ return this.returnNow();
+ }
+ } while (this.nextChar());
+ }
+ /* STRINGS, single quoted (literal) */
+ parseSingleString() {
+ if (this.char === CHAR_APOS) {
+ return this.next(this.parseLiteralMultiStringMaybe);
+ } else {
+ return this.goto(this.parseLiteralString);
+ }
+ }
+ parseLiteralString() {
+ do {
+ if (this.char === CHAR_APOS) {
+ return this.return();
+ } else if (this.atEndOfLine()) {
+ throw this.error(new TomlError("Unterminated string"));
+ } else if (this.char === CHAR_DEL || this.char <= CTRL_CHAR_BOUNDARY && this.char !== CTRL_I) {
+ throw this.errorControlCharIn("strings");
+ } else {
+ this.consume();
+ }
+ } while (this.nextChar());
+ }
+ parseLiteralMultiStringMaybe() {
+ if (this.char === CHAR_APOS) {
+ return this.next(this.parseLiteralMultiString);
+ } else {
+ return this.returnNow();
+ }
+ }
+ parseLiteralMultiString() {
+ if (this.char === CTRL_M) {
+ return null;
+ } else if (this.char === CTRL_J) {
+ return this.next(this.parseLiteralMultiStringContent);
+ } else {
+ return this.goto(this.parseLiteralMultiStringContent);
+ }
+ }
+ parseLiteralMultiStringContent() {
+ do {
+ if (this.char === CHAR_APOS) {
+ return this.next(this.parseLiteralMultiEnd);
+ } else if (this.char === Parser2.END) {
+ throw this.error(new TomlError("Unterminated multi-line string"));
+ } else if (this.char === CHAR_DEL || this.char <= CTRL_CHAR_BOUNDARY && this.char !== CTRL_I && this.char !== CTRL_J && this.char !== CTRL_M) {
+ throw this.errorControlCharIn("strings");
+ } else {
+ this.consume();
+ }
+ } while (this.nextChar());
+ }
+ parseLiteralMultiEnd() {
+ if (this.char === CHAR_APOS) {
+ return this.next(this.parseLiteralMultiEnd2);
+ } else {
+ this.state.buf += "'";
+ return this.goto(this.parseLiteralMultiStringContent);
+ }
+ }
+ parseLiteralMultiEnd2() {
+ if (this.char === CHAR_APOS) {
+ return this.next(this.parseLiteralMultiEnd3);
+ } else {
+ this.state.buf += "''";
+ return this.goto(this.parseLiteralMultiStringContent);
+ }
+ }
+ parseLiteralMultiEnd3() {
+ if (this.char === CHAR_APOS) {
+ this.state.buf += "'";
+ return this.next(this.parseLiteralMultiEnd4);
+ } else {
+ return this.returnNow();
+ }
+ }
+ parseLiteralMultiEnd4() {
+ if (this.char === CHAR_APOS) {
+ this.state.buf += "'";
+ return this.return();
+ } else {
+ return this.returnNow();
+ }
+ }
+ /* STRINGS double quoted */
+ parseDoubleString() {
+ if (this.char === CHAR_QUOT) {
+ return this.next(this.parseMultiStringMaybe);
+ } else {
+ return this.goto(this.parseBasicString);
+ }
+ }
+ parseBasicString() {
+ do {
+ if (this.char === CHAR_BSOL) {
+ return this.call(this.parseEscape, this.recordEscapeReplacement);
+ } else if (this.char === CHAR_QUOT) {
+ return this.return();
+ } else if (this.atEndOfLine()) {
+ throw this.error(new TomlError("Unterminated string"));
+ } else if (this.char === CHAR_DEL || this.char <= CTRL_CHAR_BOUNDARY && this.char !== CTRL_I) {
+ throw this.errorControlCharIn("strings");
+ } else {
+ this.consume();
+ }
+ } while (this.nextChar());
+ }
+ recordEscapeReplacement(replacement) {
+ this.state.buf += replacement;
+ return this.goto(this.parseBasicString);
+ }
+ parseMultiStringMaybe() {
+ if (this.char === CHAR_QUOT) {
+ return this.next(this.parseMultiString);
+ } else {
+ return this.returnNow();
+ }
+ }
+ parseMultiString() {
+ if (this.char === CTRL_M) {
+ return null;
+ } else if (this.char === CTRL_J) {
+ return this.next(this.parseMultiStringContent);
+ } else {
+ return this.goto(this.parseMultiStringContent);
+ }
+ }
+ parseMultiStringContent() {
+ do {
+ if (this.char === CHAR_BSOL) {
+ return this.call(this.parseMultiEscape, this.recordMultiEscapeReplacement);
+ } else if (this.char === CHAR_QUOT) {
+ return this.next(this.parseMultiEnd);
+ } else if (this.char === Parser2.END) {
+ throw this.error(new TomlError("Unterminated multi-line string"));
+ } else if (this.char === CHAR_DEL || this.char <= CTRL_CHAR_BOUNDARY && this.char !== CTRL_I && this.char !== CTRL_J && this.char !== CTRL_M) {
+ throw this.errorControlCharIn("strings");
+ } else {
+ this.consume();
+ }
+ } while (this.nextChar());
+ }
+ errorControlCharIn(type) {
+ let displayCode = "\\u00";
+ if (this.char < 16) {
+ displayCode += "0";
+ }
+ displayCode += this.char.toString(16);
+ return this.error(new TomlError(`Control characters (codes < 0x1f and 0x7f) are not allowed in ${type}, use ${displayCode} instead`));
+ }
+ recordMultiEscapeReplacement(replacement) {
+ this.state.buf += replacement;
+ return this.goto(this.parseMultiStringContent);
+ }
+ parseMultiEnd() {
+ if (this.char === CHAR_QUOT) {
+ return this.next(this.parseMultiEnd2);
+ } else {
+ this.state.buf += '"';
+ return this.goto(this.parseMultiStringContent);
+ }
+ }
+ parseMultiEnd2() {
+ if (this.char === CHAR_QUOT) {
+ return this.next(this.parseMultiEnd3);
+ } else {
+ this.state.buf += '""';
+ return this.goto(this.parseMultiStringContent);
+ }
+ }
+ parseMultiEnd3() {
+ if (this.char === CHAR_QUOT) {
+ this.state.buf += '"';
+ return this.next(this.parseMultiEnd4);
+ } else {
+ return this.returnNow();
+ }
+ }
+ parseMultiEnd4() {
+ if (this.char === CHAR_QUOT) {
+ this.state.buf += '"';
+ return this.return();
+ } else {
+ return this.returnNow();
+ }
+ }
+ parseMultiEscape() {
+ if (this.char === CTRL_M || this.char === CTRL_J) {
+ return this.next(this.parseMultiTrim);
+ } else if (this.char === CHAR_SP || this.char === CTRL_I) {
+ return this.next(this.parsePreMultiTrim);
+ } else {
+ return this.goto(this.parseEscape);
+ }
+ }
+ parsePreMultiTrim() {
+ if (this.char === CHAR_SP || this.char === CTRL_I) {
+ return null;
+ } else if (this.char === CTRL_M || this.char === CTRL_J) {
+ return this.next(this.parseMultiTrim);
+ } else {
+ throw this.error(new TomlError("Can't escape whitespace"));
+ }
+ }
+ parseMultiTrim() {
+ if (this.char === CTRL_J || this.char === CHAR_SP || this.char === CTRL_I || this.char === CTRL_M) {
+ return null;
+ } else {
+ return this.returnNow();
+ }
+ }
+ parseEscape() {
+ if (this.char in escapes) {
+ return this.return(escapes[this.char]);
+ } else if (this.char === CHAR_u) {
+ return this.call(this.parseSmallUnicode, this.parseUnicodeReturn);
+ } else if (this.char === CHAR_U) {
+ return this.call(this.parseLargeUnicode, this.parseUnicodeReturn);
+ } else {
+ throw this.error(new TomlError("Unknown escape character: " + this.char));
+ }
+ }
+ parseUnicodeReturn(char) {
+ try {
+ const codePoint = parseInt(char, 16);
+ if (codePoint >= SURROGATE_FIRST && codePoint <= SURROGATE_LAST) {
+ throw this.error(new TomlError("Invalid unicode, character in range 0xD800 - 0xDFFF is reserved"));
+ }
+ return this.returnNow(String.fromCodePoint(codePoint));
+ } catch (err) {
+ throw this.error(TomlError.wrap(err));
+ }
+ }
+ parseSmallUnicode() {
+ if (!isHexit(this.char)) {
+ throw this.error(new TomlError("Invalid character in unicode sequence, expected hex"));
+ } else {
+ this.consume();
+ if (this.state.buf.length >= 4)
+ return this.return();
+ }
+ }
+ parseLargeUnicode() {
+ if (!isHexit(this.char)) {
+ throw this.error(new TomlError("Invalid character in unicode sequence, expected hex"));
+ } else {
+ this.consume();
+ if (this.state.buf.length >= 8)
+ return this.return();
+ }
+ }
+ /* NUMBERS */
+ parseNumberSign() {
+ this.consume();
+ return this.next(this.parseMaybeSignedInfOrNan);
+ }
+ parseMaybeSignedInfOrNan() {
+ if (this.char === CHAR_i) {
+ return this.next(this.parseInf);
+ } else if (this.char === CHAR_n) {
+ return this.next(this.parseNan);
+ } else {
+ return this.callNow(this.parseNoUnder, this.parseNumberIntegerStart);
+ }
+ }
+ parseNumberIntegerStart() {
+ if (this.char === CHAR_0) {
+ this.consume();
+ return this.next(this.parseNumberIntegerExponentOrDecimal);
+ } else {
+ return this.goto(this.parseNumberInteger);
+ }
+ }
+ parseNumberIntegerExponentOrDecimal() {
+ if (this.char === CHAR_PERIOD) {
+ this.consume();
+ return this.call(this.parseNoUnder, this.parseNumberFloat);
+ } else if (this.char === CHAR_E || this.char === CHAR_e) {
+ this.consume();
+ return this.next(this.parseNumberExponentSign);
+ } else {
+ return this.returnNow(Integer(this.state.buf));
+ }
+ }
+ parseNumberInteger() {
+ if (isDigit(this.char)) {
+ this.consume();
+ } else if (this.char === CHAR_LOWBAR) {
+ return this.call(this.parseNoUnder);
+ } else if (this.char === CHAR_E || this.char === CHAR_e) {
+ this.consume();
+ return this.next(this.parseNumberExponentSign);
+ } else if (this.char === CHAR_PERIOD) {
+ this.consume();
+ return this.call(this.parseNoUnder, this.parseNumberFloat);
+ } else {
+ const result = Integer(this.state.buf);
+ if (result.isNaN()) {
+ throw this.error(new TomlError("Invalid number"));
+ } else {
+ return this.returnNow(result);
+ }
+ }
+ }
+ parseNoUnder() {
+ if (this.char === CHAR_LOWBAR || this.char === CHAR_PERIOD || this.char === CHAR_E || this.char === CHAR_e) {
+ throw this.error(new TomlError("Unexpected character, expected digit"));
+ } else if (this.atEndOfWord()) {
+ throw this.error(new TomlError("Incomplete number"));
+ }
+ return this.returnNow();
+ }
+ parseNoUnderHexOctBinLiteral() {
+ if (this.char === CHAR_LOWBAR || this.char === CHAR_PERIOD) {
+ throw this.error(new TomlError("Unexpected character, expected digit"));
+ } else if (this.atEndOfWord()) {
+ throw this.error(new TomlError("Incomplete number"));
+ }
+ return this.returnNow();
+ }
+ parseNumberFloat() {
+ if (this.char === CHAR_LOWBAR) {
+ return this.call(this.parseNoUnder, this.parseNumberFloat);
+ } else if (isDigit(this.char)) {
+ this.consume();
+ } else if (this.char === CHAR_E || this.char === CHAR_e) {
+ this.consume();
+ return this.next(this.parseNumberExponentSign);
+ } else {
+ return this.returnNow(Float(this.state.buf));
+ }
+ }
+ parseNumberExponentSign() {
+ if (isDigit(this.char)) {
+ return this.goto(this.parseNumberExponent);
+ } else if (this.char === CHAR_HYPHEN || this.char === CHAR_PLUS) {
+ this.consume();
+ this.call(this.parseNoUnder, this.parseNumberExponent);
+ } else {
+ throw this.error(new TomlError("Unexpected character, expected -, + or digit"));
+ }
+ }
+ parseNumberExponent() {
+ if (isDigit(this.char)) {
+ this.consume();
+ } else if (this.char === CHAR_LOWBAR) {
+ return this.call(this.parseNoUnder);
+ } else {
+ return this.returnNow(Float(this.state.buf));
+ }
+ }
+ /* NUMBERS or DATETIMES */
+ parseNumberOrDateTime() {
+ if (this.char === CHAR_0) {
+ this.consume();
+ return this.next(this.parseNumberBaseOrDateTime);
+ } else {
+ return this.goto(this.parseNumberOrDateTimeOnly);
+ }
+ }
+ parseNumberOrDateTimeOnly() {
+ if (this.char === CHAR_LOWBAR) {
+ return this.call(this.parseNoUnder, this.parseNumberInteger);
+ } else if (isDigit(this.char)) {
+ this.consume();
+ if (this.state.buf.length > 4)
+ this.next(this.parseNumberInteger);
+ } else if (this.char === CHAR_E || this.char === CHAR_e) {
+ this.consume();
+ return this.next(this.parseNumberExponentSign);
+ } else if (this.char === CHAR_PERIOD) {
+ this.consume();
+ return this.call(this.parseNoUnder, this.parseNumberFloat);
+ } else if (this.char === CHAR_HYPHEN) {
+ return this.goto(this.parseDateTime);
+ } else if (this.char === CHAR_COLON) {
+ return this.goto(this.parseOnlyTimeHour);
+ } else {
+ return this.returnNow(Integer(this.state.buf));
+ }
+ }
+ parseDateTimeOnly() {
+ if (this.state.buf.length < 4) {
+ if (isDigit(this.char)) {
+ return this.consume();
+ } else if (this.char === CHAR_COLON) {
+ return this.goto(this.parseOnlyTimeHour);
+ } else {
+ throw this.error(new TomlError("Expected digit while parsing year part of a date"));
+ }
+ } else {
+ if (this.char === CHAR_HYPHEN) {
+ return this.goto(this.parseDateTime);
+ } else {
+ throw this.error(new TomlError("Expected hyphen (-) while parsing year part of date"));
+ }
+ }
+ }
+ parseNumberBaseOrDateTime() {
+ if (this.char === CHAR_b) {
+ this.consume();
+ return this.call(this.parseNoUnderHexOctBinLiteral, this.parseIntegerBin);
+ } else if (this.char === CHAR_o) {
+ this.consume();
+ return this.call(this.parseNoUnderHexOctBinLiteral, this.parseIntegerOct);
+ } else if (this.char === CHAR_x) {
+ this.consume();
+ return this.call(this.parseNoUnderHexOctBinLiteral, this.parseIntegerHex);
+ } else if (this.char === CHAR_PERIOD) {
+ return this.goto(this.parseNumberInteger);
+ } else if (isDigit(this.char)) {
+ return this.goto(this.parseDateTimeOnly);
+ } else {
+ return this.returnNow(Integer(this.state.buf));
+ }
+ }
+ parseIntegerHex() {
+ if (isHexit(this.char)) {
+ this.consume();
+ } else if (this.char === CHAR_LOWBAR) {
+ return this.call(this.parseNoUnderHexOctBinLiteral);
+ } else {
+ const result = Integer(this.state.buf);
+ if (result.isNaN()) {
+ throw this.error(new TomlError("Invalid number"));
+ } else {
+ return this.returnNow(result);
+ }
+ }
+ }
+ parseIntegerOct() {
+ if (isOctit(this.char)) {
+ this.consume();
+ } else if (this.char === CHAR_LOWBAR) {
+ return this.call(this.parseNoUnderHexOctBinLiteral);
+ } else {
+ const result = Integer(this.state.buf);
+ if (result.isNaN()) {
+ throw this.error(new TomlError("Invalid number"));
+ } else {
+ return this.returnNow(result);
+ }
+ }
+ }
+ parseIntegerBin() {
+ if (isBit(this.char)) {
+ this.consume();
+ } else if (this.char === CHAR_LOWBAR) {
+ return this.call(this.parseNoUnderHexOctBinLiteral);
+ } else {
+ const result = Integer(this.state.buf);
+ if (result.isNaN()) {
+ throw this.error(new TomlError("Invalid number"));
+ } else {
+ return this.returnNow(result);
+ }
+ }
+ }
+ /* DATETIME */
+ parseDateTime() {
+ if (this.state.buf.length < 4) {
+ throw this.error(new TomlError("Years less than 1000 must be zero padded to four characters"));
+ }
+ this.state.result = this.state.buf;
+ this.state.buf = "";
+ return this.next(this.parseDateMonth);
+ }
+ parseDateMonth() {
+ if (this.char === CHAR_HYPHEN) {
+ if (this.state.buf.length < 2) {
+ throw this.error(new TomlError("Months less than 10 must be zero padded to two characters"));
+ }
+ this.state.result += "-" + this.state.buf;
+ this.state.buf = "";
+ return this.next(this.parseDateDay);
+ } else if (isDigit(this.char)) {
+ this.consume();
+ } else {
+ throw this.error(new TomlError("Incomplete datetime"));
+ }
+ }
+ parseDateDay() {
+ if (this.char === CHAR_T || this.char === CHAR_SP) {
+ if (this.state.buf.length < 2) {
+ throw this.error(new TomlError("Days less than 10 must be zero padded to two characters"));
+ }
+ this.state.result += "-" + this.state.buf;
+ this.state.buf = "";
+ return this.next(this.parseStartTimeHour);
+ } else if (this.atEndOfWord()) {
+ return this.returnNow(createDate(this.state.result + "-" + this.state.buf));
+ } else if (isDigit(this.char)) {
+ this.consume();
+ } else {
+ throw this.error(new TomlError("Incomplete datetime"));
+ }
+ }
+ parseStartTimeHour() {
+ if (this.atEndOfWord()) {
+ return this.returnNow(createDate(this.state.result));
+ } else {
+ return this.goto(this.parseTimeHour);
+ }
+ }
+ parseTimeHour() {
+ if (this.char === CHAR_COLON) {
+ if (this.state.buf.length < 2) {
+ throw this.error(new TomlError("Hours less than 10 must be zero padded to two characters"));
+ }
+ this.state.result += "T" + this.state.buf;
+ this.state.buf = "";
+ return this.next(this.parseTimeMin);
+ } else if (isDigit(this.char)) {
+ this.consume();
+ } else {
+ throw this.error(new TomlError("Incomplete datetime"));
+ }
+ }
+ parseTimeMin() {
+ if (this.state.buf.length < 2 && isDigit(this.char)) {
+ this.consume();
+ } else if (this.state.buf.length === 2 && this.char === CHAR_COLON) {
+ this.state.result += ":" + this.state.buf;
+ this.state.buf = "";
+ return this.next(this.parseTimeSec);
+ } else {
+ throw this.error(new TomlError("Incomplete datetime"));
+ }
+ }
+ parseTimeSec() {
+ if (isDigit(this.char)) {
+ this.consume();
+ if (this.state.buf.length === 2) {
+ this.state.result += ":" + this.state.buf;
+ this.state.buf = "";
+ return this.next(this.parseTimeZoneOrFraction);
+ }
+ } else {
+ throw this.error(new TomlError("Incomplete datetime"));
+ }
+ }
+ parseOnlyTimeHour() {
+ if (this.char === CHAR_COLON) {
+ if (this.state.buf.length < 2) {
+ throw this.error(new TomlError("Hours less than 10 must be zero padded to two characters"));
+ }
+ this.state.result = this.state.buf;
+ this.state.buf = "";
+ return this.next(this.parseOnlyTimeMin);
+ } else {
+ throw this.error(new TomlError("Incomplete time"));
+ }
+ }
+ parseOnlyTimeMin() {
+ if (this.state.buf.length < 2 && isDigit(this.char)) {
+ this.consume();
+ } else if (this.state.buf.length === 2 && this.char === CHAR_COLON) {
+ this.state.result += ":" + this.state.buf;
+ this.state.buf = "";
+ return this.next(this.parseOnlyTimeSec);
+ } else {
+ throw this.error(new TomlError("Incomplete time"));
+ }
+ }
+ parseOnlyTimeSec() {
+ if (isDigit(this.char)) {
+ this.consume();
+ if (this.state.buf.length === 2) {
+ return this.next(this.parseOnlyTimeFractionMaybe);
+ }
+ } else {
+ throw this.error(new TomlError("Incomplete time"));
+ }
+ }
+ parseOnlyTimeFractionMaybe() {
+ this.state.result += ":" + this.state.buf;
+ if (this.char === CHAR_PERIOD) {
+ this.state.buf = "";
+ this.next(this.parseOnlyTimeFraction);
+ } else {
+ return this.return(createTime(this.state.result));
+ }
+ }
+ parseOnlyTimeFraction() {
+ if (isDigit(this.char)) {
+ this.consume();
+ } else if (this.atEndOfWord()) {
+ if (this.state.buf.length === 0)
+ throw this.error(new TomlError("Expected digit in milliseconds"));
+ return this.returnNow(createTime(this.state.result + "." + this.state.buf));
+ } else {
+ throw this.error(new TomlError("Unexpected character in datetime, expected period (.), minus (-), plus (+) or Z"));
+ }
+ }
+ parseTimeZoneOrFraction() {
+ if (this.char === CHAR_PERIOD) {
+ this.consume();
+ this.next(this.parseDateTimeFraction);
+ } else if (this.char === CHAR_HYPHEN || this.char === CHAR_PLUS) {
+ this.consume();
+ this.next(this.parseTimeZoneHour);
+ } else if (this.char === CHAR_Z) {
+ this.consume();
+ return this.return(createDateTime(this.state.result + this.state.buf));
+ } else if (this.atEndOfWord()) {
+ return this.returnNow(createDateTimeFloat(this.state.result + this.state.buf));
+ } else {
+ throw this.error(new TomlError("Unexpected character in datetime, expected period (.), minus (-), plus (+) or Z"));
+ }
+ }
+ parseDateTimeFraction() {
+ if (isDigit(this.char)) {
+ this.consume();
+ } else if (this.state.buf.length === 1) {
+ throw this.error(new TomlError("Expected digit in milliseconds"));
+ } else if (this.char === CHAR_HYPHEN || this.char === CHAR_PLUS) {
+ this.consume();
+ this.next(this.parseTimeZoneHour);
+ } else if (this.char === CHAR_Z) {
+ this.consume();
+ return this.return(createDateTime(this.state.result + this.state.buf));
+ } else if (this.atEndOfWord()) {
+ return this.returnNow(createDateTimeFloat(this.state.result + this.state.buf));
+ } else {
+ throw this.error(new TomlError("Unexpected character in datetime, expected period (.), minus (-), plus (+) or Z"));
+ }
+ }
+ parseTimeZoneHour() {
+ if (isDigit(this.char)) {
+ this.consume();
+ if (/\d\d$/.test(this.state.buf))
+ return this.next(this.parseTimeZoneSep);
+ } else {
+ throw this.error(new TomlError("Unexpected character in datetime, expected digit"));
+ }
+ }
+ parseTimeZoneSep() {
+ if (this.char === CHAR_COLON) {
+ this.consume();
+ this.next(this.parseTimeZoneMin);
+ } else {
+ throw this.error(new TomlError("Unexpected character in datetime, expected colon"));
+ }
+ }
+ parseTimeZoneMin() {
+ if (isDigit(this.char)) {
+ this.consume();
+ if (/\d\d$/.test(this.state.buf))
+ return this.return(createDateTime(this.state.result + this.state.buf));
+ } else {
+ throw this.error(new TomlError("Unexpected character in datetime, expected digit"));
+ }
+ }
+ /* BOOLEAN */
+ parseBoolean() {
+ if (this.char === CHAR_t) {
+ this.consume();
+ return this.next(this.parseTrue_r);
+ } else if (this.char === CHAR_f) {
+ this.consume();
+ return this.next(this.parseFalse_a);
+ }
+ }
+ parseTrue_r() {
+ if (this.char === CHAR_r) {
+ this.consume();
+ return this.next(this.parseTrue_u);
+ } else {
+ throw this.error(new TomlError("Invalid boolean, expected true or false"));
+ }
+ }
+ parseTrue_u() {
+ if (this.char === CHAR_u) {
+ this.consume();
+ return this.next(this.parseTrue_e);
+ } else {
+ throw this.error(new TomlError("Invalid boolean, expected true or false"));
+ }
+ }
+ parseTrue_e() {
+ if (this.char === CHAR_e) {
+ return this.return(true);
+ } else {
+ throw this.error(new TomlError("Invalid boolean, expected true or false"));
+ }
+ }
+ parseFalse_a() {
+ if (this.char === CHAR_a) {
+ this.consume();
+ return this.next(this.parseFalse_l);
+ } else {
+ throw this.error(new TomlError("Invalid boolean, expected true or false"));
+ }
+ }
+ parseFalse_l() {
+ if (this.char === CHAR_l) {
+ this.consume();
+ return this.next(this.parseFalse_s);
+ } else {
+ throw this.error(new TomlError("Invalid boolean, expected true or false"));
+ }
+ }
+ parseFalse_s() {
+ if (this.char === CHAR_s) {
+ this.consume();
+ return this.next(this.parseFalse_e);
+ } else {
+ throw this.error(new TomlError("Invalid boolean, expected true or false"));
+ }
+ }
+ parseFalse_e() {
+ if (this.char === CHAR_e) {
+ return this.return(false);
+ } else {
+ throw this.error(new TomlError("Invalid boolean, expected true or false"));
+ }
+ }
+ /* INLINE LISTS */
+ parseInlineList() {
+ if (this.char === CHAR_SP || this.char === CTRL_I || this.char === CTRL_M || this.char === CTRL_J) {
+ return null;
+ } else if (this.char === Parser2.END) {
+ throw this.error(new TomlError("Unterminated inline array"));
+ } else if (this.char === CHAR_NUM) {
+ return this.call(this.parseComment);
+ } else if (this.char === CHAR_RSQB) {
+ return this.return(this.state.resultArr || InlineList());
+ } else {
+ return this.callNow(this.parseValue, this.recordInlineListValue);
+ }
+ }
+ recordInlineListValue(value) {
+ if (!this.state.resultArr) {
+ this.state.resultArr = InlineList(tomlType(value));
+ }
+ if (isFloat(value) || isInteger(value)) {
+ this.state.resultArr.push(value.valueOf());
+ } else {
+ this.state.resultArr.push(value);
+ }
+ return this.goto(this.parseInlineListNext);
+ }
+ parseInlineListNext() {
+ if (this.char === CHAR_SP || this.char === CTRL_I || this.char === CTRL_M || this.char === CTRL_J) {
+ return null;
+ } else if (this.char === CHAR_NUM) {
+ return this.call(this.parseComment);
+ } else if (this.char === CHAR_COMMA) {
+ return this.next(this.parseInlineList);
+ } else if (this.char === CHAR_RSQB) {
+ return this.goto(this.parseInlineList);
+ } else {
+ throw this.error(new TomlError("Invalid character, expected whitespace, comma (,) or close bracket (])"));
+ }
+ }
+ /* INLINE TABLE */
+ parseInlineTable() {
+ if (this.char === CHAR_SP || this.char === CTRL_I) {
+ return null;
+ } else if (this.char === Parser2.END || this.char === CHAR_NUM || this.char === CTRL_J || this.char === CTRL_M) {
+ throw this.error(new TomlError("Unterminated inline array"));
+ } else if (this.char === CHAR_RCUB) {
+ return this.return(this.state.resultTable || InlineTable());
+ } else {
+ if (!this.state.resultTable)
+ this.state.resultTable = InlineTable();
+ return this.callNow(this.parseAssign, this.recordInlineTableValue);
+ }
+ }
+ recordInlineTableValue(kv) {
+ let target = this.state.resultTable;
+ let finalKey = kv.key.pop();
+ for (let kw of kv.key) {
+ if (hasKey(target, kw) && (!isTable(target[kw]) || target[kw][_declared])) {
+ throw this.error(new TomlError("Can't redefine existing key"));
+ }
+ target = target[kw] = target[kw] || Table();
+ }
+ if (hasKey(target, finalKey)) {
+ throw this.error(new TomlError("Can't redefine existing key"));
+ }
+ if (isInteger(kv.value) || isFloat(kv.value)) {
+ target[finalKey] = kv.value.valueOf();
+ } else {
+ target[finalKey] = kv.value;
+ }
+ return this.goto(this.parseInlineTableNext);
+ }
+ parseInlineTableNext() {
+ if (this.char === CHAR_SP || this.char === CTRL_I) {
+ return null;
+ } else if (this.char === Parser2.END || this.char === CHAR_NUM || this.char === CTRL_J || this.char === CTRL_M) {
+ throw this.error(new TomlError("Unterminated inline array"));
+ } else if (this.char === CHAR_COMMA) {
+ return this.next(this.parseInlineTablePostComma);
+ } else if (this.char === CHAR_RCUB) {
+ return this.goto(this.parseInlineTable);
+ } else {
+ throw this.error(new TomlError("Invalid character, expected whitespace, comma (,) or close bracket (])"));
+ }
+ }
+ parseInlineTablePostComma() {
+ if (this.char === CHAR_SP || this.char === CTRL_I) {
+ return null;
+ } else if (this.char === Parser2.END || this.char === CHAR_NUM || this.char === CTRL_J || this.char === CTRL_M) {
+ throw this.error(new TomlError("Unterminated inline array"));
+ } else if (this.char === CHAR_COMMA) {
+ throw this.error(new TomlError("Empty elements in inline tables are not permitted"));
+ } else if (this.char === CHAR_RCUB) {
+ throw this.error(new TomlError("Trailing commas in inline tables are not permitted"));
+ } else {
+ return this.goto(this.parseInlineTable);
+ }
+ }
+ }
+ __name(TOMLParser, "TOMLParser");
+ return TOMLParser;
+ }
+ __name(makeParserClass, "makeParserClass");
+ }
+});
+
+// ../../node_modules/.pnpm/@iarna+toml@3.0.0/node_modules/@iarna/toml/parse-pretty-error.js
+var require_parse_pretty_error = __commonJS({
+ "../../node_modules/.pnpm/@iarna+toml@3.0.0/node_modules/@iarna/toml/parse-pretty-error.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ module2.exports = prettyError;
+ function prettyError(err, buf) {
+ if (err.pos == null || err.line == null)
+ return err;
+ let msg = err.message;
+ msg += ` at row ${err.line + 1}, col ${err.col + 1}, pos ${err.pos}:
+`;
+ if (buf && buf.split) {
+ const lines = buf.split(/\n/);
+ const lineNumWidth = String(Math.min(lines.length, err.line + 3)).length;
+ let linePadding = " ";
+ while (linePadding.length < lineNumWidth)
+ linePadding += " ";
+ for (let ii = Math.max(0, err.line - 1); ii < Math.min(lines.length, err.line + 2); ++ii) {
+ let lineNum = String(ii + 1);
+ if (lineNum.length < lineNumWidth)
+ lineNum = " " + lineNum;
+ if (err.line === ii) {
+ msg += lineNum + "> " + lines[ii] + "\n";
+ msg += linePadding + " ";
+ for (let hh = 0; hh < err.col; ++hh) {
+ msg += " ";
+ }
+ msg += "^\n";
+ } else {
+ msg += lineNum + ": " + lines[ii] + "\n";
+ }
+ }
+ }
+ err.message = msg + "\n";
+ return err;
+ }
+ __name(prettyError, "prettyError");
+ }
+});
+
+// ../../node_modules/.pnpm/@iarna+toml@3.0.0/node_modules/@iarna/toml/parse-string.js
+var require_parse_string = __commonJS({
+ "../../node_modules/.pnpm/@iarna+toml@3.0.0/node_modules/@iarna/toml/parse-string.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ module2.exports = parseString;
+ var TOMLParser = require_toml_parser();
+ var prettyError = require_parse_pretty_error();
+ function parseString(str) {
+ if (global.Buffer && global.Buffer.isBuffer(str)) {
+ str = str.toString("utf8");
+ }
+ const parser2 = new TOMLParser();
+ try {
+ parser2.parse(str);
+ return parser2.finish();
+ } catch (err) {
+ throw prettyError(err, str);
+ }
+ }
+ __name(parseString, "parseString");
+ }
+});
+
+// ../../node_modules/.pnpm/@iarna+toml@3.0.0/node_modules/@iarna/toml/parse-async.js
+var require_parse_async = __commonJS({
+ "../../node_modules/.pnpm/@iarna+toml@3.0.0/node_modules/@iarna/toml/parse-async.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ module2.exports = parseAsync;
+ var TOMLParser = require_toml_parser();
+ var prettyError = require_parse_pretty_error();
+ function parseAsync(str, opts) {
+ if (!opts)
+ opts = {};
+ const index = 0;
+ const blocksize = opts.blocksize || 40960;
+ const parser2 = new TOMLParser();
+ return new Promise((resolve18, reject) => {
+ setImmediate(parseAsyncNext, index, blocksize, resolve18, reject);
+ });
+ function parseAsyncNext(index2, blocksize2, resolve18, reject) {
+ if (index2 >= str.length) {
+ try {
+ return resolve18(parser2.finish());
+ } catch (err) {
+ return reject(prettyError(err, str));
+ }
+ }
+ try {
+ parser2.parse(str.slice(index2, index2 + blocksize2));
+ setImmediate(parseAsyncNext, index2 + blocksize2, blocksize2, resolve18, reject);
+ } catch (err) {
+ reject(prettyError(err, str));
+ }
+ }
+ __name(parseAsyncNext, "parseAsyncNext");
+ }
+ __name(parseAsync, "parseAsync");
+ }
+});
+
+// ../../node_modules/.pnpm/@iarna+toml@3.0.0/node_modules/@iarna/toml/parse-stream.js
+var require_parse_stream = __commonJS({
+ "../../node_modules/.pnpm/@iarna+toml@3.0.0/node_modules/@iarna/toml/parse-stream.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ module2.exports = parseStream;
+ var stream2 = require("stream");
+ var TOMLParser = require_toml_parser();
+ function parseStream(stm) {
+ if (stm) {
+ return parseReadable(stm);
+ } else {
+ return parseTransform(stm);
+ }
+ }
+ __name(parseStream, "parseStream");
+ function parseReadable(stm) {
+ const parser2 = new TOMLParser();
+ stm.setEncoding("utf8");
+ return new Promise((resolve18, reject) => {
+ let readable;
+ let ended = false;
+ let errored = false;
+ function finish() {
+ ended = true;
+ if (readable)
+ return;
+ try {
+ resolve18(parser2.finish());
+ } catch (err) {
+ reject(err);
+ }
+ }
+ __name(finish, "finish");
+ function error(err) {
+ errored = true;
+ reject(err);
+ }
+ __name(error, "error");
+ stm.once("end", finish);
+ stm.once("error", error);
+ readNext();
+ function readNext() {
+ readable = true;
+ let data;
+ while ((data = stm.read()) !== null) {
+ try {
+ parser2.parse(data);
+ } catch (err) {
+ return error(err);
+ }
+ }
+ readable = false;
+ if (ended)
+ return finish();
+ if (errored)
+ return;
+ stm.once("readable", readNext);
+ }
+ __name(readNext, "readNext");
+ });
+ }
+ __name(parseReadable, "parseReadable");
+ function parseTransform() {
+ const parser2 = new TOMLParser();
+ return new stream2.Transform({
+ objectMode: true,
+ transform(chunk, encoding, cb) {
+ try {
+ parser2.parse(chunk.toString(encoding));
+ } catch (err) {
+ this.emit("error", err);
+ }
+ cb();
+ },
+ flush(cb) {
+ try {
+ this.push(parser2.finish());
+ } catch (err) {
+ this.emit("error", err);
+ }
+ cb();
+ }
+ });
+ }
+ __name(parseTransform, "parseTransform");
+ }
+});
+
+// ../../node_modules/.pnpm/@iarna+toml@3.0.0/node_modules/@iarna/toml/parse.js
+var require_parse2 = __commonJS({
+ "../../node_modules/.pnpm/@iarna+toml@3.0.0/node_modules/@iarna/toml/parse.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ module2.exports = require_parse_string();
+ module2.exports.async = require_parse_async();
+ module2.exports.stream = require_parse_stream();
+ module2.exports.prettyError = require_parse_pretty_error();
+ }
+});
+
+// ../../node_modules/.pnpm/@iarna+toml@3.0.0/node_modules/@iarna/toml/stringify.js
+var require_stringify = __commonJS({
+ "../../node_modules/.pnpm/@iarna+toml@3.0.0/node_modules/@iarna/toml/stringify.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ module2.exports = stringify;
+ module2.exports.value = stringifyInline;
+ function stringify(obj) {
+ if (obj === null)
+ throw typeError("null");
+ if (obj === void 0)
+ throw typeError("undefined");
+ if (typeof obj !== "object")
+ throw typeError(typeof obj);
+ if (typeof obj.toJSON === "function")
+ obj = obj.toJSON();
+ if (obj == null)
+ return null;
+ const type = tomlType2(obj);
+ if (type !== "table")
+ throw typeError(type);
+ return stringifyObject("", "", obj);
+ }
+ __name(stringify, "stringify");
+ function typeError(type) {
+ return new Error("Can only stringify objects, not " + type);
+ }
+ __name(typeError, "typeError");
+ function getInlineKeys(obj) {
+ return Object.keys(obj).filter((key) => isInline(obj[key]));
+ }
+ __name(getInlineKeys, "getInlineKeys");
+ function getComplexKeys(obj) {
+ return Object.keys(obj).filter((key) => !isInline(obj[key]));
+ }
+ __name(getComplexKeys, "getComplexKeys");
+ function toJSON(obj) {
+ let nobj = Array.isArray(obj) ? [] : Object.prototype.hasOwnProperty.call(obj, "__proto__") ? { ["__proto__"]: void 0 } : {};
+ for (let prop of Object.keys(obj)) {
+ if (obj[prop] && typeof obj[prop].toJSON === "function" && !("toISOString" in obj[prop])) {
+ nobj[prop] = obj[prop].toJSON();
+ } else {
+ nobj[prop] = obj[prop];
+ }
+ }
+ return nobj;
+ }
+ __name(toJSON, "toJSON");
+ function stringifyObject(prefix, indent, obj) {
+ obj = toJSON(obj);
+ let inlineKeys;
+ let complexKeys;
+ inlineKeys = getInlineKeys(obj);
+ complexKeys = getComplexKeys(obj);
+ const result = [];
+ const inlineIndent = indent || "";
+ inlineKeys.forEach((key) => {
+ var type = tomlType2(obj[key]);
+ if (type !== "undefined" && type !== "null") {
+ result.push(inlineIndent + stringifyKey(key) + " = " + stringifyAnyInline(obj[key], true));
+ }
+ });
+ if (result.length > 0)
+ result.push("");
+ const complexIndent = prefix && inlineKeys.length > 0 ? indent + " " : "";
+ complexKeys.forEach((key) => {
+ result.push(stringifyComplex(prefix, complexIndent, key, obj[key]));
+ });
+ return result.join("\n");
+ }
+ __name(stringifyObject, "stringifyObject");
+ function isInline(value) {
+ switch (tomlType2(value)) {
+ case "undefined":
+ case "null":
+ case "integer":
+ case "nan":
+ case "float":
+ case "boolean":
+ case "string":
+ case "datetime":
+ return true;
+ case "array":
+ return value.length === 0 || tomlType2(value[0]) !== "table";
+ case "table":
+ return Object.keys(value).length === 0;
+ default:
+ return false;
+ }
+ }
+ __name(isInline, "isInline");
+ function tomlType2(value) {
+ if (value === void 0) {
+ return "undefined";
+ } else if (value === null) {
+ return "null";
+ } else if (typeof value === "bigint" || Number.isInteger(value) && !Object.is(value, -0)) {
+ return "integer";
+ } else if (typeof value === "number") {
+ return "float";
+ } else if (typeof value === "boolean") {
+ return "boolean";
+ } else if (typeof value === "string") {
+ return "string";
+ } else if ("toISOString" in value) {
+ return isNaN(value) ? "undefined" : "datetime";
+ } else if (Array.isArray(value)) {
+ return "array";
+ } else {
+ return "table";
+ }
+ }
+ __name(tomlType2, "tomlType");
+ function stringifyKey(key) {
+ const keyStr = String(key);
+ if (/^[-A-Za-z0-9_]+$/.test(keyStr)) {
+ return keyStr;
+ } else {
+ return stringifyBasicString(keyStr);
+ }
+ }
+ __name(stringifyKey, "stringifyKey");
+ function stringifyBasicString(str) {
+ return '"' + escapeString(str).replace(/"/g, '\\"') + '"';
+ }
+ __name(stringifyBasicString, "stringifyBasicString");
+ function stringifyLiteralString(str) {
+ return "'" + str + "'";
+ }
+ __name(stringifyLiteralString, "stringifyLiteralString");
+ function numpad(num, str) {
+ while (str.length < num)
+ str = "0" + str;
+ return str;
+ }
+ __name(numpad, "numpad");
+ function escapeString(str) {
+ return str.replace(/\\/g, "\\\\").replace(/[\b]/g, "\\b").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\f/g, "\\f").replace(/\r/g, "\\r").replace(/([\u0000-\u001f\u007f])/, (c) => "\\u" + numpad(4, c.codePointAt(0).toString(16)));
+ }
+ __name(escapeString, "escapeString");
+ function stringifyMultilineString(str) {
+ let escaped = str.split(/\n/).map((str2) => {
+ return escapeString(str2).replace(/"(?="")/g, '\\"');
+ }).join("\n");
+ if (escaped.slice(-1) === '"')
+ escaped += "\\\n";
+ return '"""\n' + escaped + '"""';
+ }
+ __name(stringifyMultilineString, "stringifyMultilineString");
+ function stringifyAnyInline(value, multilineOk) {
+ let type = tomlType2(value);
+ if (type === "string") {
+ if (multilineOk && /\n/.test(value)) {
+ type = "string-multiline";
+ } else if (!/[\b\t\n\f\r']/.test(value) && /"/.test(value)) {
+ type = "string-literal";
+ }
+ }
+ return stringifyInline(value, type);
+ }
+ __name(stringifyAnyInline, "stringifyAnyInline");
+ function stringifyInline(value, type) {
+ if (!type)
+ type = tomlType2(value);
+ switch (type) {
+ case "string-multiline":
+ return stringifyMultilineString(value);
+ case "string":
+ return stringifyBasicString(value);
+ case "string-literal":
+ return stringifyLiteralString(value);
+ case "integer":
+ return stringifyInteger(value);
+ case "float":
+ return stringifyFloat(value);
+ case "boolean":
+ return stringifyBoolean(value);
+ case "datetime":
+ return stringifyDatetime(value);
+ case "array":
+ return stringifyInlineArray(value.filter((_2) => tomlType2(_2) !== "null" && tomlType2(_2) !== "undefined" && tomlType2(_2) !== "nan"));
+ case "table":
+ return stringifyInlineTable(value);
+ default:
+ throw typeError(type);
+ }
+ }
+ __name(stringifyInline, "stringifyInline");
+ function stringifyInteger(value) {
+ return String(value).replace(/\B(?=(\d{3})+(?!\d))/g, "_");
+ }
+ __name(stringifyInteger, "stringifyInteger");
+ function stringifyFloat(value) {
+ if (value === Infinity) {
+ return "inf";
+ } else if (value === -Infinity) {
+ return "-inf";
+ } else if (Object.is(value, NaN)) {
+ return "nan";
+ } else if (Object.is(value, -0)) {
+ return "-0.0";
+ }
+ const [int, dec] = String(value).split(".");
+ return stringifyInteger(int) + "." + dec;
+ }
+ __name(stringifyFloat, "stringifyFloat");
+ function stringifyBoolean(value) {
+ return String(value);
+ }
+ __name(stringifyBoolean, "stringifyBoolean");
+ function stringifyDatetime(value) {
+ return value.toISOString();
+ }
+ __name(stringifyDatetime, "stringifyDatetime");
+ function stringifyInlineArray(values) {
+ values = toJSON(values);
+ let result = "[";
+ const stringified = values.map((_2) => stringifyInline(_2));
+ if (stringified.join(", ").length > 60 || /\n/.test(stringified)) {
+ result += "\n " + stringified.join(",\n ") + "\n";
+ } else {
+ result += " " + stringified.join(", ") + (stringified.length > 0 ? " " : "");
+ }
+ return result + "]";
+ }
+ __name(stringifyInlineArray, "stringifyInlineArray");
+ function stringifyInlineTable(value) {
+ value = toJSON(value);
+ const result = [];
+ Object.keys(value).forEach((key) => {
+ result.push(stringifyKey(key) + " = " + stringifyAnyInline(value[key], false));
+ });
+ return "{ " + result.join(", ") + (result.length > 0 ? " " : "") + "}";
+ }
+ __name(stringifyInlineTable, "stringifyInlineTable");
+ function stringifyComplex(prefix, indent, key, value) {
+ const valueType = tomlType2(value);
+ if (valueType === "array") {
+ return stringifyArrayOfTables(prefix, indent, key, value);
+ } else if (valueType === "table") {
+ return stringifyComplexTable(prefix, indent, key, value);
+ } else {
+ throw typeError(valueType);
+ }
+ }
+ __name(stringifyComplex, "stringifyComplex");
+ function stringifyArrayOfTables(prefix, indent, key, values) {
+ values = toJSON(values);
+ const firstValueType = tomlType2(values[0]);
+ if (firstValueType !== "table")
+ throw typeError(firstValueType);
+ const fullKey = prefix + stringifyKey(key);
+ let result = "";
+ values.forEach((table) => {
+ if (result.length > 0)
+ result += "\n";
+ result += indent + "[[" + fullKey + "]]\n";
+ result += stringifyObject(fullKey + ".", indent, table);
+ });
+ return result;
+ }
+ __name(stringifyArrayOfTables, "stringifyArrayOfTables");
+ function stringifyComplexTable(prefix, indent, key, value) {
+ const fullKey = prefix + stringifyKey(key);
+ let result = "";
+ if (getInlineKeys(value).length > 0) {
+ result += indent + "[" + fullKey + "]\n";
+ }
+ return result + stringifyObject(fullKey + ".", indent, value);
+ }
+ __name(stringifyComplexTable, "stringifyComplexTable");
+ }
+});
+
+// ../../node_modules/.pnpm/@iarna+toml@3.0.0/node_modules/@iarna/toml/toml.js
+var require_toml = __commonJS({
+ "../../node_modules/.pnpm/@iarna+toml@3.0.0/node_modules/@iarna/toml/toml.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ exports2.parse = require_parse2();
+ exports2.stringify = require_stringify();
+ }
+});
+
+// ../../node_modules/.pnpm/ci-info@3.3.0/node_modules/ci-info/vendors.json
+var require_vendors2 = __commonJS({
+ "../../node_modules/.pnpm/ci-info@3.3.0/node_modules/ci-info/vendors.json"(exports2, module2) {
+ module2.exports = [
+ {
+ name: "AppVeyor",
+ constant: "APPVEYOR",
+ env: "APPVEYOR",
+ pr: "APPVEYOR_PULL_REQUEST_NUMBER"
+ },
+ {
+ name: "Azure Pipelines",
+ constant: "AZURE_PIPELINES",
+ env: "SYSTEM_TEAMFOUNDATIONCOLLECTIONURI",
+ pr: "SYSTEM_PULLREQUEST_PULLREQUESTID"
+ },
+ {
+ name: "Appcircle",
+ constant: "APPCIRCLE",
+ env: "AC_APPCIRCLE"
+ },
+ {
+ name: "Bamboo",
+ constant: "BAMBOO",
+ env: "bamboo_planKey"
+ },
+ {
+ name: "Bitbucket Pipelines",
+ constant: "BITBUCKET",
+ env: "BITBUCKET_COMMIT",
+ pr: "BITBUCKET_PR_ID"
+ },
+ {
+ name: "Bitrise",
+ constant: "BITRISE",
+ env: "BITRISE_IO",
+ pr: "BITRISE_PULL_REQUEST"
+ },
+ {
+ name: "Buddy",
+ constant: "BUDDY",
+ env: "BUDDY_WORKSPACE_ID",
+ pr: "BUDDY_EXECUTION_PULL_REQUEST_ID"
+ },
+ {
+ name: "Buildkite",
+ constant: "BUILDKITE",
+ env: "BUILDKITE",
+ pr: { env: "BUILDKITE_PULL_REQUEST", ne: "false" }
+ },
+ {
+ name: "CircleCI",
+ constant: "CIRCLE",
+ env: "CIRCLECI",
+ pr: "CIRCLE_PULL_REQUEST"
+ },
+ {
+ name: "Cirrus CI",
+ constant: "CIRRUS",
+ env: "CIRRUS_CI",
+ pr: "CIRRUS_PR"
+ },
+ {
+ name: "AWS CodeBuild",
+ constant: "CODEBUILD",
+ env: "CODEBUILD_BUILD_ARN"
+ },
+ {
+ name: "Codefresh",
+ constant: "CODEFRESH",
+ env: "CF_BUILD_ID",
+ pr: { any: ["CF_PULL_REQUEST_NUMBER", "CF_PULL_REQUEST_ID"] }
+ },
+ {
+ name: "Codeship",
+ constant: "CODESHIP",
+ env: { CI_NAME: "codeship" }
+ },
+ {
+ name: "Drone",
+ constant: "DRONE",
+ env: "DRONE",
+ pr: { DRONE_BUILD_EVENT: "pull_request" }
+ },
+ {
+ name: "dsari",
+ constant: "DSARI",
+ env: "DSARI"
+ },
+ {
+ name: "Expo Application Services",
+ constant: "EAS",
+ env: "EAS_BUILD"
+ },
+ {
+ name: "GitHub Actions",
+ constant: "GITHUB_ACTIONS",
+ env: "GITHUB_ACTIONS",
+ pr: { GITHUB_EVENT_NAME: "pull_request" }
+ },
+ {
+ name: "GitLab CI",
+ constant: "GITLAB",
+ env: "GITLAB_CI",
+ pr: "CI_MERGE_REQUEST_ID"
+ },
+ {
+ name: "GoCD",
+ constant: "GOCD",
+ env: "GO_PIPELINE_LABEL"
+ },
+ {
+ name: "LayerCI",
+ constant: "LAYERCI",
+ env: "LAYERCI",
+ pr: "LAYERCI_PULL_REQUEST"
+ },
+ {
+ name: "Hudson",
+ constant: "HUDSON",
+ env: "HUDSON_URL"
+ },
+ {
+ name: "Jenkins",
+ constant: "JENKINS",
+ env: ["JENKINS_URL", "BUILD_ID"],
+ pr: { any: ["ghprbPullId", "CHANGE_ID"] }
+ },
+ {
+ name: "Magnum CI",
+ constant: "MAGNUM",
+ env: "MAGNUM"
+ },
+ {
+ name: "Netlify CI",
+ constant: "NETLIFY",
+ env: "NETLIFY",
+ pr: { env: "PULL_REQUEST", ne: "false" }
+ },
+ {
+ name: "Nevercode",
+ constant: "NEVERCODE",
+ env: "NEVERCODE",
+ pr: { env: "NEVERCODE_PULL_REQUEST", ne: "false" }
+ },
+ {
+ name: "Render",
+ constant: "RENDER",
+ env: "RENDER",
+ pr: { IS_PULL_REQUEST: "true" }
+ },
+ {
+ name: "Sail CI",
+ constant: "SAIL",
+ env: "SAILCI",
+ pr: "SAIL_PULL_REQUEST_NUMBER"
+ },
+ {
+ name: "Semaphore",
+ constant: "SEMAPHORE",
+ env: "SEMAPHORE",
+ pr: "PULL_REQUEST_NUMBER"
+ },
+ {
+ name: "Screwdriver",
+ constant: "SCREWDRIVER",
+ env: "SCREWDRIVER",
+ pr: { env: "SD_PULL_REQUEST", ne: "false" }
+ },
+ {
+ name: "Shippable",
+ constant: "SHIPPABLE",
+ env: "SHIPPABLE",
+ pr: { IS_PULL_REQUEST: "true" }
+ },
+ {
+ name: "Solano CI",
+ constant: "SOLANO",
+ env: "TDDIUM",
+ pr: "TDDIUM_PR_ID"
+ },
+ {
+ name: "Strider CD",
+ constant: "STRIDER",
+ env: "STRIDER"
+ },
+ {
+ name: "TaskCluster",
+ constant: "TASKCLUSTER",
+ env: ["TASK_ID", "RUN_ID"]
+ },
+ {
+ name: "TeamCity",
+ constant: "TEAMCITY",
+ env: "TEAMCITY_VERSION"
+ },
+ {
+ name: "Travis CI",
+ constant: "TRAVIS",
+ env: "TRAVIS",
+ pr: { env: "TRAVIS_PULL_REQUEST", ne: "false" }
+ },
+ {
+ name: "Vercel",
+ constant: "VERCEL",
+ env: "NOW_BUILDER"
+ },
+ {
+ name: "Visual Studio App Center",
+ constant: "APPCENTER",
+ env: "APPCENTER_BUILD_ID"
+ }
+ ];
+ }
+});
+
+// ../../node_modules/.pnpm/ci-info@3.3.0/node_modules/ci-info/index.js
+var require_ci_info2 = __commonJS({
+ "../../node_modules/.pnpm/ci-info@3.3.0/node_modules/ci-info/index.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ var vendors = require_vendors2();
+ var env5 = process.env;
+ Object.defineProperty(exports2, "_vendors", {
+ value: vendors.map(function(v) {
+ return v.constant;
+ })
+ });
+ exports2.name = null;
+ exports2.isPR = null;
+ vendors.forEach(function(vendor) {
+ const envs = Array.isArray(vendor.env) ? vendor.env : [vendor.env];
+ const isCI2 = envs.every(function(obj) {
+ return checkEnv(obj);
+ });
+ exports2[vendor.constant] = isCI2;
+ if (isCI2) {
+ exports2.name = vendor.name;
+ switch (typeof vendor.pr) {
+ case "string":
+ exports2.isPR = !!env5[vendor.pr];
+ break;
+ case "object":
+ if ("env" in vendor.pr) {
+ exports2.isPR = vendor.pr.env in env5 && env5[vendor.pr.env] !== vendor.pr.ne;
+ } else if ("any" in vendor.pr) {
+ exports2.isPR = vendor.pr.any.some(function(key) {
+ return !!env5[key];
+ });
+ } else {
+ exports2.isPR = checkEnv(vendor.pr);
+ }
+ break;
+ default:
+ exports2.isPR = null;
+ }
+ }
+ });
+ exports2.isCI = !!(env5.CI || // Travis CI, CircleCI, Cirrus CI, Gitlab CI, Appveyor, CodeShip, dsari
+ env5.CONTINUOUS_INTEGRATION || // Travis CI, Cirrus CI
+ env5.BUILD_NUMBER || // Jenkins, TeamCity
+ env5.RUN_ID || // TaskCluster, dsari
+ exports2.name || false);
+ function checkEnv(obj) {
+ if (typeof obj === "string")
+ return !!env5[obj];
+ return Object.keys(obj).every(function(k) {
+ return env5[k] === obj[k];
+ });
+ }
+ __name(checkEnv, "checkEnv");
+ }
+});
+
+// ../../node_modules/.pnpm/is-ci@3.0.1/node_modules/is-ci/index.js
+var require_is_ci2 = __commonJS({
+ "../../node_modules/.pnpm/is-ci@3.0.1/node_modules/is-ci/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ module2.exports = require_ci_info2().isCI;
+ }
+});
+
+// ../../node_modules/.pnpm/kleur@3.0.3/node_modules/kleur/index.js
+var require_kleur = __commonJS({
+ "../../node_modules/.pnpm/kleur@3.0.3/node_modules/kleur/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var { FORCE_COLOR, NODE_DISABLE_COLORS, TERM } = process.env;
+ var $2 = {
+ enabled: !NODE_DISABLE_COLORS && TERM !== "dumb" && FORCE_COLOR !== "0",
+ // modifiers
+ reset: init(0, 0),
+ bold: init(1, 22),
+ dim: init(2, 22),
+ italic: init(3, 23),
+ underline: init(4, 24),
+ inverse: init(7, 27),
+ hidden: init(8, 28),
+ strikethrough: init(9, 29),
+ // colors
+ black: init(30, 39),
+ red: init(31, 39),
+ green: init(32, 39),
+ yellow: init(33, 39),
+ blue: init(34, 39),
+ magenta: init(35, 39),
+ cyan: init(36, 39),
+ white: init(37, 39),
+ gray: init(90, 39),
+ grey: init(90, 39),
+ // background colors
+ bgBlack: init(40, 49),
+ bgRed: init(41, 49),
+ bgGreen: init(42, 49),
+ bgYellow: init(43, 49),
+ bgBlue: init(44, 49),
+ bgMagenta: init(45, 49),
+ bgCyan: init(46, 49),
+ bgWhite: init(47, 49)
+ };
+ function run(arr, str) {
+ let i = 0, tmp5, beg = "", end = "";
+ for (; i < arr.length; i++) {
+ tmp5 = arr[i];
+ beg += tmp5.open;
+ end += tmp5.close;
+ if (str.includes(tmp5.close)) {
+ str = str.replace(tmp5.rgx, tmp5.close + tmp5.open);
+ }
+ }
+ return beg + str + end;
+ }
+ __name(run, "run");
+ function chain(has, keys) {
+ let ctx = { has, keys };
+ ctx.reset = $2.reset.bind(ctx);
+ ctx.bold = $2.bold.bind(ctx);
+ ctx.dim = $2.dim.bind(ctx);
+ ctx.italic = $2.italic.bind(ctx);
+ ctx.underline = $2.underline.bind(ctx);
+ ctx.inverse = $2.inverse.bind(ctx);
+ ctx.hidden = $2.hidden.bind(ctx);
+ ctx.strikethrough = $2.strikethrough.bind(ctx);
+ ctx.black = $2.black.bind(ctx);
+ ctx.red = $2.red.bind(ctx);
+ ctx.green = $2.green.bind(ctx);
+ ctx.yellow = $2.yellow.bind(ctx);
+ ctx.blue = $2.blue.bind(ctx);
+ ctx.magenta = $2.magenta.bind(ctx);
+ ctx.cyan = $2.cyan.bind(ctx);
+ ctx.white = $2.white.bind(ctx);
+ ctx.gray = $2.gray.bind(ctx);
+ ctx.grey = $2.grey.bind(ctx);
+ ctx.bgBlack = $2.bgBlack.bind(ctx);
+ ctx.bgRed = $2.bgRed.bind(ctx);
+ ctx.bgGreen = $2.bgGreen.bind(ctx);
+ ctx.bgYellow = $2.bgYellow.bind(ctx);
+ ctx.bgBlue = $2.bgBlue.bind(ctx);
+ ctx.bgMagenta = $2.bgMagenta.bind(ctx);
+ ctx.bgCyan = $2.bgCyan.bind(ctx);
+ ctx.bgWhite = $2.bgWhite.bind(ctx);
+ return ctx;
+ }
+ __name(chain, "chain");
+ function init(open3, close) {
+ let blk = {
+ open: `\x1B[${open3}m`,
+ close: `\x1B[${close}m`,
+ rgx: new RegExp(`\\x1b\\[${close}m`, "g")
+ };
+ return function(txt) {
+ if (this !== void 0 && this.has !== void 0) {
+ this.has.includes(open3) || (this.has.push(open3), this.keys.push(blk));
+ return txt === void 0 ? this : $2.enabled ? run(this.keys, txt + "") : txt + "";
+ }
+ return txt === void 0 ? chain([open3], [blk]) : $2.enabled ? run([blk], txt + "") : txt + "";
+ };
+ }
+ __name(init, "init");
+ module2.exports = $2;
+ }
+});
+
+// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/util/action.js
+var require_action = __commonJS({
+ "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/util/action.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ module2.exports = (key, isSelect) => {
+ if (key.meta && key.name !== "escape")
+ return;
+ if (key.ctrl) {
+ if (key.name === "a")
+ return "first";
+ if (key.name === "c")
+ return "abort";
+ if (key.name === "d")
+ return "abort";
+ if (key.name === "e")
+ return "last";
+ if (key.name === "g")
+ return "reset";
+ }
+ if (isSelect) {
+ if (key.name === "j")
+ return "down";
+ if (key.name === "k")
+ return "up";
+ }
+ if (key.name === "return")
+ return "submit";
+ if (key.name === "enter")
+ return "submit";
+ if (key.name === "backspace")
+ return "delete";
+ if (key.name === "delete")
+ return "deleteForward";
+ if (key.name === "abort")
+ return "abort";
+ if (key.name === "escape")
+ return "exit";
+ if (key.name === "tab")
+ return "next";
+ if (key.name === "pagedown")
+ return "nextPage";
+ if (key.name === "pageup")
+ return "prevPage";
+ if (key.name === "home")
+ return "home";
+ if (key.name === "end")
+ return "end";
+ if (key.name === "up")
+ return "up";
+ if (key.name === "down")
+ return "down";
+ if (key.name === "right")
+ return "right";
+ if (key.name === "left")
+ return "left";
+ return false;
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/util/strip.js
+var require_strip = __commonJS({
+ "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/util/strip.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ module2.exports = (str) => {
+ const pattern = ["[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)", "(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PRZcf-ntqry=><~]))"].join("|");
+ const RGX = new RegExp(pattern, "g");
+ return typeof str === "string" ? str.replace(RGX, "") : str;
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/sisteransi@1.0.5/node_modules/sisteransi/src/index.js
+var require_src = __commonJS({
+ "../../node_modules/.pnpm/sisteransi@1.0.5/node_modules/sisteransi/src/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var ESC = "\x1B";
+ var CSI = `${ESC}[`;
+ var beep = "\x07";
+ var cursor = {
+ to(x, y) {
+ if (!y)
+ return `${CSI}${x + 1}G`;
+ return `${CSI}${y + 1};${x + 1}H`;
+ },
+ move(x, y) {
+ let ret = "";
+ if (x < 0)
+ ret += `${CSI}${-x}D`;
+ else if (x > 0)
+ ret += `${CSI}${x}C`;
+ if (y < 0)
+ ret += `${CSI}${-y}A`;
+ else if (y > 0)
+ ret += `${CSI}${y}B`;
+ return ret;
+ },
+ up: (count = 1) => `${CSI}${count}A`,
+ down: (count = 1) => `${CSI}${count}B`,
+ forward: (count = 1) => `${CSI}${count}C`,
+ backward: (count = 1) => `${CSI}${count}D`,
+ nextLine: (count = 1) => `${CSI}E`.repeat(count),
+ prevLine: (count = 1) => `${CSI}F`.repeat(count),
+ left: `${CSI}G`,
+ hide: `${CSI}?25l`,
+ show: `${CSI}?25h`,
+ save: `${ESC}7`,
+ restore: `${ESC}8`
+ };
+ var scroll = {
+ up: (count = 1) => `${CSI}S`.repeat(count),
+ down: (count = 1) => `${CSI}T`.repeat(count)
+ };
+ var erase = {
+ screen: `${CSI}2J`,
+ up: (count = 1) => `${CSI}1J`.repeat(count),
+ down: (count = 1) => `${CSI}J`.repeat(count),
+ line: `${CSI}2K`,
+ lineEnd: `${CSI}K`,
+ lineStart: `${CSI}1K`,
+ lines(count) {
+ let clear = "";
+ for (let i = 0; i < count; i++)
+ clear += this.line + (i < count - 1 ? cursor.up() : "");
+ if (count)
+ clear += cursor.left;
+ return clear;
+ }
+ };
+ module2.exports = { cursor, scroll, erase, beep };
+ }
+});
+
+// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/util/clear.js
+var require_clear = __commonJS({
+ "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/util/clear.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ function _createForOfIteratorHelper(o, allowArrayLike) {
+ var it2 = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
+ if (!it2) {
+ if (Array.isArray(o) || (it2 = _unsupportedIterableToArray4(o)) || allowArrayLike && o && typeof o.length === "number") {
+ if (it2)
+ o = it2;
+ var i = 0;
+ var F = /* @__PURE__ */ __name(function F2() {
+ }, "F");
+ return { s: F, n: /* @__PURE__ */ __name(function n() {
+ if (i >= o.length)
+ return { done: true };
+ return { done: false, value: o[i++] };
+ }, "n"), e: /* @__PURE__ */ __name(function e2(_e) {
+ throw _e;
+ }, "e"), f: F };
+ }
+ throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+ }
+ var normalCompletion = true, didErr = false, err;
+ return { s: /* @__PURE__ */ __name(function s() {
+ it2 = it2.call(o);
+ }, "s"), n: /* @__PURE__ */ __name(function n() {
+ var step = it2.next();
+ normalCompletion = step.done;
+ return step;
+ }, "n"), e: /* @__PURE__ */ __name(function e2(_e2) {
+ didErr = true;
+ err = _e2;
+ }, "e"), f: /* @__PURE__ */ __name(function f() {
+ try {
+ if (!normalCompletion && it2.return != null)
+ it2.return();
+ } finally {
+ if (didErr)
+ throw err;
+ }
+ }, "f") };
+ }
+ __name(_createForOfIteratorHelper, "_createForOfIteratorHelper");
+ function _unsupportedIterableToArray4(o, minLen) {
+ if (!o)
+ return;
+ if (typeof o === "string")
+ return _arrayLikeToArray4(o, minLen);
+ var n = Object.prototype.toString.call(o).slice(8, -1);
+ if (n === "Object" && o.constructor)
+ n = o.constructor.name;
+ if (n === "Map" || n === "Set")
+ return Array.from(o);
+ if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))
+ return _arrayLikeToArray4(o, minLen);
+ }
+ __name(_unsupportedIterableToArray4, "_unsupportedIterableToArray");
+ function _arrayLikeToArray4(arr, len) {
+ if (len == null || len > arr.length)
+ len = arr.length;
+ for (var i = 0, arr2 = new Array(len); i < len; i++)
+ arr2[i] = arr[i];
+ return arr2;
+ }
+ __name(_arrayLikeToArray4, "_arrayLikeToArray");
+ var strip = require_strip();
+ var _require = require_src();
+ var erase = _require.erase;
+ var cursor = _require.cursor;
+ var width = /* @__PURE__ */ __name((str) => [...strip(str)].length, "width");
+ module2.exports = function(prompt2, perLine) {
+ if (!perLine)
+ return erase.line + cursor.to(0);
+ let rows = 0;
+ const lines = prompt2.split(/\r?\n/);
+ var _iterator = _createForOfIteratorHelper(lines), _step;
+ try {
+ for (_iterator.s(); !(_step = _iterator.n()).done; ) {
+ let line = _step.value;
+ rows += 1 + Math.floor(Math.max(width(line) - 1, 0) / perLine);
+ }
+ } catch (err) {
+ _iterator.e(err);
+ } finally {
+ _iterator.f();
+ }
+ return erase.lines(rows);
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/util/figures.js
+var require_figures = __commonJS({
+ "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/util/figures.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var main2 = {
+ arrowUp: "\u2191",
+ arrowDown: "\u2193",
+ arrowLeft: "\u2190",
+ arrowRight: "\u2192",
+ radioOn: "\u25C9",
+ radioOff: "\u25EF",
+ tick: "\u2714",
+ cross: "\u2716",
+ ellipsis: "\u2026",
+ pointerSmall: "\u203A",
+ line: "\u2500",
+ pointer: "\u276F"
+ };
+ var win = {
+ arrowUp: main2.arrowUp,
+ arrowDown: main2.arrowDown,
+ arrowLeft: main2.arrowLeft,
+ arrowRight: main2.arrowRight,
+ radioOn: "(*)",
+ radioOff: "( )",
+ tick: "\u221A",
+ cross: "\xD7",
+ ellipsis: "...",
+ pointerSmall: "\xBB",
+ line: "\u2500",
+ pointer: ">"
+ };
+ var figures = process.platform === "win32" ? win : main2;
+ module2.exports = figures;
+ }
+});
+
+// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/util/style.js
+var require_style = __commonJS({
+ "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/util/style.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var c = require_kleur();
+ var figures = require_figures();
+ var styles = Object.freeze({
+ password: {
+ scale: 1,
+ render: (input) => "*".repeat(input.length)
+ },
+ emoji: {
+ scale: 2,
+ render: (input) => "\u{1F603}".repeat(input.length)
+ },
+ invisible: {
+ scale: 0,
+ render: (input) => ""
+ },
+ default: {
+ scale: 1,
+ render: (input) => `${input}`
+ }
+ });
+ var render7 = /* @__PURE__ */ __name((type) => styles[type] || styles.default, "render");
+ var symbols = Object.freeze({
+ aborted: c.red(figures.cross),
+ done: c.green(figures.tick),
+ exited: c.yellow(figures.cross),
+ default: c.cyan("?")
+ });
+ var symbol = /* @__PURE__ */ __name((done, aborted, exited) => aborted ? symbols.aborted : exited ? symbols.exited : done ? symbols.done : symbols.default, "symbol");
+ var delimiter = /* @__PURE__ */ __name((completing) => c.gray(completing ? figures.ellipsis : figures.pointerSmall), "delimiter");
+ var item = /* @__PURE__ */ __name((expandable, expanded) => c.gray(expandable ? expanded ? figures.pointerSmall : "+" : figures.line), "item");
+ module2.exports = {
+ styles,
+ render: render7,
+ symbols,
+ symbol,
+ delimiter,
+ item
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/util/lines.js
+var require_lines = __commonJS({
+ "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/util/lines.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var strip = require_strip();
+ module2.exports = function(msg, perLine) {
+ let lines = String(strip(msg) || "").split(/\r?\n/);
+ if (!perLine)
+ return lines.length;
+ return lines.map((l) => Math.ceil(l.length / perLine)).reduce((a, b) => a + b);
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/util/wrap.js
+var require_wrap = __commonJS({
+ "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/util/wrap.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ module2.exports = (msg, opts = {}) => {
+ const tab = Number.isSafeInteger(parseInt(opts.margin)) ? new Array(parseInt(opts.margin)).fill(" ").join("") : opts.margin || "";
+ const width = opts.width;
+ return (msg || "").split(/\r?\n/g).map((line) => line.split(/\s+/g).reduce((arr, w) => {
+ if (w.length + tab.length >= width || arr[arr.length - 1].length + w.length + 1 < width)
+ arr[arr.length - 1] += ` ${w}`;
+ else
+ arr.push(`${tab}${w}`);
+ return arr;
+ }, [tab]).join("\n")).join("\n");
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/util/entriesToDisplay.js
+var require_entriesToDisplay = __commonJS({
+ "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/util/entriesToDisplay.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ module2.exports = (cursor, total, maxVisible) => {
+ maxVisible = maxVisible || total;
+ let startIndex = Math.min(total - maxVisible, cursor - Math.floor(maxVisible / 2));
+ if (startIndex < 0)
+ startIndex = 0;
+ let endIndex = Math.min(startIndex + maxVisible, total);
+ return {
+ startIndex,
+ endIndex
+ };
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/util/index.js
+var require_util7 = __commonJS({
+ "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/util/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ module2.exports = {
+ action: require_action(),
+ clear: require_clear(),
+ style: require_style(),
+ strip: require_strip(),
+ figures: require_figures(),
+ lines: require_lines(),
+ wrap: require_wrap(),
+ entriesToDisplay: require_entriesToDisplay()
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/elements/prompt.js
+var require_prompt = __commonJS({
+ "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/elements/prompt.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var readline2 = require("readline");
+ var _require = require_util7();
+ var action = _require.action;
+ var EventEmitter3 = require("events");
+ var _require2 = require_src();
+ var beep = _require2.beep;
+ var cursor = _require2.cursor;
+ var color = require_kleur();
+ var Prompt = class extends EventEmitter3 {
+ constructor(opts = {}) {
+ super();
+ this.firstRender = true;
+ this.in = opts.stdin || process.stdin;
+ this.out = opts.stdout || process.stdout;
+ this.onRender = (opts.onRender || (() => void 0)).bind(this);
+ const rl = readline2.createInterface({
+ input: this.in,
+ escapeCodeTimeout: 50
+ });
+ readline2.emitKeypressEvents(this.in, rl);
+ if (this.in.isTTY)
+ this.in.setRawMode(true);
+ const isSelect = ["SelectPrompt", "MultiselectPrompt"].indexOf(this.constructor.name) > -1;
+ const keypress = /* @__PURE__ */ __name((str, key) => {
+ let a = action(key, isSelect);
+ if (a === false) {
+ this._ && this._(str, key);
+ } else if (typeof this[a] === "function") {
+ this[a](key);
+ } else {
+ this.bell();
+ }
+ }, "keypress");
+ this.close = () => {
+ this.out.write(cursor.show);
+ this.in.removeListener("keypress", keypress);
+ if (this.in.isTTY)
+ this.in.setRawMode(false);
+ rl.close();
+ this.emit(this.aborted ? "abort" : this.exited ? "exit" : "submit", this.value);
+ this.closed = true;
+ };
+ this.in.on("keypress", keypress);
+ }
+ fire() {
+ this.emit("state", {
+ value: this.value,
+ aborted: !!this.aborted,
+ exited: !!this.exited
+ });
+ }
+ bell() {
+ this.out.write(beep);
+ }
+ render() {
+ this.onRender(color);
+ if (this.firstRender)
+ this.firstRender = false;
+ }
+ };
+ __name(Prompt, "Prompt");
+ module2.exports = Prompt;
+ }
+});
+
+// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/elements/text.js
+var require_text = __commonJS({
+ "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/elements/text.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ function asyncGeneratorStep(gen, resolve18, reject, _next, _throw, key, arg) {
+ try {
+ var info = gen[key](arg);
+ var value = info.value;
+ } catch (error) {
+ reject(error);
+ return;
+ }
+ if (info.done) {
+ resolve18(value);
+ } else {
+ Promise.resolve(value).then(_next, _throw);
+ }
+ }
+ __name(asyncGeneratorStep, "asyncGeneratorStep");
+ function _asyncToGenerator(fn2) {
+ return function() {
+ var self2 = this, args = arguments;
+ return new Promise(function(resolve18, reject) {
+ var gen = fn2.apply(self2, args);
+ function _next(value) {
+ asyncGeneratorStep(gen, resolve18, reject, _next, _throw, "next", value);
+ }
+ __name(_next, "_next");
+ function _throw(err) {
+ asyncGeneratorStep(gen, resolve18, reject, _next, _throw, "throw", err);
+ }
+ __name(_throw, "_throw");
+ _next(void 0);
+ });
+ };
+ }
+ __name(_asyncToGenerator, "_asyncToGenerator");
+ var color = require_kleur();
+ var Prompt = require_prompt();
+ var _require = require_src();
+ var erase = _require.erase;
+ var cursor = _require.cursor;
+ var _require2 = require_util7();
+ var style = _require2.style;
+ var clear = _require2.clear;
+ var lines = _require2.lines;
+ var figures = _require2.figures;
+ var TextPrompt = class extends Prompt {
+ constructor(opts = {}) {
+ super(opts);
+ this.transform = style.render(opts.style);
+ this.scale = this.transform.scale;
+ this.msg = opts.message;
+ this.initial = opts.initial || ``;
+ this.validator = opts.validate || (() => true);
+ this.value = ``;
+ this.errorMsg = opts.error || `Please Enter A Valid Value`;
+ this.cursor = Number(!!this.initial);
+ this.cursorOffset = 0;
+ this.clear = clear(``, this.out.columns);
+ this.render();
+ }
+ set value(v) {
+ if (!v && this.initial) {
+ this.placeholder = true;
+ this.rendered = color.gray(this.transform.render(this.initial));
+ } else {
+ this.placeholder = false;
+ this.rendered = this.transform.render(v);
+ }
+ this._value = v;
+ this.fire();
+ }
+ get value() {
+ return this._value;
+ }
+ reset() {
+ this.value = ``;
+ this.cursor = Number(!!this.initial);
+ this.cursorOffset = 0;
+ this.fire();
+ this.render();
+ }
+ exit() {
+ this.abort();
+ }
+ abort() {
+ this.value = this.value || this.initial;
+ this.done = this.aborted = true;
+ this.error = false;
+ this.red = false;
+ this.fire();
+ this.render();
+ this.out.write("\n");
+ this.close();
+ }
+ validate() {
+ var _this = this;
+ return _asyncToGenerator(function* () {
+ let valid = yield _this.validator(_this.value);
+ if (typeof valid === `string`) {
+ _this.errorMsg = valid;
+ valid = false;
+ }
+ _this.error = !valid;
+ })();
+ }
+ submit() {
+ var _this2 = this;
+ return _asyncToGenerator(function* () {
+ _this2.value = _this2.value || _this2.initial;
+ _this2.cursorOffset = 0;
+ _this2.cursor = _this2.rendered.length;
+ yield _this2.validate();
+ if (_this2.error) {
+ _this2.red = true;
+ _this2.fire();
+ _this2.render();
+ return;
+ }
+ _this2.done = true;
+ _this2.aborted = false;
+ _this2.fire();
+ _this2.render();
+ _this2.out.write("\n");
+ _this2.close();
+ })();
+ }
+ next() {
+ if (!this.placeholder)
+ return this.bell();
+ this.value = this.initial;
+ this.cursor = this.rendered.length;
+ this.fire();
+ this.render();
+ }
+ moveCursor(n) {
+ if (this.placeholder)
+ return;
+ this.cursor = this.cursor + n;
+ this.cursorOffset += n;
+ }
+ _(c, key) {
+ let s1 = this.value.slice(0, this.cursor);
+ let s2 = this.value.slice(this.cursor);
+ this.value = `${s1}${c}${s2}`;
+ this.red = false;
+ this.cursor = this.placeholder ? 0 : s1.length + 1;
+ this.render();
+ }
+ delete() {
+ if (this.isCursorAtStart())
+ return this.bell();
+ let s1 = this.value.slice(0, this.cursor - 1);
+ let s2 = this.value.slice(this.cursor);
+ this.value = `${s1}${s2}`;
+ this.red = false;
+ if (this.isCursorAtStart()) {
+ this.cursorOffset = 0;
+ } else {
+ this.cursorOffset++;
+ this.moveCursor(-1);
+ }
+ this.render();
+ }
+ deleteForward() {
+ if (this.cursor * this.scale >= this.rendered.length || this.placeholder)
+ return this.bell();
+ let s1 = this.value.slice(0, this.cursor);
+ let s2 = this.value.slice(this.cursor + 1);
+ this.value = `${s1}${s2}`;
+ this.red = false;
+ if (this.isCursorAtEnd()) {
+ this.cursorOffset = 0;
+ } else {
+ this.cursorOffset++;
+ }
+ this.render();
+ }
+ first() {
+ this.cursor = 0;
+ this.render();
+ }
+ last() {
+ this.cursor = this.value.length;
+ this.render();
+ }
+ left() {
+ if (this.cursor <= 0 || this.placeholder)
+ return this.bell();
+ this.moveCursor(-1);
+ this.render();
+ }
+ right() {
+ if (this.cursor * this.scale >= this.rendered.length || this.placeholder)
+ return this.bell();
+ this.moveCursor(1);
+ this.render();
+ }
+ isCursorAtStart() {
+ return this.cursor === 0 || this.placeholder && this.cursor === 1;
+ }
+ isCursorAtEnd() {
+ return this.cursor === this.rendered.length || this.placeholder && this.cursor === this.rendered.length + 1;
+ }
+ render() {
+ if (this.closed)
+ return;
+ if (!this.firstRender) {
+ if (this.outputError)
+ this.out.write(cursor.down(lines(this.outputError, this.out.columns) - 1) + clear(this.outputError, this.out.columns));
+ this.out.write(clear(this.outputText, this.out.columns));
+ }
+ super.render();
+ this.outputError = "";
+ this.outputText = [style.symbol(this.done, this.aborted), color.bold(this.msg), style.delimiter(this.done), this.red ? color.red(this.rendered) : this.rendered].join(` `);
+ if (this.error) {
+ this.outputError += this.errorMsg.split(`
+`).reduce((a, l, i) => a + `
+${i ? " " : figures.pointerSmall} ${color.red().italic(l)}`, ``);
+ }
+ this.out.write(erase.line + cursor.to(0) + this.outputText + cursor.save + this.outputError + cursor.restore + cursor.move(this.cursorOffset, 0));
+ }
+ };
+ __name(TextPrompt, "TextPrompt");
+ module2.exports = TextPrompt;
+ }
+});
+
+// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/elements/select.js
+var require_select = __commonJS({
+ "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/elements/select.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var color = require_kleur();
+ var Prompt = require_prompt();
+ var _require = require_util7();
+ var style = _require.style;
+ var clear = _require.clear;
+ var figures = _require.figures;
+ var wrap2 = _require.wrap;
+ var entriesToDisplay = _require.entriesToDisplay;
+ var _require2 = require_src();
+ var cursor = _require2.cursor;
+ var SelectPrompt = class extends Prompt {
+ constructor(opts = {}) {
+ super(opts);
+ this.msg = opts.message;
+ this.hint = opts.hint || "- Use arrow-keys. Return to submit.";
+ this.warn = opts.warn || "- This option is disabled";
+ this.cursor = opts.initial || 0;
+ this.choices = opts.choices.map((ch, idx) => {
+ if (typeof ch === "string")
+ ch = {
+ title: ch,
+ value: idx
+ };
+ return {
+ title: ch && (ch.title || ch.value || ch),
+ value: ch && (ch.value === void 0 ? idx : ch.value),
+ description: ch && ch.description,
+ selected: ch && ch.selected,
+ disabled: ch && ch.disabled
+ };
+ });
+ this.optionsPerPage = opts.optionsPerPage || 10;
+ this.value = (this.choices[this.cursor] || {}).value;
+ this.clear = clear("", this.out.columns);
+ this.render();
+ }
+ moveCursor(n) {
+ this.cursor = n;
+ this.value = this.choices[n].value;
+ this.fire();
+ }
+ reset() {
+ this.moveCursor(0);
+ this.fire();
+ this.render();
+ }
+ exit() {
+ this.abort();
+ }
+ abort() {
+ this.done = this.aborted = true;
+ this.fire();
+ this.render();
+ this.out.write("\n");
+ this.close();
+ }
+ submit() {
+ if (!this.selection.disabled) {
+ this.done = true;
+ this.aborted = false;
+ this.fire();
+ this.render();
+ this.out.write("\n");
+ this.close();
+ } else
+ this.bell();
+ }
+ first() {
+ this.moveCursor(0);
+ this.render();
+ }
+ last() {
+ this.moveCursor(this.choices.length - 1);
+ this.render();
+ }
+ up() {
+ if (this.cursor === 0) {
+ this.moveCursor(this.choices.length - 1);
+ } else {
+ this.moveCursor(this.cursor - 1);
+ }
+ this.render();
+ }
+ down() {
+ if (this.cursor === this.choices.length - 1) {
+ this.moveCursor(0);
+ } else {
+ this.moveCursor(this.cursor + 1);
+ }
+ this.render();
+ }
+ next() {
+ this.moveCursor((this.cursor + 1) % this.choices.length);
+ this.render();
+ }
+ _(c, key) {
+ if (c === " ")
+ return this.submit();
+ }
+ get selection() {
+ return this.choices[this.cursor];
+ }
+ render() {
+ if (this.closed)
+ return;
+ if (this.firstRender)
+ this.out.write(cursor.hide);
+ else
+ this.out.write(clear(this.outputText, this.out.columns));
+ super.render();
+ let _entriesToDisplay = entriesToDisplay(this.cursor, this.choices.length, this.optionsPerPage), startIndex = _entriesToDisplay.startIndex, endIndex = _entriesToDisplay.endIndex;
+ this.outputText = [style.symbol(this.done, this.aborted), color.bold(this.msg), style.delimiter(false), this.done ? this.selection.title : this.selection.disabled ? color.yellow(this.warn) : color.gray(this.hint)].join(" ");
+ if (!this.done) {
+ this.outputText += "\n";
+ for (let i = startIndex; i < endIndex; i++) {
+ let title, prefix, desc = "", v = this.choices[i];
+ if (i === startIndex && startIndex > 0) {
+ prefix = figures.arrowUp;
+ } else if (i === endIndex - 1 && endIndex < this.choices.length) {
+ prefix = figures.arrowDown;
+ } else {
+ prefix = " ";
+ }
+ if (v.disabled) {
+ title = this.cursor === i ? color.gray().underline(v.title) : color.strikethrough().gray(v.title);
+ prefix = (this.cursor === i ? color.bold().gray(figures.pointer) + " " : " ") + prefix;
+ } else {
+ title = this.cursor === i ? color.cyan().underline(v.title) : v.title;
+ prefix = (this.cursor === i ? color.cyan(figures.pointer) + " " : " ") + prefix;
+ if (v.description && this.cursor === i) {
+ desc = ` - ${v.description}`;
+ if (prefix.length + title.length + desc.length >= this.out.columns || v.description.split(/\r?\n/).length > 1) {
+ desc = "\n" + wrap2(v.description, {
+ margin: 3,
+ width: this.out.columns
+ });
+ }
+ }
+ }
+ this.outputText += `${prefix} ${title}${color.gray(desc)}
+`;
+ }
+ }
+ this.out.write(this.outputText);
+ }
+ };
+ __name(SelectPrompt, "SelectPrompt");
+ module2.exports = SelectPrompt;
+ }
+});
+
+// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/elements/toggle.js
+var require_toggle = __commonJS({
+ "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/elements/toggle.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var color = require_kleur();
+ var Prompt = require_prompt();
+ var _require = require_util7();
+ var style = _require.style;
+ var clear = _require.clear;
+ var _require2 = require_src();
+ var cursor = _require2.cursor;
+ var erase = _require2.erase;
+ var TogglePrompt = class extends Prompt {
+ constructor(opts = {}) {
+ super(opts);
+ this.msg = opts.message;
+ this.value = !!opts.initial;
+ this.active = opts.active || "on";
+ this.inactive = opts.inactive || "off";
+ this.initialValue = this.value;
+ this.render();
+ }
+ reset() {
+ this.value = this.initialValue;
+ this.fire();
+ this.render();
+ }
+ exit() {
+ this.abort();
+ }
+ abort() {
+ this.done = this.aborted = true;
+ this.fire();
+ this.render();
+ this.out.write("\n");
+ this.close();
+ }
+ submit() {
+ this.done = true;
+ this.aborted = false;
+ this.fire();
+ this.render();
+ this.out.write("\n");
+ this.close();
+ }
+ deactivate() {
+ if (this.value === false)
+ return this.bell();
+ this.value = false;
+ this.render();
+ }
+ activate() {
+ if (this.value === true)
+ return this.bell();
+ this.value = true;
+ this.render();
+ }
+ delete() {
+ this.deactivate();
+ }
+ left() {
+ this.deactivate();
+ }
+ right() {
+ this.activate();
+ }
+ down() {
+ this.deactivate();
+ }
+ up() {
+ this.activate();
+ }
+ next() {
+ this.value = !this.value;
+ this.fire();
+ this.render();
+ }
+ _(c, key) {
+ if (c === " ") {
+ this.value = !this.value;
+ } else if (c === "1") {
+ this.value = true;
+ } else if (c === "0") {
+ this.value = false;
+ } else
+ return this.bell();
+ this.render();
+ }
+ render() {
+ if (this.closed)
+ return;
+ if (this.firstRender)
+ this.out.write(cursor.hide);
+ else
+ this.out.write(clear(this.outputText, this.out.columns));
+ super.render();
+ this.outputText = [style.symbol(this.done, this.aborted), color.bold(this.msg), style.delimiter(this.done), this.value ? this.inactive : color.cyan().underline(this.inactive), color.gray("/"), this.value ? color.cyan().underline(this.active) : this.active].join(" ");
+ this.out.write(erase.line + cursor.to(0) + this.outputText);
+ }
+ };
+ __name(TogglePrompt, "TogglePrompt");
+ module2.exports = TogglePrompt;
+ }
+});
+
+// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/dateparts/datepart.js
+var require_datepart = __commonJS({
+ "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/dateparts/datepart.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var DatePart = class {
+ constructor({
+ token,
+ date,
+ parts,
+ locales
+ }) {
+ this.token = token;
+ this.date = date || /* @__PURE__ */ new Date();
+ this.parts = parts || [this];
+ this.locales = locales || {};
+ }
+ up() {
+ }
+ down() {
+ }
+ next() {
+ const currentIdx = this.parts.indexOf(this);
+ return this.parts.find((part, idx) => idx > currentIdx && part instanceof DatePart);
+ }
+ setTo(val) {
+ }
+ prev() {
+ let parts = [].concat(this.parts).reverse();
+ const currentIdx = parts.indexOf(this);
+ return parts.find((part, idx) => idx > currentIdx && part instanceof DatePart);
+ }
+ toString() {
+ return String(this.date);
+ }
+ };
+ __name(DatePart, "DatePart");
+ module2.exports = DatePart;
+ }
+});
+
+// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/dateparts/meridiem.js
+var require_meridiem = __commonJS({
+ "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/dateparts/meridiem.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var DatePart = require_datepart();
+ var Meridiem = class extends DatePart {
+ constructor(opts = {}) {
+ super(opts);
+ }
+ up() {
+ this.date.setHours((this.date.getHours() + 12) % 24);
+ }
+ down() {
+ this.up();
+ }
+ toString() {
+ let meridiem = this.date.getHours() > 12 ? "pm" : "am";
+ return /\A/.test(this.token) ? meridiem.toUpperCase() : meridiem;
+ }
+ };
+ __name(Meridiem, "Meridiem");
+ module2.exports = Meridiem;
+ }
+});
+
+// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/dateparts/day.js
+var require_day = __commonJS({
+ "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/dateparts/day.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var DatePart = require_datepart();
+ var pos = /* @__PURE__ */ __name((n) => {
+ n = n % 10;
+ return n === 1 ? "st" : n === 2 ? "nd" : n === 3 ? "rd" : "th";
+ }, "pos");
+ var Day = class extends DatePart {
+ constructor(opts = {}) {
+ super(opts);
+ }
+ up() {
+ this.date.setDate(this.date.getDate() + 1);
+ }
+ down() {
+ this.date.setDate(this.date.getDate() - 1);
+ }
+ setTo(val) {
+ this.date.setDate(parseInt(val.substr(-2)));
+ }
+ toString() {
+ let date = this.date.getDate();
+ let day2 = this.date.getDay();
+ return this.token === "DD" ? String(date).padStart(2, "0") : this.token === "Do" ? date + pos(date) : this.token === "d" ? day2 + 1 : this.token === "ddd" ? this.locales.weekdaysShort[day2] : this.token === "dddd" ? this.locales.weekdays[day2] : date;
+ }
+ };
+ __name(Day, "Day");
+ module2.exports = Day;
+ }
+});
+
+// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/dateparts/hours.js
+var require_hours = __commonJS({
+ "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/dateparts/hours.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var DatePart = require_datepart();
+ var Hours = class extends DatePart {
+ constructor(opts = {}) {
+ super(opts);
+ }
+ up() {
+ this.date.setHours(this.date.getHours() + 1);
+ }
+ down() {
+ this.date.setHours(this.date.getHours() - 1);
+ }
+ setTo(val) {
+ this.date.setHours(parseInt(val.substr(-2)));
+ }
+ toString() {
+ let hours = this.date.getHours();
+ if (/h/.test(this.token))
+ hours = hours % 12 || 12;
+ return this.token.length > 1 ? String(hours).padStart(2, "0") : hours;
+ }
+ };
+ __name(Hours, "Hours");
+ module2.exports = Hours;
+ }
+});
+
+// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/dateparts/milliseconds.js
+var require_milliseconds = __commonJS({
+ "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/dateparts/milliseconds.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var DatePart = require_datepart();
+ var Milliseconds = class extends DatePart {
+ constructor(opts = {}) {
+ super(opts);
+ }
+ up() {
+ this.date.setMilliseconds(this.date.getMilliseconds() + 1);
+ }
+ down() {
+ this.date.setMilliseconds(this.date.getMilliseconds() - 1);
+ }
+ setTo(val) {
+ this.date.setMilliseconds(parseInt(val.substr(-this.token.length)));
+ }
+ toString() {
+ return String(this.date.getMilliseconds()).padStart(4, "0").substr(0, this.token.length);
+ }
+ };
+ __name(Milliseconds, "Milliseconds");
+ module2.exports = Milliseconds;
+ }
+});
+
+// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/dateparts/minutes.js
+var require_minutes = __commonJS({
+ "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/dateparts/minutes.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var DatePart = require_datepart();
+ var Minutes = class extends DatePart {
+ constructor(opts = {}) {
+ super(opts);
+ }
+ up() {
+ this.date.setMinutes(this.date.getMinutes() + 1);
+ }
+ down() {
+ this.date.setMinutes(this.date.getMinutes() - 1);
+ }
+ setTo(val) {
+ this.date.setMinutes(parseInt(val.substr(-2)));
+ }
+ toString() {
+ let m = this.date.getMinutes();
+ return this.token.length > 1 ? String(m).padStart(2, "0") : m;
+ }
+ };
+ __name(Minutes, "Minutes");
+ module2.exports = Minutes;
+ }
+});
+
+// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/dateparts/month.js
+var require_month = __commonJS({
+ "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/dateparts/month.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var DatePart = require_datepart();
+ var Month = class extends DatePart {
+ constructor(opts = {}) {
+ super(opts);
+ }
+ up() {
+ this.date.setMonth(this.date.getMonth() + 1);
+ }
+ down() {
+ this.date.setMonth(this.date.getMonth() - 1);
+ }
+ setTo(val) {
+ val = parseInt(val.substr(-2)) - 1;
+ this.date.setMonth(val < 0 ? 0 : val);
+ }
+ toString() {
+ let month2 = this.date.getMonth();
+ let tl = this.token.length;
+ return tl === 2 ? String(month2 + 1).padStart(2, "0") : tl === 3 ? this.locales.monthsShort[month2] : tl === 4 ? this.locales.months[month2] : String(month2 + 1);
+ }
+ };
+ __name(Month, "Month");
+ module2.exports = Month;
+ }
+});
+
+// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/dateparts/seconds.js
+var require_seconds = __commonJS({
+ "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/dateparts/seconds.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var DatePart = require_datepart();
+ var Seconds = class extends DatePart {
+ constructor(opts = {}) {
+ super(opts);
+ }
+ up() {
+ this.date.setSeconds(this.date.getSeconds() + 1);
+ }
+ down() {
+ this.date.setSeconds(this.date.getSeconds() - 1);
+ }
+ setTo(val) {
+ this.date.setSeconds(parseInt(val.substr(-2)));
+ }
+ toString() {
+ let s = this.date.getSeconds();
+ return this.token.length > 1 ? String(s).padStart(2, "0") : s;
+ }
+ };
+ __name(Seconds, "Seconds");
+ module2.exports = Seconds;
+ }
+});
+
+// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/dateparts/year.js
+var require_year = __commonJS({
+ "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/dateparts/year.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var DatePart = require_datepart();
+ var Year = class extends DatePart {
+ constructor(opts = {}) {
+ super(opts);
+ }
+ up() {
+ this.date.setFullYear(this.date.getFullYear() + 1);
+ }
+ down() {
+ this.date.setFullYear(this.date.getFullYear() - 1);
+ }
+ setTo(val) {
+ this.date.setFullYear(val.substr(-4));
+ }
+ toString() {
+ let year2 = String(this.date.getFullYear()).padStart(4, "0");
+ return this.token.length === 2 ? year2.substr(-2) : year2;
+ }
+ };
+ __name(Year, "Year");
+ module2.exports = Year;
+ }
+});
+
+// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/dateparts/index.js
+var require_dateparts = __commonJS({
+ "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/dateparts/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ module2.exports = {
+ DatePart: require_datepart(),
+ Meridiem: require_meridiem(),
+ Day: require_day(),
+ Hours: require_hours(),
+ Milliseconds: require_milliseconds(),
+ Minutes: require_minutes(),
+ Month: require_month(),
+ Seconds: require_seconds(),
+ Year: require_year()
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/elements/date.js
+var require_date = __commonJS({
+ "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/elements/date.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ function asyncGeneratorStep(gen, resolve18, reject, _next, _throw, key, arg) {
+ try {
+ var info = gen[key](arg);
+ var value = info.value;
+ } catch (error) {
+ reject(error);
+ return;
+ }
+ if (info.done) {
+ resolve18(value);
+ } else {
+ Promise.resolve(value).then(_next, _throw);
+ }
+ }
+ __name(asyncGeneratorStep, "asyncGeneratorStep");
+ function _asyncToGenerator(fn2) {
+ return function() {
+ var self2 = this, args = arguments;
+ return new Promise(function(resolve18, reject) {
+ var gen = fn2.apply(self2, args);
+ function _next(value) {
+ asyncGeneratorStep(gen, resolve18, reject, _next, _throw, "next", value);
+ }
+ __name(_next, "_next");
+ function _throw(err) {
+ asyncGeneratorStep(gen, resolve18, reject, _next, _throw, "throw", err);
+ }
+ __name(_throw, "_throw");
+ _next(void 0);
+ });
+ };
+ }
+ __name(_asyncToGenerator, "_asyncToGenerator");
+ var color = require_kleur();
+ var Prompt = require_prompt();
+ var _require = require_util7();
+ var style = _require.style;
+ var clear = _require.clear;
+ var figures = _require.figures;
+ var _require2 = require_src();
+ var erase = _require2.erase;
+ var cursor = _require2.cursor;
+ var _require3 = require_dateparts();
+ var DatePart = _require3.DatePart;
+ var Meridiem = _require3.Meridiem;
+ var Day = _require3.Day;
+ var Hours = _require3.Hours;
+ var Milliseconds = _require3.Milliseconds;
+ var Minutes = _require3.Minutes;
+ var Month = _require3.Month;
+ var Seconds = _require3.Seconds;
+ var Year = _require3.Year;
+ var regex = /\\(.)|"((?:\\["\\]|[^"])+)"|(D[Do]?|d{3,4}|d)|(M{1,4})|(YY(?:YY)?)|([aA])|([Hh]{1,2})|(m{1,2})|(s{1,2})|(S{1,4})|./g;
+ var regexGroups = {
+ 1: ({
+ token
+ }) => token.replace(/\\(.)/g, "$1"),
+ 2: (opts) => new Day(opts),
+ // Day // TODO
+ 3: (opts) => new Month(opts),
+ // Month
+ 4: (opts) => new Year(opts),
+ // Year
+ 5: (opts) => new Meridiem(opts),
+ // AM/PM // TODO (special)
+ 6: (opts) => new Hours(opts),
+ // Hours
+ 7: (opts) => new Minutes(opts),
+ // Minutes
+ 8: (opts) => new Seconds(opts),
+ // Seconds
+ 9: (opts) => new Milliseconds(opts)
+ // Fractional seconds
+ };
+ var dfltLocales = {
+ months: "January,February,March,April,May,June,July,August,September,October,November,December".split(","),
+ monthsShort: "Jan,Feb,Mar,Apr,May,Jun,Jul,Aug,Sep,Oct,Nov,Dec".split(","),
+ weekdays: "Sunday,Monday,Tuesday,Wednesday,Thursday,Friday,Saturday".split(","),
+ weekdaysShort: "Sun,Mon,Tue,Wed,Thu,Fri,Sat".split(",")
+ };
+ var DatePrompt = class extends Prompt {
+ constructor(opts = {}) {
+ super(opts);
+ this.msg = opts.message;
+ this.cursor = 0;
+ this.typed = "";
+ this.locales = Object.assign(dfltLocales, opts.locales);
+ this._date = opts.initial || /* @__PURE__ */ new Date();
+ this.errorMsg = opts.error || "Please Enter A Valid Value";
+ this.validator = opts.validate || (() => true);
+ this.mask = opts.mask || "YYYY-MM-DD HH:mm:ss";
+ this.clear = clear("", this.out.columns);
+ this.render();
+ }
+ get value() {
+ return this.date;
+ }
+ get date() {
+ return this._date;
+ }
+ set date(date) {
+ if (date)
+ this._date.setTime(date.getTime());
+ }
+ set mask(mask) {
+ let result;
+ this.parts = [];
+ while (result = regex.exec(mask)) {
+ let match = result.shift();
+ let idx = result.findIndex((gr) => gr != null);
+ this.parts.push(idx in regexGroups ? regexGroups[idx]({
+ token: result[idx] || match,
+ date: this.date,
+ parts: this.parts,
+ locales: this.locales
+ }) : result[idx] || match);
+ }
+ let parts = this.parts.reduce((arr, i) => {
+ if (typeof i === "string" && typeof arr[arr.length - 1] === "string")
+ arr[arr.length - 1] += i;
+ else
+ arr.push(i);
+ return arr;
+ }, []);
+ this.parts.splice(0);
+ this.parts.push(...parts);
+ this.reset();
+ }
+ moveCursor(n) {
+ this.typed = "";
+ this.cursor = n;
+ this.fire();
+ }
+ reset() {
+ this.moveCursor(this.parts.findIndex((p) => p instanceof DatePart));
+ this.fire();
+ this.render();
+ }
+ exit() {
+ this.abort();
+ }
+ abort() {
+ this.done = this.aborted = true;
+ this.error = false;
+ this.fire();
+ this.render();
+ this.out.write("\n");
+ this.close();
+ }
+ validate() {
+ var _this = this;
+ return _asyncToGenerator(function* () {
+ let valid = yield _this.validator(_this.value);
+ if (typeof valid === "string") {
+ _this.errorMsg = valid;
+ valid = false;
+ }
+ _this.error = !valid;
+ })();
+ }
+ submit() {
+ var _this2 = this;
+ return _asyncToGenerator(function* () {
+ yield _this2.validate();
+ if (_this2.error) {
+ _this2.color = "red";
+ _this2.fire();
+ _this2.render();
+ return;
+ }
+ _this2.done = true;
+ _this2.aborted = false;
+ _this2.fire();
+ _this2.render();
+ _this2.out.write("\n");
+ _this2.close();
+ })();
+ }
+ up() {
+ this.typed = "";
+ this.parts[this.cursor].up();
+ this.render();
+ }
+ down() {
+ this.typed = "";
+ this.parts[this.cursor].down();
+ this.render();
+ }
+ left() {
+ let prev = this.parts[this.cursor].prev();
+ if (prev == null)
+ return this.bell();
+ this.moveCursor(this.parts.indexOf(prev));
+ this.render();
+ }
+ right() {
+ let next = this.parts[this.cursor].next();
+ if (next == null)
+ return this.bell();
+ this.moveCursor(this.parts.indexOf(next));
+ this.render();
+ }
+ next() {
+ let next = this.parts[this.cursor].next();
+ this.moveCursor(next ? this.parts.indexOf(next) : this.parts.findIndex((part) => part instanceof DatePart));
+ this.render();
+ }
+ _(c) {
+ if (/\d/.test(c)) {
+ this.typed += c;
+ this.parts[this.cursor].setTo(this.typed);
+ this.render();
+ }
+ }
+ render() {
+ if (this.closed)
+ return;
+ if (this.firstRender)
+ this.out.write(cursor.hide);
+ else
+ this.out.write(clear(this.outputText, this.out.columns));
+ super.render();
+ this.outputText = [style.symbol(this.done, this.aborted), color.bold(this.msg), style.delimiter(false), this.parts.reduce((arr, p, idx) => arr.concat(idx === this.cursor && !this.done ? color.cyan().underline(p.toString()) : p), []).join("")].join(" ");
+ if (this.error) {
+ this.outputText += this.errorMsg.split("\n").reduce((a, l, i) => a + `
+${i ? ` ` : figures.pointerSmall} ${color.red().italic(l)}`, ``);
+ }
+ this.out.write(erase.line + cursor.to(0) + this.outputText);
+ }
+ };
+ __name(DatePrompt, "DatePrompt");
+ module2.exports = DatePrompt;
+ }
+});
+
+// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/elements/number.js
+var require_number = __commonJS({
+ "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/elements/number.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ function asyncGeneratorStep(gen, resolve18, reject, _next, _throw, key, arg) {
+ try {
+ var info = gen[key](arg);
+ var value = info.value;
+ } catch (error) {
+ reject(error);
+ return;
+ }
+ if (info.done) {
+ resolve18(value);
+ } else {
+ Promise.resolve(value).then(_next, _throw);
+ }
+ }
+ __name(asyncGeneratorStep, "asyncGeneratorStep");
+ function _asyncToGenerator(fn2) {
+ return function() {
+ var self2 = this, args = arguments;
+ return new Promise(function(resolve18, reject) {
+ var gen = fn2.apply(self2, args);
+ function _next(value) {
+ asyncGeneratorStep(gen, resolve18, reject, _next, _throw, "next", value);
+ }
+ __name(_next, "_next");
+ function _throw(err) {
+ asyncGeneratorStep(gen, resolve18, reject, _next, _throw, "throw", err);
+ }
+ __name(_throw, "_throw");
+ _next(void 0);
+ });
+ };
+ }
+ __name(_asyncToGenerator, "_asyncToGenerator");
+ var color = require_kleur();
+ var Prompt = require_prompt();
+ var _require = require_src();
+ var cursor = _require.cursor;
+ var erase = _require.erase;
+ var _require2 = require_util7();
+ var style = _require2.style;
+ var figures = _require2.figures;
+ var clear = _require2.clear;
+ var lines = _require2.lines;
+ var isNumber = /[0-9]/;
+ var isDef = /* @__PURE__ */ __name((any) => any !== void 0, "isDef");
+ var round = /* @__PURE__ */ __name((number, precision) => {
+ let factor = Math.pow(10, precision);
+ return Math.round(number * factor) / factor;
+ }, "round");
+ var NumberPrompt = class extends Prompt {
+ constructor(opts = {}) {
+ super(opts);
+ this.transform = style.render(opts.style);
+ this.msg = opts.message;
+ this.initial = isDef(opts.initial) ? opts.initial : "";
+ this.float = !!opts.float;
+ this.round = opts.round || 2;
+ this.inc = opts.increment || 1;
+ this.min = isDef(opts.min) ? opts.min : -Infinity;
+ this.max = isDef(opts.max) ? opts.max : Infinity;
+ this.errorMsg = opts.error || `Please Enter A Valid Value`;
+ this.validator = opts.validate || (() => true);
+ this.color = `cyan`;
+ this.value = ``;
+ this.typed = ``;
+ this.lastHit = 0;
+ this.render();
+ }
+ set value(v) {
+ if (!v && v !== 0) {
+ this.placeholder = true;
+ this.rendered = color.gray(this.transform.render(`${this.initial}`));
+ this._value = ``;
+ } else {
+ this.placeholder = false;
+ this.rendered = this.transform.render(`${round(v, this.round)}`);
+ this._value = round(v, this.round);
+ }
+ this.fire();
+ }
+ get value() {
+ return this._value;
+ }
+ parse(x) {
+ return this.float ? parseFloat(x) : parseInt(x);
+ }
+ valid(c) {
+ return c === `-` || c === `.` && this.float || isNumber.test(c);
+ }
+ reset() {
+ this.typed = ``;
+ this.value = ``;
+ this.fire();
+ this.render();
+ }
+ exit() {
+ this.abort();
+ }
+ abort() {
+ let x = this.value;
+ this.value = x !== `` ? x : this.initial;
+ this.done = this.aborted = true;
+ this.error = false;
+ this.fire();
+ this.render();
+ this.out.write(`
+`);
+ this.close();
+ }
+ validate() {
+ var _this = this;
+ return _asyncToGenerator(function* () {
+ let valid = yield _this.validator(_this.value);
+ if (typeof valid === `string`) {
+ _this.errorMsg = valid;
+ valid = false;
+ }
+ _this.error = !valid;
+ })();
+ }
+ submit() {
+ var _this2 = this;
+ return _asyncToGenerator(function* () {
+ yield _this2.validate();
+ if (_this2.error) {
+ _this2.color = `red`;
+ _this2.fire();
+ _this2.render();
+ return;
+ }
+ let x = _this2.value;
+ _this2.value = x !== `` ? x : _this2.initial;
+ _this2.done = true;
+ _this2.aborted = false;
+ _this2.error = false;
+ _this2.fire();
+ _this2.render();
+ _this2.out.write(`
+`);
+ _this2.close();
+ })();
+ }
+ up() {
+ this.typed = ``;
+ if (this.value === "") {
+ this.value = this.min - this.inc;
+ }
+ if (this.value >= this.max)
+ return this.bell();
+ this.value += this.inc;
+ this.color = `cyan`;
+ this.fire();
+ this.render();
+ }
+ down() {
+ this.typed = ``;
+ if (this.value === "") {
+ this.value = this.min + this.inc;
+ }
+ if (this.value <= this.min)
+ return this.bell();
+ this.value -= this.inc;
+ this.color = `cyan`;
+ this.fire();
+ this.render();
+ }
+ delete() {
+ let val = this.value.toString();
+ if (val.length === 0)
+ return this.bell();
+ this.value = this.parse(val = val.slice(0, -1)) || ``;
+ if (this.value !== "" && this.value < this.min) {
+ this.value = this.min;
+ }
+ this.color = `cyan`;
+ this.fire();
+ this.render();
+ }
+ next() {
+ this.value = this.initial;
+ this.fire();
+ this.render();
+ }
+ _(c, key) {
+ if (!this.valid(c))
+ return this.bell();
+ const now = Date.now();
+ if (now - this.lastHit > 1e3)
+ this.typed = ``;
+ this.typed += c;
+ this.lastHit = now;
+ this.color = `cyan`;
+ if (c === `.`)
+ return this.fire();
+ this.value = Math.min(this.parse(this.typed), this.max);
+ if (this.value > this.max)
+ this.value = this.max;
+ if (this.value < this.min)
+ this.value = this.min;
+ this.fire();
+ this.render();
+ }
+ render() {
+ if (this.closed)
+ return;
+ if (!this.firstRender) {
+ if (this.outputError)
+ this.out.write(cursor.down(lines(this.outputError, this.out.columns) - 1) + clear(this.outputError, this.out.columns));
+ this.out.write(clear(this.outputText, this.out.columns));
+ }
+ super.render();
+ this.outputError = "";
+ this.outputText = [style.symbol(this.done, this.aborted), color.bold(this.msg), style.delimiter(this.done), !this.done || !this.done && !this.placeholder ? color[this.color]().underline(this.rendered) : this.rendered].join(` `);
+ if (this.error) {
+ this.outputError += this.errorMsg.split(`
+`).reduce((a, l, i) => a + `
+${i ? ` ` : figures.pointerSmall} ${color.red().italic(l)}`, ``);
+ }
+ this.out.write(erase.line + cursor.to(0) + this.outputText + cursor.save + this.outputError + cursor.restore);
+ }
+ };
+ __name(NumberPrompt, "NumberPrompt");
+ module2.exports = NumberPrompt;
+ }
+});
+
+// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/elements/multiselect.js
+var require_multiselect = __commonJS({
+ "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/elements/multiselect.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var color = require_kleur();
+ var _require = require_src();
+ var cursor = _require.cursor;
+ var Prompt = require_prompt();
+ var _require2 = require_util7();
+ var clear = _require2.clear;
+ var figures = _require2.figures;
+ var style = _require2.style;
+ var wrap2 = _require2.wrap;
+ var entriesToDisplay = _require2.entriesToDisplay;
+ var MultiselectPrompt = class extends Prompt {
+ constructor(opts = {}) {
+ super(opts);
+ this.msg = opts.message;
+ this.cursor = opts.cursor || 0;
+ this.scrollIndex = opts.cursor || 0;
+ this.hint = opts.hint || "";
+ this.warn = opts.warn || "- This option is disabled -";
+ this.minSelected = opts.min;
+ this.showMinError = false;
+ this.maxChoices = opts.max;
+ this.instructions = opts.instructions;
+ this.optionsPerPage = opts.optionsPerPage || 10;
+ this.value = opts.choices.map((ch, idx) => {
+ if (typeof ch === "string")
+ ch = {
+ title: ch,
+ value: idx
+ };
+ return {
+ title: ch && (ch.title || ch.value || ch),
+ description: ch && ch.description,
+ value: ch && (ch.value === void 0 ? idx : ch.value),
+ selected: ch && ch.selected,
+ disabled: ch && ch.disabled
+ };
+ });
+ this.clear = clear("", this.out.columns);
+ if (!opts.overrideRender) {
+ this.render();
+ }
+ }
+ reset() {
+ this.value.map((v) => !v.selected);
+ this.cursor = 0;
+ this.fire();
+ this.render();
+ }
+ selected() {
+ return this.value.filter((v) => v.selected);
+ }
+ exit() {
+ this.abort();
+ }
+ abort() {
+ this.done = this.aborted = true;
+ this.fire();
+ this.render();
+ this.out.write("\n");
+ this.close();
+ }
+ submit() {
+ const selected = this.value.filter((e2) => e2.selected);
+ if (this.minSelected && selected.length < this.minSelected) {
+ this.showMinError = true;
+ this.render();
+ } else {
+ this.done = true;
+ this.aborted = false;
+ this.fire();
+ this.render();
+ this.out.write("\n");
+ this.close();
+ }
+ }
+ first() {
+ this.cursor = 0;
+ this.render();
+ }
+ last() {
+ this.cursor = this.value.length - 1;
+ this.render();
+ }
+ next() {
+ this.cursor = (this.cursor + 1) % this.value.length;
+ this.render();
+ }
+ up() {
+ if (this.cursor === 0) {
+ this.cursor = this.value.length - 1;
+ } else {
+ this.cursor--;
+ }
+ this.render();
+ }
+ down() {
+ if (this.cursor === this.value.length - 1) {
+ this.cursor = 0;
+ } else {
+ this.cursor++;
+ }
+ this.render();
+ }
+ left() {
+ this.value[this.cursor].selected = false;
+ this.render();
+ }
+ right() {
+ if (this.value.filter((e2) => e2.selected).length >= this.maxChoices)
+ return this.bell();
+ this.value[this.cursor].selected = true;
+ this.render();
+ }
+ handleSpaceToggle() {
+ const v = this.value[this.cursor];
+ if (v.selected) {
+ v.selected = false;
+ this.render();
+ } else if (v.disabled || this.value.filter((e2) => e2.selected).length >= this.maxChoices) {
+ return this.bell();
+ } else {
+ v.selected = true;
+ this.render();
+ }
+ }
+ toggleAll() {
+ if (this.maxChoices !== void 0 || this.value[this.cursor].disabled) {
+ return this.bell();
+ }
+ const newSelected = !this.value[this.cursor].selected;
+ this.value.filter((v) => !v.disabled).forEach((v) => v.selected = newSelected);
+ this.render();
+ }
+ _(c, key) {
+ if (c === " ") {
+ this.handleSpaceToggle();
+ } else if (c === "a") {
+ this.toggleAll();
+ } else {
+ return this.bell();
+ }
+ }
+ renderInstructions() {
+ if (this.instructions === void 0 || this.instructions) {
+ if (typeof this.instructions === "string") {
+ return this.instructions;
+ }
+ return `
+Instructions:
+ ${figures.arrowUp}/${figures.arrowDown}: Highlight option
+ ${figures.arrowLeft}/${figures.arrowRight}/[space]: Toggle selection
+` + (this.maxChoices === void 0 ? ` a: Toggle all
+` : "") + ` enter/return: Complete answer`;
+ }
+ return "";
+ }
+ renderOption(cursor2, v, i, arrowIndicator) {
+ const prefix = (v.selected ? color.green(figures.radioOn) : figures.radioOff) + " " + arrowIndicator + " ";
+ let title, desc;
+ if (v.disabled) {
+ title = cursor2 === i ? color.gray().underline(v.title) : color.strikethrough().gray(v.title);
+ } else {
+ title = cursor2 === i ? color.cyan().underline(v.title) : v.title;
+ if (cursor2 === i && v.description) {
+ desc = ` - ${v.description}`;
+ if (prefix.length + title.length + desc.length >= this.out.columns || v.description.split(/\r?\n/).length > 1) {
+ desc = "\n" + wrap2(v.description, {
+ margin: prefix.length,
+ width: this.out.columns
+ });
+ }
+ }
+ }
+ return prefix + title + color.gray(desc || "");
+ }
+ // shared with autocompleteMultiselect
+ paginateOptions(options14) {
+ if (options14.length === 0) {
+ return color.red("No matches for this query.");
+ }
+ let _entriesToDisplay = entriesToDisplay(this.cursor, options14.length, this.optionsPerPage), startIndex = _entriesToDisplay.startIndex, endIndex = _entriesToDisplay.endIndex;
+ let prefix, styledOptions = [];
+ for (let i = startIndex; i < endIndex; i++) {
+ if (i === startIndex && startIndex > 0) {
+ prefix = figures.arrowUp;
+ } else if (i === endIndex - 1 && endIndex < options14.length) {
+ prefix = figures.arrowDown;
+ } else {
+ prefix = " ";
+ }
+ styledOptions.push(this.renderOption(this.cursor, options14[i], i, prefix));
+ }
+ return "\n" + styledOptions.join("\n");
+ }
+ // shared with autocomleteMultiselect
+ renderOptions(options14) {
+ if (!this.done) {
+ return this.paginateOptions(options14);
+ }
+ return "";
+ }
+ renderDoneOrInstructions() {
+ if (this.done) {
+ return this.value.filter((e2) => e2.selected).map((v) => v.title).join(", ");
+ }
+ const output = [color.gray(this.hint), this.renderInstructions()];
+ if (this.value[this.cursor].disabled) {
+ output.push(color.yellow(this.warn));
+ }
+ return output.join(" ");
+ }
+ render() {
+ if (this.closed)
+ return;
+ if (this.firstRender)
+ this.out.write(cursor.hide);
+ super.render();
+ let prompt2 = [style.symbol(this.done, this.aborted), color.bold(this.msg), style.delimiter(false), this.renderDoneOrInstructions()].join(" ");
+ if (this.showMinError) {
+ prompt2 += color.red(`You must select a minimum of ${this.minSelected} choices.`);
+ this.showMinError = false;
+ }
+ prompt2 += this.renderOptions(this.value);
+ this.out.write(this.clear + prompt2);
+ this.clear = clear(prompt2, this.out.columns);
+ }
+ };
+ __name(MultiselectPrompt, "MultiselectPrompt");
+ module2.exports = MultiselectPrompt;
+ }
+});
+
+// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/elements/autocomplete.js
+var require_autocomplete = __commonJS({
+ "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/elements/autocomplete.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ function asyncGeneratorStep(gen, resolve18, reject, _next, _throw, key, arg) {
+ try {
+ var info = gen[key](arg);
+ var value = info.value;
+ } catch (error) {
+ reject(error);
+ return;
+ }
+ if (info.done) {
+ resolve18(value);
+ } else {
+ Promise.resolve(value).then(_next, _throw);
+ }
+ }
+ __name(asyncGeneratorStep, "asyncGeneratorStep");
+ function _asyncToGenerator(fn2) {
+ return function() {
+ var self2 = this, args = arguments;
+ return new Promise(function(resolve18, reject) {
+ var gen = fn2.apply(self2, args);
+ function _next(value) {
+ asyncGeneratorStep(gen, resolve18, reject, _next, _throw, "next", value);
+ }
+ __name(_next, "_next");
+ function _throw(err) {
+ asyncGeneratorStep(gen, resolve18, reject, _next, _throw, "throw", err);
+ }
+ __name(_throw, "_throw");
+ _next(void 0);
+ });
+ };
+ }
+ __name(_asyncToGenerator, "_asyncToGenerator");
+ var color = require_kleur();
+ var Prompt = require_prompt();
+ var _require = require_src();
+ var erase = _require.erase;
+ var cursor = _require.cursor;
+ var _require2 = require_util7();
+ var style = _require2.style;
+ var clear = _require2.clear;
+ var figures = _require2.figures;
+ var wrap2 = _require2.wrap;
+ var entriesToDisplay = _require2.entriesToDisplay;
+ var getVal = /* @__PURE__ */ __name((arr, i) => arr[i] && (arr[i].value || arr[i].title || arr[i]), "getVal");
+ var getTitle = /* @__PURE__ */ __name((arr, i) => arr[i] && (arr[i].title || arr[i].value || arr[i]), "getTitle");
+ var getIndex = /* @__PURE__ */ __name((arr, valOrTitle) => {
+ const index = arr.findIndex((el) => el.value === valOrTitle || el.title === valOrTitle);
+ return index > -1 ? index : void 0;
+ }, "getIndex");
+ var AutocompletePrompt = class extends Prompt {
+ constructor(opts = {}) {
+ super(opts);
+ this.msg = opts.message;
+ this.suggest = opts.suggest;
+ this.choices = opts.choices;
+ this.initial = typeof opts.initial === "number" ? opts.initial : getIndex(opts.choices, opts.initial);
+ this.select = this.initial || opts.cursor || 0;
+ this.i18n = {
+ noMatches: opts.noMatches || "no matches found"
+ };
+ this.fallback = opts.fallback || this.initial;
+ this.clearFirst = opts.clearFirst || false;
+ this.suggestions = [];
+ this.input = "";
+ this.limit = opts.limit || 10;
+ this.cursor = 0;
+ this.transform = style.render(opts.style);
+ this.scale = this.transform.scale;
+ this.render = this.render.bind(this);
+ this.complete = this.complete.bind(this);
+ this.clear = clear("", this.out.columns);
+ this.complete(this.render);
+ this.render();
+ }
+ set fallback(fb) {
+ this._fb = Number.isSafeInteger(parseInt(fb)) ? parseInt(fb) : fb;
+ }
+ get fallback() {
+ let choice;
+ if (typeof this._fb === "number")
+ choice = this.choices[this._fb];
+ else if (typeof this._fb === "string")
+ choice = {
+ title: this._fb
+ };
+ return choice || this._fb || {
+ title: this.i18n.noMatches
+ };
+ }
+ moveSelect(i) {
+ this.select = i;
+ if (this.suggestions.length > 0)
+ this.value = getVal(this.suggestions, i);
+ else
+ this.value = this.fallback.value;
+ this.fire();
+ }
+ complete(cb) {
+ var _this = this;
+ return _asyncToGenerator(function* () {
+ const p = _this.completing = _this.suggest(_this.input, _this.choices);
+ const suggestions = yield p;
+ if (_this.completing !== p)
+ return;
+ _this.suggestions = suggestions.map((s, i, arr) => ({
+ title: getTitle(arr, i),
+ value: getVal(arr, i),
+ description: s.description
+ }));
+ _this.completing = false;
+ const l = Math.max(suggestions.length - 1, 0);
+ _this.moveSelect(Math.min(l, _this.select));
+ cb && cb();
+ })();
+ }
+ reset() {
+ this.input = "";
+ this.complete(() => {
+ this.moveSelect(this.initial !== void 0 ? this.initial : 0);
+ this.render();
+ });
+ this.render();
+ }
+ exit() {
+ if (this.clearFirst && this.input.length > 0) {
+ this.reset();
+ } else {
+ this.done = this.exited = true;
+ this.aborted = false;
+ this.fire();
+ this.render();
+ this.out.write("\n");
+ this.close();
+ }
+ }
+ abort() {
+ this.done = this.aborted = true;
+ this.exited = false;
+ this.fire();
+ this.render();
+ this.out.write("\n");
+ this.close();
+ }
+ submit() {
+ this.done = true;
+ this.aborted = this.exited = false;
+ this.fire();
+ this.render();
+ this.out.write("\n");
+ this.close();
+ }
+ _(c, key) {
+ let s1 = this.input.slice(0, this.cursor);
+ let s2 = this.input.slice(this.cursor);
+ this.input = `${s1}${c}${s2}`;
+ this.cursor = s1.length + 1;
+ this.complete(this.render);
+ this.render();
+ }
+ delete() {
+ if (this.cursor === 0)
+ return this.bell();
+ let s1 = this.input.slice(0, this.cursor - 1);
+ let s2 = this.input.slice(this.cursor);
+ this.input = `${s1}${s2}`;
+ this.complete(this.render);
+ this.cursor = this.cursor - 1;
+ this.render();
+ }
+ deleteForward() {
+ if (this.cursor * this.scale >= this.rendered.length)
+ return this.bell();
+ let s1 = this.input.slice(0, this.cursor);
+ let s2 = this.input.slice(this.cursor + 1);
+ this.input = `${s1}${s2}`;
+ this.complete(this.render);
+ this.render();
+ }
+ first() {
+ this.moveSelect(0);
+ this.render();
+ }
+ last() {
+ this.moveSelect(this.suggestions.length - 1);
+ this.render();
+ }
+ up() {
+ if (this.select === 0) {
+ this.moveSelect(this.suggestions.length - 1);
+ } else {
+ this.moveSelect(this.select - 1);
+ }
+ this.render();
+ }
+ down() {
+ if (this.select === this.suggestions.length - 1) {
+ this.moveSelect(0);
+ } else {
+ this.moveSelect(this.select + 1);
+ }
+ this.render();
+ }
+ next() {
+ if (this.select === this.suggestions.length - 1) {
+ this.moveSelect(0);
+ } else
+ this.moveSelect(this.select + 1);
+ this.render();
+ }
+ nextPage() {
+ this.moveSelect(Math.min(this.select + this.limit, this.suggestions.length - 1));
+ this.render();
+ }
+ prevPage() {
+ this.moveSelect(Math.max(this.select - this.limit, 0));
+ this.render();
+ }
+ left() {
+ if (this.cursor <= 0)
+ return this.bell();
+ this.cursor = this.cursor - 1;
+ this.render();
+ }
+ right() {
+ if (this.cursor * this.scale >= this.rendered.length)
+ return this.bell();
+ this.cursor = this.cursor + 1;
+ this.render();
+ }
+ renderOption(v, hovered, isStart, isEnd) {
+ let desc;
+ let prefix = isStart ? figures.arrowUp : isEnd ? figures.arrowDown : " ";
+ let title = hovered ? color.cyan().underline(v.title) : v.title;
+ prefix = (hovered ? color.cyan(figures.pointer) + " " : " ") + prefix;
+ if (v.description) {
+ desc = ` - ${v.description}`;
+ if (prefix.length + title.length + desc.length >= this.out.columns || v.description.split(/\r?\n/).length > 1) {
+ desc = "\n" + wrap2(v.description, {
+ margin: 3,
+ width: this.out.columns
+ });
+ }
+ }
+ return prefix + " " + title + color.gray(desc || "");
+ }
+ render() {
+ if (this.closed)
+ return;
+ if (this.firstRender)
+ this.out.write(cursor.hide);
+ else
+ this.out.write(clear(this.outputText, this.out.columns));
+ super.render();
+ let _entriesToDisplay = entriesToDisplay(this.select, this.choices.length, this.limit), startIndex = _entriesToDisplay.startIndex, endIndex = _entriesToDisplay.endIndex;
+ this.outputText = [style.symbol(this.done, this.aborted, this.exited), color.bold(this.msg), style.delimiter(this.completing), this.done && this.suggestions[this.select] ? this.suggestions[this.select].title : this.rendered = this.transform.render(this.input)].join(" ");
+ if (!this.done) {
+ const suggestions = this.suggestions.slice(startIndex, endIndex).map((item, i) => this.renderOption(item, this.select === i + startIndex, i === 0 && startIndex > 0, i + startIndex === endIndex - 1 && endIndex < this.choices.length)).join("\n");
+ this.outputText += `
+` + (suggestions || color.gray(this.fallback.title));
+ }
+ this.out.write(erase.line + cursor.to(0) + this.outputText);
+ }
+ };
+ __name(AutocompletePrompt, "AutocompletePrompt");
+ module2.exports = AutocompletePrompt;
+ }
+});
+
+// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/elements/autocompleteMultiselect.js
+var require_autocompleteMultiselect = __commonJS({
+ "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/elements/autocompleteMultiselect.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var color = require_kleur();
+ var _require = require_src();
+ var cursor = _require.cursor;
+ var MultiselectPrompt = require_multiselect();
+ var _require2 = require_util7();
+ var clear = _require2.clear;
+ var style = _require2.style;
+ var figures = _require2.figures;
+ var AutocompleteMultiselectPrompt = class extends MultiselectPrompt {
+ constructor(opts = {}) {
+ opts.overrideRender = true;
+ super(opts);
+ this.inputValue = "";
+ this.clear = clear("", this.out.columns);
+ this.filteredOptions = this.value;
+ this.render();
+ }
+ last() {
+ this.cursor = this.filteredOptions.length - 1;
+ this.render();
+ }
+ next() {
+ this.cursor = (this.cursor + 1) % this.filteredOptions.length;
+ this.render();
+ }
+ up() {
+ if (this.cursor === 0) {
+ this.cursor = this.filteredOptions.length - 1;
+ } else {
+ this.cursor--;
+ }
+ this.render();
+ }
+ down() {
+ if (this.cursor === this.filteredOptions.length - 1) {
+ this.cursor = 0;
+ } else {
+ this.cursor++;
+ }
+ this.render();
+ }
+ left() {
+ this.filteredOptions[this.cursor].selected = false;
+ this.render();
+ }
+ right() {
+ if (this.value.filter((e2) => e2.selected).length >= this.maxChoices)
+ return this.bell();
+ this.filteredOptions[this.cursor].selected = true;
+ this.render();
+ }
+ delete() {
+ if (this.inputValue.length) {
+ this.inputValue = this.inputValue.substr(0, this.inputValue.length - 1);
+ this.updateFilteredOptions();
+ }
+ }
+ updateFilteredOptions() {
+ const currentHighlight = this.filteredOptions[this.cursor];
+ this.filteredOptions = this.value.filter((v) => {
+ if (this.inputValue) {
+ if (typeof v.title === "string") {
+ if (v.title.toLowerCase().includes(this.inputValue.toLowerCase())) {
+ return true;
+ }
+ }
+ if (typeof v.value === "string") {
+ if (v.value.toLowerCase().includes(this.inputValue.toLowerCase())) {
+ return true;
+ }
+ }
+ return false;
+ }
+ return true;
+ });
+ const newHighlightIndex = this.filteredOptions.findIndex((v) => v === currentHighlight);
+ this.cursor = newHighlightIndex < 0 ? 0 : newHighlightIndex;
+ this.render();
+ }
+ handleSpaceToggle() {
+ const v = this.filteredOptions[this.cursor];
+ if (v.selected) {
+ v.selected = false;
+ this.render();
+ } else if (v.disabled || this.value.filter((e2) => e2.selected).length >= this.maxChoices) {
+ return this.bell();
+ } else {
+ v.selected = true;
+ this.render();
+ }
+ }
+ handleInputChange(c) {
+ this.inputValue = this.inputValue + c;
+ this.updateFilteredOptions();
+ }
+ _(c, key) {
+ if (c === " ") {
+ this.handleSpaceToggle();
+ } else {
+ this.handleInputChange(c);
+ }
+ }
+ renderInstructions() {
+ if (this.instructions === void 0 || this.instructions) {
+ if (typeof this.instructions === "string") {
+ return this.instructions;
+ }
+ return `
+Instructions:
+ ${figures.arrowUp}/${figures.arrowDown}: Highlight option
+ ${figures.arrowLeft}/${figures.arrowRight}/[space]: Toggle selection
+ [a,b,c]/delete: Filter choices
+ enter/return: Complete answer
+`;
+ }
+ return "";
+ }
+ renderCurrentInput() {
+ return `
+Filtered results for: ${this.inputValue ? this.inputValue : color.gray("Enter something to filter")}
+`;
+ }
+ renderOption(cursor2, v, i) {
+ let title;
+ if (v.disabled)
+ title = cursor2 === i ? color.gray().underline(v.title) : color.strikethrough().gray(v.title);
+ else
+ title = cursor2 === i ? color.cyan().underline(v.title) : v.title;
+ return (v.selected ? color.green(figures.radioOn) : figures.radioOff) + " " + title;
+ }
+ renderDoneOrInstructions() {
+ if (this.done) {
+ return this.value.filter((e2) => e2.selected).map((v) => v.title).join(", ");
+ }
+ const output = [color.gray(this.hint), this.renderInstructions(), this.renderCurrentInput()];
+ if (this.filteredOptions.length && this.filteredOptions[this.cursor].disabled) {
+ output.push(color.yellow(this.warn));
+ }
+ return output.join(" ");
+ }
+ render() {
+ if (this.closed)
+ return;
+ if (this.firstRender)
+ this.out.write(cursor.hide);
+ super.render();
+ let prompt2 = [style.symbol(this.done, this.aborted), color.bold(this.msg), style.delimiter(false), this.renderDoneOrInstructions()].join(" ");
+ if (this.showMinError) {
+ prompt2 += color.red(`You must select a minimum of ${this.minSelected} choices.`);
+ this.showMinError = false;
+ }
+ prompt2 += this.renderOptions(this.filteredOptions);
+ this.out.write(this.clear + prompt2);
+ this.clear = clear(prompt2, this.out.columns);
+ }
+ };
+ __name(AutocompleteMultiselectPrompt, "AutocompleteMultiselectPrompt");
+ module2.exports = AutocompleteMultiselectPrompt;
+ }
+});
+
+// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/elements/confirm.js
+var require_confirm = __commonJS({
+ "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/elements/confirm.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var color = require_kleur();
+ var Prompt = require_prompt();
+ var _require = require_util7();
+ var style = _require.style;
+ var clear = _require.clear;
+ var _require2 = require_src();
+ var erase = _require2.erase;
+ var cursor = _require2.cursor;
+ var ConfirmPrompt = class extends Prompt {
+ constructor(opts = {}) {
+ super(opts);
+ this.msg = opts.message;
+ this.value = opts.initial;
+ this.initialValue = !!opts.initial;
+ this.yesMsg = opts.yes || "yes";
+ this.yesOption = opts.yesOption || "(Y/n)";
+ this.noMsg = opts.no || "no";
+ this.noOption = opts.noOption || "(y/N)";
+ this.render();
+ }
+ reset() {
+ this.value = this.initialValue;
+ this.fire();
+ this.render();
+ }
+ exit() {
+ this.abort();
+ }
+ abort() {
+ this.done = this.aborted = true;
+ this.fire();
+ this.render();
+ this.out.write("\n");
+ this.close();
+ }
+ submit() {
+ this.value = this.value || false;
+ this.done = true;
+ this.aborted = false;
+ this.fire();
+ this.render();
+ this.out.write("\n");
+ this.close();
+ }
+ _(c, key) {
+ if (c.toLowerCase() === "y") {
+ this.value = true;
+ return this.submit();
+ }
+ if (c.toLowerCase() === "n") {
+ this.value = false;
+ return this.submit();
+ }
+ return this.bell();
+ }
+ render() {
+ if (this.closed)
+ return;
+ if (this.firstRender)
+ this.out.write(cursor.hide);
+ else
+ this.out.write(clear(this.outputText, this.out.columns));
+ super.render();
+ this.outputText = [style.symbol(this.done, this.aborted), color.bold(this.msg), style.delimiter(this.done), this.done ? this.value ? this.yesMsg : this.noMsg : color.gray(this.initialValue ? this.yesOption : this.noOption)].join(" ");
+ this.out.write(erase.line + cursor.to(0) + this.outputText);
+ }
+ };
+ __name(ConfirmPrompt, "ConfirmPrompt");
+ module2.exports = ConfirmPrompt;
+ }
+});
+
+// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/elements/index.js
+var require_elements = __commonJS({
+ "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/elements/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ module2.exports = {
+ TextPrompt: require_text(),
+ SelectPrompt: require_select(),
+ TogglePrompt: require_toggle(),
+ DatePrompt: require_date(),
+ NumberPrompt: require_number(),
+ MultiselectPrompt: require_multiselect(),
+ AutocompletePrompt: require_autocomplete(),
+ AutocompleteMultiselectPrompt: require_autocompleteMultiselect(),
+ ConfirmPrompt: require_confirm()
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/prompts.js
+var require_prompts = __commonJS({
+ "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/prompts.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ var $2 = exports2;
+ var el = require_elements();
+ var noop = /* @__PURE__ */ __name((v) => v, "noop");
+ function toPrompt(type, args, opts = {}) {
+ return new Promise((res, rej) => {
+ const p = new el[type](args);
+ const onAbort = opts.onAbort || noop;
+ const onSubmit = opts.onSubmit || noop;
+ const onExit7 = opts.onExit || noop;
+ p.on("state", args.onState || noop);
+ p.on("submit", (x) => res(onSubmit(x)));
+ p.on("exit", (x) => res(onExit7(x)));
+ p.on("abort", (x) => rej(onAbort(x)));
+ });
+ }
+ __name(toPrompt, "toPrompt");
+ $2.text = (args) => toPrompt("TextPrompt", args);
+ $2.password = (args) => {
+ args.style = "password";
+ return $2.text(args);
+ };
+ $2.invisible = (args) => {
+ args.style = "invisible";
+ return $2.text(args);
+ };
+ $2.number = (args) => toPrompt("NumberPrompt", args);
+ $2.date = (args) => toPrompt("DatePrompt", args);
+ $2.confirm = (args) => toPrompt("ConfirmPrompt", args);
+ $2.list = (args) => {
+ const sep2 = args.separator || ",";
+ return toPrompt("TextPrompt", args, {
+ onSubmit: (str) => str.split(sep2).map((s) => s.trim())
+ });
+ };
+ $2.toggle = (args) => toPrompt("TogglePrompt", args);
+ $2.select = (args) => toPrompt("SelectPrompt", args);
+ $2.multiselect = (args) => {
+ args.choices = [].concat(args.choices || []);
+ const toSelected = /* @__PURE__ */ __name((items) => items.filter((item) => item.selected).map((item) => item.value), "toSelected");
+ return toPrompt("MultiselectPrompt", args, {
+ onAbort: toSelected,
+ onSubmit: toSelected
+ });
+ };
+ $2.autocompleteMultiselect = (args) => {
+ args.choices = [].concat(args.choices || []);
+ const toSelected = /* @__PURE__ */ __name((items) => items.filter((item) => item.selected).map((item) => item.value), "toSelected");
+ return toPrompt("AutocompleteMultiselectPrompt", args, {
+ onAbort: toSelected,
+ onSubmit: toSelected
+ });
+ };
+ var byTitle = /* @__PURE__ */ __name((input, choices) => Promise.resolve(choices.filter((item) => item.title.slice(0, input.length).toLowerCase() === input.toLowerCase())), "byTitle");
+ $2.autocomplete = (args) => {
+ args.suggest = args.suggest || byTitle;
+ args.choices = [].concat(args.choices || []);
+ return toPrompt("AutocompletePrompt", args);
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/index.js
+var require_dist2 = __commonJS({
+ "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ function ownKeys11(object, enumerableOnly) {
+ var keys = Object.keys(object);
+ if (Object.getOwnPropertySymbols) {
+ var symbols = Object.getOwnPropertySymbols(object);
+ if (enumerableOnly) {
+ symbols = symbols.filter(function(sym) {
+ return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+ });
+ }
+ keys.push.apply(keys, symbols);
+ }
+ return keys;
+ }
+ __name(ownKeys11, "ownKeys");
+ function _objectSpread11(target) {
+ for (var i = 1; i < arguments.length; i++) {
+ var source = arguments[i] != null ? arguments[i] : {};
+ if (i % 2) {
+ ownKeys11(Object(source), true).forEach(function(key) {
+ _defineProperty11(target, key, source[key]);
+ });
+ } else if (Object.getOwnPropertyDescriptors) {
+ Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+ } else {
+ ownKeys11(Object(source)).forEach(function(key) {
+ Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+ });
+ }
+ }
+ return target;
+ }
+ __name(_objectSpread11, "_objectSpread");
+ function _defineProperty11(obj, key, value) {
+ if (key in obj) {
+ Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
+ } else {
+ obj[key] = value;
+ }
+ return obj;
+ }
+ __name(_defineProperty11, "_defineProperty");
+ function _createForOfIteratorHelper(o, allowArrayLike) {
+ var it2 = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
+ if (!it2) {
+ if (Array.isArray(o) || (it2 = _unsupportedIterableToArray4(o)) || allowArrayLike && o && typeof o.length === "number") {
+ if (it2)
+ o = it2;
+ var i = 0;
+ var F = /* @__PURE__ */ __name(function F2() {
+ }, "F");
+ return { s: F, n: /* @__PURE__ */ __name(function n() {
+ if (i >= o.length)
+ return { done: true };
+ return { done: false, value: o[i++] };
+ }, "n"), e: /* @__PURE__ */ __name(function e2(_e) {
+ throw _e;
+ }, "e"), f: F };
+ }
+ throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+ }
+ var normalCompletion = true, didErr = false, err;
+ return { s: /* @__PURE__ */ __name(function s() {
+ it2 = it2.call(o);
+ }, "s"), n: /* @__PURE__ */ __name(function n() {
+ var step = it2.next();
+ normalCompletion = step.done;
+ return step;
+ }, "n"), e: /* @__PURE__ */ __name(function e2(_e2) {
+ didErr = true;
+ err = _e2;
+ }, "e"), f: /* @__PURE__ */ __name(function f() {
+ try {
+ if (!normalCompletion && it2.return != null)
+ it2.return();
+ } finally {
+ if (didErr)
+ throw err;
+ }
+ }, "f") };
+ }
+ __name(_createForOfIteratorHelper, "_createForOfIteratorHelper");
+ function _unsupportedIterableToArray4(o, minLen) {
+ if (!o)
+ return;
+ if (typeof o === "string")
+ return _arrayLikeToArray4(o, minLen);
+ var n = Object.prototype.toString.call(o).slice(8, -1);
+ if (n === "Object" && o.constructor)
+ n = o.constructor.name;
+ if (n === "Map" || n === "Set")
+ return Array.from(o);
+ if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))
+ return _arrayLikeToArray4(o, minLen);
+ }
+ __name(_unsupportedIterableToArray4, "_unsupportedIterableToArray");
+ function _arrayLikeToArray4(arr, len) {
+ if (len == null || len > arr.length)
+ len = arr.length;
+ for (var i = 0, arr2 = new Array(len); i < len; i++)
+ arr2[i] = arr[i];
+ return arr2;
+ }
+ __name(_arrayLikeToArray4, "_arrayLikeToArray");
+ function asyncGeneratorStep(gen, resolve18, reject, _next, _throw, key, arg) {
+ try {
+ var info = gen[key](arg);
+ var value = info.value;
+ } catch (error) {
+ reject(error);
+ return;
+ }
+ if (info.done) {
+ resolve18(value);
+ } else {
+ Promise.resolve(value).then(_next, _throw);
+ }
+ }
+ __name(asyncGeneratorStep, "asyncGeneratorStep");
+ function _asyncToGenerator(fn2) {
+ return function() {
+ var self2 = this, args = arguments;
+ return new Promise(function(resolve18, reject) {
+ var gen = fn2.apply(self2, args);
+ function _next(value) {
+ asyncGeneratorStep(gen, resolve18, reject, _next, _throw, "next", value);
+ }
+ __name(_next, "_next");
+ function _throw(err) {
+ asyncGeneratorStep(gen, resolve18, reject, _next, _throw, "throw", err);
+ }
+ __name(_throw, "_throw");
+ _next(void 0);
+ });
+ };
+ }
+ __name(_asyncToGenerator, "_asyncToGenerator");
+ var prompts2 = require_prompts();
+ var passOn = ["suggest", "format", "onState", "validate", "onRender", "type"];
+ var noop = /* @__PURE__ */ __name(() => {
+ }, "noop");
+ function prompt2() {
+ return _prompt.apply(this, arguments);
+ }
+ __name(prompt2, "prompt");
+ function _prompt() {
+ _prompt = _asyncToGenerator(function* (questions = [], {
+ onSubmit = noop,
+ onCancel = noop
+ } = {}) {
+ const answers = {};
+ const override2 = prompt2._override || {};
+ questions = [].concat(questions);
+ let answer, question, quit, name, type, lastPrompt;
+ const getFormattedAnswer = /* @__PURE__ */ function() {
+ var _ref = _asyncToGenerator(function* (question2, answer2, skipValidation = false) {
+ if (!skipValidation && question2.validate && question2.validate(answer2) !== true) {
+ return;
+ }
+ return question2.format ? yield question2.format(answer2, answers) : answer2;
+ });
+ return /* @__PURE__ */ __name(function getFormattedAnswer2(_x, _x2) {
+ return _ref.apply(this, arguments);
+ }, "getFormattedAnswer");
+ }();
+ var _iterator = _createForOfIteratorHelper(questions), _step;
+ try {
+ for (_iterator.s(); !(_step = _iterator.n()).done; ) {
+ question = _step.value;
+ var _question = question;
+ name = _question.name;
+ type = _question.type;
+ if (typeof type === "function") {
+ type = yield type(answer, _objectSpread11({}, answers), question);
+ question["type"] = type;
+ }
+ if (!type)
+ continue;
+ for (let key in question) {
+ if (passOn.includes(key))
+ continue;
+ let value = question[key];
+ question[key] = typeof value === "function" ? yield value(answer, _objectSpread11({}, answers), lastPrompt) : value;
+ }
+ lastPrompt = question;
+ if (typeof question.message !== "string") {
+ throw new Error("prompt message is required");
+ }
+ var _question2 = question;
+ name = _question2.name;
+ type = _question2.type;
+ if (prompts2[type] === void 0) {
+ throw new Error(`prompt type (${type}) is not defined`);
+ }
+ if (override2[question.name] !== void 0) {
+ answer = yield getFormattedAnswer(question, override2[question.name]);
+ if (answer !== void 0) {
+ answers[name] = answer;
+ continue;
+ }
+ }
+ try {
+ answer = prompt2._injected ? getInjectedAnswer(prompt2._injected, question.initial) : yield prompts2[type](question);
+ answers[name] = answer = yield getFormattedAnswer(question, answer, true);
+ quit = yield onSubmit(question, answer, answers);
+ } catch (err) {
+ quit = !(yield onCancel(question, answers));
+ }
+ if (quit)
+ return answers;
+ }
+ } catch (err) {
+ _iterator.e(err);
+ } finally {
+ _iterator.f();
+ }
+ return answers;
+ });
+ return _prompt.apply(this, arguments);
+ }
+ __name(_prompt, "_prompt");
+ function getInjectedAnswer(injected, deafultValue) {
+ const answer = injected.shift();
+ if (answer instanceof Error) {
+ throw answer;
+ }
+ return answer === void 0 ? deafultValue : answer;
+ }
+ __name(getInjectedAnswer, "getInjectedAnswer");
+ function inject(answers) {
+ prompt2._injected = (prompt2._injected || []).concat(answers);
+ }
+ __name(inject, "inject");
+ function override(answers) {
+ prompt2._override = Object.assign({}, answers);
+ }
+ __name(override, "override");
+ module2.exports = Object.assign(prompt2, {
+ prompt: prompt2,
+ prompts: prompts2,
+ inject,
+ override
+ });
+ }
+});
+
+// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/util/action.js
+var require_action2 = __commonJS({
+ "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/util/action.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ module2.exports = (key, isSelect) => {
+ if (key.meta && key.name !== "escape")
+ return;
+ if (key.ctrl) {
+ if (key.name === "a")
+ return "first";
+ if (key.name === "c")
+ return "abort";
+ if (key.name === "d")
+ return "abort";
+ if (key.name === "e")
+ return "last";
+ if (key.name === "g")
+ return "reset";
+ }
+ if (isSelect) {
+ if (key.name === "j")
+ return "down";
+ if (key.name === "k")
+ return "up";
+ }
+ if (key.name === "return")
+ return "submit";
+ if (key.name === "enter")
+ return "submit";
+ if (key.name === "backspace")
+ return "delete";
+ if (key.name === "delete")
+ return "deleteForward";
+ if (key.name === "abort")
+ return "abort";
+ if (key.name === "escape")
+ return "exit";
+ if (key.name === "tab")
+ return "next";
+ if (key.name === "pagedown")
+ return "nextPage";
+ if (key.name === "pageup")
+ return "prevPage";
+ if (key.name === "home")
+ return "home";
+ if (key.name === "end")
+ return "end";
+ if (key.name === "up")
+ return "up";
+ if (key.name === "down")
+ return "down";
+ if (key.name === "right")
+ return "right";
+ if (key.name === "left")
+ return "left";
+ return false;
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/util/strip.js
+var require_strip2 = __commonJS({
+ "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/util/strip.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ module2.exports = (str) => {
+ const pattern = [
+ "[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)",
+ "(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PRZcf-ntqry=><~]))"
+ ].join("|");
+ const RGX = new RegExp(pattern, "g");
+ return typeof str === "string" ? str.replace(RGX, "") : str;
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/util/clear.js
+var require_clear2 = __commonJS({
+ "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/util/clear.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var strip = require_strip2();
+ var { erase, cursor } = require_src();
+ var width = /* @__PURE__ */ __name((str) => [...strip(str)].length, "width");
+ module2.exports = function(prompt2, perLine) {
+ if (!perLine)
+ return erase.line + cursor.to(0);
+ let rows = 0;
+ const lines = prompt2.split(/\r?\n/);
+ for (let line of lines) {
+ rows += 1 + Math.floor(Math.max(width(line) - 1, 0) / perLine);
+ }
+ return erase.lines(rows);
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/util/figures.js
+var require_figures2 = __commonJS({
+ "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/util/figures.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var main2 = {
+ arrowUp: "\u2191",
+ arrowDown: "\u2193",
+ arrowLeft: "\u2190",
+ arrowRight: "\u2192",
+ radioOn: "\u25C9",
+ radioOff: "\u25EF",
+ tick: "\u2714",
+ cross: "\u2716",
+ ellipsis: "\u2026",
+ pointerSmall: "\u203A",
+ line: "\u2500",
+ pointer: "\u276F"
+ };
+ var win = {
+ arrowUp: main2.arrowUp,
+ arrowDown: main2.arrowDown,
+ arrowLeft: main2.arrowLeft,
+ arrowRight: main2.arrowRight,
+ radioOn: "(*)",
+ radioOff: "( )",
+ tick: "\u221A",
+ cross: "\xD7",
+ ellipsis: "...",
+ pointerSmall: "\xBB",
+ line: "\u2500",
+ pointer: ">"
+ };
+ var figures = process.platform === "win32" ? win : main2;
+ module2.exports = figures;
+ }
+});
+
+// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/util/style.js
+var require_style2 = __commonJS({
+ "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/util/style.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var c = require_kleur();
+ var figures = require_figures2();
+ var styles = Object.freeze({
+ password: { scale: 1, render: (input) => "*".repeat(input.length) },
+ emoji: { scale: 2, render: (input) => "\u{1F603}".repeat(input.length) },
+ invisible: { scale: 0, render: (input) => "" },
+ default: { scale: 1, render: (input) => `${input}` }
+ });
+ var render7 = /* @__PURE__ */ __name((type) => styles[type] || styles.default, "render");
+ var symbols = Object.freeze({
+ aborted: c.red(figures.cross),
+ done: c.green(figures.tick),
+ exited: c.yellow(figures.cross),
+ default: c.cyan("?")
+ });
+ var symbol = /* @__PURE__ */ __name((done, aborted, exited) => aborted ? symbols.aborted : exited ? symbols.exited : done ? symbols.done : symbols.default, "symbol");
+ var delimiter = /* @__PURE__ */ __name((completing) => c.gray(completing ? figures.ellipsis : figures.pointerSmall), "delimiter");
+ var item = /* @__PURE__ */ __name((expandable, expanded) => c.gray(expandable ? expanded ? figures.pointerSmall : "+" : figures.line), "item");
+ module2.exports = {
+ styles,
+ render: render7,
+ symbols,
+ symbol,
+ delimiter,
+ item
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/util/lines.js
+var require_lines2 = __commonJS({
+ "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/util/lines.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var strip = require_strip2();
+ module2.exports = function(msg, perLine) {
+ let lines = String(strip(msg) || "").split(/\r?\n/);
+ if (!perLine)
+ return lines.length;
+ return lines.map((l) => Math.ceil(l.length / perLine)).reduce((a, b) => a + b);
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/util/wrap.js
+var require_wrap2 = __commonJS({
+ "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/util/wrap.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ module2.exports = (msg, opts = {}) => {
+ const tab = Number.isSafeInteger(parseInt(opts.margin)) ? new Array(parseInt(opts.margin)).fill(" ").join("") : opts.margin || "";
+ const width = opts.width;
+ return (msg || "").split(/\r?\n/g).map((line) => line.split(/\s+/g).reduce((arr, w) => {
+ if (w.length + tab.length >= width || arr[arr.length - 1].length + w.length + 1 < width)
+ arr[arr.length - 1] += ` ${w}`;
+ else
+ arr.push(`${tab}${w}`);
+ return arr;
+ }, [tab]).join("\n")).join("\n");
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/util/entriesToDisplay.js
+var require_entriesToDisplay2 = __commonJS({
+ "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/util/entriesToDisplay.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ module2.exports = (cursor, total, maxVisible) => {
+ maxVisible = maxVisible || total;
+ let startIndex = Math.min(total - maxVisible, cursor - Math.floor(maxVisible / 2));
+ if (startIndex < 0)
+ startIndex = 0;
+ let endIndex = Math.min(startIndex + maxVisible, total);
+ return { startIndex, endIndex };
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/util/index.js
+var require_util8 = __commonJS({
+ "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/util/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ module2.exports = {
+ action: require_action2(),
+ clear: require_clear2(),
+ style: require_style2(),
+ strip: require_strip2(),
+ figures: require_figures2(),
+ lines: require_lines2(),
+ wrap: require_wrap2(),
+ entriesToDisplay: require_entriesToDisplay2()
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/elements/prompt.js
+var require_prompt2 = __commonJS({
+ "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/elements/prompt.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var readline2 = require("readline");
+ var { action } = require_util8();
+ var EventEmitter3 = require("events");
+ var { beep, cursor } = require_src();
+ var color = require_kleur();
+ var Prompt = class extends EventEmitter3 {
+ constructor(opts = {}) {
+ super();
+ this.firstRender = true;
+ this.in = opts.stdin || process.stdin;
+ this.out = opts.stdout || process.stdout;
+ this.onRender = (opts.onRender || (() => void 0)).bind(this);
+ const rl = readline2.createInterface({ input: this.in, escapeCodeTimeout: 50 });
+ readline2.emitKeypressEvents(this.in, rl);
+ if (this.in.isTTY)
+ this.in.setRawMode(true);
+ const isSelect = ["SelectPrompt", "MultiselectPrompt"].indexOf(this.constructor.name) > -1;
+ const keypress = /* @__PURE__ */ __name((str, key) => {
+ let a = action(key, isSelect);
+ if (a === false) {
+ this._ && this._(str, key);
+ } else if (typeof this[a] === "function") {
+ this[a](key);
+ } else {
+ this.bell();
+ }
+ }, "keypress");
+ this.close = () => {
+ this.out.write(cursor.show);
+ this.in.removeListener("keypress", keypress);
+ if (this.in.isTTY)
+ this.in.setRawMode(false);
+ rl.close();
+ this.emit(this.aborted ? "abort" : this.exited ? "exit" : "submit", this.value);
+ this.closed = true;
+ };
+ this.in.on("keypress", keypress);
+ }
+ fire() {
+ this.emit("state", {
+ value: this.value,
+ aborted: !!this.aborted,
+ exited: !!this.exited
+ });
+ }
+ bell() {
+ this.out.write(beep);
+ }
+ render() {
+ this.onRender(color);
+ if (this.firstRender)
+ this.firstRender = false;
+ }
+ };
+ __name(Prompt, "Prompt");
+ module2.exports = Prompt;
+ }
+});
+
+// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/elements/text.js
+var require_text2 = __commonJS({
+ "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/elements/text.js"(exports2, module2) {
+ init_import_meta_url();
+ var color = require_kleur();
+ var Prompt = require_prompt2();
+ var { erase, cursor } = require_src();
+ var { style, clear, lines, figures } = require_util8();
+ var TextPrompt = class extends Prompt {
+ constructor(opts = {}) {
+ super(opts);
+ this.transform = style.render(opts.style);
+ this.scale = this.transform.scale;
+ this.msg = opts.message;
+ this.initial = opts.initial || ``;
+ this.validator = opts.validate || (() => true);
+ this.value = ``;
+ this.errorMsg = opts.error || `Please Enter A Valid Value`;
+ this.cursor = Number(!!this.initial);
+ this.cursorOffset = 0;
+ this.clear = clear(``, this.out.columns);
+ this.render();
+ }
+ set value(v) {
+ if (!v && this.initial) {
+ this.placeholder = true;
+ this.rendered = color.gray(this.transform.render(this.initial));
+ } else {
+ this.placeholder = false;
+ this.rendered = this.transform.render(v);
+ }
+ this._value = v;
+ this.fire();
+ }
+ get value() {
+ return this._value;
+ }
+ reset() {
+ this.value = ``;
+ this.cursor = Number(!!this.initial);
+ this.cursorOffset = 0;
+ this.fire();
+ this.render();
+ }
+ exit() {
+ this.abort();
+ }
+ abort() {
+ this.value = this.value || this.initial;
+ this.done = this.aborted = true;
+ this.error = false;
+ this.red = false;
+ this.fire();
+ this.render();
+ this.out.write("\n");
+ this.close();
+ }
+ async validate() {
+ let valid = await this.validator(this.value);
+ if (typeof valid === `string`) {
+ this.errorMsg = valid;
+ valid = false;
+ }
+ this.error = !valid;
+ }
+ async submit() {
+ this.value = this.value || this.initial;
+ this.cursorOffset = 0;
+ this.cursor = this.rendered.length;
+ await this.validate();
+ if (this.error) {
+ this.red = true;
+ this.fire();
+ this.render();
+ return;
+ }
+ this.done = true;
+ this.aborted = false;
+ this.fire();
+ this.render();
+ this.out.write("\n");
+ this.close();
+ }
+ next() {
+ if (!this.placeholder)
+ return this.bell();
+ this.value = this.initial;
+ this.cursor = this.rendered.length;
+ this.fire();
+ this.render();
+ }
+ moveCursor(n) {
+ if (this.placeholder)
+ return;
+ this.cursor = this.cursor + n;
+ this.cursorOffset += n;
+ }
+ _(c, key) {
+ let s1 = this.value.slice(0, this.cursor);
+ let s2 = this.value.slice(this.cursor);
+ this.value = `${s1}${c}${s2}`;
+ this.red = false;
+ this.cursor = this.placeholder ? 0 : s1.length + 1;
+ this.render();
+ }
+ delete() {
+ if (this.isCursorAtStart())
+ return this.bell();
+ let s1 = this.value.slice(0, this.cursor - 1);
+ let s2 = this.value.slice(this.cursor);
+ this.value = `${s1}${s2}`;
+ this.red = false;
+ if (this.isCursorAtStart()) {
+ this.cursorOffset = 0;
+ } else {
+ this.cursorOffset++;
+ this.moveCursor(-1);
+ }
+ this.render();
+ }
+ deleteForward() {
+ if (this.cursor * this.scale >= this.rendered.length || this.placeholder)
+ return this.bell();
+ let s1 = this.value.slice(0, this.cursor);
+ let s2 = this.value.slice(this.cursor + 1);
+ this.value = `${s1}${s2}`;
+ this.red = false;
+ if (this.isCursorAtEnd()) {
+ this.cursorOffset = 0;
+ } else {
+ this.cursorOffset++;
+ }
+ this.render();
+ }
+ first() {
+ this.cursor = 0;
+ this.render();
+ }
+ last() {
+ this.cursor = this.value.length;
+ this.render();
+ }
+ left() {
+ if (this.cursor <= 0 || this.placeholder)
+ return this.bell();
+ this.moveCursor(-1);
+ this.render();
+ }
+ right() {
+ if (this.cursor * this.scale >= this.rendered.length || this.placeholder)
+ return this.bell();
+ this.moveCursor(1);
+ this.render();
+ }
+ isCursorAtStart() {
+ return this.cursor === 0 || this.placeholder && this.cursor === 1;
+ }
+ isCursorAtEnd() {
+ return this.cursor === this.rendered.length || this.placeholder && this.cursor === this.rendered.length + 1;
+ }
+ render() {
+ if (this.closed)
+ return;
+ if (!this.firstRender) {
+ if (this.outputError)
+ this.out.write(cursor.down(lines(this.outputError, this.out.columns) - 1) + clear(this.outputError, this.out.columns));
+ this.out.write(clear(this.outputText, this.out.columns));
+ }
+ super.render();
+ this.outputError = "";
+ this.outputText = [
+ style.symbol(this.done, this.aborted),
+ color.bold(this.msg),
+ style.delimiter(this.done),
+ this.red ? color.red(this.rendered) : this.rendered
+ ].join(` `);
+ if (this.error) {
+ this.outputError += this.errorMsg.split(`
+`).reduce((a, l, i) => a + `
+${i ? " " : figures.pointerSmall} ${color.red().italic(l)}`, ``);
+ }
+ this.out.write(erase.line + cursor.to(0) + this.outputText + cursor.save + this.outputError + cursor.restore + cursor.move(this.cursorOffset, 0));
+ }
+ };
+ __name(TextPrompt, "TextPrompt");
+ module2.exports = TextPrompt;
+ }
+});
+
+// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/elements/select.js
+var require_select2 = __commonJS({
+ "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/elements/select.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var color = require_kleur();
+ var Prompt = require_prompt2();
+ var { style, clear, figures, wrap: wrap2, entriesToDisplay } = require_util8();
+ var { cursor } = require_src();
+ var SelectPrompt = class extends Prompt {
+ constructor(opts = {}) {
+ super(opts);
+ this.msg = opts.message;
+ this.hint = opts.hint || "- Use arrow-keys. Return to submit.";
+ this.warn = opts.warn || "- This option is disabled";
+ this.cursor = opts.initial || 0;
+ this.choices = opts.choices.map((ch, idx) => {
+ if (typeof ch === "string")
+ ch = { title: ch, value: idx };
+ return {
+ title: ch && (ch.title || ch.value || ch),
+ value: ch && (ch.value === void 0 ? idx : ch.value),
+ description: ch && ch.description,
+ selected: ch && ch.selected,
+ disabled: ch && ch.disabled
+ };
+ });
+ this.optionsPerPage = opts.optionsPerPage || 10;
+ this.value = (this.choices[this.cursor] || {}).value;
+ this.clear = clear("", this.out.columns);
+ this.render();
+ }
+ moveCursor(n) {
+ this.cursor = n;
+ this.value = this.choices[n].value;
+ this.fire();
+ }
+ reset() {
+ this.moveCursor(0);
+ this.fire();
+ this.render();
+ }
+ exit() {
+ this.abort();
+ }
+ abort() {
+ this.done = this.aborted = true;
+ this.fire();
+ this.render();
+ this.out.write("\n");
+ this.close();
+ }
+ submit() {
+ if (!this.selection.disabled) {
+ this.done = true;
+ this.aborted = false;
+ this.fire();
+ this.render();
+ this.out.write("\n");
+ this.close();
+ } else
+ this.bell();
+ }
+ first() {
+ this.moveCursor(0);
+ this.render();
+ }
+ last() {
+ this.moveCursor(this.choices.length - 1);
+ this.render();
+ }
+ up() {
+ if (this.cursor === 0) {
+ this.moveCursor(this.choices.length - 1);
+ } else {
+ this.moveCursor(this.cursor - 1);
+ }
+ this.render();
+ }
+ down() {
+ if (this.cursor === this.choices.length - 1) {
+ this.moveCursor(0);
+ } else {
+ this.moveCursor(this.cursor + 1);
+ }
+ this.render();
+ }
+ next() {
+ this.moveCursor((this.cursor + 1) % this.choices.length);
+ this.render();
+ }
+ _(c, key) {
+ if (c === " ")
+ return this.submit();
+ }
+ get selection() {
+ return this.choices[this.cursor];
+ }
+ render() {
+ if (this.closed)
+ return;
+ if (this.firstRender)
+ this.out.write(cursor.hide);
+ else
+ this.out.write(clear(this.outputText, this.out.columns));
+ super.render();
+ let { startIndex, endIndex } = entriesToDisplay(this.cursor, this.choices.length, this.optionsPerPage);
+ this.outputText = [
+ style.symbol(this.done, this.aborted),
+ color.bold(this.msg),
+ style.delimiter(false),
+ this.done ? this.selection.title : this.selection.disabled ? color.yellow(this.warn) : color.gray(this.hint)
+ ].join(" ");
+ if (!this.done) {
+ this.outputText += "\n";
+ for (let i = startIndex; i < endIndex; i++) {
+ let title, prefix, desc = "", v = this.choices[i];
+ if (i === startIndex && startIndex > 0) {
+ prefix = figures.arrowUp;
+ } else if (i === endIndex - 1 && endIndex < this.choices.length) {
+ prefix = figures.arrowDown;
+ } else {
+ prefix = " ";
+ }
+ if (v.disabled) {
+ title = this.cursor === i ? color.gray().underline(v.title) : color.strikethrough().gray(v.title);
+ prefix = (this.cursor === i ? color.bold().gray(figures.pointer) + " " : " ") + prefix;
+ } else {
+ title = this.cursor === i ? color.cyan().underline(v.title) : v.title;
+ prefix = (this.cursor === i ? color.cyan(figures.pointer) + " " : " ") + prefix;
+ if (v.description && this.cursor === i) {
+ desc = ` - ${v.description}`;
+ if (prefix.length + title.length + desc.length >= this.out.columns || v.description.split(/\r?\n/).length > 1) {
+ desc = "\n" + wrap2(v.description, { margin: 3, width: this.out.columns });
+ }
+ }
+ }
+ this.outputText += `${prefix} ${title}${color.gray(desc)}
+`;
+ }
+ }
+ this.out.write(this.outputText);
+ }
+ };
+ __name(SelectPrompt, "SelectPrompt");
+ module2.exports = SelectPrompt;
+ }
+});
+
+// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/elements/toggle.js
+var require_toggle2 = __commonJS({
+ "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/elements/toggle.js"(exports2, module2) {
+ init_import_meta_url();
+ var color = require_kleur();
+ var Prompt = require_prompt2();
+ var { style, clear } = require_util8();
+ var { cursor, erase } = require_src();
+ var TogglePrompt = class extends Prompt {
+ constructor(opts = {}) {
+ super(opts);
+ this.msg = opts.message;
+ this.value = !!opts.initial;
+ this.active = opts.active || "on";
+ this.inactive = opts.inactive || "off";
+ this.initialValue = this.value;
+ this.render();
+ }
+ reset() {
+ this.value = this.initialValue;
+ this.fire();
+ this.render();
+ }
+ exit() {
+ this.abort();
+ }
+ abort() {
+ this.done = this.aborted = true;
+ this.fire();
+ this.render();
+ this.out.write("\n");
+ this.close();
+ }
+ submit() {
+ this.done = true;
+ this.aborted = false;
+ this.fire();
+ this.render();
+ this.out.write("\n");
+ this.close();
+ }
+ deactivate() {
+ if (this.value === false)
+ return this.bell();
+ this.value = false;
+ this.render();
+ }
+ activate() {
+ if (this.value === true)
+ return this.bell();
+ this.value = true;
+ this.render();
+ }
+ delete() {
+ this.deactivate();
+ }
+ left() {
+ this.deactivate();
+ }
+ right() {
+ this.activate();
+ }
+ down() {
+ this.deactivate();
+ }
+ up() {
+ this.activate();
+ }
+ next() {
+ this.value = !this.value;
+ this.fire();
+ this.render();
+ }
+ _(c, key) {
+ if (c === " ") {
+ this.value = !this.value;
+ } else if (c === "1") {
+ this.value = true;
+ } else if (c === "0") {
+ this.value = false;
+ } else
+ return this.bell();
+ this.render();
+ }
+ render() {
+ if (this.closed)
+ return;
+ if (this.firstRender)
+ this.out.write(cursor.hide);
+ else
+ this.out.write(clear(this.outputText, this.out.columns));
+ super.render();
+ this.outputText = [
+ style.symbol(this.done, this.aborted),
+ color.bold(this.msg),
+ style.delimiter(this.done),
+ this.value ? this.inactive : color.cyan().underline(this.inactive),
+ color.gray("/"),
+ this.value ? color.cyan().underline(this.active) : this.active
+ ].join(" ");
+ this.out.write(erase.line + cursor.to(0) + this.outputText);
+ }
+ };
+ __name(TogglePrompt, "TogglePrompt");
+ module2.exports = TogglePrompt;
+ }
+});
+
+// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/dateparts/datepart.js
+var require_datepart2 = __commonJS({
+ "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/dateparts/datepart.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var DatePart = class {
+ constructor({ token, date, parts, locales }) {
+ this.token = token;
+ this.date = date || /* @__PURE__ */ new Date();
+ this.parts = parts || [this];
+ this.locales = locales || {};
+ }
+ up() {
+ }
+ down() {
+ }
+ next() {
+ const currentIdx = this.parts.indexOf(this);
+ return this.parts.find((part, idx) => idx > currentIdx && part instanceof DatePart);
+ }
+ setTo(val) {
+ }
+ prev() {
+ let parts = [].concat(this.parts).reverse();
+ const currentIdx = parts.indexOf(this);
+ return parts.find((part, idx) => idx > currentIdx && part instanceof DatePart);
+ }
+ toString() {
+ return String(this.date);
+ }
+ };
+ __name(DatePart, "DatePart");
+ module2.exports = DatePart;
+ }
+});
+
+// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/dateparts/meridiem.js
+var require_meridiem2 = __commonJS({
+ "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/dateparts/meridiem.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var DatePart = require_datepart2();
+ var Meridiem = class extends DatePart {
+ constructor(opts = {}) {
+ super(opts);
+ }
+ up() {
+ this.date.setHours((this.date.getHours() + 12) % 24);
+ }
+ down() {
+ this.up();
+ }
+ toString() {
+ let meridiem = this.date.getHours() > 12 ? "pm" : "am";
+ return /\A/.test(this.token) ? meridiem.toUpperCase() : meridiem;
+ }
+ };
+ __name(Meridiem, "Meridiem");
+ module2.exports = Meridiem;
+ }
+});
+
+// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/dateparts/day.js
+var require_day2 = __commonJS({
+ "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/dateparts/day.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var DatePart = require_datepart2();
+ var pos = /* @__PURE__ */ __name((n) => {
+ n = n % 10;
+ return n === 1 ? "st" : n === 2 ? "nd" : n === 3 ? "rd" : "th";
+ }, "pos");
+ var Day = class extends DatePart {
+ constructor(opts = {}) {
+ super(opts);
+ }
+ up() {
+ this.date.setDate(this.date.getDate() + 1);
+ }
+ down() {
+ this.date.setDate(this.date.getDate() - 1);
+ }
+ setTo(val) {
+ this.date.setDate(parseInt(val.substr(-2)));
+ }
+ toString() {
+ let date = this.date.getDate();
+ let day2 = this.date.getDay();
+ return this.token === "DD" ? String(date).padStart(2, "0") : this.token === "Do" ? date + pos(date) : this.token === "d" ? day2 + 1 : this.token === "ddd" ? this.locales.weekdaysShort[day2] : this.token === "dddd" ? this.locales.weekdays[day2] : date;
+ }
+ };
+ __name(Day, "Day");
+ module2.exports = Day;
+ }
+});
+
+// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/dateparts/hours.js
+var require_hours2 = __commonJS({
+ "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/dateparts/hours.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var DatePart = require_datepart2();
+ var Hours = class extends DatePart {
+ constructor(opts = {}) {
+ super(opts);
+ }
+ up() {
+ this.date.setHours(this.date.getHours() + 1);
+ }
+ down() {
+ this.date.setHours(this.date.getHours() - 1);
+ }
+ setTo(val) {
+ this.date.setHours(parseInt(val.substr(-2)));
+ }
+ toString() {
+ let hours = this.date.getHours();
+ if (/h/.test(this.token))
+ hours = hours % 12 || 12;
+ return this.token.length > 1 ? String(hours).padStart(2, "0") : hours;
+ }
+ };
+ __name(Hours, "Hours");
+ module2.exports = Hours;
+ }
+});
+
+// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/dateparts/milliseconds.js
+var require_milliseconds2 = __commonJS({
+ "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/dateparts/milliseconds.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var DatePart = require_datepart2();
+ var Milliseconds = class extends DatePart {
+ constructor(opts = {}) {
+ super(opts);
+ }
+ up() {
+ this.date.setMilliseconds(this.date.getMilliseconds() + 1);
+ }
+ down() {
+ this.date.setMilliseconds(this.date.getMilliseconds() - 1);
+ }
+ setTo(val) {
+ this.date.setMilliseconds(parseInt(val.substr(-this.token.length)));
+ }
+ toString() {
+ return String(this.date.getMilliseconds()).padStart(4, "0").substr(0, this.token.length);
+ }
+ };
+ __name(Milliseconds, "Milliseconds");
+ module2.exports = Milliseconds;
+ }
+});
+
+// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/dateparts/minutes.js
+var require_minutes2 = __commonJS({
+ "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/dateparts/minutes.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var DatePart = require_datepart2();
+ var Minutes = class extends DatePart {
+ constructor(opts = {}) {
+ super(opts);
+ }
+ up() {
+ this.date.setMinutes(this.date.getMinutes() + 1);
+ }
+ down() {
+ this.date.setMinutes(this.date.getMinutes() - 1);
+ }
+ setTo(val) {
+ this.date.setMinutes(parseInt(val.substr(-2)));
+ }
+ toString() {
+ let m = this.date.getMinutes();
+ return this.token.length > 1 ? String(m).padStart(2, "0") : m;
+ }
+ };
+ __name(Minutes, "Minutes");
+ module2.exports = Minutes;
+ }
+});
+
+// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/dateparts/month.js
+var require_month2 = __commonJS({
+ "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/dateparts/month.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var DatePart = require_datepart2();
+ var Month = class extends DatePart {
+ constructor(opts = {}) {
+ super(opts);
+ }
+ up() {
+ this.date.setMonth(this.date.getMonth() + 1);
+ }
+ down() {
+ this.date.setMonth(this.date.getMonth() - 1);
+ }
+ setTo(val) {
+ val = parseInt(val.substr(-2)) - 1;
+ this.date.setMonth(val < 0 ? 0 : val);
+ }
+ toString() {
+ let month2 = this.date.getMonth();
+ let tl = this.token.length;
+ return tl === 2 ? String(month2 + 1).padStart(2, "0") : tl === 3 ? this.locales.monthsShort[month2] : tl === 4 ? this.locales.months[month2] : String(month2 + 1);
+ }
+ };
+ __name(Month, "Month");
+ module2.exports = Month;
+ }
+});
+
+// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/dateparts/seconds.js
+var require_seconds2 = __commonJS({
+ "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/dateparts/seconds.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var DatePart = require_datepart2();
+ var Seconds = class extends DatePart {
+ constructor(opts = {}) {
+ super(opts);
+ }
+ up() {
+ this.date.setSeconds(this.date.getSeconds() + 1);
+ }
+ down() {
+ this.date.setSeconds(this.date.getSeconds() - 1);
+ }
+ setTo(val) {
+ this.date.setSeconds(parseInt(val.substr(-2)));
+ }
+ toString() {
+ let s = this.date.getSeconds();
+ return this.token.length > 1 ? String(s).padStart(2, "0") : s;
+ }
+ };
+ __name(Seconds, "Seconds");
+ module2.exports = Seconds;
+ }
+});
+
+// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/dateparts/year.js
+var require_year2 = __commonJS({
+ "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/dateparts/year.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var DatePart = require_datepart2();
+ var Year = class extends DatePart {
+ constructor(opts = {}) {
+ super(opts);
+ }
+ up() {
+ this.date.setFullYear(this.date.getFullYear() + 1);
+ }
+ down() {
+ this.date.setFullYear(this.date.getFullYear() - 1);
+ }
+ setTo(val) {
+ this.date.setFullYear(val.substr(-4));
+ }
+ toString() {
+ let year2 = String(this.date.getFullYear()).padStart(4, "0");
+ return this.token.length === 2 ? year2.substr(-2) : year2;
+ }
+ };
+ __name(Year, "Year");
+ module2.exports = Year;
+ }
+});
+
+// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/dateparts/index.js
+var require_dateparts2 = __commonJS({
+ "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/dateparts/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ module2.exports = {
+ DatePart: require_datepart2(),
+ Meridiem: require_meridiem2(),
+ Day: require_day2(),
+ Hours: require_hours2(),
+ Milliseconds: require_milliseconds2(),
+ Minutes: require_minutes2(),
+ Month: require_month2(),
+ Seconds: require_seconds2(),
+ Year: require_year2()
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/elements/date.js
+var require_date2 = __commonJS({
+ "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/elements/date.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var color = require_kleur();
+ var Prompt = require_prompt2();
+ var { style, clear, figures } = require_util8();
+ var { erase, cursor } = require_src();
+ var { DatePart, Meridiem, Day, Hours, Milliseconds, Minutes, Month, Seconds, Year } = require_dateparts2();
+ var regex = /\\(.)|"((?:\\["\\]|[^"])+)"|(D[Do]?|d{3,4}|d)|(M{1,4})|(YY(?:YY)?)|([aA])|([Hh]{1,2})|(m{1,2})|(s{1,2})|(S{1,4})|./g;
+ var regexGroups = {
+ 1: ({ token }) => token.replace(/\\(.)/g, "$1"),
+ 2: (opts) => new Day(opts),
+ // Day // TODO
+ 3: (opts) => new Month(opts),
+ // Month
+ 4: (opts) => new Year(opts),
+ // Year
+ 5: (opts) => new Meridiem(opts),
+ // AM/PM // TODO (special)
+ 6: (opts) => new Hours(opts),
+ // Hours
+ 7: (opts) => new Minutes(opts),
+ // Minutes
+ 8: (opts) => new Seconds(opts),
+ // Seconds
+ 9: (opts) => new Milliseconds(opts)
+ // Fractional seconds
+ };
+ var dfltLocales = {
+ months: "January,February,March,April,May,June,July,August,September,October,November,December".split(","),
+ monthsShort: "Jan,Feb,Mar,Apr,May,Jun,Jul,Aug,Sep,Oct,Nov,Dec".split(","),
+ weekdays: "Sunday,Monday,Tuesday,Wednesday,Thursday,Friday,Saturday".split(","),
+ weekdaysShort: "Sun,Mon,Tue,Wed,Thu,Fri,Sat".split(",")
+ };
+ var DatePrompt = class extends Prompt {
+ constructor(opts = {}) {
+ super(opts);
+ this.msg = opts.message;
+ this.cursor = 0;
+ this.typed = "";
+ this.locales = Object.assign(dfltLocales, opts.locales);
+ this._date = opts.initial || /* @__PURE__ */ new Date();
+ this.errorMsg = opts.error || "Please Enter A Valid Value";
+ this.validator = opts.validate || (() => true);
+ this.mask = opts.mask || "YYYY-MM-DD HH:mm:ss";
+ this.clear = clear("", this.out.columns);
+ this.render();
+ }
+ get value() {
+ return this.date;
+ }
+ get date() {
+ return this._date;
+ }
+ set date(date) {
+ if (date)
+ this._date.setTime(date.getTime());
+ }
+ set mask(mask) {
+ let result;
+ this.parts = [];
+ while (result = regex.exec(mask)) {
+ let match = result.shift();
+ let idx = result.findIndex((gr) => gr != null);
+ this.parts.push(idx in regexGroups ? regexGroups[idx]({ token: result[idx] || match, date: this.date, parts: this.parts, locales: this.locales }) : result[idx] || match);
+ }
+ let parts = this.parts.reduce((arr, i) => {
+ if (typeof i === "string" && typeof arr[arr.length - 1] === "string")
+ arr[arr.length - 1] += i;
+ else
+ arr.push(i);
+ return arr;
+ }, []);
+ this.parts.splice(0);
+ this.parts.push(...parts);
+ this.reset();
+ }
+ moveCursor(n) {
+ this.typed = "";
+ this.cursor = n;
+ this.fire();
+ }
+ reset() {
+ this.moveCursor(this.parts.findIndex((p) => p instanceof DatePart));
+ this.fire();
+ this.render();
+ }
+ exit() {
+ this.abort();
+ }
+ abort() {
+ this.done = this.aborted = true;
+ this.error = false;
+ this.fire();
+ this.render();
+ this.out.write("\n");
+ this.close();
+ }
+ async validate() {
+ let valid = await this.validator(this.value);
+ if (typeof valid === "string") {
+ this.errorMsg = valid;
+ valid = false;
+ }
+ this.error = !valid;
+ }
+ async submit() {
+ await this.validate();
+ if (this.error) {
+ this.color = "red";
+ this.fire();
+ this.render();
+ return;
+ }
+ this.done = true;
+ this.aborted = false;
+ this.fire();
+ this.render();
+ this.out.write("\n");
+ this.close();
+ }
+ up() {
+ this.typed = "";
+ this.parts[this.cursor].up();
+ this.render();
+ }
+ down() {
+ this.typed = "";
+ this.parts[this.cursor].down();
+ this.render();
+ }
+ left() {
+ let prev = this.parts[this.cursor].prev();
+ if (prev == null)
+ return this.bell();
+ this.moveCursor(this.parts.indexOf(prev));
+ this.render();
+ }
+ right() {
+ let next = this.parts[this.cursor].next();
+ if (next == null)
+ return this.bell();
+ this.moveCursor(this.parts.indexOf(next));
+ this.render();
+ }
+ next() {
+ let next = this.parts[this.cursor].next();
+ this.moveCursor(next ? this.parts.indexOf(next) : this.parts.findIndex((part) => part instanceof DatePart));
+ this.render();
+ }
+ _(c) {
+ if (/\d/.test(c)) {
+ this.typed += c;
+ this.parts[this.cursor].setTo(this.typed);
+ this.render();
+ }
+ }
+ render() {
+ if (this.closed)
+ return;
+ if (this.firstRender)
+ this.out.write(cursor.hide);
+ else
+ this.out.write(clear(this.outputText, this.out.columns));
+ super.render();
+ this.outputText = [
+ style.symbol(this.done, this.aborted),
+ color.bold(this.msg),
+ style.delimiter(false),
+ this.parts.reduce((arr, p, idx) => arr.concat(idx === this.cursor && !this.done ? color.cyan().underline(p.toString()) : p), []).join("")
+ ].join(" ");
+ if (this.error) {
+ this.outputText += this.errorMsg.split("\n").reduce(
+ (a, l, i) => a + `
+${i ? ` ` : figures.pointerSmall} ${color.red().italic(l)}`,
+ ``
+ );
+ }
+ this.out.write(erase.line + cursor.to(0) + this.outputText);
+ }
+ };
+ __name(DatePrompt, "DatePrompt");
+ module2.exports = DatePrompt;
+ }
+});
+
+// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/elements/number.js
+var require_number2 = __commonJS({
+ "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/elements/number.js"(exports2, module2) {
+ init_import_meta_url();
+ var color = require_kleur();
+ var Prompt = require_prompt2();
+ var { cursor, erase } = require_src();
+ var { style, figures, clear, lines } = require_util8();
+ var isNumber = /[0-9]/;
+ var isDef = /* @__PURE__ */ __name((any) => any !== void 0, "isDef");
+ var round = /* @__PURE__ */ __name((number, precision) => {
+ let factor = Math.pow(10, precision);
+ return Math.round(number * factor) / factor;
+ }, "round");
+ var NumberPrompt = class extends Prompt {
+ constructor(opts = {}) {
+ super(opts);
+ this.transform = style.render(opts.style);
+ this.msg = opts.message;
+ this.initial = isDef(opts.initial) ? opts.initial : "";
+ this.float = !!opts.float;
+ this.round = opts.round || 2;
+ this.inc = opts.increment || 1;
+ this.min = isDef(opts.min) ? opts.min : -Infinity;
+ this.max = isDef(opts.max) ? opts.max : Infinity;
+ this.errorMsg = opts.error || `Please Enter A Valid Value`;
+ this.validator = opts.validate || (() => true);
+ this.color = `cyan`;
+ this.value = ``;
+ this.typed = ``;
+ this.lastHit = 0;
+ this.render();
+ }
+ set value(v) {
+ if (!v && v !== 0) {
+ this.placeholder = true;
+ this.rendered = color.gray(this.transform.render(`${this.initial}`));
+ this._value = ``;
+ } else {
+ this.placeholder = false;
+ this.rendered = this.transform.render(`${round(v, this.round)}`);
+ this._value = round(v, this.round);
+ }
+ this.fire();
+ }
+ get value() {
+ return this._value;
+ }
+ parse(x) {
+ return this.float ? parseFloat(x) : parseInt(x);
+ }
+ valid(c) {
+ return c === `-` || c === `.` && this.float || isNumber.test(c);
+ }
+ reset() {
+ this.typed = ``;
+ this.value = ``;
+ this.fire();
+ this.render();
+ }
+ exit() {
+ this.abort();
+ }
+ abort() {
+ let x = this.value;
+ this.value = x !== `` ? x : this.initial;
+ this.done = this.aborted = true;
+ this.error = false;
+ this.fire();
+ this.render();
+ this.out.write(`
+`);
+ this.close();
+ }
+ async validate() {
+ let valid = await this.validator(this.value);
+ if (typeof valid === `string`) {
+ this.errorMsg = valid;
+ valid = false;
+ }
+ this.error = !valid;
+ }
+ async submit() {
+ await this.validate();
+ if (this.error) {
+ this.color = `red`;
+ this.fire();
+ this.render();
+ return;
+ }
+ let x = this.value;
+ this.value = x !== `` ? x : this.initial;
+ this.done = true;
+ this.aborted = false;
+ this.error = false;
+ this.fire();
+ this.render();
+ this.out.write(`
+`);
+ this.close();
+ }
+ up() {
+ this.typed = ``;
+ if (this.value === "") {
+ this.value = this.min - this.inc;
+ }
+ if (this.value >= this.max)
+ return this.bell();
+ this.value += this.inc;
+ this.color = `cyan`;
+ this.fire();
+ this.render();
+ }
+ down() {
+ this.typed = ``;
+ if (this.value === "") {
+ this.value = this.min + this.inc;
+ }
+ if (this.value <= this.min)
+ return this.bell();
+ this.value -= this.inc;
+ this.color = `cyan`;
+ this.fire();
+ this.render();
+ }
+ delete() {
+ let val = this.value.toString();
+ if (val.length === 0)
+ return this.bell();
+ this.value = this.parse(val = val.slice(0, -1)) || ``;
+ if (this.value !== "" && this.value < this.min) {
+ this.value = this.min;
+ }
+ this.color = `cyan`;
+ this.fire();
+ this.render();
+ }
+ next() {
+ this.value = this.initial;
+ this.fire();
+ this.render();
+ }
+ _(c, key) {
+ if (!this.valid(c))
+ return this.bell();
+ const now = Date.now();
+ if (now - this.lastHit > 1e3)
+ this.typed = ``;
+ this.typed += c;
+ this.lastHit = now;
+ this.color = `cyan`;
+ if (c === `.`)
+ return this.fire();
+ this.value = Math.min(this.parse(this.typed), this.max);
+ if (this.value > this.max)
+ this.value = this.max;
+ if (this.value < this.min)
+ this.value = this.min;
+ this.fire();
+ this.render();
+ }
+ render() {
+ if (this.closed)
+ return;
+ if (!this.firstRender) {
+ if (this.outputError)
+ this.out.write(cursor.down(lines(this.outputError, this.out.columns) - 1) + clear(this.outputError, this.out.columns));
+ this.out.write(clear(this.outputText, this.out.columns));
+ }
+ super.render();
+ this.outputError = "";
+ this.outputText = [
+ style.symbol(this.done, this.aborted),
+ color.bold(this.msg),
+ style.delimiter(this.done),
+ !this.done || !this.done && !this.placeholder ? color[this.color]().underline(this.rendered) : this.rendered
+ ].join(` `);
+ if (this.error) {
+ this.outputError += this.errorMsg.split(`
+`).reduce((a, l, i) => a + `
+${i ? ` ` : figures.pointerSmall} ${color.red().italic(l)}`, ``);
+ }
+ this.out.write(erase.line + cursor.to(0) + this.outputText + cursor.save + this.outputError + cursor.restore);
+ }
+ };
+ __name(NumberPrompt, "NumberPrompt");
+ module2.exports = NumberPrompt;
+ }
+});
+
+// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/elements/multiselect.js
+var require_multiselect2 = __commonJS({
+ "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/elements/multiselect.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var color = require_kleur();
+ var { cursor } = require_src();
+ var Prompt = require_prompt2();
+ var { clear, figures, style, wrap: wrap2, entriesToDisplay } = require_util8();
+ var MultiselectPrompt = class extends Prompt {
+ constructor(opts = {}) {
+ super(opts);
+ this.msg = opts.message;
+ this.cursor = opts.cursor || 0;
+ this.scrollIndex = opts.cursor || 0;
+ this.hint = opts.hint || "";
+ this.warn = opts.warn || "- This option is disabled -";
+ this.minSelected = opts.min;
+ this.showMinError = false;
+ this.maxChoices = opts.max;
+ this.instructions = opts.instructions;
+ this.optionsPerPage = opts.optionsPerPage || 10;
+ this.value = opts.choices.map((ch, idx) => {
+ if (typeof ch === "string")
+ ch = { title: ch, value: idx };
+ return {
+ title: ch && (ch.title || ch.value || ch),
+ description: ch && ch.description,
+ value: ch && (ch.value === void 0 ? idx : ch.value),
+ selected: ch && ch.selected,
+ disabled: ch && ch.disabled
+ };
+ });
+ this.clear = clear("", this.out.columns);
+ if (!opts.overrideRender) {
+ this.render();
+ }
+ }
+ reset() {
+ this.value.map((v) => !v.selected);
+ this.cursor = 0;
+ this.fire();
+ this.render();
+ }
+ selected() {
+ return this.value.filter((v) => v.selected);
+ }
+ exit() {
+ this.abort();
+ }
+ abort() {
+ this.done = this.aborted = true;
+ this.fire();
+ this.render();
+ this.out.write("\n");
+ this.close();
+ }
+ submit() {
+ const selected = this.value.filter((e2) => e2.selected);
+ if (this.minSelected && selected.length < this.minSelected) {
+ this.showMinError = true;
+ this.render();
+ } else {
+ this.done = true;
+ this.aborted = false;
+ this.fire();
+ this.render();
+ this.out.write("\n");
+ this.close();
+ }
+ }
+ first() {
+ this.cursor = 0;
+ this.render();
+ }
+ last() {
+ this.cursor = this.value.length - 1;
+ this.render();
+ }
+ next() {
+ this.cursor = (this.cursor + 1) % this.value.length;
+ this.render();
+ }
+ up() {
+ if (this.cursor === 0) {
+ this.cursor = this.value.length - 1;
+ } else {
+ this.cursor--;
+ }
+ this.render();
+ }
+ down() {
+ if (this.cursor === this.value.length - 1) {
+ this.cursor = 0;
+ } else {
+ this.cursor++;
+ }
+ this.render();
+ }
+ left() {
+ this.value[this.cursor].selected = false;
+ this.render();
+ }
+ right() {
+ if (this.value.filter((e2) => e2.selected).length >= this.maxChoices)
+ return this.bell();
+ this.value[this.cursor].selected = true;
+ this.render();
+ }
+ handleSpaceToggle() {
+ const v = this.value[this.cursor];
+ if (v.selected) {
+ v.selected = false;
+ this.render();
+ } else if (v.disabled || this.value.filter((e2) => e2.selected).length >= this.maxChoices) {
+ return this.bell();
+ } else {
+ v.selected = true;
+ this.render();
+ }
+ }
+ toggleAll() {
+ if (this.maxChoices !== void 0 || this.value[this.cursor].disabled) {
+ return this.bell();
+ }
+ const newSelected = !this.value[this.cursor].selected;
+ this.value.filter((v) => !v.disabled).forEach((v) => v.selected = newSelected);
+ this.render();
+ }
+ _(c, key) {
+ if (c === " ") {
+ this.handleSpaceToggle();
+ } else if (c === "a") {
+ this.toggleAll();
+ } else {
+ return this.bell();
+ }
+ }
+ renderInstructions() {
+ if (this.instructions === void 0 || this.instructions) {
+ if (typeof this.instructions === "string") {
+ return this.instructions;
+ }
+ return `
+Instructions:
+ ${figures.arrowUp}/${figures.arrowDown}: Highlight option
+ ${figures.arrowLeft}/${figures.arrowRight}/[space]: Toggle selection
+` + (this.maxChoices === void 0 ? ` a: Toggle all
+` : "") + ` enter/return: Complete answer`;
+ }
+ return "";
+ }
+ renderOption(cursor2, v, i, arrowIndicator) {
+ const prefix = (v.selected ? color.green(figures.radioOn) : figures.radioOff) + " " + arrowIndicator + " ";
+ let title, desc;
+ if (v.disabled) {
+ title = cursor2 === i ? color.gray().underline(v.title) : color.strikethrough().gray(v.title);
+ } else {
+ title = cursor2 === i ? color.cyan().underline(v.title) : v.title;
+ if (cursor2 === i && v.description) {
+ desc = ` - ${v.description}`;
+ if (prefix.length + title.length + desc.length >= this.out.columns || v.description.split(/\r?\n/).length > 1) {
+ desc = "\n" + wrap2(v.description, { margin: prefix.length, width: this.out.columns });
+ }
+ }
+ }
+ return prefix + title + color.gray(desc || "");
+ }
+ // shared with autocompleteMultiselect
+ paginateOptions(options14) {
+ if (options14.length === 0) {
+ return color.red("No matches for this query.");
+ }
+ let { startIndex, endIndex } = entriesToDisplay(this.cursor, options14.length, this.optionsPerPage);
+ let prefix, styledOptions = [];
+ for (let i = startIndex; i < endIndex; i++) {
+ if (i === startIndex && startIndex > 0) {
+ prefix = figures.arrowUp;
+ } else if (i === endIndex - 1 && endIndex < options14.length) {
+ prefix = figures.arrowDown;
+ } else {
+ prefix = " ";
+ }
+ styledOptions.push(this.renderOption(this.cursor, options14[i], i, prefix));
+ }
+ return "\n" + styledOptions.join("\n");
+ }
+ // shared with autocomleteMultiselect
+ renderOptions(options14) {
+ if (!this.done) {
+ return this.paginateOptions(options14);
+ }
+ return "";
+ }
+ renderDoneOrInstructions() {
+ if (this.done) {
+ return this.value.filter((e2) => e2.selected).map((v) => v.title).join(", ");
+ }
+ const output = [color.gray(this.hint), this.renderInstructions()];
+ if (this.value[this.cursor].disabled) {
+ output.push(color.yellow(this.warn));
+ }
+ return output.join(" ");
+ }
+ render() {
+ if (this.closed)
+ return;
+ if (this.firstRender)
+ this.out.write(cursor.hide);
+ super.render();
+ let prompt2 = [
+ style.symbol(this.done, this.aborted),
+ color.bold(this.msg),
+ style.delimiter(false),
+ this.renderDoneOrInstructions()
+ ].join(" ");
+ if (this.showMinError) {
+ prompt2 += color.red(`You must select a minimum of ${this.minSelected} choices.`);
+ this.showMinError = false;
+ }
+ prompt2 += this.renderOptions(this.value);
+ this.out.write(this.clear + prompt2);
+ this.clear = clear(prompt2, this.out.columns);
+ }
+ };
+ __name(MultiselectPrompt, "MultiselectPrompt");
+ module2.exports = MultiselectPrompt;
+ }
+});
+
+// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/elements/autocomplete.js
+var require_autocomplete2 = __commonJS({
+ "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/elements/autocomplete.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var color = require_kleur();
+ var Prompt = require_prompt2();
+ var { erase, cursor } = require_src();
+ var { style, clear, figures, wrap: wrap2, entriesToDisplay } = require_util8();
+ var getVal = /* @__PURE__ */ __name((arr, i) => arr[i] && (arr[i].value || arr[i].title || arr[i]), "getVal");
+ var getTitle = /* @__PURE__ */ __name((arr, i) => arr[i] && (arr[i].title || arr[i].value || arr[i]), "getTitle");
+ var getIndex = /* @__PURE__ */ __name((arr, valOrTitle) => {
+ const index = arr.findIndex((el) => el.value === valOrTitle || el.title === valOrTitle);
+ return index > -1 ? index : void 0;
+ }, "getIndex");
+ var AutocompletePrompt = class extends Prompt {
+ constructor(opts = {}) {
+ super(opts);
+ this.msg = opts.message;
+ this.suggest = opts.suggest;
+ this.choices = opts.choices;
+ this.initial = typeof opts.initial === "number" ? opts.initial : getIndex(opts.choices, opts.initial);
+ this.select = this.initial || opts.cursor || 0;
+ this.i18n = { noMatches: opts.noMatches || "no matches found" };
+ this.fallback = opts.fallback || this.initial;
+ this.clearFirst = opts.clearFirst || false;
+ this.suggestions = [];
+ this.input = "";
+ this.limit = opts.limit || 10;
+ this.cursor = 0;
+ this.transform = style.render(opts.style);
+ this.scale = this.transform.scale;
+ this.render = this.render.bind(this);
+ this.complete = this.complete.bind(this);
+ this.clear = clear("", this.out.columns);
+ this.complete(this.render);
+ this.render();
+ }
+ set fallback(fb) {
+ this._fb = Number.isSafeInteger(parseInt(fb)) ? parseInt(fb) : fb;
+ }
+ get fallback() {
+ let choice;
+ if (typeof this._fb === "number")
+ choice = this.choices[this._fb];
+ else if (typeof this._fb === "string")
+ choice = { title: this._fb };
+ return choice || this._fb || { title: this.i18n.noMatches };
+ }
+ moveSelect(i) {
+ this.select = i;
+ if (this.suggestions.length > 0)
+ this.value = getVal(this.suggestions, i);
+ else
+ this.value = this.fallback.value;
+ this.fire();
+ }
+ async complete(cb) {
+ const p = this.completing = this.suggest(this.input, this.choices);
+ const suggestions = await p;
+ if (this.completing !== p)
+ return;
+ this.suggestions = suggestions.map((s, i, arr) => ({ title: getTitle(arr, i), value: getVal(arr, i), description: s.description }));
+ this.completing = false;
+ const l = Math.max(suggestions.length - 1, 0);
+ this.moveSelect(Math.min(l, this.select));
+ cb && cb();
+ }
+ reset() {
+ this.input = "";
+ this.complete(() => {
+ this.moveSelect(this.initial !== void 0 ? this.initial : 0);
+ this.render();
+ });
+ this.render();
+ }
+ exit() {
+ if (this.clearFirst && this.input.length > 0) {
+ this.reset();
+ } else {
+ this.done = this.exited = true;
+ this.aborted = false;
+ this.fire();
+ this.render();
+ this.out.write("\n");
+ this.close();
+ }
+ }
+ abort() {
+ this.done = this.aborted = true;
+ this.exited = false;
+ this.fire();
+ this.render();
+ this.out.write("\n");
+ this.close();
+ }
+ submit() {
+ this.done = true;
+ this.aborted = this.exited = false;
+ this.fire();
+ this.render();
+ this.out.write("\n");
+ this.close();
+ }
+ _(c, key) {
+ let s1 = this.input.slice(0, this.cursor);
+ let s2 = this.input.slice(this.cursor);
+ this.input = `${s1}${c}${s2}`;
+ this.cursor = s1.length + 1;
+ this.complete(this.render);
+ this.render();
+ }
+ delete() {
+ if (this.cursor === 0)
+ return this.bell();
+ let s1 = this.input.slice(0, this.cursor - 1);
+ let s2 = this.input.slice(this.cursor);
+ this.input = `${s1}${s2}`;
+ this.complete(this.render);
+ this.cursor = this.cursor - 1;
+ this.render();
+ }
+ deleteForward() {
+ if (this.cursor * this.scale >= this.rendered.length)
+ return this.bell();
+ let s1 = this.input.slice(0, this.cursor);
+ let s2 = this.input.slice(this.cursor + 1);
+ this.input = `${s1}${s2}`;
+ this.complete(this.render);
+ this.render();
+ }
+ first() {
+ this.moveSelect(0);
+ this.render();
+ }
+ last() {
+ this.moveSelect(this.suggestions.length - 1);
+ this.render();
+ }
+ up() {
+ if (this.select === 0) {
+ this.moveSelect(this.suggestions.length - 1);
+ } else {
+ this.moveSelect(this.select - 1);
+ }
+ this.render();
+ }
+ down() {
+ if (this.select === this.suggestions.length - 1) {
+ this.moveSelect(0);
+ } else {
+ this.moveSelect(this.select + 1);
+ }
+ this.render();
+ }
+ next() {
+ if (this.select === this.suggestions.length - 1) {
+ this.moveSelect(0);
+ } else
+ this.moveSelect(this.select + 1);
+ this.render();
+ }
+ nextPage() {
+ this.moveSelect(Math.min(this.select + this.limit, this.suggestions.length - 1));
+ this.render();
+ }
+ prevPage() {
+ this.moveSelect(Math.max(this.select - this.limit, 0));
+ this.render();
+ }
+ left() {
+ if (this.cursor <= 0)
+ return this.bell();
+ this.cursor = this.cursor - 1;
+ this.render();
+ }
+ right() {
+ if (this.cursor * this.scale >= this.rendered.length)
+ return this.bell();
+ this.cursor = this.cursor + 1;
+ this.render();
+ }
+ renderOption(v, hovered, isStart, isEnd) {
+ let desc;
+ let prefix = isStart ? figures.arrowUp : isEnd ? figures.arrowDown : " ";
+ let title = hovered ? color.cyan().underline(v.title) : v.title;
+ prefix = (hovered ? color.cyan(figures.pointer) + " " : " ") + prefix;
+ if (v.description) {
+ desc = ` - ${v.description}`;
+ if (prefix.length + title.length + desc.length >= this.out.columns || v.description.split(/\r?\n/).length > 1) {
+ desc = "\n" + wrap2(v.description, { margin: 3, width: this.out.columns });
+ }
+ }
+ return prefix + " " + title + color.gray(desc || "");
+ }
+ render() {
+ if (this.closed)
+ return;
+ if (this.firstRender)
+ this.out.write(cursor.hide);
+ else
+ this.out.write(clear(this.outputText, this.out.columns));
+ super.render();
+ let { startIndex, endIndex } = entriesToDisplay(this.select, this.choices.length, this.limit);
+ this.outputText = [
+ style.symbol(this.done, this.aborted, this.exited),
+ color.bold(this.msg),
+ style.delimiter(this.completing),
+ this.done && this.suggestions[this.select] ? this.suggestions[this.select].title : this.rendered = this.transform.render(this.input)
+ ].join(" ");
+ if (!this.done) {
+ const suggestions = this.suggestions.slice(startIndex, endIndex).map((item, i) => this.renderOption(
+ item,
+ this.select === i + startIndex,
+ i === 0 && startIndex > 0,
+ i + startIndex === endIndex - 1 && endIndex < this.choices.length
+ )).join("\n");
+ this.outputText += `
+` + (suggestions || color.gray(this.fallback.title));
+ }
+ this.out.write(erase.line + cursor.to(0) + this.outputText);
+ }
+ };
+ __name(AutocompletePrompt, "AutocompletePrompt");
+ module2.exports = AutocompletePrompt;
+ }
+});
+
+// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/elements/autocompleteMultiselect.js
+var require_autocompleteMultiselect2 = __commonJS({
+ "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/elements/autocompleteMultiselect.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var color = require_kleur();
+ var { cursor } = require_src();
+ var MultiselectPrompt = require_multiselect2();
+ var { clear, style, figures } = require_util8();
+ var AutocompleteMultiselectPrompt = class extends MultiselectPrompt {
+ constructor(opts = {}) {
+ opts.overrideRender = true;
+ super(opts);
+ this.inputValue = "";
+ this.clear = clear("", this.out.columns);
+ this.filteredOptions = this.value;
+ this.render();
+ }
+ last() {
+ this.cursor = this.filteredOptions.length - 1;
+ this.render();
+ }
+ next() {
+ this.cursor = (this.cursor + 1) % this.filteredOptions.length;
+ this.render();
+ }
+ up() {
+ if (this.cursor === 0) {
+ this.cursor = this.filteredOptions.length - 1;
+ } else {
+ this.cursor--;
+ }
+ this.render();
+ }
+ down() {
+ if (this.cursor === this.filteredOptions.length - 1) {
+ this.cursor = 0;
+ } else {
+ this.cursor++;
+ }
+ this.render();
+ }
+ left() {
+ this.filteredOptions[this.cursor].selected = false;
+ this.render();
+ }
+ right() {
+ if (this.value.filter((e2) => e2.selected).length >= this.maxChoices)
+ return this.bell();
+ this.filteredOptions[this.cursor].selected = true;
+ this.render();
+ }
+ delete() {
+ if (this.inputValue.length) {
+ this.inputValue = this.inputValue.substr(0, this.inputValue.length - 1);
+ this.updateFilteredOptions();
+ }
+ }
+ updateFilteredOptions() {
+ const currentHighlight = this.filteredOptions[this.cursor];
+ this.filteredOptions = this.value.filter((v) => {
+ if (this.inputValue) {
+ if (typeof v.title === "string") {
+ if (v.title.toLowerCase().includes(this.inputValue.toLowerCase())) {
+ return true;
+ }
+ }
+ if (typeof v.value === "string") {
+ if (v.value.toLowerCase().includes(this.inputValue.toLowerCase())) {
+ return true;
+ }
+ }
+ return false;
+ }
+ return true;
+ });
+ const newHighlightIndex = this.filteredOptions.findIndex((v) => v === currentHighlight);
+ this.cursor = newHighlightIndex < 0 ? 0 : newHighlightIndex;
+ this.render();
+ }
+ handleSpaceToggle() {
+ const v = this.filteredOptions[this.cursor];
+ if (v.selected) {
+ v.selected = false;
+ this.render();
+ } else if (v.disabled || this.value.filter((e2) => e2.selected).length >= this.maxChoices) {
+ return this.bell();
+ } else {
+ v.selected = true;
+ this.render();
+ }
+ }
+ handleInputChange(c) {
+ this.inputValue = this.inputValue + c;
+ this.updateFilteredOptions();
+ }
+ _(c, key) {
+ if (c === " ") {
+ this.handleSpaceToggle();
+ } else {
+ this.handleInputChange(c);
+ }
+ }
+ renderInstructions() {
+ if (this.instructions === void 0 || this.instructions) {
+ if (typeof this.instructions === "string") {
+ return this.instructions;
+ }
+ return `
+Instructions:
+ ${figures.arrowUp}/${figures.arrowDown}: Highlight option
+ ${figures.arrowLeft}/${figures.arrowRight}/[space]: Toggle selection
+ [a,b,c]/delete: Filter choices
+ enter/return: Complete answer
+`;
+ }
+ return "";
+ }
+ renderCurrentInput() {
+ return `
+Filtered results for: ${this.inputValue ? this.inputValue : color.gray("Enter something to filter")}
+`;
+ }
+ renderOption(cursor2, v, i) {
+ let title;
+ if (v.disabled)
+ title = cursor2 === i ? color.gray().underline(v.title) : color.strikethrough().gray(v.title);
+ else
+ title = cursor2 === i ? color.cyan().underline(v.title) : v.title;
+ return (v.selected ? color.green(figures.radioOn) : figures.radioOff) + " " + title;
+ }
+ renderDoneOrInstructions() {
+ if (this.done) {
+ return this.value.filter((e2) => e2.selected).map((v) => v.title).join(", ");
+ }
+ const output = [color.gray(this.hint), this.renderInstructions(), this.renderCurrentInput()];
+ if (this.filteredOptions.length && this.filteredOptions[this.cursor].disabled) {
+ output.push(color.yellow(this.warn));
+ }
+ return output.join(" ");
+ }
+ render() {
+ if (this.closed)
+ return;
+ if (this.firstRender)
+ this.out.write(cursor.hide);
+ super.render();
+ let prompt2 = [
+ style.symbol(this.done, this.aborted),
+ color.bold(this.msg),
+ style.delimiter(false),
+ this.renderDoneOrInstructions()
+ ].join(" ");
+ if (this.showMinError) {
+ prompt2 += color.red(`You must select a minimum of ${this.minSelected} choices.`);
+ this.showMinError = false;
+ }
+ prompt2 += this.renderOptions(this.filteredOptions);
+ this.out.write(this.clear + prompt2);
+ this.clear = clear(prompt2, this.out.columns);
+ }
+ };
+ __name(AutocompleteMultiselectPrompt, "AutocompleteMultiselectPrompt");
+ module2.exports = AutocompleteMultiselectPrompt;
+ }
+});
+
+// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/elements/confirm.js
+var require_confirm2 = __commonJS({
+ "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/elements/confirm.js"(exports2, module2) {
+ init_import_meta_url();
+ var color = require_kleur();
+ var Prompt = require_prompt2();
+ var { style, clear } = require_util8();
+ var { erase, cursor } = require_src();
+ var ConfirmPrompt = class extends Prompt {
+ constructor(opts = {}) {
+ super(opts);
+ this.msg = opts.message;
+ this.value = opts.initial;
+ this.initialValue = !!opts.initial;
+ this.yesMsg = opts.yes || "yes";
+ this.yesOption = opts.yesOption || "(Y/n)";
+ this.noMsg = opts.no || "no";
+ this.noOption = opts.noOption || "(y/N)";
+ this.render();
+ }
+ reset() {
+ this.value = this.initialValue;
+ this.fire();
+ this.render();
+ }
+ exit() {
+ this.abort();
+ }
+ abort() {
+ this.done = this.aborted = true;
+ this.fire();
+ this.render();
+ this.out.write("\n");
+ this.close();
+ }
+ submit() {
+ this.value = this.value || false;
+ this.done = true;
+ this.aborted = false;
+ this.fire();
+ this.render();
+ this.out.write("\n");
+ this.close();
+ }
+ _(c, key) {
+ if (c.toLowerCase() === "y") {
+ this.value = true;
+ return this.submit();
+ }
+ if (c.toLowerCase() === "n") {
+ this.value = false;
+ return this.submit();
+ }
+ return this.bell();
+ }
+ render() {
+ if (this.closed)
+ return;
+ if (this.firstRender)
+ this.out.write(cursor.hide);
+ else
+ this.out.write(clear(this.outputText, this.out.columns));
+ super.render();
+ this.outputText = [
+ style.symbol(this.done, this.aborted),
+ color.bold(this.msg),
+ style.delimiter(this.done),
+ this.done ? this.value ? this.yesMsg : this.noMsg : color.gray(this.initialValue ? this.yesOption : this.noOption)
+ ].join(" ");
+ this.out.write(erase.line + cursor.to(0) + this.outputText);
+ }
+ };
+ __name(ConfirmPrompt, "ConfirmPrompt");
+ module2.exports = ConfirmPrompt;
+ }
+});
+
+// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/elements/index.js
+var require_elements2 = __commonJS({
+ "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/elements/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ module2.exports = {
+ TextPrompt: require_text2(),
+ SelectPrompt: require_select2(),
+ TogglePrompt: require_toggle2(),
+ DatePrompt: require_date2(),
+ NumberPrompt: require_number2(),
+ MultiselectPrompt: require_multiselect2(),
+ AutocompletePrompt: require_autocomplete2(),
+ AutocompleteMultiselectPrompt: require_autocompleteMultiselect2(),
+ ConfirmPrompt: require_confirm2()
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/prompts.js
+var require_prompts2 = __commonJS({
+ "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/prompts.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ var $2 = exports2;
+ var el = require_elements2();
+ var noop = /* @__PURE__ */ __name((v) => v, "noop");
+ function toPrompt(type, args, opts = {}) {
+ return new Promise((res, rej) => {
+ const p = new el[type](args);
+ const onAbort = opts.onAbort || noop;
+ const onSubmit = opts.onSubmit || noop;
+ const onExit7 = opts.onExit || noop;
+ p.on("state", args.onState || noop);
+ p.on("submit", (x) => res(onSubmit(x)));
+ p.on("exit", (x) => res(onExit7(x)));
+ p.on("abort", (x) => rej(onAbort(x)));
+ });
+ }
+ __name(toPrompt, "toPrompt");
+ $2.text = (args) => toPrompt("TextPrompt", args);
+ $2.password = (args) => {
+ args.style = "password";
+ return $2.text(args);
+ };
+ $2.invisible = (args) => {
+ args.style = "invisible";
+ return $2.text(args);
+ };
+ $2.number = (args) => toPrompt("NumberPrompt", args);
+ $2.date = (args) => toPrompt("DatePrompt", args);
+ $2.confirm = (args) => toPrompt("ConfirmPrompt", args);
+ $2.list = (args) => {
+ const sep2 = args.separator || ",";
+ return toPrompt("TextPrompt", args, {
+ onSubmit: (str) => str.split(sep2).map((s) => s.trim())
+ });
+ };
+ $2.toggle = (args) => toPrompt("TogglePrompt", args);
+ $2.select = (args) => toPrompt("SelectPrompt", args);
+ $2.multiselect = (args) => {
+ args.choices = [].concat(args.choices || []);
+ const toSelected = /* @__PURE__ */ __name((items) => items.filter((item) => item.selected).map((item) => item.value), "toSelected");
+ return toPrompt("MultiselectPrompt", args, {
+ onAbort: toSelected,
+ onSubmit: toSelected
+ });
+ };
+ $2.autocompleteMultiselect = (args) => {
+ args.choices = [].concat(args.choices || []);
+ const toSelected = /* @__PURE__ */ __name((items) => items.filter((item) => item.selected).map((item) => item.value), "toSelected");
+ return toPrompt("AutocompleteMultiselectPrompt", args, {
+ onAbort: toSelected,
+ onSubmit: toSelected
+ });
+ };
+ var byTitle = /* @__PURE__ */ __name((input, choices) => Promise.resolve(
+ choices.filter((item) => item.title.slice(0, input.length).toLowerCase() === input.toLowerCase())
+ ), "byTitle");
+ $2.autocomplete = (args) => {
+ args.suggest = args.suggest || byTitle;
+ args.choices = [].concat(args.choices || []);
+ return toPrompt("AutocompletePrompt", args);
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/index.js
+var require_lib2 = __commonJS({
+ "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var prompts2 = require_prompts2();
+ var passOn = ["suggest", "format", "onState", "validate", "onRender", "type"];
+ var noop = /* @__PURE__ */ __name(() => {
+ }, "noop");
+ async function prompt2(questions = [], { onSubmit = noop, onCancel = noop } = {}) {
+ const answers = {};
+ const override2 = prompt2._override || {};
+ questions = [].concat(questions);
+ let answer, question, quit, name, type, lastPrompt;
+ const getFormattedAnswer = /* @__PURE__ */ __name(async (question2, answer2, skipValidation = false) => {
+ if (!skipValidation && question2.validate && question2.validate(answer2) !== true) {
+ return;
+ }
+ return question2.format ? await question2.format(answer2, answers) : answer2;
+ }, "getFormattedAnswer");
+ for (question of questions) {
+ ({ name, type } = question);
+ if (typeof type === "function") {
+ type = await type(answer, { ...answers }, question);
+ question["type"] = type;
+ }
+ if (!type)
+ continue;
+ for (let key in question) {
+ if (passOn.includes(key))
+ continue;
+ let value = question[key];
+ question[key] = typeof value === "function" ? await value(answer, { ...answers }, lastPrompt) : value;
+ }
+ lastPrompt = question;
+ if (typeof question.message !== "string") {
+ throw new Error("prompt message is required");
+ }
+ ({ name, type } = question);
+ if (prompts2[type] === void 0) {
+ throw new Error(`prompt type (${type}) is not defined`);
+ }
+ if (override2[question.name] !== void 0) {
+ answer = await getFormattedAnswer(question, override2[question.name]);
+ if (answer !== void 0) {
+ answers[name] = answer;
+ continue;
+ }
+ }
+ try {
+ answer = prompt2._injected ? getInjectedAnswer(prompt2._injected, question.initial) : await prompts2[type](question);
+ answers[name] = answer = await getFormattedAnswer(question, answer, true);
+ quit = await onSubmit(question, answer, answers);
+ } catch (err) {
+ quit = !await onCancel(question, answers);
+ }
+ if (quit)
+ return answers;
+ }
+ return answers;
+ }
+ __name(prompt2, "prompt");
+ function getInjectedAnswer(injected, deafultValue) {
+ const answer = injected.shift();
+ if (answer instanceof Error) {
+ throw answer;
+ }
+ return answer === void 0 ? deafultValue : answer;
+ }
+ __name(getInjectedAnswer, "getInjectedAnswer");
+ function inject(answers) {
+ prompt2._injected = (prompt2._injected || []).concat(answers);
+ }
+ __name(inject, "inject");
+ function override(answers) {
+ prompt2._override = Object.assign({}, answers);
+ }
+ __name(override, "override");
+ module2.exports = Object.assign(prompt2, { prompt: prompt2, prompts: prompts2, inject, override });
+ }
+});
+
+// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/index.js
+var require_prompts3 = __commonJS({
+ "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/index.js"(exports2, module2) {
+ init_import_meta_url();
+ function isNodeLT(tar) {
+ tar = (Array.isArray(tar) ? tar : tar.split(".")).map(Number);
+ let i = 0, src = process.versions.node.split(".").map(Number);
+ for (; i < tar.length; i++) {
+ if (src[i] > tar[i])
+ return false;
+ if (tar[i] > src[i])
+ return true;
+ }
+ return false;
+ }
+ __name(isNodeLT, "isNodeLT");
+ module2.exports = isNodeLT("8.6.0") ? require_dist2() : require_lib2();
+ }
+});
+
+// ../../node_modules/.pnpm/xdg-app-paths@7.3.0/node_modules/xdg-app-paths/dist/cjs/lib/XDGAppPaths.js
+var require_XDGAppPaths = __commonJS({
+ "../../node_modules/.pnpm/xdg-app-paths@7.3.0/node_modules/xdg-app-paths/dist/cjs/lib/XDGAppPaths.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ exports2.__esModule = true;
+ exports2.Adapt = void 0;
+ function isBoolean3(t2) {
+ return typeOf(t2) === "boolean";
+ }
+ __name(isBoolean3, "isBoolean");
+ function isObject2(t2) {
+ return typeOf(t2) === "object";
+ }
+ __name(isObject2, "isObject");
+ function isString2(t2) {
+ return typeOf(t2) === "string";
+ }
+ __name(isString2, "isString");
+ function typeOf(t2) {
+ return typeof t2;
+ }
+ __name(typeOf, "typeOf");
+ function Adapt(adapter_) {
+ var meta = adapter_.meta, path45 = adapter_.path, xdg = adapter_.xdg;
+ var XDGAppPaths_ = function() {
+ function XDGAppPaths_2(options_) {
+ if (options_ === void 0) {
+ options_ = {};
+ }
+ var _a2, _b2, _c2;
+ function XDGAppPaths(options15) {
+ if (options15 === void 0) {
+ options15 = {};
+ }
+ return new XDGAppPaths_2(options15);
+ }
+ __name(XDGAppPaths, "XDGAppPaths");
+ var options14 = isObject2(options_) ? options_ : { name: options_ };
+ var suffix = (_a2 = options14.suffix) !== null && _a2 !== void 0 ? _a2 : "";
+ var isolated_ = (_b2 = options14.isolated) !== null && _b2 !== void 0 ? _b2 : true;
+ var namePriorityList = [
+ options14.name,
+ meta.pkgMainFilename(),
+ meta.mainFilename()
+ ];
+ var nameFallback = "an-anonymous-script";
+ var name = path45.parse(((_c2 = namePriorityList.find(function(e2) {
+ return isString2(e2);
+ })) !== null && _c2 !== void 0 ? _c2 : nameFallback) + suffix).name;
+ XDGAppPaths.$name = /* @__PURE__ */ __name(function $name() {
+ return name;
+ }, "$name");
+ XDGAppPaths.$isolated = /* @__PURE__ */ __name(function $isolated() {
+ return isolated_;
+ }, "$isolated");
+ function isIsolated(dirOptions) {
+ var _a3;
+ dirOptions = dirOptions !== null && dirOptions !== void 0 ? dirOptions : { isolated: isolated_ };
+ var isolated = isBoolean3(dirOptions) ? dirOptions : (_a3 = dirOptions.isolated) !== null && _a3 !== void 0 ? _a3 : isolated_;
+ return isolated;
+ }
+ __name(isIsolated, "isIsolated");
+ function finalPathSegment(dirOptions) {
+ return isIsolated(dirOptions) ? name : "";
+ }
+ __name(finalPathSegment, "finalPathSegment");
+ XDGAppPaths.cache = /* @__PURE__ */ __name(function cache2(dirOptions) {
+ return path45.join(xdg.cache(), finalPathSegment(dirOptions));
+ }, "cache");
+ XDGAppPaths.config = /* @__PURE__ */ __name(function config(dirOptions) {
+ return path45.join(xdg.config(), finalPathSegment(dirOptions));
+ }, "config");
+ XDGAppPaths.data = /* @__PURE__ */ __name(function data(dirOptions) {
+ return path45.join(xdg.data(), finalPathSegment(dirOptions));
+ }, "data");
+ XDGAppPaths.runtime = /* @__PURE__ */ __name(function runtime(dirOptions) {
+ return xdg.runtime() ? path45.join(xdg.runtime(), finalPathSegment(dirOptions)) : void 0;
+ }, "runtime");
+ XDGAppPaths.state = /* @__PURE__ */ __name(function state(dirOptions) {
+ return path45.join(xdg.state(), finalPathSegment(dirOptions));
+ }, "state");
+ XDGAppPaths.configDirs = /* @__PURE__ */ __name(function configDirs(dirOptions) {
+ return xdg.configDirs().map(function(s) {
+ return path45.join(s, finalPathSegment(dirOptions));
+ });
+ }, "configDirs");
+ XDGAppPaths.dataDirs = /* @__PURE__ */ __name(function dataDirs(dirOptions) {
+ return xdg.dataDirs().map(function(s) {
+ return path45.join(s, finalPathSegment(dirOptions));
+ });
+ }, "dataDirs");
+ return XDGAppPaths;
+ }
+ __name(XDGAppPaths_2, "XDGAppPaths_");
+ return XDGAppPaths_2;
+ }();
+ return { XDGAppPaths: new XDGAppPaths_() };
+ }
+ __name(Adapt, "Adapt");
+ exports2.Adapt = Adapt;
+ }
+});
+
+// ../../node_modules/.pnpm/xdg-portable@9.4.0/node_modules/xdg-portable/dist/cjs/lib/XDG.js
+var require_XDG = __commonJS({
+ "../../node_modules/.pnpm/xdg-portable@9.4.0/node_modules/xdg-portable/dist/cjs/lib/XDG.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ var __spreadArrays = exports2 && exports2.__spreadArrays || function() {
+ for (var s = 0, i = 0, il = arguments.length; i < il; i++)
+ s += arguments[i].length;
+ for (var r = Array(s), k = 0, i = 0; i < il; i++)
+ for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
+ r[k] = a[j];
+ return r;
+ };
+ exports2.__esModule = true;
+ exports2.Adapt = void 0;
+ function Adapt(adapter_) {
+ var env5 = adapter_.env, osPaths = adapter_.osPaths, path45 = adapter_.path;
+ var isMacOS = /^darwin$/i.test(adapter_.process.platform);
+ var isWinOS = /^win/i.test(adapter_.process.platform);
+ function baseDir() {
+ return osPaths.home() || osPaths.temp();
+ }
+ __name(baseDir, "baseDir");
+ function valOrPath(val, pathSegments) {
+ return val || path45.join.apply(path45, pathSegments);
+ }
+ __name(valOrPath, "valOrPath");
+ var linux = /* @__PURE__ */ __name(function() {
+ var cache2 = /* @__PURE__ */ __name(function() {
+ return valOrPath(env5.get("XDG_CACHE_HOME"), [baseDir(), ".cache"]);
+ }, "cache");
+ var config = /* @__PURE__ */ __name(function() {
+ return valOrPath(env5.get("XDG_CONFIG_HOME"), [baseDir(), ".config"]);
+ }, "config");
+ var data = /* @__PURE__ */ __name(function() {
+ return valOrPath(env5.get("XDG_DATA_HOME"), [baseDir(), ".local", "share"]);
+ }, "data");
+ var runtime = /* @__PURE__ */ __name(function() {
+ return env5.get("XDG_RUNTIME_DIR") || void 0;
+ }, "runtime");
+ var state = /* @__PURE__ */ __name(function() {
+ return valOrPath(env5.get("XDG_STATE_HOME"), [baseDir(), ".local", "state"]);
+ }, "state");
+ return { cache: cache2, config, data, runtime, state };
+ }, "linux");
+ var macos = /* @__PURE__ */ __name(function() {
+ var cache2 = /* @__PURE__ */ __name(function() {
+ return valOrPath(env5.get("XDG_CACHE_HOME"), [baseDir(), "Library", "Caches"]);
+ }, "cache");
+ var config = /* @__PURE__ */ __name(function() {
+ return valOrPath(env5.get("XDG_CONFIG_HOME"), [baseDir(), "Library", "Preferences"]);
+ }, "config");
+ var data = /* @__PURE__ */ __name(function() {
+ return valOrPath(env5.get("XDG_DATA_HOME"), [baseDir(), "Library", "Application Support"]);
+ }, "data");
+ var runtime = /* @__PURE__ */ __name(function() {
+ return env5.get("XDG_RUNTIME_DIR") || void 0;
+ }, "runtime");
+ var state = /* @__PURE__ */ __name(function() {
+ return valOrPath(env5.get("XDG_STATE_HOME"), [baseDir(), "Library", "State"]);
+ }, "state");
+ return { cache: cache2, config, data, runtime, state };
+ }, "macos");
+ var windows = /* @__PURE__ */ __name(function() {
+ function appData() {
+ return valOrPath(env5.get("APPDATA"), [baseDir(), "AppData", "Roaming"]);
+ }
+ __name(appData, "appData");
+ function localAppData() {
+ return valOrPath(env5.get("LOCALAPPDATA"), [baseDir(), "AppData", "Local"]);
+ }
+ __name(localAppData, "localAppData");
+ var cache2 = /* @__PURE__ */ __name(function() {
+ return valOrPath(env5.get("XDG_CACHE_HOME"), [localAppData(), "xdg.cache"]);
+ }, "cache");
+ var config = /* @__PURE__ */ __name(function() {
+ return valOrPath(env5.get("XDG_CONFIG_HOME"), [appData(), "xdg.config"]);
+ }, "config");
+ var data = /* @__PURE__ */ __name(function() {
+ return valOrPath(env5.get("XDG_DATA_HOME"), [appData(), "xdg.data"]);
+ }, "data");
+ var runtime = /* @__PURE__ */ __name(function() {
+ return env5.get("XDG_RUNTIME_DIR") || void 0;
+ }, "runtime");
+ var state = /* @__PURE__ */ __name(function() {
+ return valOrPath(env5.get("XDG_STATE_HOME"), [localAppData(), "xdg.state"]);
+ }, "state");
+ return { cache: cache2, config, data, runtime, state };
+ }, "windows");
+ var XDG_ = function() {
+ function XDG_2() {
+ function XDG() {
+ return new XDG_2();
+ }
+ __name(XDG, "XDG");
+ var extension = isMacOS ? macos() : isWinOS ? windows() : linux();
+ XDG.cache = extension.cache;
+ XDG.config = extension.config;
+ XDG.data = extension.data;
+ XDG.runtime = extension.runtime;
+ XDG.state = extension.state;
+ XDG.configDirs = /* @__PURE__ */ __name(function configDirs() {
+ var pathList = env5.get("XDG_CONFIG_DIRS");
+ return __spreadArrays([extension.config()], pathList ? pathList.split(path45.delimiter) : []);
+ }, "configDirs");
+ XDG.dataDirs = /* @__PURE__ */ __name(function dataDirs() {
+ var pathList = env5.get("XDG_DATA_DIRS");
+ return __spreadArrays([extension.data()], pathList ? pathList.split(path45.delimiter) : []);
+ }, "dataDirs");
+ return XDG;
+ }
+ __name(XDG_2, "XDG_");
+ return XDG_2;
+ }();
+ return { XDG: new XDG_() };
+ }
+ __name(Adapt, "Adapt");
+ exports2.Adapt = Adapt;
+ }
+});
+
+// ../../node_modules/.pnpm/os-paths@6.9.0/node_modules/os-paths/dist/cjs/lib/OSPaths.js
+var require_OSPaths = __commonJS({
+ "../../node_modules/.pnpm/os-paths@6.9.0/node_modules/os-paths/dist/cjs/lib/OSPaths.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ var __spreadArrays = exports2 && exports2.__spreadArrays || function() {
+ for (var s = 0, i = 0, il = arguments.length; i < il; i++)
+ s += arguments[i].length;
+ for (var r = Array(s), k = 0, i = 0; i < il; i++)
+ for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
+ r[k] = a[j];
+ return r;
+ };
+ exports2.__esModule = true;
+ exports2.Adapt = void 0;
+ function isEmpty(s) {
+ return !s;
+ }
+ __name(isEmpty, "isEmpty");
+ function Adapt(adapter_) {
+ var env5 = adapter_.env, os9 = adapter_.os, path45 = adapter_.path;
+ var isWinOS = /^win/i.test(adapter_.process.platform);
+ function normalizePath(path_) {
+ return path_ ? adapter_.path.normalize(adapter_.path.join(path_, ".")) : void 0;
+ }
+ __name(normalizePath, "normalizePath");
+ function home() {
+ var posix = /* @__PURE__ */ __name(function() {
+ return normalizePath((typeof os9.homedir === "function" ? os9.homedir() : void 0) || env5.get("HOME"));
+ }, "posix");
+ var windows = /* @__PURE__ */ __name(function() {
+ var priorityList = [
+ typeof os9.homedir === "function" ? os9.homedir() : void 0,
+ env5.get("USERPROFILE"),
+ env5.get("HOME"),
+ env5.get("HOMEDRIVE") || env5.get("HOMEPATH") ? path45.join(env5.get("HOMEDRIVE") || "", env5.get("HOMEPATH") || "") : void 0
+ ];
+ return normalizePath(priorityList.find(function(v) {
+ return !isEmpty(v);
+ }));
+ }, "windows");
+ return isWinOS ? windows() : posix();
+ }
+ __name(home, "home");
+ function temp() {
+ function joinPathToBase(base, segments) {
+ return base ? path45.join.apply(path45, __spreadArrays([base], segments)) : void 0;
+ }
+ __name(joinPathToBase, "joinPathToBase");
+ function posix() {
+ var fallback = "/tmp";
+ var priorityList = [
+ typeof os9.tmpdir === "function" ? os9.tmpdir() : void 0,
+ env5.get("TMPDIR"),
+ env5.get("TEMP"),
+ env5.get("TMP")
+ ];
+ return normalizePath(priorityList.find(function(v) {
+ return !isEmpty(v);
+ })) || fallback;
+ }
+ __name(posix, "posix");
+ function windows() {
+ var fallback = "C:\\Temp";
+ var priorityListLazy = [
+ os9.tmpdir,
+ function() {
+ return env5.get("TEMP");
+ },
+ function() {
+ return env5.get("TMP");
+ },
+ function() {
+ return joinPathToBase(env5.get("LOCALAPPDATA"), ["Temp"]);
+ },
+ function() {
+ return joinPathToBase(home(), ["AppData", "Local", "Temp"]);
+ },
+ function() {
+ return joinPathToBase(env5.get("ALLUSERSPROFILE"), ["Temp"]);
+ },
+ function() {
+ return joinPathToBase(env5.get("SystemRoot"), ["Temp"]);
+ },
+ function() {
+ return joinPathToBase(env5.get("windir"), ["Temp"]);
+ },
+ function() {
+ return joinPathToBase(env5.get("SystemDrive"), ["\\", "Temp"]);
+ }
+ ];
+ var v = priorityListLazy.find(function(v2) {
+ return v2 && !isEmpty(v2());
+ });
+ return v && normalizePath(v()) || fallback;
+ }
+ __name(windows, "windows");
+ return isWinOS ? windows() : posix();
+ }
+ __name(temp, "temp");
+ var OSPaths_ = function() {
+ function OSPaths_2() {
+ function OSPaths() {
+ return new OSPaths_2();
+ }
+ __name(OSPaths, "OSPaths");
+ OSPaths.home = home;
+ OSPaths.temp = temp;
+ return OSPaths;
+ }
+ __name(OSPaths_2, "OSPaths_");
+ return OSPaths_2;
+ }();
+ return { OSPaths: new OSPaths_() };
+ }
+ __name(Adapt, "Adapt");
+ exports2.Adapt = Adapt;
+ }
+});
+
+// ../../node_modules/.pnpm/os-paths@6.9.0/node_modules/os-paths/dist/cjs/platform-adapters/node.js
+var require_node = __commonJS({
+ "../../node_modules/.pnpm/os-paths@6.9.0/node_modules/os-paths/dist/cjs/platform-adapters/node.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
+ if (k2 === void 0)
+ k2 = k;
+ Object.defineProperty(o, k2, { enumerable: true, get: function() {
+ return m[k];
+ } });
+ } : function(o, m, k, k2) {
+ if (k2 === void 0)
+ k2 = k;
+ o[k2] = m[k];
+ });
+ var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) {
+ Object.defineProperty(o, "default", { enumerable: true, value: v });
+ } : function(o, v) {
+ o["default"] = v;
+ });
+ var __importStar = exports2 && exports2.__importStar || function(mod) {
+ if (mod && mod.__esModule)
+ return mod;
+ var result = {};
+ if (mod != null) {
+ for (var k in mod)
+ if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k))
+ __createBinding(result, mod, k);
+ }
+ __setModuleDefault(result, mod);
+ return result;
+ };
+ exports2.__esModule = true;
+ exports2.adapter = void 0;
+ var os9 = __importStar(require("os"));
+ var path45 = __importStar(require("path"));
+ exports2.adapter = {
+ env: {
+ get: function(s) {
+ return process.env[s];
+ }
+ },
+ os: os9,
+ path: path45,
+ process
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/os-paths@6.9.0/node_modules/os-paths/dist/cjs/mod.cjs.js
+var require_mod_cjs = __commonJS({
+ "../../node_modules/.pnpm/os-paths@6.9.0/node_modules/os-paths/dist/cjs/mod.cjs.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var OSPaths_js_1 = require_OSPaths();
+ var node_js_1 = require_node();
+ module2.exports = OSPaths_js_1.Adapt(node_js_1.adapter).OSPaths;
+ }
+});
+
+// ../../node_modules/.pnpm/xdg-portable@9.4.0/node_modules/xdg-portable/dist/cjs/platform-adapters/node.js
+var require_node2 = __commonJS({
+ "../../node_modules/.pnpm/xdg-portable@9.4.0/node_modules/xdg-portable/dist/cjs/platform-adapters/node.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
+ if (k2 === void 0)
+ k2 = k;
+ Object.defineProperty(o, k2, { enumerable: true, get: function() {
+ return m[k];
+ } });
+ } : function(o, m, k, k2) {
+ if (k2 === void 0)
+ k2 = k;
+ o[k2] = m[k];
+ });
+ var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) {
+ Object.defineProperty(o, "default", { enumerable: true, value: v });
+ } : function(o, v) {
+ o["default"] = v;
+ });
+ var __importStar = exports2 && exports2.__importStar || function(mod) {
+ if (mod && mod.__esModule)
+ return mod;
+ var result = {};
+ if (mod != null) {
+ for (var k in mod)
+ if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k))
+ __createBinding(result, mod, k);
+ }
+ __setModuleDefault(result, mod);
+ return result;
+ };
+ var __importDefault = exports2 && exports2.__importDefault || function(mod) {
+ return mod && mod.__esModule ? mod : { "default": mod };
+ };
+ exports2.__esModule = true;
+ exports2.adapter = void 0;
+ var path45 = __importStar(require("path"));
+ var os_paths_1 = __importDefault(require_mod_cjs());
+ exports2.adapter = {
+ env: {
+ get: function(s) {
+ return process.env[s];
+ }
+ },
+ osPaths: os_paths_1["default"],
+ path: path45,
+ process
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/xdg-portable@9.4.0/node_modules/xdg-portable/dist/cjs/mod.cjs.js
+var require_mod_cjs2 = __commonJS({
+ "../../node_modules/.pnpm/xdg-portable@9.4.0/node_modules/xdg-portable/dist/cjs/mod.cjs.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var XDG_js_1 = require_XDG();
+ var node_js_1 = require_node2();
+ module2.exports = XDG_js_1.Adapt(node_js_1.adapter).XDG;
+ }
+});
+
+// ../../node_modules/.pnpm/xdg-app-paths@7.3.0/node_modules/xdg-app-paths/dist/cjs/platform-adapters/node.js
+var require_node3 = __commonJS({
+ "../../node_modules/.pnpm/xdg-app-paths@7.3.0/node_modules/xdg-app-paths/dist/cjs/platform-adapters/node.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
+ if (k2 === void 0)
+ k2 = k;
+ Object.defineProperty(o, k2, { enumerable: true, get: function() {
+ return m[k];
+ } });
+ } : function(o, m, k, k2) {
+ if (k2 === void 0)
+ k2 = k;
+ o[k2] = m[k];
+ });
+ var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) {
+ Object.defineProperty(o, "default", { enumerable: true, value: v });
+ } : function(o, v) {
+ o["default"] = v;
+ });
+ var __importStar = exports2 && exports2.__importStar || function(mod) {
+ if (mod && mod.__esModule)
+ return mod;
+ var result = {};
+ if (mod != null) {
+ for (var k in mod)
+ if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k))
+ __createBinding(result, mod, k);
+ }
+ __setModuleDefault(result, mod);
+ return result;
+ };
+ var __importDefault = exports2 && exports2.__importDefault || function(mod) {
+ return mod && mod.__esModule ? mod : { "default": mod };
+ };
+ exports2.__esModule = true;
+ exports2.adapter = void 0;
+ var path45 = __importStar(require("path"));
+ var xdg_portable_1 = __importDefault(require_mod_cjs2());
+ exports2.adapter = {
+ meta: {
+ mainFilename: function() {
+ var requireMain = typeof require !== "undefined" && require !== null && require.main ? require.main : { filename: void 0 };
+ var requireMainFilename = requireMain.filename;
+ var filename = (requireMainFilename !== process.execArgv[0] ? requireMainFilename : void 0) || (typeof process._eval === "undefined" ? process.argv[1] : void 0);
+ return filename;
+ },
+ pkgMainFilename: function() {
+ return process.pkg ? process.execPath : void 0;
+ }
+ },
+ path: path45,
+ process,
+ xdg: xdg_portable_1["default"]
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/xdg-app-paths@7.3.0/node_modules/xdg-app-paths/dist/cjs/mod.cjs.js
+var require_mod_cjs3 = __commonJS({
+ "../../node_modules/.pnpm/xdg-app-paths@7.3.0/node_modules/xdg-app-paths/dist/cjs/mod.cjs.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var XDGAppPaths_js_1 = require_XDGAppPaths();
+ var node_js_1 = require_node3();
+ module2.exports = XDGAppPaths_js_1.Adapt(node_js_1.adapter).XDGAppPaths;
+ }
+});
+
+// ../../node_modules/.pnpm/is-docker@2.2.1/node_modules/is-docker/index.js
+var require_is_docker = __commonJS({
+ "../../node_modules/.pnpm/is-docker@2.2.1/node_modules/is-docker/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var fs20 = require("fs");
+ var isDocker;
+ function hasDockerEnv() {
+ try {
+ fs20.statSync("/.dockerenv");
+ return true;
+ } catch (_2) {
+ return false;
+ }
+ }
+ __name(hasDockerEnv, "hasDockerEnv");
+ function hasDockerCGroup() {
+ try {
+ return fs20.readFileSync("/proc/self/cgroup", "utf8").includes("docker");
+ } catch (_2) {
+ return false;
+ }
+ }
+ __name(hasDockerCGroup, "hasDockerCGroup");
+ module2.exports = () => {
+ if (isDocker === void 0) {
+ isDocker = hasDockerEnv() || hasDockerCGroup();
+ }
+ return isDocker;
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/is-wsl@2.2.0/node_modules/is-wsl/index.js
+var require_is_wsl = __commonJS({
+ "../../node_modules/.pnpm/is-wsl@2.2.0/node_modules/is-wsl/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var os9 = require("os");
+ var fs20 = require("fs");
+ var isDocker = require_is_docker();
+ var isWsl = /* @__PURE__ */ __name(() => {
+ if (process.platform !== "linux") {
+ return false;
+ }
+ if (os9.release().toLowerCase().includes("microsoft")) {
+ if (isDocker()) {
+ return false;
+ }
+ return true;
+ }
+ try {
+ return fs20.readFileSync("/proc/version", "utf8").toLowerCase().includes("microsoft") ? !isDocker() : false;
+ } catch (_2) {
+ return false;
+ }
+ }, "isWsl");
+ if (process.env.__IS_WSL_TEST__) {
+ module2.exports = isWsl;
+ } else {
+ module2.exports = isWsl();
+ }
+ }
+});
+
+// ../../node_modules/.pnpm/define-lazy-prop@2.0.0/node_modules/define-lazy-prop/index.js
+var require_define_lazy_prop = __commonJS({
+ "../../node_modules/.pnpm/define-lazy-prop@2.0.0/node_modules/define-lazy-prop/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ module2.exports = (object, propertyName, fn2) => {
+ const define2 = /* @__PURE__ */ __name((value) => Object.defineProperty(object, propertyName, { value, enumerable: true, writable: true }), "define");
+ Object.defineProperty(object, propertyName, {
+ configurable: true,
+ enumerable: true,
+ get() {
+ const result = fn2();
+ define2(result);
+ return result;
+ },
+ set(value) {
+ define2(value);
+ }
+ });
+ return object;
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/open@8.4.0/node_modules/open/index.js
+var require_open = __commonJS({
+ "../../node_modules/.pnpm/open@8.4.0/node_modules/open/index.js"(exports2, module2) {
+ init_import_meta_url();
+ var path45 = require("path");
+ var childProcess2 = require("child_process");
+ var { promises: fs20, constants: fsConstants } = require("fs");
+ var isWsl = require_is_wsl();
+ var isDocker = require_is_docker();
+ var defineLazyProperty = require_define_lazy_prop();
+ var localXdgOpenPath = path45.join(__dirname, "xdg-open");
+ var { platform, arch: arch2 } = process;
+ var getWslDrivesMountPoint = (() => {
+ const defaultMountPoint = "/mnt/";
+ let mountPoint;
+ return async function() {
+ if (mountPoint) {
+ return mountPoint;
+ }
+ const configFilePath = "/etc/wsl.conf";
+ let isConfigFileExists = false;
+ try {
+ await fs20.access(configFilePath, fsConstants.F_OK);
+ isConfigFileExists = true;
+ } catch {
+ }
+ if (!isConfigFileExists) {
+ return defaultMountPoint;
+ }
+ const configContent = await fs20.readFile(configFilePath, { encoding: "utf8" });
+ const configMountPoint = /(?.*)/g.exec(configContent);
+ if (!configMountPoint) {
+ return defaultMountPoint;
+ }
+ mountPoint = configMountPoint.groups.mountPoint.trim();
+ mountPoint = mountPoint.endsWith("/") ? mountPoint : `${mountPoint}/`;
+ return mountPoint;
+ };
+ })();
+ var pTryEach = /* @__PURE__ */ __name(async (array, mapper) => {
+ let latestError;
+ for (const item of array) {
+ try {
+ return await mapper(item);
+ } catch (error) {
+ latestError = error;
+ }
+ }
+ throw latestError;
+ }, "pTryEach");
+ var baseOpen = /* @__PURE__ */ __name(async (options14) => {
+ options14 = {
+ wait: false,
+ background: false,
+ newInstance: false,
+ allowNonzeroExitCode: false,
+ ...options14
+ };
+ if (Array.isArray(options14.app)) {
+ return pTryEach(options14.app, (singleApp) => baseOpen({
+ ...options14,
+ app: singleApp
+ }));
+ }
+ let { name: app, arguments: appArguments = [] } = options14.app || {};
+ appArguments = [...appArguments];
+ if (Array.isArray(app)) {
+ return pTryEach(app, (appName) => baseOpen({
+ ...options14,
+ app: {
+ name: appName,
+ arguments: appArguments
+ }
+ }));
+ }
+ let command2;
+ const cliArguments = [];
+ const childProcessOptions = {};
+ if (platform === "darwin") {
+ command2 = "open";
+ if (options14.wait) {
+ cliArguments.push("--wait-apps");
+ }
+ if (options14.background) {
+ cliArguments.push("--background");
+ }
+ if (options14.newInstance) {
+ cliArguments.push("--new");
+ }
+ if (app) {
+ cliArguments.push("-a", app);
+ }
+ } else if (platform === "win32" || isWsl && !isDocker()) {
+ const mountPoint = await getWslDrivesMountPoint();
+ command2 = isWsl ? `${mountPoint}c/Windows/System32/WindowsPowerShell/v1.0/powershell.exe` : `${process.env.SYSTEMROOT}\\System32\\WindowsPowerShell\\v1.0\\powershell`;
+ cliArguments.push(
+ "-NoProfile",
+ "-NonInteractive",
+ "\u2013ExecutionPolicy",
+ "Bypass",
+ "-EncodedCommand"
+ );
+ if (!isWsl) {
+ childProcessOptions.windowsVerbatimArguments = true;
+ }
+ const encodedArguments = ["Start"];
+ if (options14.wait) {
+ encodedArguments.push("-Wait");
+ }
+ if (app) {
+ encodedArguments.push(`"\`"${app}\`""`, "-ArgumentList");
+ if (options14.target) {
+ appArguments.unshift(options14.target);
+ }
+ } else if (options14.target) {
+ encodedArguments.push(`"${options14.target}"`);
+ }
+ if (appArguments.length > 0) {
+ appArguments = appArguments.map((arg) => `"\`"${arg}\`""`);
+ encodedArguments.push(appArguments.join(","));
+ }
+ options14.target = Buffer.from(encodedArguments.join(" "), "utf16le").toString("base64");
+ } else {
+ if (app) {
+ command2 = app;
+ } else {
+ const isBundled = !__dirname || __dirname === "/";
+ let exeLocalXdgOpen = false;
+ try {
+ await fs20.access(localXdgOpenPath, fsConstants.X_OK);
+ exeLocalXdgOpen = true;
+ } catch {
+ }
+ const useSystemXdgOpen = process.versions.electron || platform === "android" || isBundled || !exeLocalXdgOpen;
+ command2 = useSystemXdgOpen ? "xdg-open" : localXdgOpenPath;
+ }
+ if (appArguments.length > 0) {
+ cliArguments.push(...appArguments);
+ }
+ if (!options14.wait) {
+ childProcessOptions.stdio = "ignore";
+ childProcessOptions.detached = true;
+ }
+ }
+ if (options14.target) {
+ cliArguments.push(options14.target);
+ }
+ if (platform === "darwin" && appArguments.length > 0) {
+ cliArguments.push("--args", ...appArguments);
+ }
+ const subprocess = childProcess2.spawn(command2, cliArguments, childProcessOptions);
+ if (options14.wait) {
+ return new Promise((resolve18, reject) => {
+ subprocess.once("error", reject);
+ subprocess.once("close", (exitCode) => {
+ if (options14.allowNonzeroExitCode && exitCode > 0) {
+ reject(new Error(`Exited with code ${exitCode}`));
+ return;
+ }
+ resolve18(subprocess);
+ });
+ });
+ }
+ subprocess.unref();
+ return subprocess;
+ }, "baseOpen");
+ var open3 = /* @__PURE__ */ __name((target, options14) => {
+ if (typeof target !== "string") {
+ throw new TypeError("Expected a `target`");
+ }
+ return baseOpen({
+ ...options14,
+ target
+ });
+ }, "open");
+ var openApp = /* @__PURE__ */ __name((name, options14) => {
+ if (typeof name !== "string") {
+ throw new TypeError("Expected a `name`");
+ }
+ const { arguments: appArguments = [] } = options14 || {};
+ if (appArguments !== void 0 && appArguments !== null && !Array.isArray(appArguments)) {
+ throw new TypeError("Expected `appArguments` as Array type");
+ }
+ return baseOpen({
+ ...options14,
+ app: {
+ name,
+ arguments: appArguments
+ }
+ });
+ }, "openApp");
+ function detectArchBinary(binary) {
+ if (typeof binary === "string" || Array.isArray(binary)) {
+ return binary;
+ }
+ const { [arch2]: archBinary } = binary;
+ if (!archBinary) {
+ throw new Error(`${arch2} is not supported`);
+ }
+ return archBinary;
+ }
+ __name(detectArchBinary, "detectArchBinary");
+ function detectPlatformBinary({ [platform]: platformBinary }, { wsl }) {
+ if (wsl && isWsl) {
+ return detectArchBinary(wsl);
+ }
+ if (!platformBinary) {
+ throw new Error(`${platform} is not supported`);
+ }
+ return detectArchBinary(platformBinary);
+ }
+ __name(detectPlatformBinary, "detectPlatformBinary");
+ var apps = {};
+ defineLazyProperty(apps, "chrome", () => detectPlatformBinary({
+ darwin: "google chrome",
+ win32: "chrome",
+ linux: ["google-chrome", "google-chrome-stable", "chromium"]
+ }, {
+ wsl: {
+ ia32: "/mnt/c/Program Files (x86)/Google/Chrome/Application/chrome.exe",
+ x64: ["/mnt/c/Program Files/Google/Chrome/Application/chrome.exe", "/mnt/c/Program Files (x86)/Google/Chrome/Application/chrome.exe"]
+ }
+ }));
+ defineLazyProperty(apps, "firefox", () => detectPlatformBinary({
+ darwin: "firefox",
+ win32: "C:\\Program Files\\Mozilla Firefox\\firefox.exe",
+ linux: "firefox"
+ }, {
+ wsl: "/mnt/c/Program Files/Mozilla Firefox/firefox.exe"
+ }));
+ defineLazyProperty(apps, "edge", () => detectPlatformBinary({
+ darwin: "microsoft edge",
+ win32: "msedge",
+ linux: ["microsoft-edge", "microsoft-edge-dev"]
+ }, {
+ wsl: "/mnt/c/Program Files (x86)/Microsoft/Edge/Application/msedge.exe"
+ }));
+ open3.apps = apps;
+ open3.openApp = openApp;
+ module2.exports = open3;
+ }
+});
+
+// ../../node_modules/.pnpm/fs.realpath@1.0.0/node_modules/fs.realpath/old.js
+var require_old = __commonJS({
+ "../../node_modules/.pnpm/fs.realpath@1.0.0/node_modules/fs.realpath/old.js"(exports2) {
+ init_import_meta_url();
+ var pathModule = require("path");
+ var isWindows2 = process.platform === "win32";
+ var fs20 = require("fs");
+ var DEBUG = process.env.NODE_DEBUG && /fs/.test(process.env.NODE_DEBUG);
+ function rethrow() {
+ var callback;
+ if (DEBUG) {
+ var backtrace = new Error();
+ callback = debugCallback;
+ } else
+ callback = missingCallback;
+ return callback;
+ function debugCallback(err) {
+ if (err) {
+ backtrace.message = err.message;
+ err = backtrace;
+ missingCallback(err);
+ }
+ }
+ __name(debugCallback, "debugCallback");
+ function missingCallback(err) {
+ if (err) {
+ if (process.throwDeprecation)
+ throw err;
+ else if (!process.noDeprecation) {
+ var msg = "fs: missing callback " + (err.stack || err.message);
+ if (process.traceDeprecation)
+ console.trace(msg);
+ else
+ console.error(msg);
+ }
+ }
+ }
+ __name(missingCallback, "missingCallback");
+ }
+ __name(rethrow, "rethrow");
+ function maybeCallback(cb) {
+ return typeof cb === "function" ? cb : rethrow();
+ }
+ __name(maybeCallback, "maybeCallback");
+ var normalize2 = pathModule.normalize;
+ if (isWindows2) {
+ nextPartRe = /(.*?)(?:[\/\\]+|$)/g;
+ } else {
+ nextPartRe = /(.*?)(?:[\/]+|$)/g;
+ }
+ var nextPartRe;
+ if (isWindows2) {
+ splitRootRe = /^(?:[a-zA-Z]:|[\\\/]{2}[^\\\/]+[\\\/][^\\\/]+)?[\\\/]*/;
+ } else {
+ splitRootRe = /^[\/]*/;
+ }
+ var splitRootRe;
+ exports2.realpathSync = /* @__PURE__ */ __name(function realpathSync3(p, cache2) {
+ p = pathModule.resolve(p);
+ if (cache2 && Object.prototype.hasOwnProperty.call(cache2, p)) {
+ return cache2[p];
+ }
+ var original = p, seenLinks = {}, knownHard = {};
+ var pos;
+ var current;
+ var base;
+ var previous;
+ start();
+ function start() {
+ var m = splitRootRe.exec(p);
+ pos = m[0].length;
+ current = m[0];
+ base = m[0];
+ previous = "";
+ if (isWindows2 && !knownHard[base]) {
+ fs20.lstatSync(base);
+ knownHard[base] = true;
+ }
+ }
+ __name(start, "start");
+ while (pos < p.length) {
+ nextPartRe.lastIndex = pos;
+ var result = nextPartRe.exec(p);
+ previous = current;
+ current += result[0];
+ base = previous + result[1];
+ pos = nextPartRe.lastIndex;
+ if (knownHard[base] || cache2 && cache2[base] === base) {
+ continue;
+ }
+ var resolvedLink;
+ if (cache2 && Object.prototype.hasOwnProperty.call(cache2, base)) {
+ resolvedLink = cache2[base];
+ } else {
+ var stat3 = fs20.lstatSync(base);
+ if (!stat3.isSymbolicLink()) {
+ knownHard[base] = true;
+ if (cache2)
+ cache2[base] = base;
+ continue;
+ }
+ var linkTarget = null;
+ if (!isWindows2) {
+ var id = stat3.dev.toString(32) + ":" + stat3.ino.toString(32);
+ if (seenLinks.hasOwnProperty(id)) {
+ linkTarget = seenLinks[id];
+ }
+ }
+ if (linkTarget === null) {
+ fs20.statSync(base);
+ linkTarget = fs20.readlinkSync(base);
+ }
+ resolvedLink = pathModule.resolve(previous, linkTarget);
+ if (cache2)
+ cache2[base] = resolvedLink;
+ if (!isWindows2)
+ seenLinks[id] = linkTarget;
+ }
+ p = pathModule.resolve(resolvedLink, p.slice(pos));
+ start();
+ }
+ if (cache2)
+ cache2[original] = p;
+ return p;
+ }, "realpathSync");
+ exports2.realpath = /* @__PURE__ */ __name(function realpath(p, cache2, cb) {
+ if (typeof cb !== "function") {
+ cb = maybeCallback(cache2);
+ cache2 = null;
+ }
+ p = pathModule.resolve(p);
+ if (cache2 && Object.prototype.hasOwnProperty.call(cache2, p)) {
+ return process.nextTick(cb.bind(null, null, cache2[p]));
+ }
+ var original = p, seenLinks = {}, knownHard = {};
+ var pos;
+ var current;
+ var base;
+ var previous;
+ start();
+ function start() {
+ var m = splitRootRe.exec(p);
+ pos = m[0].length;
+ current = m[0];
+ base = m[0];
+ previous = "";
+ if (isWindows2 && !knownHard[base]) {
+ fs20.lstat(base, function(err) {
+ if (err)
+ return cb(err);
+ knownHard[base] = true;
+ LOOP();
+ });
+ } else {
+ process.nextTick(LOOP);
+ }
+ }
+ __name(start, "start");
+ function LOOP() {
+ if (pos >= p.length) {
+ if (cache2)
+ cache2[original] = p;
+ return cb(null, p);
+ }
+ nextPartRe.lastIndex = pos;
+ var result = nextPartRe.exec(p);
+ previous = current;
+ current += result[0];
+ base = previous + result[1];
+ pos = nextPartRe.lastIndex;
+ if (knownHard[base] || cache2 && cache2[base] === base) {
+ return process.nextTick(LOOP);
+ }
+ if (cache2 && Object.prototype.hasOwnProperty.call(cache2, base)) {
+ return gotResolvedLink(cache2[base]);
+ }
+ return fs20.lstat(base, gotStat);
+ }
+ __name(LOOP, "LOOP");
+ function gotStat(err, stat3) {
+ if (err)
+ return cb(err);
+ if (!stat3.isSymbolicLink()) {
+ knownHard[base] = true;
+ if (cache2)
+ cache2[base] = base;
+ return process.nextTick(LOOP);
+ }
+ if (!isWindows2) {
+ var id = stat3.dev.toString(32) + ":" + stat3.ino.toString(32);
+ if (seenLinks.hasOwnProperty(id)) {
+ return gotTarget(null, seenLinks[id], base);
+ }
+ }
+ fs20.stat(base, function(err2) {
+ if (err2)
+ return cb(err2);
+ fs20.readlink(base, function(err3, target) {
+ if (!isWindows2)
+ seenLinks[id] = target;
+ gotTarget(err3, target);
+ });
+ });
+ }
+ __name(gotStat, "gotStat");
+ function gotTarget(err, target, base2) {
+ if (err)
+ return cb(err);
+ var resolvedLink = pathModule.resolve(previous, target);
+ if (cache2)
+ cache2[base2] = resolvedLink;
+ gotResolvedLink(resolvedLink);
+ }
+ __name(gotTarget, "gotTarget");
+ function gotResolvedLink(resolvedLink) {
+ p = pathModule.resolve(resolvedLink, p.slice(pos));
+ start();
+ }
+ __name(gotResolvedLink, "gotResolvedLink");
+ }, "realpath");
+ }
+});
+
+// ../../node_modules/.pnpm/fs.realpath@1.0.0/node_modules/fs.realpath/index.js
+var require_fs = __commonJS({
+ "../../node_modules/.pnpm/fs.realpath@1.0.0/node_modules/fs.realpath/index.js"(exports2, module2) {
+ init_import_meta_url();
+ module2.exports = realpath;
+ realpath.realpath = realpath;
+ realpath.sync = realpathSync3;
+ realpath.realpathSync = realpathSync3;
+ realpath.monkeypatch = monkeypatch;
+ realpath.unmonkeypatch = unmonkeypatch;
+ var fs20 = require("fs");
+ var origRealpath = fs20.realpath;
+ var origRealpathSync = fs20.realpathSync;
+ var version2 = process.version;
+ var ok = /^v[0-5]\./.test(version2);
+ var old = require_old();
+ function newError(er) {
+ return er && er.syscall === "realpath" && (er.code === "ELOOP" || er.code === "ENOMEM" || er.code === "ENAMETOOLONG");
+ }
+ __name(newError, "newError");
+ function realpath(p, cache2, cb) {
+ if (ok) {
+ return origRealpath(p, cache2, cb);
+ }
+ if (typeof cache2 === "function") {
+ cb = cache2;
+ cache2 = null;
+ }
+ origRealpath(p, cache2, function(er, result) {
+ if (newError(er)) {
+ old.realpath(p, cache2, cb);
+ } else {
+ cb(er, result);
+ }
+ });
+ }
+ __name(realpath, "realpath");
+ function realpathSync3(p, cache2) {
+ if (ok) {
+ return origRealpathSync(p, cache2);
+ }
+ try {
+ return origRealpathSync(p, cache2);
+ } catch (er) {
+ if (newError(er)) {
+ return old.realpathSync(p, cache2);
+ } else {
+ throw er;
+ }
+ }
+ }
+ __name(realpathSync3, "realpathSync");
+ function monkeypatch() {
+ fs20.realpath = realpath;
+ fs20.realpathSync = realpathSync3;
+ }
+ __name(monkeypatch, "monkeypatch");
+ function unmonkeypatch() {
+ fs20.realpath = origRealpath;
+ fs20.realpathSync = origRealpathSync;
+ }
+ __name(unmonkeypatch, "unmonkeypatch");
+ }
+});
+
+// ../../node_modules/.pnpm/concat-map@0.0.1/node_modules/concat-map/index.js
+var require_concat_map = __commonJS({
+ "../../node_modules/.pnpm/concat-map@0.0.1/node_modules/concat-map/index.js"(exports2, module2) {
+ init_import_meta_url();
+ module2.exports = function(xs, fn2) {
+ var res = [];
+ for (var i = 0; i < xs.length; i++) {
+ var x = fn2(xs[i], i);
+ if (isArray(x))
+ res.push.apply(res, x);
+ else
+ res.push(x);
+ }
+ return res;
+ };
+ var isArray = Array.isArray || function(xs) {
+ return Object.prototype.toString.call(xs) === "[object Array]";
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/balanced-match@1.0.2/node_modules/balanced-match/index.js
+var require_balanced_match = __commonJS({
+ "../../node_modules/.pnpm/balanced-match@1.0.2/node_modules/balanced-match/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ module2.exports = balanced;
+ function balanced(a, b, str) {
+ if (a instanceof RegExp)
+ a = maybeMatch(a, str);
+ if (b instanceof RegExp)
+ b = maybeMatch(b, str);
+ var r = range(a, b, str);
+ return r && {
+ start: r[0],
+ end: r[1],
+ pre: str.slice(0, r[0]),
+ body: str.slice(r[0] + a.length, r[1]),
+ post: str.slice(r[1] + b.length)
+ };
+ }
+ __name(balanced, "balanced");
+ function maybeMatch(reg, str) {
+ var m = str.match(reg);
+ return m ? m[0] : null;
+ }
+ __name(maybeMatch, "maybeMatch");
+ balanced.range = range;
+ function range(a, b, str) {
+ var begs, beg, left2, right2, result;
+ var ai = str.indexOf(a);
+ var bi = str.indexOf(b, ai + 1);
+ var i = ai;
+ if (ai >= 0 && bi > 0) {
+ if (a === b) {
+ return [ai, bi];
+ }
+ begs = [];
+ left2 = str.length;
+ while (i >= 0 && !result) {
+ if (i == ai) {
+ begs.push(i);
+ ai = str.indexOf(a, i + 1);
+ } else if (begs.length == 1) {
+ result = [begs.pop(), bi];
+ } else {
+ beg = begs.pop();
+ if (beg < left2) {
+ left2 = beg;
+ right2 = bi;
+ }
+ bi = str.indexOf(b, i + 1);
+ }
+ i = ai < bi && ai >= 0 ? ai : bi;
+ }
+ if (begs.length) {
+ result = [left2, right2];
+ }
+ }
+ return result;
+ }
+ __name(range, "range");
+ }
+});
+
+// ../../node_modules/.pnpm/brace-expansion@1.1.11/node_modules/brace-expansion/index.js
+var require_brace_expansion = __commonJS({
+ "../../node_modules/.pnpm/brace-expansion@1.1.11/node_modules/brace-expansion/index.js"(exports2, module2) {
+ init_import_meta_url();
+ var concatMap = require_concat_map();
+ var balanced = require_balanced_match();
+ module2.exports = expandTop;
+ var escSlash = "\0SLASH" + Math.random() + "\0";
+ var escOpen = "\0OPEN" + Math.random() + "\0";
+ var escClose = "\0CLOSE" + Math.random() + "\0";
+ var escComma = "\0COMMA" + Math.random() + "\0";
+ var escPeriod = "\0PERIOD" + Math.random() + "\0";
+ function numeric(str) {
+ return parseInt(str, 10) == str ? parseInt(str, 10) : str.charCodeAt(0);
+ }
+ __name(numeric, "numeric");
+ function escapeBraces(str) {
+ return str.split("\\\\").join(escSlash).split("\\{").join(escOpen).split("\\}").join(escClose).split("\\,").join(escComma).split("\\.").join(escPeriod);
+ }
+ __name(escapeBraces, "escapeBraces");
+ function unescapeBraces(str) {
+ return str.split(escSlash).join("\\").split(escOpen).join("{").split(escClose).join("}").split(escComma).join(",").split(escPeriod).join(".");
+ }
+ __name(unescapeBraces, "unescapeBraces");
+ function parseCommaParts(str) {
+ if (!str)
+ return [""];
+ var parts = [];
+ var m = balanced("{", "}", str);
+ if (!m)
+ return str.split(",");
+ var pre = m.pre;
+ var body = m.body;
+ var post = m.post;
+ var p = pre.split(",");
+ p[p.length - 1] += "{" + body + "}";
+ var postParts = parseCommaParts(post);
+ if (post.length) {
+ p[p.length - 1] += postParts.shift();
+ p.push.apply(p, postParts);
+ }
+ parts.push.apply(parts, p);
+ return parts;
+ }
+ __name(parseCommaParts, "parseCommaParts");
+ function expandTop(str) {
+ if (!str)
+ return [];
+ if (str.substr(0, 2) === "{}") {
+ str = "\\{\\}" + str.substr(2);
+ }
+ return expand(escapeBraces(str), true).map(unescapeBraces);
+ }
+ __name(expandTop, "expandTop");
+ function embrace(str) {
+ return "{" + str + "}";
+ }
+ __name(embrace, "embrace");
+ function isPadded(el) {
+ return /^-?0\d/.test(el);
+ }
+ __name(isPadded, "isPadded");
+ function lte(i, y) {
+ return i <= y;
+ }
+ __name(lte, "lte");
+ function gte(i, y) {
+ return i >= y;
+ }
+ __name(gte, "gte");
+ function expand(str, isTop) {
+ var expansions = [];
+ var m = balanced("{", "}", str);
+ if (!m || /\$$/.test(m.pre))
+ return [str];
+ var isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
+ var isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
+ var isSequence = isNumericSequence || isAlphaSequence;
+ var isOptions = m.body.indexOf(",") >= 0;
+ if (!isSequence && !isOptions) {
+ if (m.post.match(/,.*\}/)) {
+ str = m.pre + "{" + m.body + escClose + m.post;
+ return expand(str);
+ }
+ return [str];
+ }
+ var n;
+ if (isSequence) {
+ n = m.body.split(/\.\./);
+ } else {
+ n = parseCommaParts(m.body);
+ if (n.length === 1) {
+ n = expand(n[0], false).map(embrace);
+ if (n.length === 1) {
+ var post = m.post.length ? expand(m.post, false) : [""];
+ return post.map(function(p) {
+ return m.pre + n[0] + p;
+ });
+ }
+ }
+ }
+ var pre = m.pre;
+ var post = m.post.length ? expand(m.post, false) : [""];
+ var N;
+ if (isSequence) {
+ var x = numeric(n[0]);
+ var y = numeric(n[1]);
+ var width = Math.max(n[0].length, n[1].length);
+ var incr = n.length == 3 ? Math.abs(numeric(n[2])) : 1;
+ var test = lte;
+ var reverse = y < x;
+ if (reverse) {
+ incr *= -1;
+ test = gte;
+ }
+ var pad2 = n.some(isPadded);
+ N = [];
+ for (var i = x; test(i, y); i += incr) {
+ var c;
+ if (isAlphaSequence) {
+ c = String.fromCharCode(i);
+ if (c === "\\")
+ c = "";
+ } else {
+ c = String(i);
+ if (pad2) {
+ var need = width - c.length;
+ if (need > 0) {
+ var z = new Array(need + 1).join("0");
+ if (i < 0)
+ c = "-" + z + c.slice(1);
+ else
+ c = z + c;
+ }
+ }
+ }
+ N.push(c);
+ }
+ } else {
+ N = concatMap(n, function(el) {
+ return expand(el, false);
+ });
+ }
+ for (var j = 0; j < N.length; j++) {
+ for (var k = 0; k < post.length; k++) {
+ var expansion = pre + N[j] + post[k];
+ if (!isTop || isSequence || expansion)
+ expansions.push(expansion);
+ }
+ }
+ return expansions;
+ }
+ __name(expand, "expand");
+ }
+});
+
+// ../../node_modules/.pnpm/minimatch@3.1.2/node_modules/minimatch/minimatch.js
+var require_minimatch = __commonJS({
+ "../../node_modules/.pnpm/minimatch@3.1.2/node_modules/minimatch/minimatch.js"(exports2, module2) {
+ init_import_meta_url();
+ module2.exports = minimatch;
+ minimatch.Minimatch = Minimatch2;
+ var path45 = function() {
+ try {
+ return require("path");
+ } catch (e2) {
+ }
+ }() || {
+ sep: "/"
+ };
+ minimatch.sep = path45.sep;
+ var GLOBSTAR = minimatch.GLOBSTAR = Minimatch2.GLOBSTAR = {};
+ var expand = require_brace_expansion();
+ var plTypes = {
+ "!": { open: "(?:(?!(?:", close: "))[^/]*?)" },
+ "?": { open: "(?:", close: ")?" },
+ "+": { open: "(?:", close: ")+" },
+ "*": { open: "(?:", close: ")*" },
+ "@": { open: "(?:", close: ")" }
+ };
+ var qmark = "[^/]";
+ var star = qmark + "*?";
+ var twoStarDot = "(?:(?!(?:\\/|^)(?:\\.{1,2})($|\\/)).)*?";
+ var twoStarNoDot = "(?:(?!(?:\\/|^)\\.).)*?";
+ var reSpecials = charSet("().*{}+?[]^$\\!");
+ function charSet(s) {
+ return s.split("").reduce(function(set, c) {
+ set[c] = true;
+ return set;
+ }, {});
+ }
+ __name(charSet, "charSet");
+ var slashSplit = /\/+/;
+ minimatch.filter = filter;
+ function filter(pattern, options14) {
+ options14 = options14 || {};
+ return function(p, i, list) {
+ return minimatch(p, pattern, options14);
+ };
+ }
+ __name(filter, "filter");
+ function ext(a, b) {
+ b = b || {};
+ var t2 = {};
+ Object.keys(a).forEach(function(k) {
+ t2[k] = a[k];
+ });
+ Object.keys(b).forEach(function(k) {
+ t2[k] = b[k];
+ });
+ return t2;
+ }
+ __name(ext, "ext");
+ minimatch.defaults = function(def) {
+ if (!def || typeof def !== "object" || !Object.keys(def).length) {
+ return minimatch;
+ }
+ var orig = minimatch;
+ var m = /* @__PURE__ */ __name(function minimatch2(p, pattern, options14) {
+ return orig(p, pattern, ext(def, options14));
+ }, "minimatch");
+ m.Minimatch = /* @__PURE__ */ __name(function Minimatch3(pattern, options14) {
+ return new orig.Minimatch(pattern, ext(def, options14));
+ }, "Minimatch");
+ m.Minimatch.defaults = /* @__PURE__ */ __name(function defaults(options14) {
+ return orig.defaults(ext(def, options14)).Minimatch;
+ }, "defaults");
+ m.filter = /* @__PURE__ */ __name(function filter2(pattern, options14) {
+ return orig.filter(pattern, ext(def, options14));
+ }, "filter");
+ m.defaults = /* @__PURE__ */ __name(function defaults(options14) {
+ return orig.defaults(ext(def, options14));
+ }, "defaults");
+ m.makeRe = /* @__PURE__ */ __name(function makeRe2(pattern, options14) {
+ return orig.makeRe(pattern, ext(def, options14));
+ }, "makeRe");
+ m.braceExpand = /* @__PURE__ */ __name(function braceExpand2(pattern, options14) {
+ return orig.braceExpand(pattern, ext(def, options14));
+ }, "braceExpand");
+ m.match = function(list, pattern, options14) {
+ return orig.match(list, pattern, ext(def, options14));
+ };
+ return m;
+ };
+ Minimatch2.defaults = function(def) {
+ return minimatch.defaults(def).Minimatch;
+ };
+ function minimatch(p, pattern, options14) {
+ assertValidPattern(pattern);
+ if (!options14)
+ options14 = {};
+ if (!options14.nocomment && pattern.charAt(0) === "#") {
+ return false;
+ }
+ return new Minimatch2(pattern, options14).match(p);
+ }
+ __name(minimatch, "minimatch");
+ function Minimatch2(pattern, options14) {
+ if (!(this instanceof Minimatch2)) {
+ return new Minimatch2(pattern, options14);
+ }
+ assertValidPattern(pattern);
+ if (!options14)
+ options14 = {};
+ pattern = pattern.trim();
+ if (!options14.allowWindowsEscape && path45.sep !== "/") {
+ pattern = pattern.split(path45.sep).join("/");
+ }
+ this.options = options14;
+ this.set = [];
+ this.pattern = pattern;
+ this.regexp = null;
+ this.negate = false;
+ this.comment = false;
+ this.empty = false;
+ this.partial = !!options14.partial;
+ this.make();
+ }
+ __name(Minimatch2, "Minimatch");
+ Minimatch2.prototype.debug = function() {
+ };
+ Minimatch2.prototype.make = make;
+ function make() {
+ var pattern = this.pattern;
+ var options14 = this.options;
+ if (!options14.nocomment && pattern.charAt(0) === "#") {
+ this.comment = true;
+ return;
+ }
+ if (!pattern) {
+ this.empty = true;
+ return;
+ }
+ this.parseNegate();
+ var set = this.globSet = this.braceExpand();
+ if (options14.debug)
+ this.debug = /* @__PURE__ */ __name(function debug() {
+ console.error.apply(console, arguments);
+ }, "debug");
+ this.debug(this.pattern, set);
+ set = this.globParts = set.map(function(s) {
+ return s.split(slashSplit);
+ });
+ this.debug(this.pattern, set);
+ set = set.map(function(s, si2, set2) {
+ return s.map(this.parse, this);
+ }, this);
+ this.debug(this.pattern, set);
+ set = set.filter(function(s) {
+ return s.indexOf(false) === -1;
+ });
+ this.debug(this.pattern, set);
+ this.set = set;
+ }
+ __name(make, "make");
+ Minimatch2.prototype.parseNegate = parseNegate;
+ function parseNegate() {
+ var pattern = this.pattern;
+ var negate = false;
+ var options14 = this.options;
+ var negateOffset = 0;
+ if (options14.nonegate)
+ return;
+ for (var i = 0, l = pattern.length; i < l && pattern.charAt(i) === "!"; i++) {
+ negate = !negate;
+ negateOffset++;
+ }
+ if (negateOffset)
+ this.pattern = pattern.substr(negateOffset);
+ this.negate = negate;
+ }
+ __name(parseNegate, "parseNegate");
+ minimatch.braceExpand = function(pattern, options14) {
+ return braceExpand(pattern, options14);
+ };
+ Minimatch2.prototype.braceExpand = braceExpand;
+ function braceExpand(pattern, options14) {
+ if (!options14) {
+ if (this instanceof Minimatch2) {
+ options14 = this.options;
+ } else {
+ options14 = {};
+ }
+ }
+ pattern = typeof pattern === "undefined" ? this.pattern : pattern;
+ assertValidPattern(pattern);
+ if (options14.nobrace || !/\{(?:(?!\{).)*\}/.test(pattern)) {
+ return [pattern];
+ }
+ return expand(pattern);
+ }
+ __name(braceExpand, "braceExpand");
+ var MAX_PATTERN_LENGTH = 1024 * 64;
+ var assertValidPattern = /* @__PURE__ */ __name(function(pattern) {
+ if (typeof pattern !== "string") {
+ throw new TypeError("invalid pattern");
+ }
+ if (pattern.length > MAX_PATTERN_LENGTH) {
+ throw new TypeError("pattern is too long");
+ }
+ }, "assertValidPattern");
+ Minimatch2.prototype.parse = parse4;
+ var SUBPARSE = {};
+ function parse4(pattern, isSub) {
+ assertValidPattern(pattern);
+ var options14 = this.options;
+ if (pattern === "**") {
+ if (!options14.noglobstar)
+ return GLOBSTAR;
+ else
+ pattern = "*";
+ }
+ if (pattern === "")
+ return "";
+ var re = "";
+ var hasMagic = !!options14.nocase;
+ var escaping = false;
+ var patternListStack = [];
+ var negativeLists = [];
+ var stateChar;
+ var inClass = false;
+ var reClassStart = -1;
+ var classStart = -1;
+ var patternStart = pattern.charAt(0) === "." ? "" : options14.dot ? "(?!(?:^|\\/)\\.{1,2}(?:$|\\/))" : "(?!\\.)";
+ var self2 = this;
+ function clearStateChar() {
+ if (stateChar) {
+ switch (stateChar) {
+ case "*":
+ re += star;
+ hasMagic = true;
+ break;
+ case "?":
+ re += qmark;
+ hasMagic = true;
+ break;
+ default:
+ re += "\\" + stateChar;
+ break;
+ }
+ self2.debug("clearStateChar %j %j", stateChar, re);
+ stateChar = false;
+ }
+ }
+ __name(clearStateChar, "clearStateChar");
+ for (var i = 0, len = pattern.length, c; i < len && (c = pattern.charAt(i)); i++) {
+ this.debug("%s %s %s %j", pattern, i, re, c);
+ if (escaping && reSpecials[c]) {
+ re += "\\" + c;
+ escaping = false;
+ continue;
+ }
+ switch (c) {
+ case "/": {
+ return false;
+ }
+ case "\\":
+ clearStateChar();
+ escaping = true;
+ continue;
+ case "?":
+ case "*":
+ case "+":
+ case "@":
+ case "!":
+ this.debug("%s %s %s %j <-- stateChar", pattern, i, re, c);
+ if (inClass) {
+ this.debug(" in class");
+ if (c === "!" && i === classStart + 1)
+ c = "^";
+ re += c;
+ continue;
+ }
+ self2.debug("call clearStateChar %j", stateChar);
+ clearStateChar();
+ stateChar = c;
+ if (options14.noext)
+ clearStateChar();
+ continue;
+ case "(":
+ if (inClass) {
+ re += "(";
+ continue;
+ }
+ if (!stateChar) {
+ re += "\\(";
+ continue;
+ }
+ patternListStack.push({
+ type: stateChar,
+ start: i - 1,
+ reStart: re.length,
+ open: plTypes[stateChar].open,
+ close: plTypes[stateChar].close
+ });
+ re += stateChar === "!" ? "(?:(?!(?:" : "(?:";
+ this.debug("plType %j %j", stateChar, re);
+ stateChar = false;
+ continue;
+ case ")":
+ if (inClass || !patternListStack.length) {
+ re += "\\)";
+ continue;
+ }
+ clearStateChar();
+ hasMagic = true;
+ var pl2 = patternListStack.pop();
+ re += pl2.close;
+ if (pl2.type === "!") {
+ negativeLists.push(pl2);
+ }
+ pl2.reEnd = re.length;
+ continue;
+ case "|":
+ if (inClass || !patternListStack.length || escaping) {
+ re += "\\|";
+ escaping = false;
+ continue;
+ }
+ clearStateChar();
+ re += "|";
+ continue;
+ case "[":
+ clearStateChar();
+ if (inClass) {
+ re += "\\" + c;
+ continue;
+ }
+ inClass = true;
+ classStart = i;
+ reClassStart = re.length;
+ re += c;
+ continue;
+ case "]":
+ if (i === classStart + 1 || !inClass) {
+ re += "\\" + c;
+ escaping = false;
+ continue;
+ }
+ var cs2 = pattern.substring(classStart + 1, i);
+ try {
+ RegExp("[" + cs2 + "]");
+ } catch (er) {
+ var sp = this.parse(cs2, SUBPARSE);
+ re = re.substr(0, reClassStart) + "\\[" + sp[0] + "\\]";
+ hasMagic = hasMagic || sp[1];
+ inClass = false;
+ continue;
+ }
+ hasMagic = true;
+ inClass = false;
+ re += c;
+ continue;
+ default:
+ clearStateChar();
+ if (escaping) {
+ escaping = false;
+ } else if (reSpecials[c] && !(c === "^" && inClass)) {
+ re += "\\";
+ }
+ re += c;
+ }
+ }
+ if (inClass) {
+ cs2 = pattern.substr(classStart + 1);
+ sp = this.parse(cs2, SUBPARSE);
+ re = re.substr(0, reClassStart) + "\\[" + sp[0];
+ hasMagic = hasMagic || sp[1];
+ }
+ for (pl2 = patternListStack.pop(); pl2; pl2 = patternListStack.pop()) {
+ var tail = re.slice(pl2.reStart + pl2.open.length);
+ this.debug("setting tail", re, pl2);
+ tail = tail.replace(/((?:\\{2}){0,64})(\\?)\|/g, function(_2, $1, $2) {
+ if (!$2) {
+ $2 = "\\";
+ }
+ return $1 + $1 + $2 + "|";
+ });
+ this.debug("tail=%j\n %s", tail, tail, pl2, re);
+ var t2 = pl2.type === "*" ? star : pl2.type === "?" ? qmark : "\\" + pl2.type;
+ hasMagic = true;
+ re = re.slice(0, pl2.reStart) + t2 + "\\(" + tail;
+ }
+ clearStateChar();
+ if (escaping) {
+ re += "\\\\";
+ }
+ var addPatternStart = false;
+ switch (re.charAt(0)) {
+ case "[":
+ case ".":
+ case "(":
+ addPatternStart = true;
+ }
+ for (var n = negativeLists.length - 1; n > -1; n--) {
+ var nl = negativeLists[n];
+ var nlBefore = re.slice(0, nl.reStart);
+ var nlFirst = re.slice(nl.reStart, nl.reEnd - 8);
+ var nlLast = re.slice(nl.reEnd - 8, nl.reEnd);
+ var nlAfter = re.slice(nl.reEnd);
+ nlLast += nlAfter;
+ var openParensBefore = nlBefore.split("(").length - 1;
+ var cleanAfter = nlAfter;
+ for (i = 0; i < openParensBefore; i++) {
+ cleanAfter = cleanAfter.replace(/\)[+*?]?/, "");
+ }
+ nlAfter = cleanAfter;
+ var dollar = "";
+ if (nlAfter === "" && isSub !== SUBPARSE) {
+ dollar = "$";
+ }
+ var newRe = nlBefore + nlFirst + nlAfter + dollar + nlLast;
+ re = newRe;
+ }
+ if (re !== "" && hasMagic) {
+ re = "(?=.)" + re;
+ }
+ if (addPatternStart) {
+ re = patternStart + re;
+ }
+ if (isSub === SUBPARSE) {
+ return [re, hasMagic];
+ }
+ if (!hasMagic) {
+ return globUnescape(pattern);
+ }
+ var flags = options14.nocase ? "i" : "";
+ try {
+ var regExp = new RegExp("^" + re + "$", flags);
+ } catch (er) {
+ return new RegExp("$.");
+ }
+ regExp._glob = pattern;
+ regExp._src = re;
+ return regExp;
+ }
+ __name(parse4, "parse");
+ minimatch.makeRe = function(pattern, options14) {
+ return new Minimatch2(pattern, options14 || {}).makeRe();
+ };
+ Minimatch2.prototype.makeRe = makeRe;
+ function makeRe() {
+ if (this.regexp || this.regexp === false)
+ return this.regexp;
+ var set = this.set;
+ if (!set.length) {
+ this.regexp = false;
+ return this.regexp;
+ }
+ var options14 = this.options;
+ var twoStar = options14.noglobstar ? star : options14.dot ? twoStarDot : twoStarNoDot;
+ var flags = options14.nocase ? "i" : "";
+ var re = set.map(function(pattern) {
+ return pattern.map(function(p) {
+ return p === GLOBSTAR ? twoStar : typeof p === "string" ? regExpEscape(p) : p._src;
+ }).join("\\/");
+ }).join("|");
+ re = "^(?:" + re + ")$";
+ if (this.negate)
+ re = "^(?!" + re + ").*$";
+ try {
+ this.regexp = new RegExp(re, flags);
+ } catch (ex) {
+ this.regexp = false;
+ }
+ return this.regexp;
+ }
+ __name(makeRe, "makeRe");
+ minimatch.match = function(list, pattern, options14) {
+ options14 = options14 || {};
+ var mm = new Minimatch2(pattern, options14);
+ list = list.filter(function(f) {
+ return mm.match(f);
+ });
+ if (mm.options.nonull && !list.length) {
+ list.push(pattern);
+ }
+ return list;
+ };
+ Minimatch2.prototype.match = /* @__PURE__ */ __name(function match(f, partial) {
+ if (typeof partial === "undefined")
+ partial = this.partial;
+ this.debug("match", f, this.pattern);
+ if (this.comment)
+ return false;
+ if (this.empty)
+ return f === "";
+ if (f === "/" && partial)
+ return true;
+ var options14 = this.options;
+ if (path45.sep !== "/") {
+ f = f.split(path45.sep).join("/");
+ }
+ f = f.split(slashSplit);
+ this.debug(this.pattern, "split", f);
+ var set = this.set;
+ this.debug(this.pattern, "set", set);
+ var filename;
+ var i;
+ for (i = f.length - 1; i >= 0; i--) {
+ filename = f[i];
+ if (filename)
+ break;
+ }
+ for (i = 0; i < set.length; i++) {
+ var pattern = set[i];
+ var file = f;
+ if (options14.matchBase && pattern.length === 1) {
+ file = [filename];
+ }
+ var hit = this.matchOne(file, pattern, partial);
+ if (hit) {
+ if (options14.flipNegate)
+ return true;
+ return !this.negate;
+ }
+ }
+ if (options14.flipNegate)
+ return false;
+ return this.negate;
+ }, "match");
+ Minimatch2.prototype.matchOne = function(file, pattern, partial) {
+ var options14 = this.options;
+ this.debug(
+ "matchOne",
+ { "this": this, file, pattern }
+ );
+ this.debug("matchOne", file.length, pattern.length);
+ for (var fi = 0, pi = 0, fl = file.length, pl2 = pattern.length; fi < fl && pi < pl2; fi++, pi++) {
+ this.debug("matchOne loop");
+ var p = pattern[pi];
+ var f = file[fi];
+ this.debug(pattern, p, f);
+ if (p === false)
+ return false;
+ if (p === GLOBSTAR) {
+ this.debug("GLOBSTAR", [pattern, p, f]);
+ var fr2 = fi;
+ var pr = pi + 1;
+ if (pr === pl2) {
+ this.debug("** at the end");
+ for (; fi < fl; fi++) {
+ if (file[fi] === "." || file[fi] === ".." || !options14.dot && file[fi].charAt(0) === ".")
+ return false;
+ }
+ return true;
+ }
+ while (fr2 < fl) {
+ var swallowee = file[fr2];
+ this.debug("\nglobstar while", file, fr2, pattern, pr, swallowee);
+ if (this.matchOne(file.slice(fr2), pattern.slice(pr), partial)) {
+ this.debug("globstar found match!", fr2, fl, swallowee);
+ return true;
+ } else {
+ if (swallowee === "." || swallowee === ".." || !options14.dot && swallowee.charAt(0) === ".") {
+ this.debug("dot detected!", file, fr2, pattern, pr);
+ break;
+ }
+ this.debug("globstar swallow a segment, and continue");
+ fr2++;
+ }
+ }
+ if (partial) {
+ this.debug("\n>>> no match, partial?", file, fr2, pattern, pr);
+ if (fr2 === fl)
+ return true;
+ }
+ return false;
+ }
+ var hit;
+ if (typeof p === "string") {
+ hit = f === p;
+ this.debug("string match", p, f, hit);
+ } else {
+ hit = f.match(p);
+ this.debug("pattern match", p, f, hit);
+ }
+ if (!hit)
+ return false;
+ }
+ if (fi === fl && pi === pl2) {
+ return true;
+ } else if (fi === fl) {
+ return partial;
+ } else if (pi === pl2) {
+ return fi === fl - 1 && file[fi] === "";
+ }
+ throw new Error("wtf?");
+ };
+ function globUnescape(s) {
+ return s.replace(/\\(.)/g, "$1");
+ }
+ __name(globUnescape, "globUnescape");
+ function regExpEscape(s) {
+ return s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+ }
+ __name(regExpEscape, "regExpEscape");
+ }
+});
+
+// ../../node_modules/.pnpm/inherits@2.0.4/node_modules/inherits/inherits_browser.js
+var require_inherits_browser = __commonJS({
+ "../../node_modules/.pnpm/inherits@2.0.4/node_modules/inherits/inherits_browser.js"(exports2, module2) {
+ init_import_meta_url();
+ if (typeof Object.create === "function") {
+ module2.exports = /* @__PURE__ */ __name(function inherits(ctor, superCtor) {
+ if (superCtor) {
+ ctor.super_ = superCtor;
+ ctor.prototype = Object.create(superCtor.prototype, {
+ constructor: {
+ value: ctor,
+ enumerable: false,
+ writable: true,
+ configurable: true
+ }
+ });
+ }
+ }, "inherits");
+ } else {
+ module2.exports = /* @__PURE__ */ __name(function inherits(ctor, superCtor) {
+ if (superCtor) {
+ ctor.super_ = superCtor;
+ var TempCtor = /* @__PURE__ */ __name(function() {
+ }, "TempCtor");
+ TempCtor.prototype = superCtor.prototype;
+ ctor.prototype = new TempCtor();
+ ctor.prototype.constructor = ctor;
+ }
+ }, "inherits");
+ }
+ }
+});
+
+// ../../node_modules/.pnpm/inherits@2.0.4/node_modules/inherits/inherits.js
+var require_inherits = __commonJS({
+ "../../node_modules/.pnpm/inherits@2.0.4/node_modules/inherits/inherits.js"(exports2, module2) {
+ init_import_meta_url();
+ try {
+ util3 = require("util");
+ if (typeof util3.inherits !== "function")
+ throw "";
+ module2.exports = util3.inherits;
+ } catch (e2) {
+ module2.exports = require_inherits_browser();
+ }
+ var util3;
+ }
+});
+
+// ../../node_modules/.pnpm/path-is-absolute@1.0.1/node_modules/path-is-absolute/index.js
+var require_path_is_absolute = __commonJS({
+ "../../node_modules/.pnpm/path-is-absolute@1.0.1/node_modules/path-is-absolute/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ function posix(path45) {
+ return path45.charAt(0) === "/";
+ }
+ __name(posix, "posix");
+ function win32(path45) {
+ var splitDeviceRe = /^([a-zA-Z]:|[\\\/]{2}[^\\\/]+[\\\/]+[^\\\/]+)?([\\\/])?([\s\S]*?)$/;
+ var result = splitDeviceRe.exec(path45);
+ var device = result[1] || "";
+ var isUnc = Boolean(device && device.charAt(1) !== ":");
+ return Boolean(result[2] || isUnc);
+ }
+ __name(win32, "win32");
+ module2.exports = process.platform === "win32" ? win32 : posix;
+ module2.exports.posix = posix;
+ module2.exports.win32 = win32;
+ }
+});
+
+// ../../node_modules/.pnpm/glob@7.2.0/node_modules/glob/common.js
+var require_common = __commonJS({
+ "../../node_modules/.pnpm/glob@7.2.0/node_modules/glob/common.js"(exports2) {
+ init_import_meta_url();
+ exports2.setopts = setopts;
+ exports2.ownProp = ownProp;
+ exports2.makeAbs = makeAbs;
+ exports2.finish = finish;
+ exports2.mark = mark;
+ exports2.isIgnored = isIgnored;
+ exports2.childrenIgnored = childrenIgnored;
+ function ownProp(obj, field) {
+ return Object.prototype.hasOwnProperty.call(obj, field);
+ }
+ __name(ownProp, "ownProp");
+ var fs20 = require("fs");
+ var path45 = require("path");
+ var minimatch = require_minimatch();
+ var isAbsolute = require_path_is_absolute();
+ var Minimatch2 = minimatch.Minimatch;
+ function alphasort(a, b) {
+ return a.localeCompare(b, "en");
+ }
+ __name(alphasort, "alphasort");
+ function setupIgnores(self2, options14) {
+ self2.ignore = options14.ignore || [];
+ if (!Array.isArray(self2.ignore))
+ self2.ignore = [self2.ignore];
+ if (self2.ignore.length) {
+ self2.ignore = self2.ignore.map(ignoreMap);
+ }
+ }
+ __name(setupIgnores, "setupIgnores");
+ function ignoreMap(pattern) {
+ var gmatcher = null;
+ if (pattern.slice(-3) === "/**") {
+ var gpattern = pattern.replace(/(\/\*\*)+$/, "");
+ gmatcher = new Minimatch2(gpattern, { dot: true });
+ }
+ return {
+ matcher: new Minimatch2(pattern, { dot: true }),
+ gmatcher
+ };
+ }
+ __name(ignoreMap, "ignoreMap");
+ function setopts(self2, pattern, options14) {
+ if (!options14)
+ options14 = {};
+ if (options14.matchBase && -1 === pattern.indexOf("/")) {
+ if (options14.noglobstar) {
+ throw new Error("base matching requires globstar");
+ }
+ pattern = "**/" + pattern;
+ }
+ self2.silent = !!options14.silent;
+ self2.pattern = pattern;
+ self2.strict = options14.strict !== false;
+ self2.realpath = !!options14.realpath;
+ self2.realpathCache = options14.realpathCache || /* @__PURE__ */ Object.create(null);
+ self2.follow = !!options14.follow;
+ self2.dot = !!options14.dot;
+ self2.mark = !!options14.mark;
+ self2.nodir = !!options14.nodir;
+ if (self2.nodir)
+ self2.mark = true;
+ self2.sync = !!options14.sync;
+ self2.nounique = !!options14.nounique;
+ self2.nonull = !!options14.nonull;
+ self2.nosort = !!options14.nosort;
+ self2.nocase = !!options14.nocase;
+ self2.stat = !!options14.stat;
+ self2.noprocess = !!options14.noprocess;
+ self2.absolute = !!options14.absolute;
+ self2.fs = options14.fs || fs20;
+ self2.maxLength = options14.maxLength || Infinity;
+ self2.cache = options14.cache || /* @__PURE__ */ Object.create(null);
+ self2.statCache = options14.statCache || /* @__PURE__ */ Object.create(null);
+ self2.symlinks = options14.symlinks || /* @__PURE__ */ Object.create(null);
+ setupIgnores(self2, options14);
+ self2.changedCwd = false;
+ var cwd2 = process.cwd();
+ if (!ownProp(options14, "cwd"))
+ self2.cwd = cwd2;
+ else {
+ self2.cwd = path45.resolve(options14.cwd);
+ self2.changedCwd = self2.cwd !== cwd2;
+ }
+ self2.root = options14.root || path45.resolve(self2.cwd, "/");
+ self2.root = path45.resolve(self2.root);
+ if (process.platform === "win32")
+ self2.root = self2.root.replace(/\\/g, "/");
+ self2.cwdAbs = isAbsolute(self2.cwd) ? self2.cwd : makeAbs(self2, self2.cwd);
+ if (process.platform === "win32")
+ self2.cwdAbs = self2.cwdAbs.replace(/\\/g, "/");
+ self2.nomount = !!options14.nomount;
+ options14.nonegate = true;
+ options14.nocomment = true;
+ self2.minimatch = new Minimatch2(pattern, options14);
+ self2.options = self2.minimatch.options;
+ }
+ __name(setopts, "setopts");
+ function finish(self2) {
+ var nou = self2.nounique;
+ var all2 = nou ? [] : /* @__PURE__ */ Object.create(null);
+ for (var i = 0, l = self2.matches.length; i < l; i++) {
+ var matches = self2.matches[i];
+ if (!matches || Object.keys(matches).length === 0) {
+ if (self2.nonull) {
+ var literal = self2.minimatch.globSet[i];
+ if (nou)
+ all2.push(literal);
+ else
+ all2[literal] = true;
+ }
+ } else {
+ var m = Object.keys(matches);
+ if (nou)
+ all2.push.apply(all2, m);
+ else
+ m.forEach(function(m2) {
+ all2[m2] = true;
+ });
+ }
+ }
+ if (!nou)
+ all2 = Object.keys(all2);
+ if (!self2.nosort)
+ all2 = all2.sort(alphasort);
+ if (self2.mark) {
+ for (var i = 0; i < all2.length; i++) {
+ all2[i] = self2._mark(all2[i]);
+ }
+ if (self2.nodir) {
+ all2 = all2.filter(function(e2) {
+ var notDir = !/\/$/.test(e2);
+ var c = self2.cache[e2] || self2.cache[makeAbs(self2, e2)];
+ if (notDir && c)
+ notDir = c !== "DIR" && !Array.isArray(c);
+ return notDir;
+ });
+ }
+ }
+ if (self2.ignore.length)
+ all2 = all2.filter(function(m2) {
+ return !isIgnored(self2, m2);
+ });
+ self2.found = all2;
+ }
+ __name(finish, "finish");
+ function mark(self2, p) {
+ var abs = makeAbs(self2, p);
+ var c = self2.cache[abs];
+ var m = p;
+ if (c) {
+ var isDir = c === "DIR" || Array.isArray(c);
+ var slash = p.slice(-1) === "/";
+ if (isDir && !slash)
+ m += "/";
+ else if (!isDir && slash)
+ m = m.slice(0, -1);
+ if (m !== p) {
+ var mabs = makeAbs(self2, m);
+ self2.statCache[mabs] = self2.statCache[abs];
+ self2.cache[mabs] = self2.cache[abs];
+ }
+ }
+ return m;
+ }
+ __name(mark, "mark");
+ function makeAbs(self2, f) {
+ var abs = f;
+ if (f.charAt(0) === "/") {
+ abs = path45.join(self2.root, f);
+ } else if (isAbsolute(f) || f === "") {
+ abs = f;
+ } else if (self2.changedCwd) {
+ abs = path45.resolve(self2.cwd, f);
+ } else {
+ abs = path45.resolve(f);
+ }
+ if (process.platform === "win32")
+ abs = abs.replace(/\\/g, "/");
+ return abs;
+ }
+ __name(makeAbs, "makeAbs");
+ function isIgnored(self2, path46) {
+ if (!self2.ignore.length)
+ return false;
+ return self2.ignore.some(function(item) {
+ return item.matcher.match(path46) || !!(item.gmatcher && item.gmatcher.match(path46));
+ });
+ }
+ __name(isIgnored, "isIgnored");
+ function childrenIgnored(self2, path46) {
+ if (!self2.ignore.length)
+ return false;
+ return self2.ignore.some(function(item) {
+ return !!(item.gmatcher && item.gmatcher.match(path46));
+ });
+ }
+ __name(childrenIgnored, "childrenIgnored");
+ }
+});
+
+// ../../node_modules/.pnpm/glob@7.2.0/node_modules/glob/sync.js
+var require_sync = __commonJS({
+ "../../node_modules/.pnpm/glob@7.2.0/node_modules/glob/sync.js"(exports2, module2) {
+ init_import_meta_url();
+ module2.exports = globSync;
+ globSync.GlobSync = GlobSync;
+ var rp = require_fs();
+ var minimatch = require_minimatch();
+ var Minimatch2 = minimatch.Minimatch;
+ var Glob = require_glob().Glob;
+ var util3 = require("util");
+ var path45 = require("path");
+ var assert18 = require("assert");
+ var isAbsolute = require_path_is_absolute();
+ var common = require_common();
+ var setopts = common.setopts;
+ var ownProp = common.ownProp;
+ var childrenIgnored = common.childrenIgnored;
+ var isIgnored = common.isIgnored;
+ function globSync(pattern, options14) {
+ if (typeof options14 === "function" || arguments.length === 3)
+ throw new TypeError("callback provided to sync glob\nSee: https://github.com/isaacs/node-glob/issues/167");
+ return new GlobSync(pattern, options14).found;
+ }
+ __name(globSync, "globSync");
+ function GlobSync(pattern, options14) {
+ if (!pattern)
+ throw new Error("must provide pattern");
+ if (typeof options14 === "function" || arguments.length === 3)
+ throw new TypeError("callback provided to sync glob\nSee: https://github.com/isaacs/node-glob/issues/167");
+ if (!(this instanceof GlobSync))
+ return new GlobSync(pattern, options14);
+ setopts(this, pattern, options14);
+ if (this.noprocess)
+ return this;
+ var n = this.minimatch.set.length;
+ this.matches = new Array(n);
+ for (var i = 0; i < n; i++) {
+ this._process(this.minimatch.set[i], i, false);
+ }
+ this._finish();
+ }
+ __name(GlobSync, "GlobSync");
+ GlobSync.prototype._finish = function() {
+ assert18(this instanceof GlobSync);
+ if (this.realpath) {
+ var self2 = this;
+ this.matches.forEach(function(matchset, index) {
+ var set = self2.matches[index] = /* @__PURE__ */ Object.create(null);
+ for (var p in matchset) {
+ try {
+ p = self2._makeAbs(p);
+ var real = rp.realpathSync(p, self2.realpathCache);
+ set[real] = true;
+ } catch (er) {
+ if (er.syscall === "stat")
+ set[self2._makeAbs(p)] = true;
+ else
+ throw er;
+ }
+ }
+ });
+ }
+ common.finish(this);
+ };
+ GlobSync.prototype._process = function(pattern, index, inGlobStar) {
+ assert18(this instanceof GlobSync);
+ var n = 0;
+ while (typeof pattern[n] === "string") {
+ n++;
+ }
+ var prefix;
+ switch (n) {
+ case pattern.length:
+ this._processSimple(pattern.join("/"), index);
+ return;
+ case 0:
+ prefix = null;
+ break;
+ default:
+ prefix = pattern.slice(0, n).join("/");
+ break;
+ }
+ var remain = pattern.slice(n);
+ var read;
+ if (prefix === null)
+ read = ".";
+ else if (isAbsolute(prefix) || isAbsolute(pattern.join("/"))) {
+ if (!prefix || !isAbsolute(prefix))
+ prefix = "/" + prefix;
+ read = prefix;
+ } else
+ read = prefix;
+ var abs = this._makeAbs(read);
+ if (childrenIgnored(this, read))
+ return;
+ var isGlobStar = remain[0] === minimatch.GLOBSTAR;
+ if (isGlobStar)
+ this._processGlobStar(prefix, read, abs, remain, index, inGlobStar);
+ else
+ this._processReaddir(prefix, read, abs, remain, index, inGlobStar);
+ };
+ GlobSync.prototype._processReaddir = function(prefix, read, abs, remain, index, inGlobStar) {
+ var entries = this._readdir(abs, inGlobStar);
+ if (!entries)
+ return;
+ var pn = remain[0];
+ var negate = !!this.minimatch.negate;
+ var rawGlob = pn._glob;
+ var dotOk = this.dot || rawGlob.charAt(0) === ".";
+ var matchedEntries = [];
+ for (var i = 0; i < entries.length; i++) {
+ var e2 = entries[i];
+ if (e2.charAt(0) !== "." || dotOk) {
+ var m;
+ if (negate && !prefix) {
+ m = !e2.match(pn);
+ } else {
+ m = e2.match(pn);
+ }
+ if (m)
+ matchedEntries.push(e2);
+ }
+ }
+ var len = matchedEntries.length;
+ if (len === 0)
+ return;
+ if (remain.length === 1 && !this.mark && !this.stat) {
+ if (!this.matches[index])
+ this.matches[index] = /* @__PURE__ */ Object.create(null);
+ for (var i = 0; i < len; i++) {
+ var e2 = matchedEntries[i];
+ if (prefix) {
+ if (prefix.slice(-1) !== "/")
+ e2 = prefix + "/" + e2;
+ else
+ e2 = prefix + e2;
+ }
+ if (e2.charAt(0) === "/" && !this.nomount) {
+ e2 = path45.join(this.root, e2);
+ }
+ this._emitMatch(index, e2);
+ }
+ return;
+ }
+ remain.shift();
+ for (var i = 0; i < len; i++) {
+ var e2 = matchedEntries[i];
+ var newPattern;
+ if (prefix)
+ newPattern = [prefix, e2];
+ else
+ newPattern = [e2];
+ this._process(newPattern.concat(remain), index, inGlobStar);
+ }
+ };
+ GlobSync.prototype._emitMatch = function(index, e2) {
+ if (isIgnored(this, e2))
+ return;
+ var abs = this._makeAbs(e2);
+ if (this.mark)
+ e2 = this._mark(e2);
+ if (this.absolute) {
+ e2 = abs;
+ }
+ if (this.matches[index][e2])
+ return;
+ if (this.nodir) {
+ var c = this.cache[abs];
+ if (c === "DIR" || Array.isArray(c))
+ return;
+ }
+ this.matches[index][e2] = true;
+ if (this.stat)
+ this._stat(e2);
+ };
+ GlobSync.prototype._readdirInGlobStar = function(abs) {
+ if (this.follow)
+ return this._readdir(abs, false);
+ var entries;
+ var lstat3;
+ var stat3;
+ try {
+ lstat3 = this.fs.lstatSync(abs);
+ } catch (er) {
+ if (er.code === "ENOENT") {
+ return null;
+ }
+ }
+ var isSym = lstat3 && lstat3.isSymbolicLink();
+ this.symlinks[abs] = isSym;
+ if (!isSym && lstat3 && !lstat3.isDirectory())
+ this.cache[abs] = "FILE";
+ else
+ entries = this._readdir(abs, false);
+ return entries;
+ };
+ GlobSync.prototype._readdir = function(abs, inGlobStar) {
+ var entries;
+ if (inGlobStar && !ownProp(this.symlinks, abs))
+ return this._readdirInGlobStar(abs);
+ if (ownProp(this.cache, abs)) {
+ var c = this.cache[abs];
+ if (!c || c === "FILE")
+ return null;
+ if (Array.isArray(c))
+ return c;
+ }
+ try {
+ return this._readdirEntries(abs, this.fs.readdirSync(abs));
+ } catch (er) {
+ this._readdirError(abs, er);
+ return null;
+ }
+ };
+ GlobSync.prototype._readdirEntries = function(abs, entries) {
+ if (!this.mark && !this.stat) {
+ for (var i = 0; i < entries.length; i++) {
+ var e2 = entries[i];
+ if (abs === "/")
+ e2 = abs + e2;
+ else
+ e2 = abs + "/" + e2;
+ this.cache[e2] = true;
+ }
+ }
+ this.cache[abs] = entries;
+ return entries;
+ };
+ GlobSync.prototype._readdirError = function(f, er) {
+ switch (er.code) {
+ case "ENOTSUP":
+ case "ENOTDIR":
+ var abs = this._makeAbs(f);
+ this.cache[abs] = "FILE";
+ if (abs === this.cwdAbs) {
+ var error = new Error(er.code + " invalid cwd " + this.cwd);
+ error.path = this.cwd;
+ error.code = er.code;
+ throw error;
+ }
+ break;
+ case "ENOENT":
+ case "ELOOP":
+ case "ENAMETOOLONG":
+ case "UNKNOWN":
+ this.cache[this._makeAbs(f)] = false;
+ break;
+ default:
+ this.cache[this._makeAbs(f)] = false;
+ if (this.strict)
+ throw er;
+ if (!this.silent)
+ console.error("glob error", er);
+ break;
+ }
+ };
+ GlobSync.prototype._processGlobStar = function(prefix, read, abs, remain, index, inGlobStar) {
+ var entries = this._readdir(abs, inGlobStar);
+ if (!entries)
+ return;
+ var remainWithoutGlobStar = remain.slice(1);
+ var gspref = prefix ? [prefix] : [];
+ var noGlobStar = gspref.concat(remainWithoutGlobStar);
+ this._process(noGlobStar, index, false);
+ var len = entries.length;
+ var isSym = this.symlinks[abs];
+ if (isSym && inGlobStar)
+ return;
+ for (var i = 0; i < len; i++) {
+ var e2 = entries[i];
+ if (e2.charAt(0) === "." && !this.dot)
+ continue;
+ var instead = gspref.concat(entries[i], remainWithoutGlobStar);
+ this._process(instead, index, true);
+ var below = gspref.concat(entries[i], remain);
+ this._process(below, index, true);
+ }
+ };
+ GlobSync.prototype._processSimple = function(prefix, index) {
+ var exists = this._stat(prefix);
+ if (!this.matches[index])
+ this.matches[index] = /* @__PURE__ */ Object.create(null);
+ if (!exists)
+ return;
+ if (prefix && isAbsolute(prefix) && !this.nomount) {
+ var trail = /[\/\\]$/.test(prefix);
+ if (prefix.charAt(0) === "/") {
+ prefix = path45.join(this.root, prefix);
+ } else {
+ prefix = path45.resolve(this.root, prefix);
+ if (trail)
+ prefix += "/";
+ }
+ }
+ if (process.platform === "win32")
+ prefix = prefix.replace(/\\/g, "/");
+ this._emitMatch(index, prefix);
+ };
+ GlobSync.prototype._stat = function(f) {
+ var abs = this._makeAbs(f);
+ var needDir = f.slice(-1) === "/";
+ if (f.length > this.maxLength)
+ return false;
+ if (!this.stat && ownProp(this.cache, abs)) {
+ var c = this.cache[abs];
+ if (Array.isArray(c))
+ c = "DIR";
+ if (!needDir || c === "DIR")
+ return c;
+ if (needDir && c === "FILE")
+ return false;
+ }
+ var exists;
+ var stat3 = this.statCache[abs];
+ if (!stat3) {
+ var lstat3;
+ try {
+ lstat3 = this.fs.lstatSync(abs);
+ } catch (er) {
+ if (er && (er.code === "ENOENT" || er.code === "ENOTDIR")) {
+ this.statCache[abs] = false;
+ return false;
+ }
+ }
+ if (lstat3 && lstat3.isSymbolicLink()) {
+ try {
+ stat3 = this.fs.statSync(abs);
+ } catch (er) {
+ stat3 = lstat3;
+ }
+ } else {
+ stat3 = lstat3;
+ }
+ }
+ this.statCache[abs] = stat3;
+ var c = true;
+ if (stat3)
+ c = stat3.isDirectory() ? "DIR" : "FILE";
+ this.cache[abs] = this.cache[abs] || c;
+ if (needDir && c === "FILE")
+ return false;
+ return c;
+ };
+ GlobSync.prototype._mark = function(p) {
+ return common.mark(this, p);
+ };
+ GlobSync.prototype._makeAbs = function(f) {
+ return common.makeAbs(this, f);
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/wrappy@1.0.2/node_modules/wrappy/wrappy.js
+var require_wrappy = __commonJS({
+ "../../node_modules/.pnpm/wrappy@1.0.2/node_modules/wrappy/wrappy.js"(exports2, module2) {
+ init_import_meta_url();
+ module2.exports = wrappy;
+ function wrappy(fn2, cb) {
+ if (fn2 && cb)
+ return wrappy(fn2)(cb);
+ if (typeof fn2 !== "function")
+ throw new TypeError("need wrapper function");
+ Object.keys(fn2).forEach(function(k) {
+ wrapper[k] = fn2[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 = fn2.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;
+ }
+ __name(wrapper, "wrapper");
+ }
+ __name(wrappy, "wrappy");
+ }
+});
+
+// ../../node_modules/.pnpm/once@1.4.0/node_modules/once/once.js
+var require_once = __commonJS({
+ "../../node_modules/.pnpm/once@1.4.0/node_modules/once/once.js"(exports2, module2) {
+ init_import_meta_url();
+ 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(fn2) {
+ var f = /* @__PURE__ */ __name(function() {
+ if (f.called)
+ return f.value;
+ f.called = true;
+ return f.value = fn2.apply(this, arguments);
+ }, "f");
+ f.called = false;
+ return f;
+ }
+ __name(once, "once");
+ function onceStrict(fn2) {
+ var f = /* @__PURE__ */ __name(function() {
+ if (f.called)
+ throw new Error(f.onceError);
+ f.called = true;
+ return f.value = fn2.apply(this, arguments);
+ }, "f");
+ var name = fn2.name || "Function wrapped with `once`";
+ f.onceError = name + " shouldn't be called more than once";
+ f.called = false;
+ return f;
+ }
+ __name(onceStrict, "onceStrict");
+ }
+});
+
+// ../../node_modules/.pnpm/inflight@1.0.6/node_modules/inflight/inflight.js
+var require_inflight = __commonJS({
+ "../../node_modules/.pnpm/inflight@1.0.6/node_modules/inflight/inflight.js"(exports2, module2) {
+ init_import_meta_url();
+ var wrappy = require_wrappy();
+ var reqs = /* @__PURE__ */ Object.create(null);
+ var once = require_once();
+ module2.exports = wrappy(inflight);
+ function inflight(key, cb) {
+ if (reqs[key]) {
+ reqs[key].push(cb);
+ return null;
+ } else {
+ reqs[key] = [cb];
+ return makeres(key);
+ }
+ }
+ __name(inflight, "inflight");
+ function makeres(key) {
+ return once(/* @__PURE__ */ __name(function RES() {
+ var cbs = reqs[key];
+ var len = cbs.length;
+ var args = slice(arguments);
+ try {
+ for (var i = 0; i < len; i++) {
+ cbs[i].apply(null, args);
+ }
+ } finally {
+ if (cbs.length > len) {
+ cbs.splice(0, len);
+ process.nextTick(function() {
+ RES.apply(null, args);
+ });
+ } else {
+ delete reqs[key];
+ }
+ }
+ }, "RES"));
+ }
+ __name(makeres, "makeres");
+ function slice(args) {
+ var length = args.length;
+ var array = [];
+ for (var i = 0; i < length; i++)
+ array[i] = args[i];
+ return array;
+ }
+ __name(slice, "slice");
+ }
+});
+
+// ../../node_modules/.pnpm/glob@7.2.0/node_modules/glob/glob.js
+var require_glob = __commonJS({
+ "../../node_modules/.pnpm/glob@7.2.0/node_modules/glob/glob.js"(exports2, module2) {
+ init_import_meta_url();
+ module2.exports = glob;
+ var rp = require_fs();
+ var minimatch = require_minimatch();
+ var Minimatch2 = minimatch.Minimatch;
+ var inherits = require_inherits();
+ var EE = require("events").EventEmitter;
+ var path45 = require("path");
+ var assert18 = require("assert");
+ var isAbsolute = require_path_is_absolute();
+ var globSync = require_sync();
+ var common = require_common();
+ var setopts = common.setopts;
+ var ownProp = common.ownProp;
+ var inflight = require_inflight();
+ var util3 = require("util");
+ var childrenIgnored = common.childrenIgnored;
+ var isIgnored = common.isIgnored;
+ var once = require_once();
+ function glob(pattern, options14, cb) {
+ if (typeof options14 === "function")
+ cb = options14, options14 = {};
+ if (!options14)
+ options14 = {};
+ if (options14.sync) {
+ if (cb)
+ throw new TypeError("callback provided to sync glob");
+ return globSync(pattern, options14);
+ }
+ return new Glob(pattern, options14, cb);
+ }
+ __name(glob, "glob");
+ glob.sync = globSync;
+ var GlobSync = glob.GlobSync = globSync.GlobSync;
+ glob.glob = glob;
+ function extend(origin, add) {
+ if (add === null || typeof add !== "object") {
+ return origin;
+ }
+ var keys = Object.keys(add);
+ var i = keys.length;
+ while (i--) {
+ origin[keys[i]] = add[keys[i]];
+ }
+ return origin;
+ }
+ __name(extend, "extend");
+ glob.hasMagic = function(pattern, options_) {
+ var options14 = extend({}, options_);
+ options14.noprocess = true;
+ var g = new Glob(pattern, options14);
+ var set = g.minimatch.set;
+ if (!pattern)
+ return false;
+ if (set.length > 1)
+ return true;
+ for (var j = 0; j < set[0].length; j++) {
+ if (typeof set[0][j] !== "string")
+ return true;
+ }
+ return false;
+ };
+ glob.Glob = Glob;
+ inherits(Glob, EE);
+ function Glob(pattern, options14, cb) {
+ if (typeof options14 === "function") {
+ cb = options14;
+ options14 = null;
+ }
+ if (options14 && options14.sync) {
+ if (cb)
+ throw new TypeError("callback provided to sync glob");
+ return new GlobSync(pattern, options14);
+ }
+ if (!(this instanceof Glob))
+ return new Glob(pattern, options14, cb);
+ setopts(this, pattern, options14);
+ this._didRealPath = false;
+ var n = this.minimatch.set.length;
+ this.matches = new Array(n);
+ if (typeof cb === "function") {
+ cb = once(cb);
+ this.on("error", cb);
+ this.on("end", function(matches) {
+ cb(null, matches);
+ });
+ }
+ var self2 = this;
+ this._processing = 0;
+ this._emitQueue = [];
+ this._processQueue = [];
+ this.paused = false;
+ if (this.noprocess)
+ return this;
+ if (n === 0)
+ return done();
+ var sync = true;
+ for (var i = 0; i < n; i++) {
+ this._process(this.minimatch.set[i], i, false, done);
+ }
+ sync = false;
+ function done() {
+ --self2._processing;
+ if (self2._processing <= 0) {
+ if (sync) {
+ process.nextTick(function() {
+ self2._finish();
+ });
+ } else {
+ self2._finish();
+ }
+ }
+ }
+ __name(done, "done");
+ }
+ __name(Glob, "Glob");
+ Glob.prototype._finish = function() {
+ assert18(this instanceof Glob);
+ if (this.aborted)
+ return;
+ if (this.realpath && !this._didRealpath)
+ return this._realpath();
+ common.finish(this);
+ this.emit("end", this.found);
+ };
+ Glob.prototype._realpath = function() {
+ if (this._didRealpath)
+ return;
+ this._didRealpath = true;
+ var n = this.matches.length;
+ if (n === 0)
+ return this._finish();
+ var self2 = this;
+ for (var i = 0; i < this.matches.length; i++)
+ this._realpathSet(i, next);
+ function next() {
+ if (--n === 0)
+ self2._finish();
+ }
+ __name(next, "next");
+ };
+ Glob.prototype._realpathSet = function(index, cb) {
+ var matchset = this.matches[index];
+ if (!matchset)
+ return cb();
+ var found = Object.keys(matchset);
+ var self2 = this;
+ var n = found.length;
+ if (n === 0)
+ return cb();
+ var set = this.matches[index] = /* @__PURE__ */ Object.create(null);
+ found.forEach(function(p, i) {
+ p = self2._makeAbs(p);
+ rp.realpath(p, self2.realpathCache, function(er, real) {
+ if (!er)
+ set[real] = true;
+ else if (er.syscall === "stat")
+ set[p] = true;
+ else
+ self2.emit("error", er);
+ if (--n === 0) {
+ self2.matches[index] = set;
+ cb();
+ }
+ });
+ });
+ };
+ Glob.prototype._mark = function(p) {
+ return common.mark(this, p);
+ };
+ Glob.prototype._makeAbs = function(f) {
+ return common.makeAbs(this, f);
+ };
+ Glob.prototype.abort = function() {
+ this.aborted = true;
+ this.emit("abort");
+ };
+ Glob.prototype.pause = function() {
+ if (!this.paused) {
+ this.paused = true;
+ this.emit("pause");
+ }
+ };
+ Glob.prototype.resume = function() {
+ if (this.paused) {
+ this.emit("resume");
+ this.paused = false;
+ if (this._emitQueue.length) {
+ var eq = this._emitQueue.slice(0);
+ this._emitQueue.length = 0;
+ for (var i = 0; i < eq.length; i++) {
+ var e2 = eq[i];
+ this._emitMatch(e2[0], e2[1]);
+ }
+ }
+ if (this._processQueue.length) {
+ var pq = this._processQueue.slice(0);
+ this._processQueue.length = 0;
+ for (var i = 0; i < pq.length; i++) {
+ var p = pq[i];
+ this._processing--;
+ this._process(p[0], p[1], p[2], p[3]);
+ }
+ }
+ }
+ };
+ Glob.prototype._process = function(pattern, index, inGlobStar, cb) {
+ assert18(this instanceof Glob);
+ assert18(typeof cb === "function");
+ if (this.aborted)
+ return;
+ this._processing++;
+ if (this.paused) {
+ this._processQueue.push([pattern, index, inGlobStar, cb]);
+ return;
+ }
+ var n = 0;
+ while (typeof pattern[n] === "string") {
+ n++;
+ }
+ var prefix;
+ switch (n) {
+ case pattern.length:
+ this._processSimple(pattern.join("/"), index, cb);
+ return;
+ case 0:
+ prefix = null;
+ break;
+ default:
+ prefix = pattern.slice(0, n).join("/");
+ break;
+ }
+ var remain = pattern.slice(n);
+ var read;
+ if (prefix === null)
+ read = ".";
+ else if (isAbsolute(prefix) || isAbsolute(pattern.join("/"))) {
+ if (!prefix || !isAbsolute(prefix))
+ prefix = "/" + prefix;
+ read = prefix;
+ } else
+ read = prefix;
+ var abs = this._makeAbs(read);
+ if (childrenIgnored(this, read))
+ return cb();
+ var isGlobStar = remain[0] === minimatch.GLOBSTAR;
+ if (isGlobStar)
+ this._processGlobStar(prefix, read, abs, remain, index, inGlobStar, cb);
+ else
+ this._processReaddir(prefix, read, abs, remain, index, inGlobStar, cb);
+ };
+ Glob.prototype._processReaddir = function(prefix, read, abs, remain, index, inGlobStar, cb) {
+ var self2 = this;
+ this._readdir(abs, inGlobStar, function(er, entries) {
+ return self2._processReaddir2(prefix, read, abs, remain, index, inGlobStar, entries, cb);
+ });
+ };
+ Glob.prototype._processReaddir2 = function(prefix, read, abs, remain, index, inGlobStar, entries, cb) {
+ if (!entries)
+ return cb();
+ var pn = remain[0];
+ var negate = !!this.minimatch.negate;
+ var rawGlob = pn._glob;
+ var dotOk = this.dot || rawGlob.charAt(0) === ".";
+ var matchedEntries = [];
+ for (var i = 0; i < entries.length; i++) {
+ var e2 = entries[i];
+ if (e2.charAt(0) !== "." || dotOk) {
+ var m;
+ if (negate && !prefix) {
+ m = !e2.match(pn);
+ } else {
+ m = e2.match(pn);
+ }
+ if (m)
+ matchedEntries.push(e2);
+ }
+ }
+ var len = matchedEntries.length;
+ if (len === 0)
+ return cb();
+ if (remain.length === 1 && !this.mark && !this.stat) {
+ if (!this.matches[index])
+ this.matches[index] = /* @__PURE__ */ Object.create(null);
+ for (var i = 0; i < len; i++) {
+ var e2 = matchedEntries[i];
+ if (prefix) {
+ if (prefix !== "/")
+ e2 = prefix + "/" + e2;
+ else
+ e2 = prefix + e2;
+ }
+ if (e2.charAt(0) === "/" && !this.nomount) {
+ e2 = path45.join(this.root, e2);
+ }
+ this._emitMatch(index, e2);
+ }
+ return cb();
+ }
+ remain.shift();
+ for (var i = 0; i < len; i++) {
+ var e2 = matchedEntries[i];
+ var newPattern;
+ if (prefix) {
+ if (prefix !== "/")
+ e2 = prefix + "/" + e2;
+ else
+ e2 = prefix + e2;
+ }
+ this._process([e2].concat(remain), index, inGlobStar, cb);
+ }
+ cb();
+ };
+ Glob.prototype._emitMatch = function(index, e2) {
+ if (this.aborted)
+ return;
+ if (isIgnored(this, e2))
+ return;
+ if (this.paused) {
+ this._emitQueue.push([index, e2]);
+ return;
+ }
+ var abs = isAbsolute(e2) ? e2 : this._makeAbs(e2);
+ if (this.mark)
+ e2 = this._mark(e2);
+ if (this.absolute)
+ e2 = abs;
+ if (this.matches[index][e2])
+ return;
+ if (this.nodir) {
+ var c = this.cache[abs];
+ if (c === "DIR" || Array.isArray(c))
+ return;
+ }
+ this.matches[index][e2] = true;
+ var st = this.statCache[abs];
+ if (st)
+ this.emit("stat", e2, st);
+ this.emit("match", e2);
+ };
+ Glob.prototype._readdirInGlobStar = function(abs, cb) {
+ if (this.aborted)
+ return;
+ if (this.follow)
+ return this._readdir(abs, false, cb);
+ var lstatkey = "lstat\0" + abs;
+ var self2 = this;
+ var lstatcb = inflight(lstatkey, lstatcb_);
+ if (lstatcb)
+ self2.fs.lstat(abs, lstatcb);
+ function lstatcb_(er, lstat3) {
+ if (er && er.code === "ENOENT")
+ return cb();
+ var isSym = lstat3 && lstat3.isSymbolicLink();
+ self2.symlinks[abs] = isSym;
+ if (!isSym && lstat3 && !lstat3.isDirectory()) {
+ self2.cache[abs] = "FILE";
+ cb();
+ } else
+ self2._readdir(abs, false, cb);
+ }
+ __name(lstatcb_, "lstatcb_");
+ };
+ Glob.prototype._readdir = function(abs, inGlobStar, cb) {
+ if (this.aborted)
+ return;
+ cb = inflight("readdir\0" + abs + "\0" + inGlobStar, cb);
+ if (!cb)
+ return;
+ if (inGlobStar && !ownProp(this.symlinks, abs))
+ return this._readdirInGlobStar(abs, cb);
+ if (ownProp(this.cache, abs)) {
+ var c = this.cache[abs];
+ if (!c || c === "FILE")
+ return cb();
+ if (Array.isArray(c))
+ return cb(null, c);
+ }
+ var self2 = this;
+ self2.fs.readdir(abs, readdirCb(this, abs, cb));
+ };
+ function readdirCb(self2, abs, cb) {
+ return function(er, entries) {
+ if (er)
+ self2._readdirError(abs, er, cb);
+ else
+ self2._readdirEntries(abs, entries, cb);
+ };
+ }
+ __name(readdirCb, "readdirCb");
+ Glob.prototype._readdirEntries = function(abs, entries, cb) {
+ if (this.aborted)
+ return;
+ if (!this.mark && !this.stat) {
+ for (var i = 0; i < entries.length; i++) {
+ var e2 = entries[i];
+ if (abs === "/")
+ e2 = abs + e2;
+ else
+ e2 = abs + "/" + e2;
+ this.cache[e2] = true;
+ }
+ }
+ this.cache[abs] = entries;
+ return cb(null, entries);
+ };
+ Glob.prototype._readdirError = function(f, er, cb) {
+ if (this.aborted)
+ return;
+ switch (er.code) {
+ case "ENOTSUP":
+ case "ENOTDIR":
+ var abs = this._makeAbs(f);
+ this.cache[abs] = "FILE";
+ if (abs === this.cwdAbs) {
+ var error = new Error(er.code + " invalid cwd " + this.cwd);
+ error.path = this.cwd;
+ error.code = er.code;
+ this.emit("error", error);
+ this.abort();
+ }
+ break;
+ case "ENOENT":
+ case "ELOOP":
+ case "ENAMETOOLONG":
+ case "UNKNOWN":
+ this.cache[this._makeAbs(f)] = false;
+ break;
+ default:
+ this.cache[this._makeAbs(f)] = false;
+ if (this.strict) {
+ this.emit("error", er);
+ this.abort();
+ }
+ if (!this.silent)
+ console.error("glob error", er);
+ break;
+ }
+ return cb();
+ };
+ Glob.prototype._processGlobStar = function(prefix, read, abs, remain, index, inGlobStar, cb) {
+ var self2 = this;
+ this._readdir(abs, inGlobStar, function(er, entries) {
+ self2._processGlobStar2(prefix, read, abs, remain, index, inGlobStar, entries, cb);
+ });
+ };
+ Glob.prototype._processGlobStar2 = function(prefix, read, abs, remain, index, inGlobStar, entries, cb) {
+ if (!entries)
+ return cb();
+ var remainWithoutGlobStar = remain.slice(1);
+ var gspref = prefix ? [prefix] : [];
+ var noGlobStar = gspref.concat(remainWithoutGlobStar);
+ this._process(noGlobStar, index, false, cb);
+ var isSym = this.symlinks[abs];
+ var len = entries.length;
+ if (isSym && inGlobStar)
+ return cb();
+ for (var i = 0; i < len; i++) {
+ var e2 = entries[i];
+ if (e2.charAt(0) === "." && !this.dot)
+ continue;
+ var instead = gspref.concat(entries[i], remainWithoutGlobStar);
+ this._process(instead, index, true, cb);
+ var below = gspref.concat(entries[i], remain);
+ this._process(below, index, true, cb);
+ }
+ cb();
+ };
+ Glob.prototype._processSimple = function(prefix, index, cb) {
+ var self2 = this;
+ this._stat(prefix, function(er, exists) {
+ self2._processSimple2(prefix, index, er, exists, cb);
+ });
+ };
+ Glob.prototype._processSimple2 = function(prefix, index, er, exists, cb) {
+ if (!this.matches[index])
+ this.matches[index] = /* @__PURE__ */ Object.create(null);
+ if (!exists)
+ return cb();
+ if (prefix && isAbsolute(prefix) && !this.nomount) {
+ var trail = /[\/\\]$/.test(prefix);
+ if (prefix.charAt(0) === "/") {
+ prefix = path45.join(this.root, prefix);
+ } else {
+ prefix = path45.resolve(this.root, prefix);
+ if (trail)
+ prefix += "/";
+ }
+ }
+ if (process.platform === "win32")
+ prefix = prefix.replace(/\\/g, "/");
+ this._emitMatch(index, prefix);
+ cb();
+ };
+ Glob.prototype._stat = function(f, cb) {
+ var abs = this._makeAbs(f);
+ var needDir = f.slice(-1) === "/";
+ if (f.length > this.maxLength)
+ return cb();
+ if (!this.stat && ownProp(this.cache, abs)) {
+ var c = this.cache[abs];
+ if (Array.isArray(c))
+ c = "DIR";
+ if (!needDir || c === "DIR")
+ return cb(null, c);
+ if (needDir && c === "FILE")
+ return cb();
+ }
+ var exists;
+ var stat3 = this.statCache[abs];
+ if (stat3 !== void 0) {
+ if (stat3 === false)
+ return cb(null, stat3);
+ else {
+ var type = stat3.isDirectory() ? "DIR" : "FILE";
+ if (needDir && type === "FILE")
+ return cb();
+ else
+ return cb(null, type, stat3);
+ }
+ }
+ var self2 = this;
+ var statcb = inflight("stat\0" + abs, lstatcb_);
+ if (statcb)
+ self2.fs.lstat(abs, statcb);
+ function lstatcb_(er, lstat3) {
+ if (lstat3 && lstat3.isSymbolicLink()) {
+ return self2.fs.stat(abs, function(er2, stat4) {
+ if (er2)
+ self2._stat2(f, abs, null, lstat3, cb);
+ else
+ self2._stat2(f, abs, er2, stat4, cb);
+ });
+ } else {
+ self2._stat2(f, abs, er, lstat3, cb);
+ }
+ }
+ __name(lstatcb_, "lstatcb_");
+ };
+ Glob.prototype._stat2 = function(f, abs, er, stat3, cb) {
+ if (er && (er.code === "ENOENT" || er.code === "ENOTDIR")) {
+ this.statCache[abs] = false;
+ return cb();
+ }
+ var needDir = f.slice(-1) === "/";
+ this.statCache[abs] = stat3;
+ if (abs.slice(-1) === "/" && stat3 && !stat3.isDirectory())
+ return cb(null, false, stat3);
+ var c = true;
+ if (stat3)
+ c = stat3.isDirectory() ? "DIR" : "FILE";
+ this.cache[abs] = this.cache[abs] || c;
+ if (needDir && c === "FILE")
+ return cb();
+ return cb(null, c, stat3);
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/rimraf@3.0.2/node_modules/rimraf/rimraf.js
+var require_rimraf = __commonJS({
+ "../../node_modules/.pnpm/rimraf@3.0.2/node_modules/rimraf/rimraf.js"(exports2, module2) {
+ init_import_meta_url();
+ var assert18 = require("assert");
+ var path45 = require("path");
+ var fs20 = require("fs");
+ var glob = void 0;
+ try {
+ glob = require_glob();
+ } catch (_err) {
+ }
+ var defaultGlobOpts = {
+ nosort: true,
+ silent: true
+ };
+ var timeout = 0;
+ var isWindows2 = process.platform === "win32";
+ var defaults = /* @__PURE__ */ __name((options14) => {
+ const methods = [
+ "unlink",
+ "chmod",
+ "stat",
+ "lstat",
+ "rmdir",
+ "readdir"
+ ];
+ methods.forEach((m) => {
+ options14[m] = options14[m] || fs20[m];
+ m = m + "Sync";
+ options14[m] = options14[m] || fs20[m];
+ });
+ options14.maxBusyTries = options14.maxBusyTries || 3;
+ options14.emfileWait = options14.emfileWait || 1e3;
+ if (options14.glob === false) {
+ options14.disableGlob = true;
+ }
+ if (options14.disableGlob !== true && glob === void 0) {
+ throw Error("glob dependency not found, set `options.disableGlob = true` if intentional");
+ }
+ options14.disableGlob = options14.disableGlob || false;
+ options14.glob = options14.glob || defaultGlobOpts;
+ }, "defaults");
+ var rimraf = /* @__PURE__ */ __name((p, options14, cb) => {
+ if (typeof options14 === "function") {
+ cb = options14;
+ options14 = {};
+ }
+ assert18(p, "rimraf: missing path");
+ assert18.equal(typeof p, "string", "rimraf: path should be a string");
+ assert18.equal(typeof cb, "function", "rimraf: callback function required");
+ assert18(options14, "rimraf: invalid options argument provided");
+ assert18.equal(typeof options14, "object", "rimraf: options should be object");
+ defaults(options14);
+ let busyTries = 0;
+ let errState = null;
+ let n = 0;
+ const next = /* @__PURE__ */ __name((er) => {
+ errState = errState || er;
+ if (--n === 0)
+ cb(errState);
+ }, "next");
+ const afterGlob = /* @__PURE__ */ __name((er, results) => {
+ if (er)
+ return cb(er);
+ n = results.length;
+ if (n === 0)
+ return cb();
+ results.forEach((p2) => {
+ const CB = /* @__PURE__ */ __name((er2) => {
+ if (er2) {
+ if ((er2.code === "EBUSY" || er2.code === "ENOTEMPTY" || er2.code === "EPERM") && busyTries < options14.maxBusyTries) {
+ busyTries++;
+ return setTimeout(() => rimraf_(p2, options14, CB), busyTries * 100);
+ }
+ if (er2.code === "EMFILE" && timeout < options14.emfileWait) {
+ return setTimeout(() => rimraf_(p2, options14, CB), timeout++);
+ }
+ if (er2.code === "ENOENT")
+ er2 = null;
+ }
+ timeout = 0;
+ next(er2);
+ }, "CB");
+ rimraf_(p2, options14, CB);
+ });
+ }, "afterGlob");
+ if (options14.disableGlob || !glob.hasMagic(p))
+ return afterGlob(null, [p]);
+ options14.lstat(p, (er, stat3) => {
+ if (!er)
+ return afterGlob(null, [p]);
+ glob(p, options14.glob, afterGlob);
+ });
+ }, "rimraf");
+ var rimraf_ = /* @__PURE__ */ __name((p, options14, cb) => {
+ assert18(p);
+ assert18(options14);
+ assert18(typeof cb === "function");
+ options14.lstat(p, (er, st) => {
+ if (er && er.code === "ENOENT")
+ return cb(null);
+ if (er && er.code === "EPERM" && isWindows2)
+ fixWinEPERM(p, options14, er, cb);
+ if (st && st.isDirectory())
+ return rmdir(p, options14, er, cb);
+ options14.unlink(p, (er2) => {
+ if (er2) {
+ if (er2.code === "ENOENT")
+ return cb(null);
+ if (er2.code === "EPERM")
+ return isWindows2 ? fixWinEPERM(p, options14, er2, cb) : rmdir(p, options14, er2, cb);
+ if (er2.code === "EISDIR")
+ return rmdir(p, options14, er2, cb);
+ }
+ return cb(er2);
+ });
+ });
+ }, "rimraf_");
+ var fixWinEPERM = /* @__PURE__ */ __name((p, options14, er, cb) => {
+ assert18(p);
+ assert18(options14);
+ assert18(typeof cb === "function");
+ options14.chmod(p, 438, (er2) => {
+ if (er2)
+ cb(er2.code === "ENOENT" ? null : er);
+ else
+ options14.stat(p, (er3, stats) => {
+ if (er3)
+ cb(er3.code === "ENOENT" ? null : er);
+ else if (stats.isDirectory())
+ rmdir(p, options14, er, cb);
+ else
+ options14.unlink(p, cb);
+ });
+ });
+ }, "fixWinEPERM");
+ var fixWinEPERMSync = /* @__PURE__ */ __name((p, options14, er) => {
+ assert18(p);
+ assert18(options14);
+ try {
+ options14.chmodSync(p, 438);
+ } catch (er2) {
+ if (er2.code === "ENOENT")
+ return;
+ else
+ throw er;
+ }
+ let stats;
+ try {
+ stats = options14.statSync(p);
+ } catch (er3) {
+ if (er3.code === "ENOENT")
+ return;
+ else
+ throw er;
+ }
+ if (stats.isDirectory())
+ rmdirSync(p, options14, er);
+ else
+ options14.unlinkSync(p);
+ }, "fixWinEPERMSync");
+ var rmdir = /* @__PURE__ */ __name((p, options14, originalEr, cb) => {
+ assert18(p);
+ assert18(options14);
+ assert18(typeof cb === "function");
+ options14.rmdir(p, (er) => {
+ if (er && (er.code === "ENOTEMPTY" || er.code === "EEXIST" || er.code === "EPERM"))
+ rmkids(p, options14, cb);
+ else if (er && er.code === "ENOTDIR")
+ cb(originalEr);
+ else
+ cb(er);
+ });
+ }, "rmdir");
+ var rmkids = /* @__PURE__ */ __name((p, options14, cb) => {
+ assert18(p);
+ assert18(options14);
+ assert18(typeof cb === "function");
+ options14.readdir(p, (er, files) => {
+ if (er)
+ return cb(er);
+ let n = files.length;
+ if (n === 0)
+ return options14.rmdir(p, cb);
+ let errState;
+ files.forEach((f) => {
+ rimraf(path45.join(p, f), options14, (er2) => {
+ if (errState)
+ return;
+ if (er2)
+ return cb(errState = er2);
+ if (--n === 0)
+ options14.rmdir(p, cb);
+ });
+ });
+ });
+ }, "rmkids");
+ var rimrafSync = /* @__PURE__ */ __name((p, options14) => {
+ options14 = options14 || {};
+ defaults(options14);
+ assert18(p, "rimraf: missing path");
+ assert18.equal(typeof p, "string", "rimraf: path should be a string");
+ assert18(options14, "rimraf: missing options");
+ assert18.equal(typeof options14, "object", "rimraf: options should be object");
+ let results;
+ if (options14.disableGlob || !glob.hasMagic(p)) {
+ results = [p];
+ } else {
+ try {
+ options14.lstatSync(p);
+ results = [p];
+ } catch (er) {
+ results = glob.sync(p, options14.glob);
+ }
+ }
+ if (!results.length)
+ return;
+ for (let i = 0; i < results.length; i++) {
+ const p2 = results[i];
+ let st;
+ try {
+ st = options14.lstatSync(p2);
+ } catch (er) {
+ if (er.code === "ENOENT")
+ return;
+ if (er.code === "EPERM" && isWindows2)
+ fixWinEPERMSync(p2, options14, er);
+ }
+ try {
+ if (st && st.isDirectory())
+ rmdirSync(p2, options14, null);
+ else
+ options14.unlinkSync(p2);
+ } catch (er) {
+ if (er.code === "ENOENT")
+ return;
+ if (er.code === "EPERM")
+ return isWindows2 ? fixWinEPERMSync(p2, options14, er) : rmdirSync(p2, options14, er);
+ if (er.code !== "EISDIR")
+ throw er;
+ rmdirSync(p2, options14, er);
+ }
+ }
+ }, "rimrafSync");
+ var rmdirSync = /* @__PURE__ */ __name((p, options14, originalEr) => {
+ assert18(p);
+ assert18(options14);
+ try {
+ options14.rmdirSync(p);
+ } catch (er) {
+ if (er.code === "ENOENT")
+ return;
+ if (er.code === "ENOTDIR")
+ throw originalEr;
+ if (er.code === "ENOTEMPTY" || er.code === "EEXIST" || er.code === "EPERM")
+ rmkidsSync(p, options14);
+ }
+ }, "rmdirSync");
+ var rmkidsSync = /* @__PURE__ */ __name((p, options14) => {
+ assert18(p);
+ assert18(options14);
+ options14.readdirSync(p).forEach((f) => rimrafSync(path45.join(p, f), options14));
+ const retries = isWindows2 ? 100 : 1;
+ let i = 0;
+ do {
+ let threw = true;
+ try {
+ const ret = options14.rmdirSync(p, options14);
+ threw = false;
+ return ret;
+ } finally {
+ if (++i < retries && threw)
+ continue;
+ }
+ } while (true);
+ }, "rmkidsSync");
+ module2.exports = rimraf;
+ rimraf.sync = rimrafSync;
+ }
+});
+
+// ../../node_modules/.pnpm/tmp@0.2.1/node_modules/tmp/lib/tmp.js
+var require_tmp = __commonJS({
+ "../../node_modules/.pnpm/tmp@0.2.1/node_modules/tmp/lib/tmp.js"(exports2, module2) {
+ init_import_meta_url();
+ var fs20 = require("fs");
+ var os9 = require("os");
+ var path45 = require("path");
+ var crypto6 = require("crypto");
+ var _c2 = { fs: fs20.constants, os: os9.constants };
+ var rimraf = require_rimraf();
+ var RANDOM_CHARS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+ var TEMPLATE_PATTERN = /XXXXXX/;
+ var DEFAULT_TRIES = 3;
+ var CREATE_FLAGS = (_c2.O_CREAT || _c2.fs.O_CREAT) | (_c2.O_EXCL || _c2.fs.O_EXCL) | (_c2.O_RDWR || _c2.fs.O_RDWR);
+ var IS_WIN32 = os9.platform() === "win32";
+ var EBADF = _c2.EBADF || _c2.os.errno.EBADF;
+ var ENOENT = _c2.ENOENT || _c2.os.errno.ENOENT;
+ var DIR_MODE = 448;
+ var FILE_MODE = 384;
+ var EXIT = "exit";
+ var _removeObjects = [];
+ var FN_RMDIR_SYNC = fs20.rmdirSync.bind(fs20);
+ var FN_RIMRAF_SYNC = rimraf.sync;
+ var _gracefulCleanup = false;
+ function tmpName(options14, callback) {
+ const args = _parseArguments(options14, callback), opts = args[0], cb = args[1];
+ try {
+ _assertAndSanitizeOptions(opts);
+ } catch (err) {
+ return cb(err);
+ }
+ let tries = opts.tries;
+ (/* @__PURE__ */ __name(function _getUniqueName() {
+ try {
+ const name = _generateTmpName(opts);
+ fs20.stat(name, function(err) {
+ if (!err) {
+ if (tries-- > 0)
+ return _getUniqueName();
+ return cb(new Error("Could not get a unique tmp filename, max tries reached " + name));
+ }
+ cb(null, name);
+ });
+ } catch (err) {
+ cb(err);
+ }
+ }, "_getUniqueName"))();
+ }
+ __name(tmpName, "tmpName");
+ function tmpNameSync(options14) {
+ const args = _parseArguments(options14), opts = args[0];
+ _assertAndSanitizeOptions(opts);
+ let tries = opts.tries;
+ do {
+ const name = _generateTmpName(opts);
+ try {
+ fs20.statSync(name);
+ } catch (e2) {
+ return name;
+ }
+ } while (tries-- > 0);
+ throw new Error("Could not get a unique tmp filename, max tries reached");
+ }
+ __name(tmpNameSync, "tmpNameSync");
+ function file(options14, callback) {
+ const args = _parseArguments(options14, callback), opts = args[0], cb = args[1];
+ tmpName(opts, /* @__PURE__ */ __name(function _tmpNameCreated(err, name) {
+ if (err)
+ return cb(err);
+ fs20.open(name, CREATE_FLAGS, opts.mode || FILE_MODE, /* @__PURE__ */ __name(function _fileCreated(err2, fd) {
+ if (err2)
+ return cb(err2);
+ if (opts.discardDescriptor) {
+ return fs20.close(fd, /* @__PURE__ */ __name(function _discardCallback(possibleErr) {
+ return cb(possibleErr, name, void 0, _prepareTmpFileRemoveCallback(name, -1, opts, false));
+ }, "_discardCallback"));
+ } else {
+ const discardOrDetachDescriptor = opts.discardDescriptor || opts.detachDescriptor;
+ cb(null, name, fd, _prepareTmpFileRemoveCallback(name, discardOrDetachDescriptor ? -1 : fd, opts, false));
+ }
+ }, "_fileCreated"));
+ }, "_tmpNameCreated"));
+ }
+ __name(file, "file");
+ function fileSync(options14) {
+ const args = _parseArguments(options14), opts = args[0];
+ const discardOrDetachDescriptor = opts.discardDescriptor || opts.detachDescriptor;
+ const name = tmpNameSync(opts);
+ var fd = fs20.openSync(name, CREATE_FLAGS, opts.mode || FILE_MODE);
+ if (opts.discardDescriptor) {
+ fs20.closeSync(fd);
+ fd = void 0;
+ }
+ return {
+ name,
+ fd,
+ removeCallback: _prepareTmpFileRemoveCallback(name, discardOrDetachDescriptor ? -1 : fd, opts, true)
+ };
+ }
+ __name(fileSync, "fileSync");
+ function dir(options14, callback) {
+ const args = _parseArguments(options14, callback), opts = args[0], cb = args[1];
+ tmpName(opts, /* @__PURE__ */ __name(function _tmpNameCreated(err, name) {
+ if (err)
+ return cb(err);
+ fs20.mkdir(name, opts.mode || DIR_MODE, /* @__PURE__ */ __name(function _dirCreated(err2) {
+ if (err2)
+ return cb(err2);
+ cb(null, name, _prepareTmpDirRemoveCallback(name, opts, false));
+ }, "_dirCreated"));
+ }, "_tmpNameCreated"));
+ }
+ __name(dir, "dir");
+ function dirSync(options14) {
+ const args = _parseArguments(options14), opts = args[0];
+ const name = tmpNameSync(opts);
+ fs20.mkdirSync(name, opts.mode || DIR_MODE);
+ return {
+ name,
+ removeCallback: _prepareTmpDirRemoveCallback(name, opts, true)
+ };
+ }
+ __name(dirSync, "dirSync");
+ function _removeFileAsync(fdPath, next) {
+ const _handler = /* @__PURE__ */ __name(function(err) {
+ if (err && !_isENOENT(err)) {
+ return next(err);
+ }
+ next();
+ }, "_handler");
+ if (0 <= fdPath[0])
+ fs20.close(fdPath[0], function() {
+ fs20.unlink(fdPath[1], _handler);
+ });
+ else
+ fs20.unlink(fdPath[1], _handler);
+ }
+ __name(_removeFileAsync, "_removeFileAsync");
+ function _removeFileSync(fdPath) {
+ let rethrownException = null;
+ try {
+ if (0 <= fdPath[0])
+ fs20.closeSync(fdPath[0]);
+ } catch (e2) {
+ if (!_isEBADF(e2) && !_isENOENT(e2))
+ throw e2;
+ } finally {
+ try {
+ fs20.unlinkSync(fdPath[1]);
+ } catch (e2) {
+ if (!_isENOENT(e2))
+ rethrownException = e2;
+ }
+ }
+ if (rethrownException !== null) {
+ throw rethrownException;
+ }
+ }
+ __name(_removeFileSync, "_removeFileSync");
+ function _prepareTmpFileRemoveCallback(name, fd, opts, sync) {
+ const removeCallbackSync = _prepareRemoveCallback(_removeFileSync, [fd, name], sync);
+ const removeCallback = _prepareRemoveCallback(_removeFileAsync, [fd, name], sync, removeCallbackSync);
+ if (!opts.keep)
+ _removeObjects.unshift(removeCallbackSync);
+ return sync ? removeCallbackSync : removeCallback;
+ }
+ __name(_prepareTmpFileRemoveCallback, "_prepareTmpFileRemoveCallback");
+ function _prepareTmpDirRemoveCallback(name, opts, sync) {
+ const removeFunction = opts.unsafeCleanup ? rimraf : fs20.rmdir.bind(fs20);
+ const removeFunctionSync = opts.unsafeCleanup ? FN_RIMRAF_SYNC : FN_RMDIR_SYNC;
+ const removeCallbackSync = _prepareRemoveCallback(removeFunctionSync, name, sync);
+ const removeCallback = _prepareRemoveCallback(removeFunction, name, sync, removeCallbackSync);
+ if (!opts.keep)
+ _removeObjects.unshift(removeCallbackSync);
+ return sync ? removeCallbackSync : removeCallback;
+ }
+ __name(_prepareTmpDirRemoveCallback, "_prepareTmpDirRemoveCallback");
+ function _prepareRemoveCallback(removeFunction, fileOrDirName, sync, cleanupCallbackSync) {
+ let called = false;
+ return /* @__PURE__ */ __name(function _cleanupCallback(next) {
+ if (!called) {
+ const toRemove = cleanupCallbackSync || _cleanupCallback;
+ const index = _removeObjects.indexOf(toRemove);
+ if (index >= 0)
+ _removeObjects.splice(index, 1);
+ called = true;
+ if (sync || removeFunction === FN_RMDIR_SYNC || removeFunction === FN_RIMRAF_SYNC) {
+ return removeFunction(fileOrDirName);
+ } else {
+ return removeFunction(fileOrDirName, next || function() {
+ });
+ }
+ }
+ }, "_cleanupCallback");
+ }
+ __name(_prepareRemoveCallback, "_prepareRemoveCallback");
+ function _garbageCollector() {
+ if (!_gracefulCleanup)
+ return;
+ while (_removeObjects.length) {
+ try {
+ _removeObjects[0]();
+ } catch (e2) {
+ }
+ }
+ }
+ __name(_garbageCollector, "_garbageCollector");
+ function _randomChars(howMany) {
+ let value = [], rnd = null;
+ try {
+ rnd = crypto6.randomBytes(howMany);
+ } catch (e2) {
+ rnd = crypto6.pseudoRandomBytes(howMany);
+ }
+ for (var i = 0; i < howMany; i++) {
+ value.push(RANDOM_CHARS[rnd[i] % RANDOM_CHARS.length]);
+ }
+ return value.join("");
+ }
+ __name(_randomChars, "_randomChars");
+ function _isBlank(s) {
+ return s === null || _isUndefined(s) || !s.trim();
+ }
+ __name(_isBlank, "_isBlank");
+ function _isUndefined(obj) {
+ return typeof obj === "undefined";
+ }
+ __name(_isUndefined, "_isUndefined");
+ function _parseArguments(options14, callback) {
+ if (typeof options14 === "function") {
+ return [{}, options14];
+ }
+ if (_isUndefined(options14)) {
+ return [{}, callback];
+ }
+ const actualOptions = {};
+ for (const key of Object.getOwnPropertyNames(options14)) {
+ actualOptions[key] = options14[key];
+ }
+ return [actualOptions, callback];
+ }
+ __name(_parseArguments, "_parseArguments");
+ function _generateTmpName(opts) {
+ const tmpDir = opts.tmpdir;
+ if (!_isUndefined(opts.name))
+ return path45.join(tmpDir, opts.dir, opts.name);
+ if (!_isUndefined(opts.template))
+ return path45.join(tmpDir, opts.dir, opts.template).replace(TEMPLATE_PATTERN, _randomChars(6));
+ const name = [
+ opts.prefix ? opts.prefix : "tmp",
+ "-",
+ process.pid,
+ "-",
+ _randomChars(12),
+ opts.postfix ? "-" + opts.postfix : ""
+ ].join("");
+ return path45.join(tmpDir, opts.dir, name);
+ }
+ __name(_generateTmpName, "_generateTmpName");
+ function _assertAndSanitizeOptions(options14) {
+ options14.tmpdir = _getTmpDir(options14);
+ const tmpDir = options14.tmpdir;
+ if (!_isUndefined(options14.name))
+ _assertIsRelative(options14.name, "name", tmpDir);
+ if (!_isUndefined(options14.dir))
+ _assertIsRelative(options14.dir, "dir", tmpDir);
+ if (!_isUndefined(options14.template)) {
+ _assertIsRelative(options14.template, "template", tmpDir);
+ if (!options14.template.match(TEMPLATE_PATTERN))
+ throw new Error(`Invalid template, found "${options14.template}".`);
+ }
+ if (!_isUndefined(options14.tries) && isNaN(options14.tries) || options14.tries < 0)
+ throw new Error(`Invalid tries, found "${options14.tries}".`);
+ options14.tries = _isUndefined(options14.name) ? options14.tries || DEFAULT_TRIES : 1;
+ options14.keep = !!options14.keep;
+ options14.detachDescriptor = !!options14.detachDescriptor;
+ options14.discardDescriptor = !!options14.discardDescriptor;
+ options14.unsafeCleanup = !!options14.unsafeCleanup;
+ options14.dir = _isUndefined(options14.dir) ? "" : path45.relative(tmpDir, _resolvePath(options14.dir, tmpDir));
+ options14.template = _isUndefined(options14.template) ? void 0 : path45.relative(tmpDir, _resolvePath(options14.template, tmpDir));
+ options14.template = _isBlank(options14.template) ? void 0 : path45.relative(options14.dir, options14.template);
+ options14.name = _isUndefined(options14.name) ? void 0 : _sanitizeName(options14.name);
+ options14.prefix = _isUndefined(options14.prefix) ? "" : options14.prefix;
+ options14.postfix = _isUndefined(options14.postfix) ? "" : options14.postfix;
+ }
+ __name(_assertAndSanitizeOptions, "_assertAndSanitizeOptions");
+ function _resolvePath(name, tmpDir) {
+ const sanitizedName = _sanitizeName(name);
+ if (sanitizedName.startsWith(tmpDir)) {
+ return path45.resolve(sanitizedName);
+ } else {
+ return path45.resolve(path45.join(tmpDir, sanitizedName));
+ }
+ }
+ __name(_resolvePath, "_resolvePath");
+ function _sanitizeName(name) {
+ if (_isBlank(name)) {
+ return name;
+ }
+ return name.replace(/["']/g, "");
+ }
+ __name(_sanitizeName, "_sanitizeName");
+ function _assertIsRelative(name, option, tmpDir) {
+ if (option === "name") {
+ if (path45.isAbsolute(name))
+ throw new Error(`${option} option must not contain an absolute path, found "${name}".`);
+ let basename6 = path45.basename(name);
+ if (basename6 === ".." || basename6 === "." || basename6 !== name)
+ throw new Error(`${option} option must not contain a path, found "${name}".`);
+ } else {
+ if (path45.isAbsolute(name) && !name.startsWith(tmpDir)) {
+ throw new Error(`${option} option must be relative to "${tmpDir}", found "${name}".`);
+ }
+ let resolvedPath = _resolvePath(name, tmpDir);
+ if (!resolvedPath.startsWith(tmpDir))
+ throw new Error(`${option} option must be relative to "${tmpDir}", found "${resolvedPath}".`);
+ }
+ }
+ __name(_assertIsRelative, "_assertIsRelative");
+ function _isEBADF(error) {
+ return _isExpectedError(error, -EBADF, "EBADF");
+ }
+ __name(_isEBADF, "_isEBADF");
+ function _isENOENT(error) {
+ return _isExpectedError(error, -ENOENT, "ENOENT");
+ }
+ __name(_isENOENT, "_isENOENT");
+ function _isExpectedError(error, errno, code) {
+ return IS_WIN32 ? error.code === code : error.code === code && error.errno === errno;
+ }
+ __name(_isExpectedError, "_isExpectedError");
+ function setGracefulCleanup() {
+ _gracefulCleanup = true;
+ }
+ __name(setGracefulCleanup, "setGracefulCleanup");
+ function _getTmpDir(options14) {
+ return path45.resolve(_sanitizeName(options14 && options14.tmpdir || os9.tmpdir()));
+ }
+ __name(_getTmpDir, "_getTmpDir");
+ process.addListener(EXIT, _garbageCollector);
+ Object.defineProperty(module2.exports, "tmpdir", {
+ enumerable: true,
+ configurable: false,
+ get: function() {
+ return _getTmpDir();
+ }
+ });
+ module2.exports.dir = dir;
+ module2.exports.dirSync = dirSync;
+ module2.exports.file = file;
+ module2.exports.fileSync = fileSync;
+ module2.exports.tmpName = tmpName;
+ module2.exports.tmpNameSync = tmpNameSync;
+ module2.exports.setGracefulCleanup = setGracefulCleanup;
+ }
+});
+
+// ../../node_modules/.pnpm/tmp-promise@3.0.3/node_modules/tmp-promise/index.js
+var require_tmp_promise = __commonJS({
+ "../../node_modules/.pnpm/tmp-promise@3.0.3/node_modules/tmp-promise/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var { promisify: promisify2 } = require("util");
+ var tmp5 = require_tmp();
+ module2.exports.fileSync = tmp5.fileSync;
+ var fileWithOptions = promisify2(
+ (options14, cb) => tmp5.file(
+ options14,
+ (err, path45, fd, cleanup) => err ? cb(err) : cb(void 0, { path: path45, fd, cleanup: promisify2(cleanup) })
+ )
+ );
+ module2.exports.file = async (options14) => fileWithOptions(options14);
+ module2.exports.withFile = /* @__PURE__ */ __name(async function withFile(fn2, options14) {
+ const { path: path45, fd, cleanup } = await module2.exports.file(options14);
+ try {
+ return await fn2({ path: path45, fd });
+ } finally {
+ await cleanup();
+ }
+ }, "withFile");
+ module2.exports.dirSync = tmp5.dirSync;
+ var dirWithOptions = promisify2(
+ (options14, cb) => tmp5.dir(
+ options14,
+ (err, path45, cleanup) => err ? cb(err) : cb(void 0, { path: path45, cleanup: promisify2(cleanup) })
+ )
+ );
+ module2.exports.dir = async (options14) => dirWithOptions(options14);
+ module2.exports.withDir = /* @__PURE__ */ __name(async function withDir(fn2, options14) {
+ const { path: path45, cleanup } = await module2.exports.dir(options14);
+ try {
+ return await fn2({ path: path45 });
+ } finally {
+ await cleanup();
+ }
+ }, "withDir");
+ module2.exports.tmpNameSync = tmp5.tmpNameSync;
+ module2.exports.tmpName = promisify2(tmp5.tmpName);
+ module2.exports.tmpdir = tmp5.tmpdir;
+ module2.exports.setGracefulCleanup = tmp5.setGracefulCleanup;
+ }
+});
+
+// ../../node_modules/.pnpm/glob-to-regexp@0.4.1/node_modules/glob-to-regexp/index.js
+var require_glob_to_regexp = __commonJS({
+ "../../node_modules/.pnpm/glob-to-regexp@0.4.1/node_modules/glob-to-regexp/index.js"(exports2, module2) {
+ init_import_meta_url();
+ module2.exports = function(glob, opts) {
+ if (typeof glob !== "string") {
+ throw new TypeError("Expected a string");
+ }
+ var str = String(glob);
+ var reStr = "";
+ var extended = opts ? !!opts.extended : false;
+ var globstar = opts ? !!opts.globstar : false;
+ var inGroup = false;
+ var flags = opts && typeof opts.flags === "string" ? opts.flags : "";
+ var c;
+ for (var i = 0, len = str.length; i < len; i++) {
+ c = str[i];
+ switch (c) {
+ case "/":
+ case "$":
+ case "^":
+ case "+":
+ case ".":
+ case "(":
+ case ")":
+ case "=":
+ case "!":
+ case "|":
+ reStr += "\\" + c;
+ break;
+ case "?":
+ if (extended) {
+ reStr += ".";
+ break;
+ }
+ case "[":
+ case "]":
+ if (extended) {
+ reStr += c;
+ break;
+ }
+ case "{":
+ if (extended) {
+ inGroup = true;
+ reStr += "(";
+ break;
+ }
+ case "}":
+ if (extended) {
+ inGroup = false;
+ reStr += ")";
+ break;
+ }
+ case ",":
+ if (inGroup) {
+ reStr += "|";
+ break;
+ }
+ reStr += "\\" + c;
+ break;
+ case "*":
+ var prevChar = str[i - 1];
+ var starCount = 1;
+ while (str[i + 1] === "*") {
+ starCount++;
+ i++;
+ }
+ var nextChar = str[i + 1];
+ if (!globstar) {
+ reStr += ".*";
+ } else {
+ var isGlobstar = starCount > 1 && (prevChar === "/" || prevChar === void 0) && (nextChar === "/" || nextChar === void 0);
+ if (isGlobstar) {
+ reStr += "((?:[^/]*(?:/|$))*)";
+ i++;
+ } else {
+ reStr += "([^/]*)";
+ }
+ }
+ break;
+ default:
+ reStr += c;
+ }
+ }
+ if (!flags || !~flags.indexOf("g")) {
+ reStr = "^" + reStr + "$";
+ }
+ return new RegExp(reStr, flags);
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/windows.js
+var require_windows = __commonJS({
+ "../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/windows.js"(exports2, module2) {
+ init_import_meta_url();
+ module2.exports = isexe;
+ isexe.sync = sync;
+ var fs20 = require("fs");
+ function checkPathExt(path45, options14) {
+ var pathext = options14.pathExt !== void 0 ? options14.pathExt : process.env.PATHEXT;
+ if (!pathext) {
+ return true;
+ }
+ pathext = pathext.split(";");
+ if (pathext.indexOf("") !== -1) {
+ return true;
+ }
+ for (var i = 0; i < pathext.length; i++) {
+ var p = pathext[i].toLowerCase();
+ if (p && path45.substr(-p.length).toLowerCase() === p) {
+ return true;
+ }
+ }
+ return false;
+ }
+ __name(checkPathExt, "checkPathExt");
+ function checkStat(stat3, path45, options14) {
+ if (!stat3.isSymbolicLink() && !stat3.isFile()) {
+ return false;
+ }
+ return checkPathExt(path45, options14);
+ }
+ __name(checkStat, "checkStat");
+ function isexe(path45, options14, cb) {
+ fs20.stat(path45, function(er, stat3) {
+ cb(er, er ? false : checkStat(stat3, path45, options14));
+ });
+ }
+ __name(isexe, "isexe");
+ function sync(path45, options14) {
+ return checkStat(fs20.statSync(path45), path45, options14);
+ }
+ __name(sync, "sync");
+ }
+});
+
+// ../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/mode.js
+var require_mode = __commonJS({
+ "../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/mode.js"(exports2, module2) {
+ init_import_meta_url();
+ module2.exports = isexe;
+ isexe.sync = sync;
+ var fs20 = require("fs");
+ function isexe(path45, options14, cb) {
+ fs20.stat(path45, function(er, stat3) {
+ cb(er, er ? false : checkStat(stat3, options14));
+ });
+ }
+ __name(isexe, "isexe");
+ function sync(path45, options14) {
+ return checkStat(fs20.statSync(path45), options14);
+ }
+ __name(sync, "sync");
+ function checkStat(stat3, options14) {
+ return stat3.isFile() && checkMode(stat3, options14);
+ }
+ __name(checkStat, "checkStat");
+ function checkMode(stat3, options14) {
+ var mod = stat3.mode;
+ var uid = stat3.uid;
+ var gid = stat3.gid;
+ var myUid = options14.uid !== void 0 ? options14.uid : process.getuid && process.getuid();
+ var myGid = options14.gid !== void 0 ? options14.gid : process.getgid && process.getgid();
+ var u = parseInt("100", 8);
+ var g = parseInt("010", 8);
+ var o = parseInt("001", 8);
+ var ug = u | g;
+ var ret = mod & o || mod & g && gid === myGid || mod & u && uid === myUid || mod & ug && myUid === 0;
+ return ret;
+ }
+ __name(checkMode, "checkMode");
+ }
+});
+
+// ../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/index.js
+var require_isexe = __commonJS({
+ "../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/index.js"(exports2, module2) {
+ init_import_meta_url();
+ var fs20 = require("fs");
+ var core;
+ if (process.platform === "win32" || global.TESTING_WINDOWS) {
+ core = require_windows();
+ } else {
+ core = require_mode();
+ }
+ module2.exports = isexe;
+ isexe.sync = sync;
+ function isexe(path45, options14, cb) {
+ if (typeof options14 === "function") {
+ cb = options14;
+ options14 = {};
+ }
+ if (!cb) {
+ if (typeof Promise !== "function") {
+ throw new TypeError("callback not provided");
+ }
+ return new Promise(function(resolve18, reject) {
+ isexe(path45, options14 || {}, function(er, is2) {
+ if (er) {
+ reject(er);
+ } else {
+ resolve18(is2);
+ }
+ });
+ });
+ }
+ core(path45, options14 || {}, function(er, is2) {
+ if (er) {
+ if (er.code === "EACCES" || options14 && options14.ignoreErrors) {
+ er = null;
+ is2 = false;
+ }
+ }
+ cb(er, is2);
+ });
+ }
+ __name(isexe, "isexe");
+ function sync(path45, options14) {
+ try {
+ return core.sync(path45, options14 || {});
+ } catch (er) {
+ if (options14 && options14.ignoreErrors || er.code === "EACCES") {
+ return false;
+ } else {
+ throw er;
+ }
+ }
+ }
+ __name(sync, "sync");
+ }
+});
+
+// ../../node_modules/.pnpm/which@2.0.2/node_modules/which/which.js
+var require_which = __commonJS({
+ "../../node_modules/.pnpm/which@2.0.2/node_modules/which/which.js"(exports2, module2) {
+ init_import_meta_url();
+ var isWindows2 = process.platform === "win32" || process.env.OSTYPE === "cygwin" || process.env.OSTYPE === "msys";
+ var path45 = require("path");
+ var COLON = isWindows2 ? ";" : ":";
+ var isexe = require_isexe();
+ var getNotFoundError = /* @__PURE__ */ __name((cmd) => Object.assign(new Error(`not found: ${cmd}`), { code: "ENOENT" }), "getNotFoundError");
+ var getPathInfo = /* @__PURE__ */ __name((cmd, opt) => {
+ const colon = opt.colon || COLON;
+ const pathEnv = cmd.match(/\//) || isWindows2 && cmd.match(/\\/) ? [""] : [
+ // windows always checks the cwd first
+ ...isWindows2 ? [process.cwd()] : [],
+ ...(opt.path || process.env.PATH || /* istanbul ignore next: very unusual */
+ "").split(colon)
+ ];
+ const pathExtExe = isWindows2 ? opt.pathExt || process.env.PATHEXT || ".EXE;.CMD;.BAT;.COM" : "";
+ const pathExt = isWindows2 ? pathExtExe.split(colon) : [""];
+ if (isWindows2) {
+ if (cmd.indexOf(".") !== -1 && pathExt[0] !== "")
+ pathExt.unshift("");
+ }
+ return {
+ pathEnv,
+ pathExt,
+ pathExtExe
+ };
+ }, "getPathInfo");
+ var which = /* @__PURE__ */ __name((cmd, opt, cb) => {
+ if (typeof opt === "function") {
+ cb = opt;
+ opt = {};
+ }
+ if (!opt)
+ opt = {};
+ const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
+ const found = [];
+ const step = /* @__PURE__ */ __name((i) => new Promise((resolve18, reject) => {
+ if (i === pathEnv.length)
+ return opt.all && found.length ? resolve18(found) : reject(getNotFoundError(cmd));
+ const ppRaw = pathEnv[i];
+ const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
+ const pCmd = path45.join(pathPart, cmd);
+ const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
+ resolve18(subStep(p, i, 0));
+ }), "step");
+ const subStep = /* @__PURE__ */ __name((p, i, ii) => new Promise((resolve18, reject) => {
+ if (ii === pathExt.length)
+ return resolve18(step(i + 1));
+ const ext = pathExt[ii];
+ isexe(p + ext, { pathExt: pathExtExe }, (er, is2) => {
+ if (!er && is2) {
+ if (opt.all)
+ found.push(p + ext);
+ else
+ return resolve18(p + ext);
+ }
+ return resolve18(subStep(p, i, ii + 1));
+ });
+ }), "subStep");
+ return cb ? step(0).then((res) => cb(null, res), cb) : step(0);
+ }, "which");
+ var whichSync = /* @__PURE__ */ __name((cmd, opt) => {
+ opt = opt || {};
+ const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
+ const found = [];
+ for (let i = 0; i < pathEnv.length; i++) {
+ const ppRaw = pathEnv[i];
+ const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
+ const pCmd = path45.join(pathPart, cmd);
+ const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
+ for (let j = 0; j < pathExt.length; j++) {
+ const cur = p + pathExt[j];
+ try {
+ const is2 = isexe.sync(cur, { pathExt: pathExtExe });
+ if (is2) {
+ if (opt.all)
+ found.push(cur);
+ else
+ return cur;
+ }
+ } catch (ex) {
+ }
+ }
+ }
+ if (opt.all && found.length)
+ return found;
+ if (opt.nothrow)
+ return null;
+ throw getNotFoundError(cmd);
+ }, "whichSync");
+ module2.exports = which;
+ which.sync = whichSync;
+ }
+});
+
+// ../../node_modules/.pnpm/path-key@3.1.1/node_modules/path-key/index.js
+var require_path_key = __commonJS({
+ "../../node_modules/.pnpm/path-key@3.1.1/node_modules/path-key/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var pathKey2 = /* @__PURE__ */ __name((options14 = {}) => {
+ const environment = options14.env || process.env;
+ const platform = options14.platform || process.platform;
+ if (platform !== "win32") {
+ return "PATH";
+ }
+ return Object.keys(environment).reverse().find((key) => key.toUpperCase() === "PATH") || "Path";
+ }, "pathKey");
+ module2.exports = pathKey2;
+ module2.exports.default = pathKey2;
+ }
+});
+
+// ../../node_modules/.pnpm/cross-spawn@7.0.3/node_modules/cross-spawn/lib/util/resolveCommand.js
+var require_resolveCommand = __commonJS({
+ "../../node_modules/.pnpm/cross-spawn@7.0.3/node_modules/cross-spawn/lib/util/resolveCommand.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var path45 = require("path");
+ var which = require_which();
+ var getPathKey = require_path_key();
+ function resolveCommandAttempt(parsed, withoutPathExt) {
+ const env5 = parsed.options.env || process.env;
+ const cwd2 = process.cwd();
+ const hasCustomCwd = parsed.options.cwd != null;
+ const shouldSwitchCwd = hasCustomCwd && process.chdir !== void 0 && !process.chdir.disabled;
+ if (shouldSwitchCwd) {
+ try {
+ process.chdir(parsed.options.cwd);
+ } catch (err) {
+ }
+ }
+ let resolved;
+ try {
+ resolved = which.sync(parsed.command, {
+ path: env5[getPathKey({ env: env5 })],
+ pathExt: withoutPathExt ? path45.delimiter : void 0
+ });
+ } catch (e2) {
+ } finally {
+ if (shouldSwitchCwd) {
+ process.chdir(cwd2);
+ }
+ }
+ if (resolved) {
+ resolved = path45.resolve(hasCustomCwd ? parsed.options.cwd : "", resolved);
+ }
+ return resolved;
+ }
+ __name(resolveCommandAttempt, "resolveCommandAttempt");
+ function resolveCommand(parsed) {
+ return resolveCommandAttempt(parsed) || resolveCommandAttempt(parsed, true);
+ }
+ __name(resolveCommand, "resolveCommand");
+ module2.exports = resolveCommand;
+ }
+});
+
+// ../../node_modules/.pnpm/cross-spawn@7.0.3/node_modules/cross-spawn/lib/util/escape.js
+var require_escape = __commonJS({
+ "../../node_modules/.pnpm/cross-spawn@7.0.3/node_modules/cross-spawn/lib/util/escape.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var metaCharsRegExp = /([()\][%!^"`<>&|;, *?])/g;
+ function escapeCommand(arg) {
+ arg = arg.replace(metaCharsRegExp, "^$1");
+ return arg;
+ }
+ __name(escapeCommand, "escapeCommand");
+ function escapeArgument(arg, doubleEscapeMetaChars) {
+ arg = `${arg}`;
+ arg = arg.replace(/(\\*)"/g, '$1$1\\"');
+ arg = arg.replace(/(\\*)$/, "$1$1");
+ arg = `"${arg}"`;
+ arg = arg.replace(metaCharsRegExp, "^$1");
+ if (doubleEscapeMetaChars) {
+ arg = arg.replace(metaCharsRegExp, "^$1");
+ }
+ return arg;
+ }
+ __name(escapeArgument, "escapeArgument");
+ module2.exports.command = escapeCommand;
+ module2.exports.argument = escapeArgument;
+ }
+});
+
+// ../../node_modules/.pnpm/shebang-regex@3.0.0/node_modules/shebang-regex/index.js
+var require_shebang_regex = __commonJS({
+ "../../node_modules/.pnpm/shebang-regex@3.0.0/node_modules/shebang-regex/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ module2.exports = /^#!(.*)/;
+ }
+});
+
+// ../../node_modules/.pnpm/shebang-command@2.0.0/node_modules/shebang-command/index.js
+var require_shebang_command = __commonJS({
+ "../../node_modules/.pnpm/shebang-command@2.0.0/node_modules/shebang-command/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var shebangRegex = require_shebang_regex();
+ module2.exports = (string = "") => {
+ const match = string.match(shebangRegex);
+ if (!match) {
+ return null;
+ }
+ const [path45, argument] = match[0].replace(/#! ?/, "").split(" ");
+ const binary = path45.split("/").pop();
+ if (binary === "env") {
+ return argument;
+ }
+ return argument ? `${binary} ${argument}` : binary;
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/cross-spawn@7.0.3/node_modules/cross-spawn/lib/util/readShebang.js
+var require_readShebang = __commonJS({
+ "../../node_modules/.pnpm/cross-spawn@7.0.3/node_modules/cross-spawn/lib/util/readShebang.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var fs20 = require("fs");
+ var shebangCommand = require_shebang_command();
+ function readShebang(command2) {
+ const size = 150;
+ const buffer = Buffer.alloc(size);
+ let fd;
+ try {
+ fd = fs20.openSync(command2, "r");
+ fs20.readSync(fd, buffer, 0, size, 0);
+ fs20.closeSync(fd);
+ } catch (e2) {
+ }
+ return shebangCommand(buffer.toString());
+ }
+ __name(readShebang, "readShebang");
+ module2.exports = readShebang;
+ }
+});
+
+// ../../node_modules/.pnpm/cross-spawn@7.0.3/node_modules/cross-spawn/lib/parse.js
+var require_parse3 = __commonJS({
+ "../../node_modules/.pnpm/cross-spawn@7.0.3/node_modules/cross-spawn/lib/parse.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var path45 = require("path");
+ var resolveCommand = require_resolveCommand();
+ var escape2 = require_escape();
+ var readShebang = require_readShebang();
+ var isWin = process.platform === "win32";
+ var isExecutableRegExp = /\.(?:com|exe)$/i;
+ var isCmdShimRegExp = /node_modules[\\/].bin[\\/][^\\/]+\.cmd$/i;
+ function detectShebang(parsed) {
+ parsed.file = resolveCommand(parsed);
+ const shebang = parsed.file && readShebang(parsed.file);
+ if (shebang) {
+ parsed.args.unshift(parsed.file);
+ parsed.command = shebang;
+ return resolveCommand(parsed);
+ }
+ return parsed.file;
+ }
+ __name(detectShebang, "detectShebang");
+ function parseNonShell(parsed) {
+ if (!isWin) {
+ return parsed;
+ }
+ const commandFile = detectShebang(parsed);
+ const needsShell = !isExecutableRegExp.test(commandFile);
+ if (parsed.options.forceShell || needsShell) {
+ const needsDoubleEscapeMetaChars = isCmdShimRegExp.test(commandFile);
+ parsed.command = path45.normalize(parsed.command);
+ parsed.command = escape2.command(parsed.command);
+ parsed.args = parsed.args.map((arg) => escape2.argument(arg, needsDoubleEscapeMetaChars));
+ const shellCommand = [parsed.command].concat(parsed.args).join(" ");
+ parsed.args = ["/d", "/s", "/c", `"${shellCommand}"`];
+ parsed.command = process.env.comspec || "cmd.exe";
+ parsed.options.windowsVerbatimArguments = true;
+ }
+ return parsed;
+ }
+ __name(parseNonShell, "parseNonShell");
+ function parse4(command2, args, options14) {
+ if (args && !Array.isArray(args)) {
+ options14 = args;
+ args = null;
+ }
+ args = args ? args.slice(0) : [];
+ options14 = Object.assign({}, options14);
+ const parsed = {
+ command: command2,
+ args,
+ options: options14,
+ file: void 0,
+ original: {
+ command: command2,
+ args
+ }
+ };
+ return options14.shell ? parsed : parseNonShell(parsed);
+ }
+ __name(parse4, "parse");
+ module2.exports = parse4;
+ }
+});
+
+// ../../node_modules/.pnpm/cross-spawn@7.0.3/node_modules/cross-spawn/lib/enoent.js
+var require_enoent = __commonJS({
+ "../../node_modules/.pnpm/cross-spawn@7.0.3/node_modules/cross-spawn/lib/enoent.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var isWin = process.platform === "win32";
+ function notFoundError(original, syscall) {
+ return Object.assign(new Error(`${syscall} ${original.command} ENOENT`), {
+ code: "ENOENT",
+ errno: "ENOENT",
+ syscall: `${syscall} ${original.command}`,
+ path: original.command,
+ spawnargs: original.args
+ });
+ }
+ __name(notFoundError, "notFoundError");
+ function hookChildProcess(cp2, parsed) {
+ if (!isWin) {
+ return;
+ }
+ const originalEmit = cp2.emit;
+ cp2.emit = function(name, arg1) {
+ if (name === "exit") {
+ const err = verifyENOENT(arg1, parsed, "spawn");
+ if (err) {
+ return originalEmit.call(cp2, "error", err);
+ }
+ }
+ return originalEmit.apply(cp2, arguments);
+ };
+ }
+ __name(hookChildProcess, "hookChildProcess");
+ function verifyENOENT(status, parsed) {
+ if (isWin && status === 1 && !parsed.file) {
+ return notFoundError(parsed.original, "spawn");
+ }
+ return null;
+ }
+ __name(verifyENOENT, "verifyENOENT");
+ function verifyENOENTSync(status, parsed) {
+ if (isWin && status === 1 && !parsed.file) {
+ return notFoundError(parsed.original, "spawnSync");
+ }
+ return null;
+ }
+ __name(verifyENOENTSync, "verifyENOENTSync");
+ module2.exports = {
+ hookChildProcess,
+ verifyENOENT,
+ verifyENOENTSync,
+ notFoundError
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/cross-spawn@7.0.3/node_modules/cross-spawn/index.js
+var require_cross_spawn = __commonJS({
+ "../../node_modules/.pnpm/cross-spawn@7.0.3/node_modules/cross-spawn/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var cp2 = require("child_process");
+ var parse4 = require_parse3();
+ var enoent = require_enoent();
+ function spawn3(command2, args, options14) {
+ const parsed = parse4(command2, args, options14);
+ const spawned = cp2.spawn(parsed.command, parsed.args, parsed.options);
+ enoent.hookChildProcess(spawned, parsed);
+ return spawned;
+ }
+ __name(spawn3, "spawn");
+ function spawnSync3(command2, args, options14) {
+ const parsed = parse4(command2, args, options14);
+ const result = cp2.spawnSync(parsed.command, parsed.args, parsed.options);
+ result.error = result.error || enoent.verifyENOENTSync(result.status, parsed);
+ return result;
+ }
+ __name(spawnSync3, "spawnSync");
+ module2.exports = spawn3;
+ module2.exports.spawn = spawn3;
+ module2.exports.sync = spawnSync3;
+ module2.exports._parse = parse4;
+ module2.exports._enoent = enoent;
+ }
+});
+
+// ../../node_modules/.pnpm/get-stream@6.0.1/node_modules/get-stream/buffer-stream.js
+var require_buffer_stream = __commonJS({
+ "../../node_modules/.pnpm/get-stream@6.0.1/node_modules/get-stream/buffer-stream.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var { PassThrough: PassThroughStream } = require("stream");
+ module2.exports = (options14) => {
+ options14 = { ...options14 };
+ const { array } = options14;
+ let { encoding } = options14;
+ const isBuffer = encoding === "buffer";
+ let objectMode = false;
+ if (array) {
+ objectMode = !(encoding || isBuffer);
+ } else {
+ encoding = encoding || "utf8";
+ }
+ if (isBuffer) {
+ encoding = null;
+ }
+ const stream2 = new PassThroughStream({ objectMode });
+ if (encoding) {
+ stream2.setEncoding(encoding);
+ }
+ let length = 0;
+ const chunks = [];
+ stream2.on("data", (chunk) => {
+ chunks.push(chunk);
+ if (objectMode) {
+ length = chunks.length;
+ } else {
+ length += chunk.length;
+ }
+ });
+ stream2.getBufferedValue = () => {
+ if (array) {
+ return chunks;
+ }
+ return isBuffer ? Buffer.concat(chunks, length) : chunks.join("");
+ };
+ stream2.getBufferedLength = () => length;
+ return stream2;
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/get-stream@6.0.1/node_modules/get-stream/index.js
+var require_get_stream = __commonJS({
+ "../../node_modules/.pnpm/get-stream@6.0.1/node_modules/get-stream/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var { constants: BufferConstants } = require("buffer");
+ var stream2 = require("stream");
+ var { promisify: promisify2 } = require("util");
+ var bufferStream = require_buffer_stream();
+ var streamPipelinePromisified = promisify2(stream2.pipeline);
+ var MaxBufferError = class extends Error {
+ constructor() {
+ super("maxBuffer exceeded");
+ this.name = "MaxBufferError";
+ }
+ };
+ __name(MaxBufferError, "MaxBufferError");
+ async function getStream2(inputStream, options14) {
+ if (!inputStream) {
+ throw new Error("Expected a stream");
+ }
+ options14 = {
+ maxBuffer: Infinity,
+ ...options14
+ };
+ const { maxBuffer } = options14;
+ const stream3 = bufferStream(options14);
+ await new Promise((resolve18, reject) => {
+ const rejectPromise = /* @__PURE__ */ __name((error) => {
+ if (error && stream3.getBufferedLength() <= BufferConstants.MAX_LENGTH) {
+ error.bufferedData = stream3.getBufferedValue();
+ }
+ reject(error);
+ }, "rejectPromise");
+ (async () => {
+ try {
+ await streamPipelinePromisified(inputStream, stream3);
+ resolve18();
+ } catch (error) {
+ rejectPromise(error);
+ }
+ })();
+ stream3.on("data", () => {
+ if (stream3.getBufferedLength() > maxBuffer) {
+ rejectPromise(new MaxBufferError());
+ }
+ });
+ });
+ return stream3.getBufferedValue();
+ }
+ __name(getStream2, "getStream");
+ module2.exports = getStream2;
+ module2.exports.buffer = (stream3, options14) => getStream2(stream3, { ...options14, encoding: "buffer" });
+ module2.exports.array = (stream3, options14) => getStream2(stream3, { ...options14, array: true });
+ module2.exports.MaxBufferError = MaxBufferError;
+ }
+});
+
+// ../../node_modules/.pnpm/merge-stream@2.0.0/node_modules/merge-stream/index.js
+var require_merge_stream = __commonJS({
+ "../../node_modules/.pnpm/merge-stream@2.0.0/node_modules/merge-stream/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var { PassThrough } = require("stream");
+ module2.exports = function() {
+ var sources = [];
+ var output = new PassThrough({ objectMode: true });
+ output.setMaxListeners(0);
+ output.add = add;
+ output.isEmpty = isEmpty;
+ output.on("unpipe", remove);
+ Array.prototype.slice.call(arguments).forEach(add);
+ return output;
+ function add(source) {
+ if (Array.isArray(source)) {
+ source.forEach(add);
+ return this;
+ }
+ sources.push(source);
+ source.once("end", remove.bind(null, source));
+ source.once("error", output.emit.bind(output, "error"));
+ source.pipe(output, { end: false });
+ return this;
+ }
+ __name(add, "add");
+ function isEmpty() {
+ return sources.length == 0;
+ }
+ __name(isEmpty, "isEmpty");
+ function remove(source) {
+ sources = sources.filter(function(it2) {
+ return it2 !== source;
+ });
+ if (!sources.length && output.readable) {
+ output.end();
+ }
+ }
+ __name(remove, "remove");
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/strip-final-newline@2.0.0/node_modules/strip-final-newline/index.js
+var require_strip_final_newline = __commonJS({
+ "../../node_modules/.pnpm/strip-final-newline@2.0.0/node_modules/strip-final-newline/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ module2.exports = (input) => {
+ const LF = typeof input === "string" ? "\n" : "\n".charCodeAt();
+ const CR = typeof input === "string" ? "\r" : "\r".charCodeAt();
+ if (input[input.length - 1] === LF) {
+ input = input.slice(0, input.length - 1);
+ }
+ if (input[input.length - 1] === CR) {
+ input = input.slice(0, input.length - 1);
+ }
+ return input;
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/npm-run-path@4.0.1/node_modules/npm-run-path/index.js
+var require_npm_run_path = __commonJS({
+ "../../node_modules/.pnpm/npm-run-path@4.0.1/node_modules/npm-run-path/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var path45 = require("path");
+ var pathKey2 = require_path_key();
+ var npmRunPath2 = /* @__PURE__ */ __name((options14) => {
+ options14 = {
+ cwd: process.cwd(),
+ path: process.env[pathKey2()],
+ execPath: process.execPath,
+ ...options14
+ };
+ let previous;
+ let cwdPath = path45.resolve(options14.cwd);
+ const result = [];
+ while (previous !== cwdPath) {
+ result.push(path45.join(cwdPath, "node_modules/.bin"));
+ previous = cwdPath;
+ cwdPath = path45.resolve(cwdPath, "..");
+ }
+ const execPathDir = path45.resolve(options14.cwd, options14.execPath, "..");
+ result.push(execPathDir);
+ return result.concat(options14.path).join(path45.delimiter);
+ }, "npmRunPath");
+ module2.exports = npmRunPath2;
+ module2.exports.default = npmRunPath2;
+ module2.exports.env = (options14) => {
+ options14 = {
+ env: process.env,
+ ...options14
+ };
+ const env5 = { ...options14.env };
+ const path46 = pathKey2({ env: env5 });
+ options14.path = env5[path46];
+ env5[path46] = module2.exports(options14);
+ return env5;
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/human-signals@2.1.0/node_modules/human-signals/build/src/core.js
+var require_core = __commonJS({
+ "../../node_modules/.pnpm/human-signals@2.1.0/node_modules/human-signals/build/src/core.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ Object.defineProperty(exports2, "__esModule", { value: true });
+ exports2.SIGNALS = void 0;
+ var SIGNALS2 = [
+ {
+ name: "SIGHUP",
+ number: 1,
+ action: "terminate",
+ description: "Terminal closed",
+ standard: "posix"
+ },
+ {
+ name: "SIGINT",
+ number: 2,
+ action: "terminate",
+ description: "User interruption with CTRL-C",
+ standard: "ansi"
+ },
+ {
+ name: "SIGQUIT",
+ number: 3,
+ action: "core",
+ description: "User interruption with CTRL-\\",
+ standard: "posix"
+ },
+ {
+ name: "SIGILL",
+ number: 4,
+ action: "core",
+ description: "Invalid machine instruction",
+ standard: "ansi"
+ },
+ {
+ name: "SIGTRAP",
+ number: 5,
+ action: "core",
+ description: "Debugger breakpoint",
+ standard: "posix"
+ },
+ {
+ name: "SIGABRT",
+ number: 6,
+ action: "core",
+ description: "Aborted",
+ standard: "ansi"
+ },
+ {
+ name: "SIGIOT",
+ number: 6,
+ action: "core",
+ description: "Aborted",
+ standard: "bsd"
+ },
+ {
+ name: "SIGBUS",
+ number: 7,
+ action: "core",
+ description: "Bus error due to misaligned, non-existing address or paging error",
+ standard: "bsd"
+ },
+ {
+ name: "SIGEMT",
+ number: 7,
+ action: "terminate",
+ description: "Command should be emulated but is not implemented",
+ standard: "other"
+ },
+ {
+ name: "SIGFPE",
+ number: 8,
+ action: "core",
+ description: "Floating point arithmetic error",
+ standard: "ansi"
+ },
+ {
+ name: "SIGKILL",
+ number: 9,
+ action: "terminate",
+ description: "Forced termination",
+ standard: "posix",
+ forced: true
+ },
+ {
+ name: "SIGUSR1",
+ number: 10,
+ action: "terminate",
+ description: "Application-specific signal",
+ standard: "posix"
+ },
+ {
+ name: "SIGSEGV",
+ number: 11,
+ action: "core",
+ description: "Segmentation fault",
+ standard: "ansi"
+ },
+ {
+ name: "SIGUSR2",
+ number: 12,
+ action: "terminate",
+ description: "Application-specific signal",
+ standard: "posix"
+ },
+ {
+ name: "SIGPIPE",
+ number: 13,
+ action: "terminate",
+ description: "Broken pipe or socket",
+ standard: "posix"
+ },
+ {
+ name: "SIGALRM",
+ number: 14,
+ action: "terminate",
+ description: "Timeout or timer",
+ standard: "posix"
+ },
+ {
+ name: "SIGTERM",
+ number: 15,
+ action: "terminate",
+ description: "Termination",
+ standard: "ansi"
+ },
+ {
+ name: "SIGSTKFLT",
+ number: 16,
+ action: "terminate",
+ description: "Stack is empty or overflowed",
+ standard: "other"
+ },
+ {
+ name: "SIGCHLD",
+ number: 17,
+ action: "ignore",
+ description: "Child process terminated, paused or unpaused",
+ standard: "posix"
+ },
+ {
+ name: "SIGCLD",
+ number: 17,
+ action: "ignore",
+ description: "Child process terminated, paused or unpaused",
+ standard: "other"
+ },
+ {
+ name: "SIGCONT",
+ number: 18,
+ action: "unpause",
+ description: "Unpaused",
+ standard: "posix",
+ forced: true
+ },
+ {
+ name: "SIGSTOP",
+ number: 19,
+ action: "pause",
+ description: "Paused",
+ standard: "posix",
+ forced: true
+ },
+ {
+ name: "SIGTSTP",
+ number: 20,
+ action: "pause",
+ description: 'Paused using CTRL-Z or "suspend"',
+ standard: "posix"
+ },
+ {
+ name: "SIGTTIN",
+ number: 21,
+ action: "pause",
+ description: "Background process cannot read terminal input",
+ standard: "posix"
+ },
+ {
+ name: "SIGBREAK",
+ number: 21,
+ action: "terminate",
+ description: "User interruption with CTRL-BREAK",
+ standard: "other"
+ },
+ {
+ name: "SIGTTOU",
+ number: 22,
+ action: "pause",
+ description: "Background process cannot write to terminal output",
+ standard: "posix"
+ },
+ {
+ name: "SIGURG",
+ number: 23,
+ action: "ignore",
+ description: "Socket received out-of-band data",
+ standard: "bsd"
+ },
+ {
+ name: "SIGXCPU",
+ number: 24,
+ action: "core",
+ description: "Process timed out",
+ standard: "bsd"
+ },
+ {
+ name: "SIGXFSZ",
+ number: 25,
+ action: "core",
+ description: "File too big",
+ standard: "bsd"
+ },
+ {
+ name: "SIGVTALRM",
+ number: 26,
+ action: "terminate",
+ description: "Timeout or timer",
+ standard: "bsd"
+ },
+ {
+ name: "SIGPROF",
+ number: 27,
+ action: "terminate",
+ description: "Timeout or timer",
+ standard: "bsd"
+ },
+ {
+ name: "SIGWINCH",
+ number: 28,
+ action: "ignore",
+ description: "Terminal window size changed",
+ standard: "bsd"
+ },
+ {
+ name: "SIGIO",
+ number: 29,
+ action: "terminate",
+ description: "I/O is available",
+ standard: "other"
+ },
+ {
+ name: "SIGPOLL",
+ number: 29,
+ action: "terminate",
+ description: "Watched event",
+ standard: "other"
+ },
+ {
+ name: "SIGINFO",
+ number: 29,
+ action: "ignore",
+ description: "Request for process information",
+ standard: "other"
+ },
+ {
+ name: "SIGPWR",
+ number: 30,
+ action: "terminate",
+ description: "Device running out of power",
+ standard: "systemv"
+ },
+ {
+ name: "SIGSYS",
+ number: 31,
+ action: "core",
+ description: "Invalid system call",
+ standard: "other"
+ },
+ {
+ name: "SIGUNUSED",
+ number: 31,
+ action: "terminate",
+ description: "Invalid system call",
+ standard: "other"
+ }
+ ];
+ exports2.SIGNALS = SIGNALS2;
+ }
+});
+
+// ../../node_modules/.pnpm/human-signals@2.1.0/node_modules/human-signals/build/src/realtime.js
+var require_realtime = __commonJS({
+ "../../node_modules/.pnpm/human-signals@2.1.0/node_modules/human-signals/build/src/realtime.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ Object.defineProperty(exports2, "__esModule", { value: true });
+ exports2.SIGRTMAX = exports2.getRealtimeSignals = void 0;
+ var getRealtimeSignals2 = /* @__PURE__ */ __name(function() {
+ const length = SIGRTMAX2 - SIGRTMIN2 + 1;
+ return Array.from({ length }, getRealtimeSignal2);
+ }, "getRealtimeSignals");
+ exports2.getRealtimeSignals = getRealtimeSignals2;
+ var getRealtimeSignal2 = /* @__PURE__ */ __name(function(value, index) {
+ return {
+ name: `SIGRT${index + 1}`,
+ number: SIGRTMIN2 + index,
+ action: "terminate",
+ description: "Application-specific signal (realtime)",
+ standard: "posix"
+ };
+ }, "getRealtimeSignal");
+ var SIGRTMIN2 = 34;
+ var SIGRTMAX2 = 64;
+ exports2.SIGRTMAX = SIGRTMAX2;
+ }
+});
+
+// ../../node_modules/.pnpm/human-signals@2.1.0/node_modules/human-signals/build/src/signals.js
+var require_signals2 = __commonJS({
+ "../../node_modules/.pnpm/human-signals@2.1.0/node_modules/human-signals/build/src/signals.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ Object.defineProperty(exports2, "__esModule", { value: true });
+ exports2.getSignals = void 0;
+ var _os = require("os");
+ var _core = require_core();
+ var _realtime = require_realtime();
+ var getSignals2 = /* @__PURE__ */ __name(function() {
+ const realtimeSignals = (0, _realtime.getRealtimeSignals)();
+ const signals = [..._core.SIGNALS, ...realtimeSignals].map(normalizeSignal2);
+ return signals;
+ }, "getSignals");
+ exports2.getSignals = getSignals2;
+ var normalizeSignal2 = /* @__PURE__ */ __name(function({
+ name,
+ number: defaultNumber,
+ description,
+ action,
+ forced = false,
+ standard
+ }) {
+ const {
+ signals: { [name]: constantSignal }
+ } = _os.constants;
+ const supported = constantSignal !== void 0;
+ const number = supported ? constantSignal : defaultNumber;
+ return { name, number, description, supported, action, forced, standard };
+ }, "normalizeSignal");
+ }
+});
+
+// ../../node_modules/.pnpm/human-signals@2.1.0/node_modules/human-signals/build/src/main.js
+var require_main2 = __commonJS({
+ "../../node_modules/.pnpm/human-signals@2.1.0/node_modules/human-signals/build/src/main.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ Object.defineProperty(exports2, "__esModule", { value: true });
+ exports2.signalsByNumber = exports2.signalsByName = void 0;
+ var _os = require("os");
+ var _signals = require_signals2();
+ var _realtime = require_realtime();
+ var getSignalsByName2 = /* @__PURE__ */ __name(function() {
+ const signals = (0, _signals.getSignals)();
+ return signals.reduce(getSignalByName2, {});
+ }, "getSignalsByName");
+ var getSignalByName2 = /* @__PURE__ */ __name(function(signalByNameMemo, { name, number, description, supported, action, forced, standard }) {
+ return {
+ ...signalByNameMemo,
+ [name]: { name, number, description, supported, action, forced, standard }
+ };
+ }, "getSignalByName");
+ var signalsByName2 = getSignalsByName2();
+ exports2.signalsByName = signalsByName2;
+ var getSignalsByNumber2 = /* @__PURE__ */ __name(function() {
+ const signals = (0, _signals.getSignals)();
+ const length = _realtime.SIGRTMAX + 1;
+ const signalsA = Array.from({ length }, (value, number) => getSignalByNumber2(number, signals));
+ return Object.assign({}, ...signalsA);
+ }, "getSignalsByNumber");
+ var getSignalByNumber2 = /* @__PURE__ */ __name(function(number, signals) {
+ const signal = findSignalByNumber2(number, signals);
+ if (signal === void 0) {
+ return {};
+ }
+ const { name, description, supported, action, forced, standard } = signal;
+ return {
+ [number]: {
+ name,
+ number,
+ description,
+ supported,
+ action,
+ forced,
+ standard
+ }
+ };
+ }, "getSignalByNumber");
+ var findSignalByNumber2 = /* @__PURE__ */ __name(function(number, signals) {
+ const signal = signals.find(({ name }) => _os.constants.signals[name] === number);
+ if (signal !== void 0) {
+ return signal;
+ }
+ return signals.find((signalA) => signalA.number === number);
+ }, "findSignalByNumber");
+ var signalsByNumber2 = getSignalsByNumber2();
+ exports2.signalsByNumber = signalsByNumber2;
+ }
+});
+
+// ../../node_modules/.pnpm/execa@5.1.1/node_modules/execa/lib/error.js
+var require_error = __commonJS({
+ "../../node_modules/.pnpm/execa@5.1.1/node_modules/execa/lib/error.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var { signalsByName: signalsByName2 } = require_main2();
+ var getErrorPrefix2 = /* @__PURE__ */ __name(({ timedOut, timeout, errorCode, signal, signalDescription, exitCode, isCanceled }) => {
+ if (timedOut) {
+ return `timed out after ${timeout} milliseconds`;
+ }
+ if (isCanceled) {
+ return "was canceled";
+ }
+ if (errorCode !== void 0) {
+ return `failed with ${errorCode}`;
+ }
+ if (signal !== void 0) {
+ return `was killed with ${signal} (${signalDescription})`;
+ }
+ if (exitCode !== void 0) {
+ return `failed with exit code ${exitCode}`;
+ }
+ return "failed";
+ }, "getErrorPrefix");
+ var makeError3 = /* @__PURE__ */ __name(({
+ stdout,
+ stderr,
+ all: all2,
+ error,
+ signal,
+ exitCode,
+ command: command2,
+ escapedCommand,
+ timedOut,
+ isCanceled,
+ killed,
+ parsed: { options: { timeout } }
+ }) => {
+ exitCode = exitCode === null ? void 0 : exitCode;
+ signal = signal === null ? void 0 : signal;
+ const signalDescription = signal === void 0 ? void 0 : signalsByName2[signal].description;
+ const errorCode = error && error.code;
+ const prefix = getErrorPrefix2({ timedOut, timeout, errorCode, signal, signalDescription, exitCode, isCanceled });
+ const execaMessage = `Command ${prefix}: ${command2}`;
+ const isError = Object.prototype.toString.call(error) === "[object Error]";
+ const shortMessage = isError ? `${execaMessage}
+${error.message}` : execaMessage;
+ const message = [shortMessage, stderr, stdout].filter(Boolean).join("\n");
+ if (isError) {
+ error.originalMessage = error.message;
+ error.message = message;
+ } else {
+ error = new Error(message);
+ }
+ error.shortMessage = shortMessage;
+ error.command = command2;
+ error.escapedCommand = escapedCommand;
+ error.exitCode = exitCode;
+ error.signal = signal;
+ error.signalDescription = signalDescription;
+ error.stdout = stdout;
+ error.stderr = stderr;
+ if (all2 !== void 0) {
+ error.all = all2;
+ }
+ if ("bufferedData" in error) {
+ delete error.bufferedData;
+ }
+ error.failed = true;
+ error.timedOut = Boolean(timedOut);
+ error.isCanceled = isCanceled;
+ error.killed = killed && !timedOut;
+ return error;
+ }, "makeError");
+ module2.exports = makeError3;
+ }
+});
+
+// ../../node_modules/.pnpm/execa@5.1.1/node_modules/execa/lib/stdio.js
+var require_stdio = __commonJS({
+ "../../node_modules/.pnpm/execa@5.1.1/node_modules/execa/lib/stdio.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var aliases2 = ["stdin", "stdout", "stderr"];
+ var hasAlias2 = /* @__PURE__ */ __name((options14) => aliases2.some((alias) => options14[alias] !== void 0), "hasAlias");
+ var normalizeStdio2 = /* @__PURE__ */ __name((options14) => {
+ if (!options14) {
+ return;
+ }
+ const { stdio } = options14;
+ if (stdio === void 0) {
+ return aliases2.map((alias) => options14[alias]);
+ }
+ if (hasAlias2(options14)) {
+ throw new Error(`It's not possible to provide \`stdio\` in combination with one of ${aliases2.map((alias) => `\`${alias}\``).join(", ")}`);
+ }
+ if (typeof stdio === "string") {
+ return stdio;
+ }
+ if (!Array.isArray(stdio)) {
+ throw new TypeError(`Expected \`stdio\` to be of type \`string\` or \`Array\`, got \`${typeof stdio}\``);
+ }
+ const length = Math.max(stdio.length, aliases2.length);
+ return Array.from({ length }, (value, index) => stdio[index]);
+ }, "normalizeStdio");
+ module2.exports = normalizeStdio2;
+ module2.exports.node = (options14) => {
+ const stdio = normalizeStdio2(options14);
+ if (stdio === "ipc") {
+ return "ipc";
+ }
+ if (stdio === void 0 || typeof stdio === "string") {
+ return [stdio, stdio, stdio, "ipc"];
+ }
+ if (stdio.includes("ipc")) {
+ return stdio;
+ }
+ return [...stdio, "ipc"];
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/execa@5.1.1/node_modules/execa/lib/kill.js
+var require_kill = __commonJS({
+ "../../node_modules/.pnpm/execa@5.1.1/node_modules/execa/lib/kill.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var os9 = require("os");
+ var onExit7 = require_signal_exit();
+ var DEFAULT_FORCE_KILL_TIMEOUT2 = 1e3 * 5;
+ var spawnedKill2 = /* @__PURE__ */ __name((kill, signal = "SIGTERM", options14 = {}) => {
+ const killResult = kill(signal);
+ setKillTimeout2(kill, signal, options14, killResult);
+ return killResult;
+ }, "spawnedKill");
+ var setKillTimeout2 = /* @__PURE__ */ __name((kill, signal, options14, killResult) => {
+ if (!shouldForceKill2(signal, options14, killResult)) {
+ return;
+ }
+ const timeout = getForceKillAfterTimeout2(options14);
+ const t2 = setTimeout(() => {
+ kill("SIGKILL");
+ }, timeout);
+ if (t2.unref) {
+ t2.unref();
+ }
+ }, "setKillTimeout");
+ var shouldForceKill2 = /* @__PURE__ */ __name((signal, { forceKillAfterTimeout }, killResult) => {
+ return isSigterm2(signal) && forceKillAfterTimeout !== false && killResult;
+ }, "shouldForceKill");
+ var isSigterm2 = /* @__PURE__ */ __name((signal) => {
+ return signal === os9.constants.signals.SIGTERM || typeof signal === "string" && signal.toUpperCase() === "SIGTERM";
+ }, "isSigterm");
+ var getForceKillAfterTimeout2 = /* @__PURE__ */ __name(({ forceKillAfterTimeout = true }) => {
+ if (forceKillAfterTimeout === true) {
+ return DEFAULT_FORCE_KILL_TIMEOUT2;
+ }
+ if (!Number.isFinite(forceKillAfterTimeout) || forceKillAfterTimeout < 0) {
+ throw new TypeError(`Expected the \`forceKillAfterTimeout\` option to be a non-negative integer, got \`${forceKillAfterTimeout}\` (${typeof forceKillAfterTimeout})`);
+ }
+ return forceKillAfterTimeout;
+ }, "getForceKillAfterTimeout");
+ var spawnedCancel2 = /* @__PURE__ */ __name((spawned, context2) => {
+ const killResult = spawned.kill();
+ if (killResult) {
+ context2.isCanceled = true;
+ }
+ }, "spawnedCancel");
+ var timeoutKill2 = /* @__PURE__ */ __name((spawned, signal, reject) => {
+ spawned.kill(signal);
+ reject(Object.assign(new Error("Timed out"), { timedOut: true, signal }));
+ }, "timeoutKill");
+ var setupTimeout2 = /* @__PURE__ */ __name((spawned, { timeout, killSignal = "SIGTERM" }, spawnedPromise) => {
+ if (timeout === 0 || timeout === void 0) {
+ return spawnedPromise;
+ }
+ let timeoutId;
+ const timeoutPromise = new Promise((resolve18, reject) => {
+ timeoutId = setTimeout(() => {
+ timeoutKill2(spawned, killSignal, reject);
+ }, timeout);
+ });
+ const safeSpawnedPromise = spawnedPromise.finally(() => {
+ clearTimeout(timeoutId);
+ });
+ return Promise.race([timeoutPromise, safeSpawnedPromise]);
+ }, "setupTimeout");
+ var validateTimeout2 = /* @__PURE__ */ __name(({ timeout }) => {
+ if (timeout !== void 0 && (!Number.isFinite(timeout) || timeout < 0)) {
+ throw new TypeError(`Expected the \`timeout\` option to be a non-negative integer, got \`${timeout}\` (${typeof timeout})`);
+ }
+ }, "validateTimeout");
+ var setExitHandler2 = /* @__PURE__ */ __name(async (spawned, { cleanup, detached }, timedPromise) => {
+ if (!cleanup || detached) {
+ return timedPromise;
+ }
+ const removeExitHandler = onExit7(() => {
+ spawned.kill();
+ });
+ return timedPromise.finally(() => {
+ removeExitHandler();
+ });
+ }, "setExitHandler");
+ module2.exports = {
+ spawnedKill: spawnedKill2,
+ spawnedCancel: spawnedCancel2,
+ setupTimeout: setupTimeout2,
+ validateTimeout: validateTimeout2,
+ setExitHandler: setExitHandler2
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/is-stream@2.0.1/node_modules/is-stream/index.js
+var require_is_stream = __commonJS({
+ "../../node_modules/.pnpm/is-stream@2.0.1/node_modules/is-stream/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var isStream2 = /* @__PURE__ */ __name((stream2) => stream2 !== null && typeof stream2 === "object" && typeof stream2.pipe === "function", "isStream");
+ isStream2.writable = (stream2) => isStream2(stream2) && stream2.writable !== false && typeof stream2._write === "function" && typeof stream2._writableState === "object";
+ isStream2.readable = (stream2) => isStream2(stream2) && stream2.readable !== false && typeof stream2._read === "function" && typeof stream2._readableState === "object";
+ isStream2.duplex = (stream2) => isStream2.writable(stream2) && isStream2.readable(stream2);
+ isStream2.transform = (stream2) => isStream2.duplex(stream2) && typeof stream2._transform === "function";
+ module2.exports = isStream2;
+ }
+});
+
+// ../../node_modules/.pnpm/execa@5.1.1/node_modules/execa/lib/stream.js
+var require_stream2 = __commonJS({
+ "../../node_modules/.pnpm/execa@5.1.1/node_modules/execa/lib/stream.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var isStream2 = require_is_stream();
+ var getStream2 = require_get_stream();
+ var mergeStream2 = require_merge_stream();
+ var handleInput2 = /* @__PURE__ */ __name((spawned, input) => {
+ if (input === void 0 || spawned.stdin === void 0) {
+ return;
+ }
+ if (isStream2(input)) {
+ input.pipe(spawned.stdin);
+ } else {
+ spawned.stdin.end(input);
+ }
+ }, "handleInput");
+ var makeAllStream2 = /* @__PURE__ */ __name((spawned, { all: all2 }) => {
+ if (!all2 || !spawned.stdout && !spawned.stderr) {
+ return;
+ }
+ const mixed = mergeStream2();
+ if (spawned.stdout) {
+ mixed.add(spawned.stdout);
+ }
+ if (spawned.stderr) {
+ mixed.add(spawned.stderr);
+ }
+ return mixed;
+ }, "makeAllStream");
+ var getBufferedData2 = /* @__PURE__ */ __name(async (stream2, streamPromise) => {
+ if (!stream2) {
+ return;
+ }
+ stream2.destroy();
+ try {
+ return await streamPromise;
+ } catch (error) {
+ return error.bufferedData;
+ }
+ }, "getBufferedData");
+ var getStreamPromise2 = /* @__PURE__ */ __name((stream2, { encoding, buffer, maxBuffer }) => {
+ if (!stream2 || !buffer) {
+ return;
+ }
+ if (encoding) {
+ return getStream2(stream2, { encoding, maxBuffer });
+ }
+ return getStream2.buffer(stream2, { maxBuffer });
+ }, "getStreamPromise");
+ var getSpawnedResult2 = /* @__PURE__ */ __name(async ({ stdout, stderr, all: all2 }, { encoding, buffer, maxBuffer }, processDone) => {
+ const stdoutPromise = getStreamPromise2(stdout, { encoding, buffer, maxBuffer });
+ const stderrPromise = getStreamPromise2(stderr, { encoding, buffer, maxBuffer });
+ const allPromise = getStreamPromise2(all2, { encoding, buffer, maxBuffer: maxBuffer * 2 });
+ try {
+ return await Promise.all([processDone, stdoutPromise, stderrPromise, allPromise]);
+ } catch (error) {
+ return Promise.all([
+ { error, signal: error.signal, timedOut: error.timedOut },
+ getBufferedData2(stdout, stdoutPromise),
+ getBufferedData2(stderr, stderrPromise),
+ getBufferedData2(all2, allPromise)
+ ]);
+ }
+ }, "getSpawnedResult");
+ var validateInputSync2 = /* @__PURE__ */ __name(({ input }) => {
+ if (isStream2(input)) {
+ throw new TypeError("The `input` option cannot be a stream in sync mode");
+ }
+ }, "validateInputSync");
+ module2.exports = {
+ handleInput: handleInput2,
+ makeAllStream: makeAllStream2,
+ getSpawnedResult: getSpawnedResult2,
+ validateInputSync: validateInputSync2
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/execa@5.1.1/node_modules/execa/lib/promise.js
+var require_promise = __commonJS({
+ "../../node_modules/.pnpm/execa@5.1.1/node_modules/execa/lib/promise.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var nativePromisePrototype2 = (async () => {
+ })().constructor.prototype;
+ var descriptors2 = ["then", "catch", "finally"].map((property) => [
+ property,
+ Reflect.getOwnPropertyDescriptor(nativePromisePrototype2, property)
+ ]);
+ var mergePromise2 = /* @__PURE__ */ __name((spawned, promise) => {
+ for (const [property, descriptor2] of descriptors2) {
+ const value = typeof promise === "function" ? (...args) => Reflect.apply(descriptor2.value, promise(), args) : descriptor2.value.bind(promise);
+ Reflect.defineProperty(spawned, property, { ...descriptor2, value });
+ }
+ return spawned;
+ }, "mergePromise");
+ var getSpawnedPromise2 = /* @__PURE__ */ __name((spawned) => {
+ return new Promise((resolve18, reject) => {
+ spawned.on("exit", (exitCode, signal) => {
+ resolve18({ exitCode, signal });
+ });
+ spawned.on("error", (error) => {
+ reject(error);
+ });
+ if (spawned.stdin) {
+ spawned.stdin.on("error", (error) => {
+ reject(error);
+ });
+ }
+ });
+ }, "getSpawnedPromise");
+ module2.exports = {
+ mergePromise: mergePromise2,
+ getSpawnedPromise: getSpawnedPromise2
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/execa@5.1.1/node_modules/execa/lib/command.js
+var require_command = __commonJS({
+ "../../node_modules/.pnpm/execa@5.1.1/node_modules/execa/lib/command.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var normalizeArgs2 = /* @__PURE__ */ __name((file, args = []) => {
+ if (!Array.isArray(args)) {
+ return [file];
+ }
+ return [file, ...args];
+ }, "normalizeArgs");
+ var NO_ESCAPE_REGEXP2 = /^[\w.-]+$/;
+ var DOUBLE_QUOTES_REGEXP2 = /"/g;
+ var escapeArg2 = /* @__PURE__ */ __name((arg) => {
+ if (typeof arg !== "string" || NO_ESCAPE_REGEXP2.test(arg)) {
+ return arg;
+ }
+ return `"${arg.replace(DOUBLE_QUOTES_REGEXP2, '\\"')}"`;
+ }, "escapeArg");
+ var joinCommand2 = /* @__PURE__ */ __name((file, args) => {
+ return normalizeArgs2(file, args).join(" ");
+ }, "joinCommand");
+ var getEscapedCommand2 = /* @__PURE__ */ __name((file, args) => {
+ return normalizeArgs2(file, args).map((arg) => escapeArg2(arg)).join(" ");
+ }, "getEscapedCommand");
+ var SPACES_REGEXP2 = / +/g;
+ var parseCommand3 = /* @__PURE__ */ __name((command2) => {
+ const tokens = [];
+ for (const token of command2.trim().split(SPACES_REGEXP2)) {
+ const previousToken = tokens[tokens.length - 1];
+ if (previousToken && previousToken.endsWith("\\")) {
+ tokens[tokens.length - 1] = `${previousToken.slice(0, -1)} ${token}`;
+ } else {
+ tokens.push(token);
+ }
+ }
+ return tokens;
+ }, "parseCommand");
+ module2.exports = {
+ joinCommand: joinCommand2,
+ getEscapedCommand: getEscapedCommand2,
+ parseCommand: parseCommand3
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/execa@5.1.1/node_modules/execa/index.js
+var require_execa = __commonJS({
+ "../../node_modules/.pnpm/execa@5.1.1/node_modules/execa/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var path45 = require("path");
+ var childProcess2 = require("child_process");
+ var crossSpawn2 = require_cross_spawn();
+ var stripFinalNewline2 = require_strip_final_newline();
+ var npmRunPath2 = require_npm_run_path();
+ var onetime2 = require_onetime();
+ var makeError3 = require_error();
+ var normalizeStdio2 = require_stdio();
+ var { spawnedKill: spawnedKill2, spawnedCancel: spawnedCancel2, setupTimeout: setupTimeout2, validateTimeout: validateTimeout2, setExitHandler: setExitHandler2 } = require_kill();
+ var { handleInput: handleInput2, getSpawnedResult: getSpawnedResult2, makeAllStream: makeAllStream2, validateInputSync: validateInputSync2 } = require_stream2();
+ var { mergePromise: mergePromise2, getSpawnedPromise: getSpawnedPromise2 } = require_promise();
+ var { joinCommand: joinCommand2, parseCommand: parseCommand3, getEscapedCommand: getEscapedCommand2 } = require_command();
+ var DEFAULT_MAX_BUFFER2 = 1e3 * 1e3 * 100;
+ var getEnv2 = /* @__PURE__ */ __name(({ env: envOption, extendEnv, preferLocal, localDir, execPath }) => {
+ const env5 = extendEnv ? { ...process.env, ...envOption } : envOption;
+ if (preferLocal) {
+ return npmRunPath2.env({ env: env5, cwd: localDir, execPath });
+ }
+ return env5;
+ }, "getEnv");
+ var handleArguments2 = /* @__PURE__ */ __name((file, args, options14 = {}) => {
+ const parsed = crossSpawn2._parse(file, args, options14);
+ file = parsed.command;
+ args = parsed.args;
+ options14 = parsed.options;
+ options14 = {
+ maxBuffer: DEFAULT_MAX_BUFFER2,
+ buffer: true,
+ stripFinalNewline: true,
+ extendEnv: true,
+ preferLocal: false,
+ localDir: options14.cwd || process.cwd(),
+ execPath: process.execPath,
+ encoding: "utf8",
+ reject: true,
+ cleanup: true,
+ all: false,
+ windowsHide: true,
+ ...options14
+ };
+ options14.env = getEnv2(options14);
+ options14.stdio = normalizeStdio2(options14);
+ if (process.platform === "win32" && path45.basename(file, ".exe") === "cmd") {
+ args.unshift("/q");
+ }
+ return { file, args, options: options14, parsed };
+ }, "handleArguments");
+ var handleOutput2 = /* @__PURE__ */ __name((options14, value, error) => {
+ if (typeof value !== "string" && !Buffer.isBuffer(value)) {
+ return error === void 0 ? void 0 : "";
+ }
+ if (options14.stripFinalNewline) {
+ return stripFinalNewline2(value);
+ }
+ return value;
+ }, "handleOutput");
+ var execa6 = /* @__PURE__ */ __name((file, args, options14) => {
+ const parsed = handleArguments2(file, args, options14);
+ const command2 = joinCommand2(file, args);
+ const escapedCommand = getEscapedCommand2(file, args);
+ validateTimeout2(parsed.options);
+ let spawned;
+ try {
+ spawned = childProcess2.spawn(parsed.file, parsed.args, parsed.options);
+ } catch (error) {
+ const dummySpawned = new childProcess2.ChildProcess();
+ const errorPromise = Promise.reject(makeError3({
+ error,
+ stdout: "",
+ stderr: "",
+ all: "",
+ command: command2,
+ escapedCommand,
+ parsed,
+ timedOut: false,
+ isCanceled: false,
+ killed: false
+ }));
+ return mergePromise2(dummySpawned, errorPromise);
+ }
+ const spawnedPromise = getSpawnedPromise2(spawned);
+ const timedPromise = setupTimeout2(spawned, parsed.options, spawnedPromise);
+ const processDone = setExitHandler2(spawned, parsed.options, timedPromise);
+ const context2 = { isCanceled: false };
+ spawned.kill = spawnedKill2.bind(null, spawned.kill.bind(spawned));
+ spawned.cancel = spawnedCancel2.bind(null, spawned, context2);
+ const handlePromise = /* @__PURE__ */ __name(async () => {
+ const [{ error, exitCode, signal, timedOut }, stdoutResult, stderrResult, allResult] = await getSpawnedResult2(spawned, parsed.options, processDone);
+ const stdout = handleOutput2(parsed.options, stdoutResult);
+ const stderr = handleOutput2(parsed.options, stderrResult);
+ const all2 = handleOutput2(parsed.options, allResult);
+ if (error || exitCode !== 0 || signal !== null) {
+ const returnedError = makeError3({
+ error,
+ exitCode,
+ signal,
+ stdout,
+ stderr,
+ all: all2,
+ command: command2,
+ escapedCommand,
+ parsed,
+ timedOut,
+ isCanceled: context2.isCanceled,
+ killed: spawned.killed
+ });
+ if (!parsed.options.reject) {
+ return returnedError;
+ }
+ throw returnedError;
+ }
+ return {
+ command: command2,
+ escapedCommand,
+ exitCode: 0,
+ stdout,
+ stderr,
+ all: all2,
+ failed: false,
+ timedOut: false,
+ isCanceled: false,
+ killed: false
+ };
+ }, "handlePromise");
+ const handlePromiseOnce = onetime2(handlePromise);
+ handleInput2(spawned, parsed.options.input);
+ spawned.all = makeAllStream2(spawned, parsed.options);
+ return mergePromise2(spawned, handlePromiseOnce);
+ }, "execa");
+ module2.exports = execa6;
+ module2.exports.sync = (file, args, options14) => {
+ const parsed = handleArguments2(file, args, options14);
+ const command2 = joinCommand2(file, args);
+ const escapedCommand = getEscapedCommand2(file, args);
+ validateInputSync2(parsed.options);
+ let result;
+ try {
+ result = childProcess2.spawnSync(parsed.file, parsed.args, parsed.options);
+ } catch (error) {
+ throw makeError3({
+ error,
+ stdout: "",
+ stderr: "",
+ all: "",
+ command: command2,
+ escapedCommand,
+ parsed,
+ timedOut: false,
+ isCanceled: false,
+ killed: false
+ });
+ }
+ const stdout = handleOutput2(parsed.options, result.stdout, result.error);
+ const stderr = handleOutput2(parsed.options, result.stderr, result.error);
+ if (result.error || result.status !== 0 || result.signal !== null) {
+ const error = makeError3({
+ stdout,
+ stderr,
+ error: result.error,
+ signal: result.signal,
+ exitCode: result.status,
+ command: command2,
+ escapedCommand,
+ parsed,
+ timedOut: result.error && result.error.code === "ETIMEDOUT",
+ isCanceled: false,
+ killed: result.signal !== null
+ });
+ if (!parsed.options.reject) {
+ return error;
+ }
+ throw error;
+ }
+ return {
+ command: command2,
+ escapedCommand,
+ exitCode: 0,
+ stdout,
+ stderr,
+ failed: false,
+ timedOut: false,
+ isCanceled: false,
+ killed: false
+ };
+ };
+ module2.exports.command = (command2, options14) => {
+ const [file, ...args] = parseCommand3(command2);
+ return execa6(file, args, options14);
+ };
+ module2.exports.commandSync = (command2, options14) => {
+ const [file, ...args] = parseCommand3(command2);
+ return execa6.sync(file, args, options14);
+ };
+ module2.exports.node = (scriptPath, args, options14 = {}) => {
+ if (args && !Array.isArray(args) && typeof args === "object") {
+ options14 = args;
+ args = [];
+ }
+ const stdio = normalizeStdio2.node(options14);
+ const defaultExecArgv = process.execArgv.filter((arg) => !arg.startsWith("--inspect"));
+ const {
+ nodePath = process.execPath,
+ nodeOptions = defaultExecArgv
+ } = options14;
+ return execa6(
+ nodePath,
+ [
+ ...nodeOptions,
+ scriptPath,
+ ...Array.isArray(args) ? args : []
+ ],
+ {
+ ...options14,
+ stdin: void 0,
+ stdout: void 0,
+ stderr: void 0,
+ stdio,
+ shell: false
+ }
+ );
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/arch@2.2.0/node_modules/arch/index.js
+var require_arch = __commonJS({
+ "../../node_modules/.pnpm/arch@2.2.0/node_modules/arch/index.js"(exports2, module2) {
+ init_import_meta_url();
+ var cp2 = require("child_process");
+ var fs20 = require("fs");
+ var path45 = require("path");
+ module2.exports = /* @__PURE__ */ __name(function arch2() {
+ if (process.arch === "x64") {
+ return "x64";
+ }
+ if (process.platform === "darwin") {
+ return "x64";
+ }
+ if (process.platform === "win32") {
+ var useEnv = false;
+ try {
+ useEnv = !!(process.env.SYSTEMROOT && fs20.statSync(process.env.SYSTEMROOT));
+ } catch (err) {
+ }
+ var sysRoot = useEnv ? process.env.SYSTEMROOT : "C:\\Windows";
+ var isWOW64 = false;
+ try {
+ isWOW64 = !!fs20.statSync(path45.join(sysRoot, "sysnative"));
+ } catch (err) {
+ }
+ return isWOW64 ? "x64" : "x86";
+ }
+ if (process.platform === "linux") {
+ var output = cp2.execSync("getconf LONG_BIT", { encoding: "utf8" });
+ return output === "64\n" ? "x64" : "x86";
+ }
+ return "x86";
+ }, "arch");
+ }
+});
+
+// ../../node_modules/.pnpm/command-exists@1.2.9/node_modules/command-exists/lib/command-exists.js
+var require_command_exists = __commonJS({
+ "../../node_modules/.pnpm/command-exists@1.2.9/node_modules/command-exists/lib/command-exists.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var exec = require("child_process").exec;
+ var execSync4 = require("child_process").execSync;
+ var fs20 = require("fs");
+ var path45 = require("path");
+ var access3 = fs20.access;
+ var accessSync = fs20.accessSync;
+ var constants3 = fs20.constants || fs20;
+ var isUsingWindows = process.platform == "win32";
+ var fileNotExists = /* @__PURE__ */ __name(function(commandName, callback) {
+ access3(
+ commandName,
+ constants3.F_OK,
+ function(err) {
+ callback(!err);
+ }
+ );
+ }, "fileNotExists");
+ var fileNotExistsSync = /* @__PURE__ */ __name(function(commandName) {
+ try {
+ accessSync(commandName, constants3.F_OK);
+ return false;
+ } catch (e2) {
+ return true;
+ }
+ }, "fileNotExistsSync");
+ var localExecutable = /* @__PURE__ */ __name(function(commandName, callback) {
+ access3(
+ commandName,
+ constants3.F_OK | constants3.X_OK,
+ function(err) {
+ callback(null, !err);
+ }
+ );
+ }, "localExecutable");
+ var localExecutableSync = /* @__PURE__ */ __name(function(commandName) {
+ try {
+ accessSync(commandName, constants3.F_OK | constants3.X_OK);
+ return true;
+ } catch (e2) {
+ return false;
+ }
+ }, "localExecutableSync");
+ var commandExistsUnix = /* @__PURE__ */ __name(function(commandName, cleanedCommandName, callback) {
+ fileNotExists(commandName, function(isFile) {
+ if (!isFile) {
+ var child = exec(
+ "command -v " + cleanedCommandName + " 2>/dev/null && { echo >&1 " + cleanedCommandName + "; exit 0; }",
+ function(error, stdout, stderr) {
+ callback(null, !!stdout);
+ }
+ );
+ return;
+ }
+ localExecutable(commandName, callback);
+ });
+ }, "commandExistsUnix");
+ var commandExistsWindows = /* @__PURE__ */ __name(function(commandName, cleanedCommandName, callback) {
+ if (!/^(?!(?:.*\s|.*\.|\W+)$)(?:[a-zA-Z]:)?(?:(?:[^<>:"\|\?\*\n])+(?:\/\/|\/|\\\\|\\)?)+$/m.test(commandName)) {
+ callback(null, false);
+ return;
+ }
+ var child = exec(
+ "where " + cleanedCommandName,
+ function(error) {
+ if (error !== null) {
+ callback(null, false);
+ } else {
+ callback(null, true);
+ }
+ }
+ );
+ }, "commandExistsWindows");
+ var commandExistsUnixSync = /* @__PURE__ */ __name(function(commandName, cleanedCommandName) {
+ if (fileNotExistsSync(commandName)) {
+ try {
+ var stdout = execSync4(
+ "command -v " + cleanedCommandName + " 2>/dev/null && { echo >&1 " + cleanedCommandName + "; exit 0; }"
+ );
+ return !!stdout;
+ } catch (error) {
+ return false;
+ }
+ }
+ return localExecutableSync(commandName);
+ }, "commandExistsUnixSync");
+ var commandExistsWindowsSync = /* @__PURE__ */ __name(function(commandName, cleanedCommandName, callback) {
+ if (!/^(?!(?:.*\s|.*\.|\W+)$)(?:[a-zA-Z]:)?(?:(?:[^<>:"\|\?\*\n])+(?:\/\/|\/|\\\\|\\)?)+$/m.test(commandName)) {
+ return false;
+ }
+ try {
+ var stdout = execSync4("where " + cleanedCommandName, { stdio: [] });
+ return !!stdout;
+ } catch (error) {
+ return false;
+ }
+ }, "commandExistsWindowsSync");
+ var cleanInput = /* @__PURE__ */ __name(function(s) {
+ if (/[^A-Za-z0-9_\/:=-]/.test(s)) {
+ s = "'" + s.replace(/'/g, "'\\''") + "'";
+ s = s.replace(/^(?:'')+/g, "").replace(/\\'''/g, "\\'");
+ }
+ return s;
+ }, "cleanInput");
+ if (isUsingWindows) {
+ cleanInput = /* @__PURE__ */ __name(function(s) {
+ var isPathName = /[\\]/.test(s);
+ if (isPathName) {
+ var dirname10 = '"' + path45.dirname(s) + '"';
+ var basename6 = '"' + path45.basename(s) + '"';
+ return dirname10 + ":" + basename6;
+ }
+ return '"' + s + '"';
+ }, "cleanInput");
+ }
+ module2.exports = /* @__PURE__ */ __name(function commandExists2(commandName, callback) {
+ var cleanedCommandName = cleanInput(commandName);
+ if (!callback && typeof Promise !== "undefined") {
+ return new Promise(function(resolve18, reject) {
+ commandExists2(commandName, function(error, output) {
+ if (output) {
+ resolve18(commandName);
+ } else {
+ reject(error);
+ }
+ });
+ });
+ }
+ if (isUsingWindows) {
+ commandExistsWindows(commandName, cleanedCommandName, callback);
+ } else {
+ commandExistsUnix(commandName, cleanedCommandName, callback);
+ }
+ }, "commandExists");
+ module2.exports.sync = function(commandName) {
+ var cleanedCommandName = cleanInput(commandName);
+ if (isUsingWindows) {
+ return commandExistsWindowsSync(commandName, cleanedCommandName);
+ } else {
+ return commandExistsUnixSync(commandName, cleanedCommandName);
+ }
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/command-exists@1.2.9/node_modules/command-exists/index.js
+var require_command_exists2 = __commonJS({
+ "../../node_modules/.pnpm/command-exists@1.2.9/node_modules/command-exists/index.js"(exports2, module2) {
+ init_import_meta_url();
+ module2.exports = require_command_exists();
+ }
+});
+
+// ../../node_modules/.pnpm/depd@2.0.0/node_modules/depd/index.js
+var require_depd = __commonJS({
+ "../../node_modules/.pnpm/depd@2.0.0/node_modules/depd/index.js"(exports2, module2) {
+ init_import_meta_url();
+ var relative12 = 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;
+ }
+ __name(containsNamespace, "containsNamespace");
+ function convertDataDescriptorToAccessor(obj, prop, message) {
+ var descriptor2 = Object.getOwnPropertyDescriptor(obj, prop);
+ var value = descriptor2.value;
+ descriptor2.get = /* @__PURE__ */ __name(function getter() {
+ return value;
+ }, "getter");
+ if (descriptor2.writable) {
+ descriptor2.set = /* @__PURE__ */ __name(function setter(val) {
+ return value = val;
+ }, "setter");
+ }
+ delete descriptor2.value;
+ delete descriptor2.writable;
+ Object.defineProperty(obj, prop, descriptor2);
+ return descriptor2;
+ }
+ __name(convertDataDescriptorToAccessor, "convertDataDescriptorToAccessor");
+ function createArgumentsString(arity) {
+ var str = "";
+ for (var i = 0; i < arity; i++) {
+ str += ", arg" + i;
+ }
+ return str.substr(2);
+ }
+ __name(createArgumentsString, "createArgumentsString");
+ 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;
+ }
+ __name(createStackString, "createStackString");
+ 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);
+ }
+ __name(deprecate, "deprecate");
+ 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;
+ }
+ __name(depd, "depd");
+ function eehaslisteners(emitter, type) {
+ var count = typeof emitter.listenerCount !== "function" ? emitter.listeners(type).length : emitter.listenerCount(type);
+ return count > 0;
+ }
+ __name(eehaslisteners, "eehaslisteners");
+ function isignored(namespace) {
+ if (process.noDeprecation) {
+ return true;
+ }
+ var str = process.env.NO_DEPRECATION || "";
+ return containsNamespace(str, namespace);
+ }
+ __name(isignored, "isignored");
+ function istraced(namespace) {
+ if (process.traceDeprecation) {
+ return true;
+ }
+ var str = process.env.TRACE_DEPRECATION || "";
+ return containsNamespace(str, namespace);
+ }
+ __name(istraced, "istraced");
+ 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 err = DeprecationError2(this._namespace, msg, stack.slice(i));
+ process.emit("deprecation", err);
+ return;
+ }
+ var format8 = process.stderr.isTTY ? formatColor : formatPlain;
+ var output = format8.call(this, msg, caller, stack.slice(i));
+ process.stderr.write(output + "\n", "utf8");
+ }
+ __name(log, "log");
+ 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;
+ }
+ __name(callSiteLocation, "callSiteLocation");
+ function defaultMessage(site) {
+ var callSite = site.callSite;
+ var funcName = site.name;
+ if (!funcName) {
+ funcName = "";
+ }
+ var context2 = callSite.getThis();
+ var typeName = context2 && callSite.getTypeName();
+ if (typeName === "Object") {
+ typeName = void 0;
+ }
+ if (typeName === "Function") {
+ typeName = context2.name || typeName;
+ }
+ return typeName && callSite.getMethodName() ? typeName + "." + funcName : funcName;
+ }
+ __name(defaultMessage, "defaultMessage");
+ 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;
+ }
+ __name(formatPlain, "formatPlain");
+ 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;
+ }
+ __name(formatColor, "formatColor");
+ function formatLocation(callSite) {
+ return relative12(basePath, callSite[0]) + ":" + callSite[1] + ":" + callSite[2];
+ }
+ __name(formatLocation, "formatLocation");
+ 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;
+ }
+ __name(getStack, "getStack");
+ function prepareObjectStackTrace(obj, stack) {
+ return stack;
+ }
+ __name(prepareObjectStackTrace, "prepareObjectStackTrace");
+ function wrapfunction(fn2, message) {
+ if (typeof fn2 !== "function") {
+ throw new TypeError("argument fn must be a function");
+ }
+ var args = createArgumentsString(fn2.length);
+ var stack = getStack();
+ var site = callSiteLocation(stack[1]);
+ site.name = fn2.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}"
+ )(fn2, log, this, message, site);
+ return deprecatedfn;
+ }
+ __name(wrapfunction, "wrapfunction");
+ function wrapproperty(obj, prop, message) {
+ if (!obj || typeof obj !== "object" && typeof obj !== "function") {
+ throw new TypeError("argument obj must be object");
+ }
+ var descriptor2 = Object.getOwnPropertyDescriptor(obj, prop);
+ if (!descriptor2) {
+ throw new TypeError("must call property on owner object");
+ }
+ if (!descriptor2.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 descriptor2) {
+ descriptor2 = convertDataDescriptorToAccessor(obj, prop, message);
+ }
+ var get = descriptor2.get;
+ var set = descriptor2.set;
+ if (typeof get === "function") {
+ descriptor2.get = /* @__PURE__ */ __name(function getter() {
+ log.call(deprecate, message, site);
+ return get.apply(this, arguments);
+ }, "getter");
+ }
+ if (typeof set === "function") {
+ descriptor2.set = /* @__PURE__ */ __name(function setter() {
+ log.call(deprecate, message, site);
+ return set.apply(this, arguments);
+ }, "setter");
+ }
+ Object.defineProperty(obj, prop, descriptor2);
+ }
+ __name(wrapproperty, "wrapproperty");
+ function DeprecationError2(namespace, message, stack) {
+ var error = new Error();
+ var stackString;
+ Object.defineProperty(error, "constructor", {
+ value: DeprecationError2
+ });
+ 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: /* @__PURE__ */ __name(function setter(val) {
+ stackString = val;
+ }, "setter")
+ });
+ return error;
+ }
+ __name(DeprecationError2, "DeprecationError");
+ }
+});
+
+// ../../node_modules/.pnpm/bytes@3.1.2/node_modules/bytes/index.js
+var require_bytes = __commonJS({
+ "../../node_modules/.pnpm/bytes@3.1.2/node_modules/bytes/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ module2.exports = bytes;
+ module2.exports.format = format8;
+ module2.exports.parse = parse4;
+ 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, options14) {
+ if (typeof value === "string") {
+ return parse4(value);
+ }
+ if (typeof value === "number") {
+ return format8(value, options14);
+ }
+ return null;
+ }
+ __name(bytes, "bytes");
+ function format8(value, options14) {
+ if (!Number.isFinite(value)) {
+ return null;
+ }
+ var mag = Math.abs(value);
+ var thousandsSeparator = options14 && options14.thousandsSeparator || "";
+ var unitSeparator = options14 && options14.unitSeparator || "";
+ var decimalPlaces = options14 && options14.decimalPlaces !== void 0 ? options14.decimalPlaces : 2;
+ var fixedDecimals = Boolean(options14 && options14.fixedDecimals);
+ var unit = options14 && options14.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;
+ }
+ __name(format8, "format");
+ function parse4(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);
+ }
+ __name(parse4, "parse");
+ }
+});
+
+// ../../node_modules/.pnpm/content-type@1.0.4/node_modules/content-type/index.js
+var require_content_type = __commonJS({
+ "../../node_modules/.pnpm/content-type@1.0.4/node_modules/content-type/index.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ 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 = format8;
+ exports2.parse = parse4;
+ function format8(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;
+ }
+ __name(format8, "format");
+ function parse4(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.substr(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[0] === '"') {
+ value = value.substr(1, value.length - 2).replace(QESC_REGEXP, "$1");
+ }
+ obj.parameters[key] = value;
+ }
+ if (index !== header.length) {
+ throw new TypeError("invalid parameter format");
+ }
+ }
+ return obj;
+ }
+ __name(parse4, "parse");
+ 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;
+ }
+ __name(getcontenttype, "getcontenttype");
+ 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") + '"';
+ }
+ __name(qstring, "qstring");
+ function ContentType(type) {
+ this.parameters = /* @__PURE__ */ Object.create(null);
+ this.type = type;
+ }
+ __name(ContentType, "ContentType");
+ }
+});
+
+// ../../node_modules/.pnpm/setprototypeof@1.2.0/node_modules/setprototypeof/index.js
+var require_setprototypeof = __commonJS({
+ "../../node_modules/.pnpm/setprototypeof@1.2.0/node_modules/setprototypeof/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ module2.exports = Object.setPrototypeOf || ({ __proto__: [] } instanceof Array ? setProtoOf : mixinProperties);
+ function setProtoOf(obj, proto) {
+ obj.__proto__ = proto;
+ return obj;
+ }
+ __name(setProtoOf, "setProtoOf");
+ function mixinProperties(obj, proto) {
+ for (var prop in proto) {
+ if (!Object.prototype.hasOwnProperty.call(obj, prop)) {
+ obj[prop] = proto[prop];
+ }
+ }
+ return obj;
+ }
+ __name(mixinProperties, "mixinProperties");
+ }
+});
+
+// ../../node_modules/.pnpm/statuses@2.0.1/node_modules/statuses/codes.json
+var require_codes = __commonJS({
+ "../../node_modules/.pnpm/statuses@2.0.1/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"
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/statuses@2.0.1/node_modules/statuses/index.js
+var require_statuses = __commonJS({
+ "../../node_modules/.pnpm/statuses@2.0.1/node_modules/statuses/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ 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(/* @__PURE__ */ __name(function forEachCode(code) {
+ var message = codes2[code];
+ var status2 = Number(code);
+ map[message.toLowerCase()] = status2;
+ }, "forEachCode"));
+ return map;
+ }
+ __name(createMessageToStatusCodeMap, "createMessageToStatusCodeMap");
+ function createStatusCodeList(codes2) {
+ return Object.keys(codes2).map(/* @__PURE__ */ __name(function mapCode(code) {
+ return Number(code);
+ }, "mapCode"));
+ }
+ __name(createStatusCodeList, "createStatusCodeList");
+ 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];
+ }
+ __name(getStatusCode, "getStatusCode");
+ function getStatusMessage(code) {
+ if (!Object.prototype.hasOwnProperty.call(status.message, code)) {
+ throw new Error("invalid status code: " + code);
+ }
+ return status.message[code];
+ }
+ __name(getStatusMessage, "getStatusMessage");
+ 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);
+ }
+ __name(status, "status");
+ }
+});
+
+// ../../node_modules/.pnpm/toidentifier@1.0.1/node_modules/toidentifier/index.js
+var require_toidentifier = __commonJS({
+ "../../node_modules/.pnpm/toidentifier@1.0.1/node_modules/toidentifier/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ 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, "");
+ }
+ __name(toIdentifier, "toIdentifier");
+ }
+});
+
+// ../../node_modules/.pnpm/http-errors@2.0.0/node_modules/http-errors/index.js
+var require_http_errors = __commonJS({
+ "../../node_modules/.pnpm/http-errors@2.0.0/node_modules/http-errors/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ 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");
+ }
+ __name(codeClass, "codeClass");
+ function createError() {
+ var err;
+ 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) {
+ err = arg;
+ status = err.status || err.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 (!err) {
+ err = HttpError ? new HttpError(msg) : new Error(msg || statuses.message[status]);
+ Error.captureStackTrace(err, createError);
+ }
+ if (!HttpError || !(err instanceof HttpError) || err.status !== status) {
+ err.expose = status < 500;
+ err.status = err.statusCode = status;
+ }
+ for (var key in props) {
+ if (key !== "status" && key !== "statusCode") {
+ err[key] = props[key];
+ }
+ }
+ return err;
+ }
+ __name(createError, "createError");
+ function createHttpErrorConstructor() {
+ function HttpError() {
+ throw new TypeError("cannot construct abstract class");
+ }
+ __name(HttpError, "HttpError");
+ inherits(HttpError, Error);
+ return HttpError;
+ }
+ __name(createHttpErrorConstructor, "createHttpErrorConstructor");
+ function createClientErrorConstructor(HttpError, name, code) {
+ var className = toClassName(name);
+ function ClientError(message) {
+ var msg = message != null ? message : statuses.message[code];
+ var err = new Error(msg);
+ Error.captureStackTrace(err, ClientError);
+ setPrototypeOf(err, ClientError.prototype);
+ Object.defineProperty(err, "message", {
+ enumerable: true,
+ configurable: true,
+ value: msg,
+ writable: true
+ });
+ Object.defineProperty(err, "name", {
+ enumerable: false,
+ configurable: true,
+ value: className,
+ writable: true
+ });
+ return err;
+ }
+ __name(ClientError, "ClientError");
+ inherits(ClientError, HttpError);
+ nameFunc(ClientError, className);
+ ClientError.prototype.status = code;
+ ClientError.prototype.statusCode = code;
+ ClientError.prototype.expose = true;
+ return ClientError;
+ }
+ __name(createClientErrorConstructor, "createClientErrorConstructor");
+ function createIsHttpErrorFunction(HttpError) {
+ return /* @__PURE__ */ __name(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;
+ }, "isHttpError");
+ }
+ __name(createIsHttpErrorFunction, "createIsHttpErrorFunction");
+ function createServerErrorConstructor(HttpError, name, code) {
+ var className = toClassName(name);
+ function ServerError(message) {
+ var msg = message != null ? message : statuses.message[code];
+ var err = new Error(msg);
+ Error.captureStackTrace(err, ServerError);
+ setPrototypeOf(err, ServerError.prototype);
+ Object.defineProperty(err, "message", {
+ enumerable: true,
+ configurable: true,
+ value: msg,
+ writable: true
+ });
+ Object.defineProperty(err, "name", {
+ enumerable: false,
+ configurable: true,
+ value: className,
+ writable: true
+ });
+ return err;
+ }
+ __name(ServerError, "ServerError");
+ inherits(ServerError, HttpError);
+ nameFunc(ServerError, className);
+ ServerError.prototype.status = code;
+ ServerError.prototype.statusCode = code;
+ ServerError.prototype.expose = false;
+ return ServerError;
+ }
+ __name(createServerErrorConstructor, "createServerErrorConstructor");
+ function nameFunc(func, name) {
+ var desc = Object.getOwnPropertyDescriptor(func, "name");
+ if (desc && desc.configurable) {
+ desc.value = name;
+ Object.defineProperty(func, "name", desc);
+ }
+ }
+ __name(nameFunc, "nameFunc");
+ function populateConstructorExports(exports3, codes, HttpError) {
+ codes.forEach(/* @__PURE__ */ __name(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;
+ }
+ }, "forEachCode"));
+ }
+ __name(populateConstructorExports, "populateConstructorExports");
+ function toClassName(name) {
+ return name.substr(-5) !== "Error" ? name + "Error" : name;
+ }
+ __name(toClassName, "toClassName");
+ }
+});
+
+// ../../node_modules/.pnpm/ms@2.0.0/node_modules/ms/index.js
+var require_ms = __commonJS({
+ "../../node_modules/.pnpm/ms@2.0.0/node_modules/ms/index.js"(exports2, module2) {
+ init_import_meta_url();
+ var s = 1e3;
+ var m = s * 60;
+ var h = m * 60;
+ var d = h * 24;
+ var y = d * 365.25;
+ module2.exports = function(val, options14) {
+ options14 = options14 || {};
+ var type = typeof val;
+ if (type === "string" && val.length > 0) {
+ return parse4(val);
+ } else if (type === "number" && isNaN(val) === false) {
+ return options14.long ? fmtLong(val) : fmtShort(val);
+ }
+ throw new Error(
+ "val is not a non-empty string or a valid number. val=" + JSON.stringify(val)
+ );
+ };
+ function parse4(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|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 "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;
+ }
+ }
+ __name(parse4, "parse");
+ function fmtShort(ms) {
+ if (ms >= d) {
+ return Math.round(ms / d) + "d";
+ }
+ if (ms >= h) {
+ return Math.round(ms / h) + "h";
+ }
+ if (ms >= m) {
+ return Math.round(ms / m) + "m";
+ }
+ if (ms >= s) {
+ return Math.round(ms / s) + "s";
+ }
+ return ms + "ms";
+ }
+ __name(fmtShort, "fmtShort");
+ function fmtLong(ms) {
+ return plural(ms, d, "day") || plural(ms, h, "hour") || plural(ms, m, "minute") || plural(ms, s, "second") || ms + " ms";
+ }
+ __name(fmtLong, "fmtLong");
+ function plural(ms, n, name) {
+ if (ms < n) {
+ return;
+ }
+ if (ms < n * 1.5) {
+ return Math.floor(ms / n) + " " + name;
+ }
+ return Math.ceil(ms / n) + " " + name + "s";
+ }
+ __name(plural, "plural");
+ }
+});
+
+// ../../node_modules/.pnpm/debug@2.6.9_supports-color@9.2.2/node_modules/debug/src/debug.js
+var require_debug2 = __commonJS({
+ "../../node_modules/.pnpm/debug@2.6.9_supports-color@9.2.2/node_modules/debug/src/debug.js"(exports2, module2) {
+ init_import_meta_url();
+ exports2 = module2.exports = createDebug.debug = createDebug["default"] = createDebug;
+ exports2.coerce = coerce;
+ exports2.disable = disable;
+ exports2.enable = enable;
+ exports2.enabled = enabled;
+ exports2.humanize = require_ms();
+ exports2.names = [];
+ exports2.skips = [];
+ exports2.formatters = {};
+ var prevTime;
+ function selectColor(namespace) {
+ var hash = 0, i;
+ for (i in namespace) {
+ hash = (hash << 5) - hash + namespace.charCodeAt(i);
+ hash |= 0;
+ }
+ return exports2.colors[Math.abs(hash) % exports2.colors.length];
+ }
+ __name(selectColor, "selectColor");
+ function createDebug(namespace) {
+ function debug() {
+ if (!debug.enabled)
+ return;
+ var self2 = debug;
+ var curr = +/* @__PURE__ */ new Date();
+ var ms = curr - (prevTime || curr);
+ self2.diff = ms;
+ self2.prev = prevTime;
+ self2.curr = curr;
+ prevTime = curr;
+ var args = new Array(arguments.length);
+ for (var i = 0; i < args.length; i++) {
+ args[i] = arguments[i];
+ }
+ args[0] = exports2.coerce(args[0]);
+ if ("string" !== typeof args[0]) {
+ args.unshift("%O");
+ }
+ var index = 0;
+ args[0] = args[0].replace(/%([a-zA-Z%])/g, function(match, format8) {
+ if (match === "%%")
+ return match;
+ index++;
+ var formatter = exports2.formatters[format8];
+ if ("function" === typeof formatter) {
+ var val = args[index];
+ match = formatter.call(self2, val);
+ args.splice(index, 1);
+ index--;
+ }
+ return match;
+ });
+ exports2.formatArgs.call(self2, args);
+ var logFn = debug.log || exports2.log || console.log.bind(console);
+ logFn.apply(self2, args);
+ }
+ __name(debug, "debug");
+ debug.namespace = namespace;
+ debug.enabled = exports2.enabled(namespace);
+ debug.useColors = exports2.useColors();
+ debug.color = selectColor(namespace);
+ if ("function" === typeof exports2.init) {
+ exports2.init(debug);
+ }
+ return debug;
+ }
+ __name(createDebug, "createDebug");
+ function enable(namespaces) {
+ exports2.save(namespaces);
+ exports2.names = [];
+ exports2.skips = [];
+ var split = (typeof namespaces === "string" ? namespaces : "").split(/[\s,]+/);
+ var len = split.length;
+ for (var i = 0; i < len; i++) {
+ if (!split[i])
+ continue;
+ namespaces = split[i].replace(/\*/g, ".*?");
+ if (namespaces[0] === "-") {
+ exports2.skips.push(new RegExp("^" + namespaces.substr(1) + "$"));
+ } else {
+ exports2.names.push(new RegExp("^" + namespaces + "$"));
+ }
+ }
+ }
+ __name(enable, "enable");
+ function disable() {
+ exports2.enable("");
+ }
+ __name(disable, "disable");
+ function enabled(name) {
+ var i, len;
+ for (i = 0, len = exports2.skips.length; i < len; i++) {
+ if (exports2.skips[i].test(name)) {
+ return false;
+ }
+ }
+ for (i = 0, len = exports2.names.length; i < len; i++) {
+ if (exports2.names[i].test(name)) {
+ return true;
+ }
+ }
+ return false;
+ }
+ __name(enabled, "enabled");
+ function coerce(val) {
+ if (val instanceof Error)
+ return val.stack || val.message;
+ return val;
+ }
+ __name(coerce, "coerce");
+ }
+});
+
+// ../../node_modules/.pnpm/debug@2.6.9_supports-color@9.2.2/node_modules/debug/src/browser.js
+var require_browser = __commonJS({
+ "../../node_modules/.pnpm/debug@2.6.9_supports-color@9.2.2/node_modules/debug/src/browser.js"(exports2, module2) {
+ init_import_meta_url();
+ exports2 = module2.exports = require_debug2();
+ exports2.log = log;
+ exports2.formatArgs = formatArgs;
+ exports2.save = save;
+ exports2.load = load;
+ exports2.useColors = useColors;
+ exports2.storage = "undefined" != typeof chrome && "undefined" != typeof chrome.storage ? chrome.storage.local : localstorage();
+ exports2.colors = [
+ "lightseagreen",
+ "forestgreen",
+ "goldenrod",
+ "dodgerblue",
+ "darkorchid",
+ "crimson"
+ ];
+ function useColors() {
+ if (typeof window !== "undefined" && window.process && window.process.type === "renderer") {
+ return true;
+ }
+ 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 && navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$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+)/);
+ }
+ __name(useColors, "useColors");
+ exports2.formatters.j = function(v) {
+ try {
+ return JSON.stringify(v);
+ } catch (err) {
+ return "[UnexpectedJSONParseError]: " + err.message;
+ }
+ };
+ function formatArgs(args) {
+ var useColors2 = this.useColors;
+ args[0] = (useColors2 ? "%c" : "") + this.namespace + (useColors2 ? " %c" : " ") + args[0] + (useColors2 ? "%c " : " ") + "+" + exports2.humanize(this.diff);
+ if (!useColors2)
+ return;
+ var c = "color: " + this.color;
+ args.splice(1, 0, c, "color: inherit");
+ var index = 0;
+ var lastC = 0;
+ args[0].replace(/%[a-zA-Z%]/g, function(match) {
+ if ("%%" === match)
+ return;
+ index++;
+ if ("%c" === match) {
+ lastC = index;
+ }
+ });
+ args.splice(lastC, 0, c);
+ }
+ __name(formatArgs, "formatArgs");
+ function log() {
+ return "object" === typeof console && console.log && Function.prototype.apply.call(console.log, console, arguments);
+ }
+ __name(log, "log");
+ function save(namespaces) {
+ try {
+ if (null == namespaces) {
+ exports2.storage.removeItem("debug");
+ } else {
+ exports2.storage.debug = namespaces;
+ }
+ } catch (e2) {
+ }
+ }
+ __name(save, "save");
+ function load() {
+ var r;
+ try {
+ r = exports2.storage.debug;
+ } catch (e2) {
+ }
+ if (!r && typeof process !== "undefined" && "env" in process) {
+ r = process.env.DEBUG;
+ }
+ return r;
+ }
+ __name(load, "load");
+ exports2.enable(load());
+ function localstorage() {
+ try {
+ return window.localStorage;
+ } catch (e2) {
+ }
+ }
+ __name(localstorage, "localstorage");
+ }
+});
+
+// ../../node_modules/.pnpm/debug@2.6.9_supports-color@9.2.2/node_modules/debug/src/node.js
+var require_node4 = __commonJS({
+ "../../node_modules/.pnpm/debug@2.6.9_supports-color@9.2.2/node_modules/debug/src/node.js"(exports2, module2) {
+ init_import_meta_url();
+ var tty2 = require("tty");
+ var util3 = require("util");
+ exports2 = module2.exports = require_debug2();
+ exports2.init = init;
+ exports2.log = log;
+ exports2.formatArgs = formatArgs;
+ exports2.save = save;
+ exports2.load = load;
+ exports2.useColors = useColors;
+ exports2.colors = [6, 2, 3, 4, 5, 1];
+ exports2.inspectOpts = Object.keys(process.env).filter(function(key) {
+ return /^debug_/i.test(key);
+ }).reduce(function(obj, key) {
+ var prop = key.substring(6).toLowerCase().replace(/_([a-z])/g, function(_2, k) {
+ return k.toUpperCase();
+ });
+ var 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;
+ }, {});
+ var fd = parseInt(process.env.DEBUG_FD, 10) || 2;
+ if (1 !== fd && 2 !== fd) {
+ util3.deprecate(function() {
+ }, "except for stderr(2) and stdout(1), any other usage of DEBUG_FD is deprecated. Override debug.log if you want to use a different log function (https://git.io/debug_fd)")();
+ }
+ var stream2 = 1 === fd ? process.stdout : 2 === fd ? process.stderr : createWritableStdioStream(fd);
+ function useColors() {
+ return "colors" in exports2.inspectOpts ? Boolean(exports2.inspectOpts.colors) : tty2.isatty(fd);
+ }
+ __name(useColors, "useColors");
+ exports2.formatters.o = function(v) {
+ this.inspectOpts.colors = this.useColors;
+ return util3.inspect(v, this.inspectOpts).split("\n").map(function(str) {
+ return str.trim();
+ }).join(" ");
+ };
+ exports2.formatters.O = function(v) {
+ this.inspectOpts.colors = this.useColors;
+ return util3.inspect(v, this.inspectOpts);
+ };
+ function formatArgs(args) {
+ var name = this.namespace;
+ var useColors2 = this.useColors;
+ if (useColors2) {
+ var c = this.color;
+ var prefix = " \x1B[3" + c + ";1m" + name + " \x1B[0m";
+ args[0] = prefix + args[0].split("\n").join("\n" + prefix);
+ args.push("\x1B[3" + c + "m+" + exports2.humanize(this.diff) + "\x1B[0m");
+ } else {
+ args[0] = (/* @__PURE__ */ new Date()).toUTCString() + " " + name + " " + args[0];
+ }
+ }
+ __name(formatArgs, "formatArgs");
+ function log() {
+ return stream2.write(util3.format.apply(util3, arguments) + "\n");
+ }
+ __name(log, "log");
+ function save(namespaces) {
+ if (null == namespaces) {
+ delete process.env.DEBUG;
+ } else {
+ process.env.DEBUG = namespaces;
+ }
+ }
+ __name(save, "save");
+ function load() {
+ return process.env.DEBUG;
+ }
+ __name(load, "load");
+ function createWritableStdioStream(fd2) {
+ var stream3;
+ var tty_wrap = process.binding("tty_wrap");
+ switch (tty_wrap.guessHandleType(fd2)) {
+ case "TTY":
+ stream3 = new tty2.WriteStream(fd2);
+ stream3._type = "tty";
+ if (stream3._handle && stream3._handle.unref) {
+ stream3._handle.unref();
+ }
+ break;
+ case "FILE":
+ var fs20 = require("fs");
+ stream3 = new fs20.SyncWriteStream(fd2, { autoClose: false });
+ stream3._type = "fs";
+ break;
+ case "PIPE":
+ case "TCP":
+ var net3 = require("net");
+ stream3 = new net3.Socket({
+ fd: fd2,
+ readable: false,
+ writable: true
+ });
+ stream3.readable = false;
+ stream3.read = null;
+ stream3._type = "pipe";
+ if (stream3._handle && stream3._handle.unref) {
+ stream3._handle.unref();
+ }
+ break;
+ default:
+ throw new Error("Implement me. Unknown stream file type!");
+ }
+ stream3.fd = fd2;
+ stream3._isStdio = true;
+ return stream3;
+ }
+ __name(createWritableStdioStream, "createWritableStdioStream");
+ function init(debug) {
+ debug.inspectOpts = {};
+ var keys = Object.keys(exports2.inspectOpts);
+ for (var i = 0; i < keys.length; i++) {
+ debug.inspectOpts[keys[i]] = exports2.inspectOpts[keys[i]];
+ }
+ }
+ __name(init, "init");
+ exports2.enable(load());
+ }
+});
+
+// ../../node_modules/.pnpm/debug@2.6.9_supports-color@9.2.2/node_modules/debug/src/index.js
+var require_src2 = __commonJS({
+ "../../node_modules/.pnpm/debug@2.6.9_supports-color@9.2.2/node_modules/debug/src/index.js"(exports2, module2) {
+ init_import_meta_url();
+ if (typeof process !== "undefined" && process.type === "renderer") {
+ module2.exports = require_browser();
+ } else {
+ module2.exports = require_node4();
+ }
+ }
+});
+
+// ../../node_modules/.pnpm/destroy@1.2.0/node_modules/destroy/index.js
+var require_destroy = __commonJS({
+ "../../node_modules/.pnpm/destroy@1.2.0/node_modules/destroy/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var EventEmitter3 = require("events").EventEmitter;
+ var ReadStream = require("fs").ReadStream;
+ var Stream = require("stream");
+ var Zlib = require("zlib");
+ module2.exports = destroy;
+ function destroy(stream2, suppress) {
+ if (isFsReadStream(stream2)) {
+ destroyReadStream(stream2);
+ } else if (isZlibStream(stream2)) {
+ destroyZlibStream(stream2);
+ } else if (hasDestroy(stream2)) {
+ stream2.destroy();
+ }
+ if (isEventEmitter(stream2) && suppress) {
+ stream2.removeAllListeners("error");
+ stream2.addListener("error", noop);
+ }
+ return stream2;
+ }
+ __name(destroy, "destroy");
+ function destroyReadStream(stream2) {
+ stream2.destroy();
+ if (typeof stream2.close === "function") {
+ stream2.on("open", onOpenClose);
+ }
+ }
+ __name(destroyReadStream, "destroyReadStream");
+ function closeZlibStream(stream2) {
+ if (stream2._hadError === true) {
+ var prop = stream2._binding === null ? "_binding" : "_handle";
+ stream2[prop] = {
+ close: function() {
+ this[prop] = null;
+ }
+ };
+ }
+ stream2.close();
+ }
+ __name(closeZlibStream, "closeZlibStream");
+ function destroyZlibStream(stream2) {
+ if (typeof stream2.destroy === "function") {
+ if (stream2._binding) {
+ stream2.destroy();
+ if (stream2._processing) {
+ stream2._needDrain = true;
+ stream2.once("drain", onDrainClearBinding);
+ } else {
+ stream2._binding.clear();
+ }
+ } else if (stream2._destroy && stream2._destroy !== Stream.Transform.prototype._destroy) {
+ stream2.destroy();
+ } else if (stream2._destroy && typeof stream2.close === "function") {
+ stream2.destroyed = true;
+ stream2.close();
+ } else {
+ stream2.destroy();
+ }
+ } else if (typeof stream2.close === "function") {
+ closeZlibStream(stream2);
+ }
+ }
+ __name(destroyZlibStream, "destroyZlibStream");
+ function hasDestroy(stream2) {
+ return stream2 instanceof Stream && typeof stream2.destroy === "function";
+ }
+ __name(hasDestroy, "hasDestroy");
+ function isEventEmitter(val) {
+ return val instanceof EventEmitter3;
+ }
+ __name(isEventEmitter, "isEventEmitter");
+ function isFsReadStream(stream2) {
+ return stream2 instanceof ReadStream;
+ }
+ __name(isFsReadStream, "isFsReadStream");
+ function isZlibStream(stream2) {
+ return stream2 instanceof Zlib.Gzip || stream2 instanceof Zlib.Gunzip || stream2 instanceof Zlib.Deflate || stream2 instanceof Zlib.DeflateRaw || stream2 instanceof Zlib.Inflate || stream2 instanceof Zlib.InflateRaw || stream2 instanceof Zlib.Unzip;
+ }
+ __name(isZlibStream, "isZlibStream");
+ function noop() {
+ }
+ __name(noop, "noop");
+ function onDrainClearBinding() {
+ this._binding.clear();
+ }
+ __name(onDrainClearBinding, "onDrainClearBinding");
+ function onOpenClose() {
+ if (typeof this.fd === "number") {
+ this.close();
+ }
+ }
+ __name(onOpenClose, "onOpenClose");
+ }
+});
+
+// ../../node_modules/.pnpm/safer-buffer@2.1.2/node_modules/safer-buffer/safer.js
+var require_safer = __commonJS({
+ "../../node_modules/.pnpm/safer-buffer@2.1.2/node_modules/safer-buffer/safer.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var buffer = require("buffer");
+ var Buffer3 = 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 Buffer3) {
+ if (!Buffer3.hasOwnProperty(key))
+ continue;
+ if (key === "allocUnsafe" || key === "allocUnsafeSlow")
+ continue;
+ Safer[key] = Buffer3[key];
+ }
+ safer.Buffer.prototype = Buffer3.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 Buffer3(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 = Buffer3(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 (e2) {
+ }
+ }
+ if (!safer.constants) {
+ safer.constants = {
+ MAX_LENGTH: safer.kMaxLength
+ };
+ if (safer.kStringMaxLength) {
+ safer.constants.MAX_STRING_LENGTH = safer.kStringMaxLength;
+ }
+ }
+ module2.exports = safer;
+ }
+});
+
+// ../../node_modules/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/lib/bom-handling.js
+var require_bom_handling = __commonJS({
+ "../../node_modules/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/lib/bom-handling.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ var BOMChar = "\uFEFF";
+ exports2.PrependBOM = PrependBOMWrapper;
+ function PrependBOMWrapper(encoder, options14) {
+ this.encoder = encoder;
+ this.addBOM = true;
+ }
+ __name(PrependBOMWrapper, "PrependBOMWrapper");
+ 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, options14) {
+ this.decoder = decoder;
+ this.pass = false;
+ this.options = options14 || {};
+ }
+ __name(StripBOMWrapper, "StripBOMWrapper");
+ StripBOMWrapper.prototype.write = function(buf) {
+ var res = this.decoder.write(buf);
+ if (this.pass || !res)
+ return res;
+ if (res[0] === BOMChar) {
+ res = res.slice(1);
+ if (typeof this.options.stripBOM === "function")
+ this.options.stripBOM();
+ }
+ this.pass = true;
+ return res;
+ };
+ StripBOMWrapper.prototype.end = function() {
+ return this.decoder.end();
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/encodings/internal.js
+var require_internal = __commonJS({
+ "../../node_modules/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/encodings/internal.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var Buffer3 = 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 (Buffer3.from("eda0bdedb2a9", "hex").toString() !== "\u{1F4A9}") {
+ this.decoder = InternalDecoderCesu8;
+ this.defaultCharUnicode = iconv.defaultCharUnicode;
+ }
+ }
+ }
+ __name(InternalCodec, "InternalCodec");
+ InternalCodec.prototype.encoder = InternalEncoder;
+ InternalCodec.prototype.decoder = InternalDecoder;
+ var StringDecoder2 = require("string_decoder").StringDecoder;
+ if (!StringDecoder2.prototype.end)
+ StringDecoder2.prototype.end = function() {
+ };
+ function InternalDecoder(options14, codec) {
+ StringDecoder2.call(this, codec.enc);
+ }
+ __name(InternalDecoder, "InternalDecoder");
+ InternalDecoder.prototype = StringDecoder2.prototype;
+ function InternalEncoder(options14, codec) {
+ this.enc = codec.enc;
+ }
+ __name(InternalEncoder, "InternalEncoder");
+ InternalEncoder.prototype.write = function(str) {
+ return Buffer3.from(str, this.enc);
+ };
+ InternalEncoder.prototype.end = function() {
+ };
+ function InternalEncoderBase64(options14, codec) {
+ this.prevStr = "";
+ }
+ __name(InternalEncoderBase64, "InternalEncoderBase64");
+ 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 Buffer3.from(str, "base64");
+ };
+ InternalEncoderBase64.prototype.end = function() {
+ return Buffer3.from(this.prevStr, "base64");
+ };
+ function InternalEncoderCesu8(options14, codec) {
+ }
+ __name(InternalEncoderCesu8, "InternalEncoderCesu8");
+ InternalEncoderCesu8.prototype.write = function(str) {
+ var buf = Buffer3.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(options14, codec) {
+ this.acc = 0;
+ this.contBytes = 0;
+ this.accBytes = 0;
+ this.defaultCharUnicode = codec.defaultCharUnicode;
+ }
+ __name(InternalDecoderCesu8, "InternalDecoderCesu8");
+ 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;
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/encodings/utf16.js
+var require_utf16 = __commonJS({
+ "../../node_modules/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/encodings/utf16.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ var Buffer3 = require_safer().Buffer;
+ exports2.utf16be = Utf16BECodec;
+ function Utf16BECodec() {
+ }
+ __name(Utf16BECodec, "Utf16BECodec");
+ Utf16BECodec.prototype.encoder = Utf16BEEncoder;
+ Utf16BECodec.prototype.decoder = Utf16BEDecoder;
+ Utf16BECodec.prototype.bomAware = true;
+ function Utf16BEEncoder() {
+ }
+ __name(Utf16BEEncoder, "Utf16BEEncoder");
+ Utf16BEEncoder.prototype.write = function(str) {
+ var buf = Buffer3.from(str, "ucs2");
+ for (var i = 0; i < buf.length; i += 2) {
+ var tmp5 = buf[i];
+ buf[i] = buf[i + 1];
+ buf[i + 1] = tmp5;
+ }
+ return buf;
+ };
+ Utf16BEEncoder.prototype.end = function() {
+ };
+ function Utf16BEDecoder() {
+ this.overflowByte = -1;
+ }
+ __name(Utf16BEDecoder, "Utf16BEDecoder");
+ Utf16BEDecoder.prototype.write = function(buf) {
+ if (buf.length == 0)
+ return "";
+ var buf2 = Buffer3.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() {
+ };
+ exports2.utf16 = Utf16Codec;
+ function Utf16Codec(codecOptions, iconv) {
+ this.iconv = iconv;
+ }
+ __name(Utf16Codec, "Utf16Codec");
+ Utf16Codec.prototype.encoder = Utf16Encoder;
+ Utf16Codec.prototype.decoder = Utf16Decoder;
+ function Utf16Encoder(options14, codec) {
+ options14 = options14 || {};
+ if (options14.addBOM === void 0)
+ options14.addBOM = true;
+ this.encoder = codec.iconv.getEncoder("utf-16le", options14);
+ }
+ __name(Utf16Encoder, "Utf16Encoder");
+ Utf16Encoder.prototype.write = function(str) {
+ return this.encoder.write(str);
+ };
+ Utf16Encoder.prototype.end = function() {
+ return this.encoder.end();
+ };
+ function Utf16Decoder(options14, codec) {
+ this.decoder = null;
+ this.initialBytes = [];
+ this.initialBytesLen = 0;
+ this.options = options14 || {};
+ this.iconv = codec.iconv;
+ }
+ __name(Utf16Decoder, "Utf16Decoder");
+ Utf16Decoder.prototype.write = function(buf) {
+ if (!this.decoder) {
+ this.initialBytes.push(buf);
+ this.initialBytesLen += buf.length;
+ if (this.initialBytesLen < 16)
+ return "";
+ var buf = Buffer3.concat(this.initialBytes), encoding = detectEncoding(buf, this.options.defaultEncoding);
+ this.decoder = this.iconv.getDecoder(encoding, this.options);
+ this.initialBytes.length = this.initialBytesLen = 0;
+ }
+ return this.decoder.write(buf);
+ };
+ Utf16Decoder.prototype.end = function() {
+ if (!this.decoder) {
+ var buf = Buffer3.concat(this.initialBytes), encoding = detectEncoding(buf, this.options.defaultEncoding);
+ this.decoder = this.iconv.getDecoder(encoding, this.options);
+ var res = this.decoder.write(buf), trail = this.decoder.end();
+ return trail ? res + trail : res;
+ }
+ return this.decoder.end();
+ };
+ function detectEncoding(buf, defaultEncoding) {
+ var enc = defaultEncoding || "utf-16le";
+ if (buf.length >= 2) {
+ if (buf[0] == 254 && buf[1] == 255)
+ enc = "utf-16be";
+ else if (buf[0] == 255 && buf[1] == 254)
+ enc = "utf-16le";
+ else {
+ var asciiCharsLE = 0, asciiCharsBE = 0, _len = Math.min(buf.length - buf.length % 2, 64);
+ for (var i = 0; i < _len; i += 2) {
+ if (buf[i] === 0 && buf[i + 1] !== 0)
+ asciiCharsBE++;
+ if (buf[i] !== 0 && buf[i + 1] === 0)
+ asciiCharsLE++;
+ }
+ if (asciiCharsBE > asciiCharsLE)
+ enc = "utf-16be";
+ else if (asciiCharsBE < asciiCharsLE)
+ enc = "utf-16le";
+ }
+ }
+ return enc;
+ }
+ __name(detectEncoding, "detectEncoding");
+ }
+});
+
+// ../../node_modules/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/encodings/utf7.js
+var require_utf7 = __commonJS({
+ "../../node_modules/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/encodings/utf7.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ var Buffer3 = require_safer().Buffer;
+ exports2.utf7 = Utf7Codec;
+ exports2.unicode11utf7 = "utf7";
+ function Utf7Codec(codecOptions, iconv) {
+ this.iconv = iconv;
+ }
+ __name(Utf7Codec, "Utf7Codec");
+ Utf7Codec.prototype.encoder = Utf7Encoder;
+ Utf7Codec.prototype.decoder = Utf7Decoder;
+ Utf7Codec.prototype.bomAware = true;
+ var nonDirectChars = /[^A-Za-z0-9'\(\),-\.\/:\? \n\r\t]+/g;
+ function Utf7Encoder(options14, codec) {
+ this.iconv = codec.iconv;
+ }
+ __name(Utf7Encoder, "Utf7Encoder");
+ Utf7Encoder.prototype.write = function(str) {
+ return Buffer3.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(options14, codec) {
+ this.iconv = codec.iconv;
+ this.inBase64 = false;
+ this.base64Accum = "";
+ }
+ __name(Utf7Decoder, "Utf7Decoder");
+ var base64Regex = /[A-Za-z0-9\/+]/;
+ var base64Chars = [];
+ for (i = 0; i < 256; i++)
+ base64Chars[i] = base64Regex.test(String.fromCharCode(i));
+ var i;
+ var plusChar = "+".charCodeAt(0);
+ var minusChar = "-".charCodeAt(0);
+ var andChar = "&".charCodeAt(0);
+ Utf7Decoder.prototype.write = function(buf) {
+ var res = "", 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 + buf.slice(lastI, i2).toString();
+ res += this.iconv.decode(Buffer3.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 + buf.slice(lastI).toString();
+ var canBeDecoded = b64str.length - b64str.length % 8;
+ base64Accum = b64str.slice(canBeDecoded);
+ b64str = b64str.slice(0, canBeDecoded);
+ res += this.iconv.decode(Buffer3.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(Buffer3.from(this.base64Accum, "base64"), "utf16-be");
+ this.inBase64 = false;
+ this.base64Accum = "";
+ return res;
+ };
+ exports2.utf7imap = Utf7IMAPCodec;
+ function Utf7IMAPCodec(codecOptions, iconv) {
+ this.iconv = iconv;
+ }
+ __name(Utf7IMAPCodec, "Utf7IMAPCodec");
+ Utf7IMAPCodec.prototype.encoder = Utf7IMAPEncoder;
+ Utf7IMAPCodec.prototype.decoder = Utf7IMAPDecoder;
+ Utf7IMAPCodec.prototype.bomAware = true;
+ function Utf7IMAPEncoder(options14, codec) {
+ this.iconv = codec.iconv;
+ this.inBase64 = false;
+ this.base64Accum = Buffer3.alloc(6);
+ this.base64AccumIdx = 0;
+ }
+ __name(Utf7IMAPEncoder, "Utf7IMAPEncoder");
+ Utf7IMAPEncoder.prototype.write = function(str) {
+ var inBase64 = this.inBase64, base64Accum = this.base64Accum, base64AccumIdx = this.base64AccumIdx, buf = Buffer3.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 = Buffer3.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(options14, codec) {
+ this.iconv = codec.iconv;
+ this.inBase64 = false;
+ this.base64Accum = "";
+ }
+ __name(Utf7IMAPDecoder, "Utf7IMAPDecoder");
+ 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 + buf.slice(lastI, i2).toString().replace(/,/g, "/");
+ res += this.iconv.decode(Buffer3.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 + buf.slice(lastI).toString().replace(/,/g, "/");
+ var canBeDecoded = b64str.length - b64str.length % 8;
+ base64Accum = b64str.slice(canBeDecoded);
+ b64str = b64str.slice(0, canBeDecoded);
+ res += this.iconv.decode(Buffer3.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(Buffer3.from(this.base64Accum, "base64"), "utf16-be");
+ this.inBase64 = false;
+ this.base64Accum = "";
+ return res;
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/encodings/sbcs-codec.js
+var require_sbcs_codec = __commonJS({
+ "../../node_modules/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/encodings/sbcs-codec.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ var Buffer3 = 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 = Buffer3.from(codecOptions.chars, "ucs2");
+ var encodeBuf = Buffer3.alloc(65536, iconv.defaultCharSingleByte.charCodeAt(0));
+ for (var i = 0; i < codecOptions.chars.length; i++)
+ encodeBuf[codecOptions.chars.charCodeAt(i)] = i;
+ this.encodeBuf = encodeBuf;
+ }
+ __name(SBCSCodec, "SBCSCodec");
+ SBCSCodec.prototype.encoder = SBCSEncoder;
+ SBCSCodec.prototype.decoder = SBCSDecoder;
+ function SBCSEncoder(options14, codec) {
+ this.encodeBuf = codec.encodeBuf;
+ }
+ __name(SBCSEncoder, "SBCSEncoder");
+ SBCSEncoder.prototype.write = function(str) {
+ var buf = Buffer3.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(options14, codec) {
+ this.decodeBuf = codec.decodeBuf;
+ }
+ __name(SBCSDecoder, "SBCSDecoder");
+ SBCSDecoder.prototype.write = function(buf) {
+ var decodeBuf = this.decodeBuf;
+ var newBuf = Buffer3.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() {
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/encodings/sbcs-data.js
+var require_sbcs_data = __commonJS({
+ "../../node_modules/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/encodings/sbcs-data.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ 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"
+ },
+ // 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"
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/encodings/sbcs-data-generated.js
+var require_sbcs_data_generated = __commonJS({
+ "../../node_modules/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/encodings/sbcs-data-generated.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ module2.exports = {
+ "437": "cp437",
+ "737": "cp737",
+ "775": "cp775",
+ "850": "cp850",
+ "852": "cp852",
+ "855": "cp855",
+ "856": "cp856",
+ "857": "cp857",
+ "858": "cp858",
+ "860": "cp860",
+ "861": "cp861",
+ "862": "cp862",
+ "863": "cp863",
+ "864": "cp864",
+ "865": "cp865",
+ "866": "cp866",
+ "869": "cp869",
+ "874": "windows874",
+ "922": "cp922",
+ "1046": "cp1046",
+ "1124": "cp1124",
+ "1125": "cp1125",
+ "1129": "cp1129",
+ "1133": "cp1133",
+ "1161": "cp1161",
+ "1162": "cp1162",
+ "1163": "cp1163",
+ "1250": "windows1250",
+ "1251": "windows1251",
+ "1252": "windows1252",
+ "1253": "windows1253",
+ "1254": "windows1254",
+ "1255": "windows1255",
+ "1256": "windows1256",
+ "1257": "windows1257",
+ "1258": "windows1258",
+ "28591": "iso88591",
+ "28592": "iso88592",
+ "28593": "iso88593",
+ "28594": "iso88594",
+ "28595": "iso88595",
+ "28596": "iso88596",
+ "28597": "iso88597",
+ "28598": "iso88598",
+ "28599": "iso88599",
+ "28600": "iso885910",
+ "28601": "iso885911",
+ "28603": "iso885913",
+ "28604": "iso885914",
+ "28605": "iso885915",
+ "28606": "iso885916",
+ "windows874": {
+ "type": "_sbcs",
+ "chars": "\u20AC\uFFFD\uFFFD\uFFFD\uFFFD\u2026\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\u2018\u2019\u201C\u201D\u2022\u2013\u2014\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\xA0\u0E01\u0E02\u0E03\u0E04\u0E05\u0E06\u0E07\u0E08\u0E09\u0E0A\u0E0B\u0E0C\u0E0D\u0E0E\u0E0F\u0E10\u0E11\u0E12\u0E13\u0E14\u0E15\u0E16\u0E17\u0E18\u0E19\u0E1A\u0E1B\u0E1C\u0E1D\u0E1E\u0E1F\u0E20\u0E21\u0E22\u0E23\u0E24\u0E25\u0E26\u0E27\u0E28\u0E29\u0E2A\u0E2B\u0E2C\u0E2D\u0E2E\u0E2F\u0E30\u0E31\u0E32\u0E33\u0E34\u0E35\u0E36\u0E37\u0E38\u0E39\u0E3A\uFFFD\uFFFD\uFFFD\uFFFD\u0E3F\u0E40\u0E41\u0E42\u0E43\u0E44\u0E45\u0E46\u0E47\u0E48\u0E49\u0E4A\u0E4B\u0E4C\u0E4D\u0E4E\u0E4F\u0E50\u0E51\u0E52\u0E53\u0E54\u0E55\u0E56\u0E57\u0E58\u0E59\u0E5A\u0E5B\uFFFD\uFFFD\uFFFD\uFFFD"
+ },
+ "win874": "windows874",
+ "cp874": "windows874",
+ "windows1250": {
+ "type": "_sbcs",
+ "chars": "\u20AC\uFFFD\u201A\uFFFD\u201E\u2026\u2020\u2021\uFFFD\u2030\u0160\u2039\u015A\u0164\u017D\u0179\uFFFD\u2018\u2019\u201C\u201D\u2022\u2013\u2014\uFFFD\u2122\u0161\u203A\u015B\u0165\u017E\u017A\xA0\u02C7\u02D8\u0141\xA4\u0104\xA6\xA7\xA8\xA9\u015E\xAB\xAC\xAD\xAE\u017B\xB0\xB1\u02DB\u0142\xB4\xB5\xB6\xB7\xB8\u0105\u015F\xBB\u013D\u02DD\u013E\u017C\u0154\xC1\xC2\u0102\xC4\u0139\u0106\xC7\u010C\xC9\u0118\xCB\u011A\xCD\xCE\u010E\u0110\u0143\u0147\xD3\xD4\u0150\xD6\xD7\u0158\u016E\xDA\u0170\xDC\xDD\u0162\xDF\u0155\xE1\xE2\u0103\xE4\u013A\u0107\xE7\u010D\xE9\u0119\xEB\u011B\xED\xEE\u010F\u0111\u0144\u0148\xF3\xF4\u0151\xF6\xF7\u0159\u016F\xFA\u0171\xFC\xFD\u0163\u02D9"
+ },
+ "win1250": "windows1250",
+ "cp1250": "windows1250",
+ "windows1251": {
+ "type": "_sbcs",
+ "chars": "\u0402\u0403\u201A\u0453\u201E\u2026\u2020\u2021\u20AC\u2030\u0409\u2039\u040A\u040C\u040B\u040F\u0452\u2018\u2019\u201C\u201D\u2022\u2013\u2014\uFFFD\u2122\u0459\u203A\u045A\u045C\u045B\u045F\xA0\u040E\u045E\u0408\xA4\u0490\xA6\xA7\u0401\xA9\u0404\xAB\xAC\xAD\xAE\u0407\xB0\xB1\u0406\u0456\u0491\xB5\xB6\xB7\u0451\u2116\u0454\xBB\u0458\u0405\u0455\u0457\u0410\u0411\u0412\u0413\u0414\u0415\u0416\u0417\u0418\u0419\u041A\u041B\u041C\u041D\u041E\u041F\u0420\u0421\u0422\u0423\u0424\u0425\u0426\u0427\u0428\u0429\u042A\u042B\u042C\u042D\u042E\u042F\u0430\u0431\u0432\u0433\u0434\u0435\u0436\u0437\u0438\u0439\u043A\u043B\u043C\u043D\u043E\u043F\u0440\u0441\u0442\u0443\u0444\u0445\u0446\u0447\u0448\u0449\u044A\u044B\u044C\u044D\u044E\u044F"
+ },
+ "win1251": "windows1251",
+ "cp1251": "windows1251",
+ "windows1252": {
+ "type": "_sbcs",
+ "chars": "\u20AC\uFFFD\u201A\u0192\u201E\u2026\u2020\u2021\u02C6\u2030\u0160\u2039\u0152\uFFFD\u017D\uFFFD\uFFFD\u2018\u2019\u201C\u201D\u2022\u2013\u2014\u02DC\u2122\u0161\u203A\u0153\uFFFD\u017E\u0178\xA0\xA1\xA2\xA3\xA4\xA5\xA6\xA7\xA8\xA9\xAA\xAB\xAC\xAD\xAE\xAF\xB0\xB1\xB2\xB3\xB4\xB5\xB6\xB7\xB8\xB9\xBA\xBB\xBC\xBD\xBE\xBF\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF\xD0\xD1\xD2\xD3\xD4\xD5\xD6\xD7\xD8\xD9\xDA\xDB\xDC\xDD\xDE\xDF\xE0\xE1\xE2\xE3\xE4\xE5\xE6\xE7\xE8\xE9\xEA\xEB\xEC\xED\xEE\xEF\xF0\xF1\xF2\xF3\xF4\xF5\xF6\xF7\xF8\xF9\xFA\xFB\xFC\xFD\xFE\xFF"
+ },
+ "win1252": "windows1252",
+ "cp1252": "windows1252",
+ "windows1253": {
+ "type": "_sbcs",
+ "chars": "\u20AC\uFFFD\u201A\u0192\u201E\u2026\u2020\u2021\uFFFD\u2030\uFFFD\u2039\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\u2018\u2019\u201C\u201D\u2022\u2013\u2014\uFFFD\u2122\uFFFD\u203A\uFFFD\uFFFD\uFFFD\uFFFD\xA0\u0385\u0386\xA3\xA4\xA5\xA6\xA7\xA8\xA9\uFFFD\xAB\xAC\xAD\xAE\u2015\xB0\xB1\xB2\xB3\u0384\xB5\xB6\xB7\u0388\u0389\u038A\xBB\u038C\xBD\u038E\u038F\u0390\u0391\u0392\u0393\u0394\u0395\u0396\u0397\u0398\u0399\u039A\u039B\u039C\u039D\u039E\u039F\u03A0\u03A1\uFFFD\u03A3\u03A4\u03A5\u03A6\u03A7\u03A8\u03A9\u03AA\u03AB\u03AC\u03AD\u03AE\u03AF\u03B0\u03B1\u03B2\u03B3\u03B4\u03B5\u03B6\u03B7\u03B8\u03B9\u03BA\u03BB\u03BC\u03BD\u03BE\u03BF\u03C0\u03C1\u03C2\u03C3\u03C4\u03C5\u03C6\u03C7\u03C8\u03C9\u03CA\u03CB\u03CC\u03CD\u03CE\uFFFD"
+ },
+ "win1253": "windows1253",
+ "cp1253": "windows1253",
+ "windows1254": {
+ "type": "_sbcs",
+ "chars": "\u20AC\uFFFD\u201A\u0192\u201E\u2026\u2020\u2021\u02C6\u2030\u0160\u2039\u0152\uFFFD\uFFFD\uFFFD\uFFFD\u2018\u2019\u201C\u201D\u2022\u2013\u2014\u02DC\u2122\u0161\u203A\u0153\uFFFD\uFFFD\u0178\xA0\xA1\xA2\xA3\xA4\xA5\xA6\xA7\xA8\xA9\xAA\xAB\xAC\xAD\xAE\xAF\xB0\xB1\xB2\xB3\xB4\xB5\xB6\xB7\xB8\xB9\xBA\xBB\xBC\xBD\xBE\xBF\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF\u011E\xD1\xD2\xD3\xD4\xD5\xD6\xD7\xD8\xD9\xDA\xDB\xDC\u0130\u015E\xDF\xE0\xE1\xE2\xE3\xE4\xE5\xE6\xE7\xE8\xE9\xEA\xEB\xEC\xED\xEE\xEF\u011F\xF1\xF2\xF3\xF4\xF5\xF6\xF7\xF8\xF9\xFA\xFB\xFC\u0131\u015F\xFF"
+ },
+ "win1254": "windows1254",
+ "cp1254": "windows1254",
+ "windows1255": {
+ "type": "_sbcs",
+ "chars": "\u20AC\uFFFD\u201A\u0192\u201E\u2026\u2020\u2021\u02C6\u2030\uFFFD\u2039\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\u2018\u2019\u201C\u201D\u2022\u2013\u2014\u02DC\u2122\uFFFD\u203A\uFFFD\uFFFD\uFFFD\uFFFD\xA0\xA1\xA2\xA3\u20AA\xA5\xA6\xA7\xA8\xA9\xD7\xAB\xAC\xAD\xAE\xAF\xB0\xB1\xB2\xB3\xB4\xB5\xB6\xB7\xB8\xB9\xF7\xBB\xBC\xBD\xBE\xBF\u05B0\u05B1\u05B2\u05B3\u05B4\u05B5\u05B6\u05B7\u05B8\u05B9\u05BA\u05BB\u05BC\u05BD\u05BE\u05BF\u05C0\u05C1\u05C2\u05C3\u05F0\u05F1\u05F2\u05F3\u05F4\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\u05D0\u05D1\u05D2\u05D3\u05D4\u05D5\u05D6\u05D7\u05D8\u05D9\u05DA\u05DB\u05DC\u05DD\u05DE\u05DF\u05E0\u05E1\u05E2\u05E3\u05E4\u05E5\u05E6\u05E7\u05E8\u05E9\u05EA\uFFFD\uFFFD\u200E\u200F\uFFFD"
+ },
+ "win1255": "windows1255",
+ "cp1255": "windows1255",
+ "windows1256": {
+ "type": "_sbcs",
+ "chars": "\u20AC\u067E\u201A\u0192\u201E\u2026\u2020\u2021\u02C6\u2030\u0679\u2039\u0152\u0686\u0698\u0688\u06AF\u2018\u2019\u201C\u201D\u2022\u2013\u2014\u06A9\u2122\u0691\u203A\u0153\u200C\u200D\u06BA\xA0\u060C\xA2\xA3\xA4\xA5\xA6\xA7\xA8\xA9\u06BE\xAB\xAC\xAD\xAE\xAF\xB0\xB1\xB2\xB3\xB4\xB5\xB6\xB7\xB8\xB9\u061B\xBB\xBC\xBD\xBE\u061F\u06C1\u0621\u0622\u0623\u0624\u0625\u0626\u0627\u0628\u0629\u062A\u062B\u062C\u062D\u062E\u062F\u0630\u0631\u0632\u0633\u0634\u0635\u0636\xD7\u0637\u0638\u0639\u063A\u0640\u0641\u0642\u0643\xE0\u0644\xE2\u0645\u0646\u0647\u0648\xE7\xE8\xE9\xEA\xEB\u0649\u064A\xEE\xEF\u064B\u064C\u064D\u064E\xF4\u064F\u0650\xF7\u0651\xF9\u0652\xFB\xFC\u200E\u200F\u06D2"
+ },
+ "win1256": "windows1256",
+ "cp1256": "windows1256",
+ "windows1257": {
+ "type": "_sbcs",
+ "chars": "\u20AC\uFFFD\u201A\uFFFD\u201E\u2026\u2020\u2021\uFFFD\u2030\uFFFD\u2039\uFFFD\xA8\u02C7\xB8\uFFFD\u2018\u2019\u201C\u201D\u2022\u2013\u2014\uFFFD\u2122\uFFFD\u203A\uFFFD\xAF\u02DB\uFFFD\xA0\uFFFD\xA2\xA3\xA4\uFFFD\xA6\xA7\xD8\xA9\u0156\xAB\xAC\xAD\xAE\xC6\xB0\xB1\xB2\xB3\xB4\xB5\xB6\xB7\xF8\xB9\u0157\xBB\xBC\xBD\xBE\xE6\u0104\u012E\u0100\u0106\xC4\xC5\u0118\u0112\u010C\xC9\u0179\u0116\u0122\u0136\u012A\u013B\u0160\u0143\u0145\xD3\u014C\xD5\xD6\xD7\u0172\u0141\u015A\u016A\xDC\u017B\u017D\xDF\u0105\u012F\u0101\u0107\xE4\xE5\u0119\u0113\u010D\xE9\u017A\u0117\u0123\u0137\u012B\u013C\u0161\u0144\u0146\xF3\u014D\xF5\xF6\xF7\u0173\u0142\u015B\u016B\xFC\u017C\u017E\u02D9"
+ },
+ "win1257": "windows1257",
+ "cp1257": "windows1257",
+ "windows1258": {
+ "type": "_sbcs",
+ "chars": "\u20AC\uFFFD\u201A\u0192\u201E\u2026\u2020\u2021\u02C6\u2030\uFFFD\u2039\u0152\uFFFD\uFFFD\uFFFD\uFFFD\u2018\u2019\u201C\u201D\u2022\u2013\u2014\u02DC\u2122\uFFFD\u203A\u0153\uFFFD\uFFFD\u0178\xA0\xA1\xA2\xA3\xA4\xA5\xA6\xA7\xA8\xA9\xAA\xAB\xAC\xAD\xAE\xAF\xB0\xB1\xB2\xB3\xB4\xB5\xB6\xB7\xB8\xB9\xBA\xBB\xBC\xBD\xBE\xBF\xC0\xC1\xC2\u0102\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\u0300\xCD\xCE\xCF\u0110\xD1\u0309\xD3\xD4\u01A0\xD6\xD7\xD8\xD9\xDA\xDB\xDC\u01AF\u0303\xDF\xE0\xE1\xE2\u0103\xE4\xE5\xE6\xE7\xE8\xE9\xEA\xEB\u0301\xED\xEE\xEF\u0111\xF1\u0323\xF3\xF4\u01A1\xF6\xF7\xF8\xF9\xFA\xFB\xFC\u01B0\u20AB\xFF"
+ },
+ "win1258": "windows1258",
+ "cp1258": "windows1258",
+ "iso88591": {
+ "type": "_sbcs",
+ "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\xA1\xA2\xA3\xA4\xA5\xA6\xA7\xA8\xA9\xAA\xAB\xAC\xAD\xAE\xAF\xB0\xB1\xB2\xB3\xB4\xB5\xB6\xB7\xB8\xB9\xBA\xBB\xBC\xBD\xBE\xBF\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF\xD0\xD1\xD2\xD3\xD4\xD5\xD6\xD7\xD8\xD9\xDA\xDB\xDC\xDD\xDE\xDF\xE0\xE1\xE2\xE3\xE4\xE5\xE6\xE7\xE8\xE9\xEA\xEB\xEC\xED\xEE\xEF\xF0\xF1\xF2\xF3\xF4\xF5\xF6\xF7\xF8\xF9\xFA\xFB\xFC\xFD\xFE\xFF"
+ },
+ "cp28591": "iso88591",
+ "iso88592": {
+ "type": "_sbcs",
+ "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\u0104\u02D8\u0141\xA4\u013D\u015A\xA7\xA8\u0160\u015E\u0164\u0179\xAD\u017D\u017B\xB0\u0105\u02DB\u0142\xB4\u013E\u015B\u02C7\xB8\u0161\u015F\u0165\u017A\u02DD\u017E\u017C\u0154\xC1\xC2\u0102\xC4\u0139\u0106\xC7\u010C\xC9\u0118\xCB\u011A\xCD\xCE\u010E\u0110\u0143\u0147\xD3\xD4\u0150\xD6\xD7\u0158\u016E\xDA\u0170\xDC\xDD\u0162\xDF\u0155\xE1\xE2\u0103\xE4\u013A\u0107\xE7\u010D\xE9\u0119\xEB\u011B\xED\xEE\u010F\u0111\u0144\u0148\xF3\xF4\u0151\xF6\xF7\u0159\u016F\xFA\u0171\xFC\xFD\u0163\u02D9"
+ },
+ "cp28592": "iso88592",
+ "iso88593": {
+ "type": "_sbcs",
+ "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\u0126\u02D8\xA3\xA4\uFFFD\u0124\xA7\xA8\u0130\u015E\u011E\u0134\xAD\uFFFD\u017B\xB0\u0127\xB2\xB3\xB4\xB5\u0125\xB7\xB8\u0131\u015F\u011F\u0135\xBD\uFFFD\u017C\xC0\xC1\xC2\uFFFD\xC4\u010A\u0108\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF\uFFFD\xD1\xD2\xD3\xD4\u0120\xD6\xD7\u011C\xD9\xDA\xDB\xDC\u016C\u015C\xDF\xE0\xE1\xE2\uFFFD\xE4\u010B\u0109\xE7\xE8\xE9\xEA\xEB\xEC\xED\xEE\xEF\uFFFD\xF1\xF2\xF3\xF4\u0121\xF6\xF7\u011D\xF9\xFA\xFB\xFC\u016D\u015D\u02D9"
+ },
+ "cp28593": "iso88593",
+ "iso88594": {
+ "type": "_sbcs",
+ "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\u0104\u0138\u0156\xA4\u0128\u013B\xA7\xA8\u0160\u0112\u0122\u0166\xAD\u017D\xAF\xB0\u0105\u02DB\u0157\xB4\u0129\u013C\u02C7\xB8\u0161\u0113\u0123\u0167\u014A\u017E\u014B\u0100\xC1\xC2\xC3\xC4\xC5\xC6\u012E\u010C\xC9\u0118\xCB\u0116\xCD\xCE\u012A\u0110\u0145\u014C\u0136\xD4\xD5\xD6\xD7\xD8\u0172\xDA\xDB\xDC\u0168\u016A\xDF\u0101\xE1\xE2\xE3\xE4\xE5\xE6\u012F\u010D\xE9\u0119\xEB\u0117\xED\xEE\u012B\u0111\u0146\u014D\u0137\xF4\xF5\xF6\xF7\xF8\u0173\xFA\xFB\xFC\u0169\u016B\u02D9"
+ },
+ "cp28594": "iso88594",
+ "iso88595": {
+ "type": "_sbcs",
+ "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\u0401\u0402\u0403\u0404\u0405\u0406\u0407\u0408\u0409\u040A\u040B\u040C\xAD\u040E\u040F\u0410\u0411\u0412\u0413\u0414\u0415\u0416\u0417\u0418\u0419\u041A\u041B\u041C\u041D\u041E\u041F\u0420\u0421\u0422\u0423\u0424\u0425\u0426\u0427\u0428\u0429\u042A\u042B\u042C\u042D\u042E\u042F\u0430\u0431\u0432\u0433\u0434\u0435\u0436\u0437\u0438\u0439\u043A\u043B\u043C\u043D\u043E\u043F\u0440\u0441\u0442\u0443\u0444\u0445\u0446\u0447\u0448\u0449\u044A\u044B\u044C\u044D\u044E\u044F\u2116\u0451\u0452\u0453\u0454\u0455\u0456\u0457\u0458\u0459\u045A\u045B\u045C\xA7\u045E\u045F"
+ },
+ "cp28595": "iso88595",
+ "iso88596": {
+ "type": "_sbcs",
+ "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\uFFFD\uFFFD\uFFFD\xA4\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\u060C\xAD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\u061B\uFFFD\uFFFD\uFFFD\u061F\uFFFD\u0621\u0622\u0623\u0624\u0625\u0626\u0627\u0628\u0629\u062A\u062B\u062C\u062D\u062E\u062F\u0630\u0631\u0632\u0633\u0634\u0635\u0636\u0637\u0638\u0639\u063A\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\u0640\u0641\u0642\u0643\u0644\u0645\u0646\u0647\u0648\u0649\u064A\u064B\u064C\u064D\u064E\u064F\u0650\u0651\u0652\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD"
+ },
+ "cp28596": "iso88596",
+ "iso88597": {
+ "type": "_sbcs",
+ "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\u2018\u2019\xA3\u20AC\u20AF\xA6\xA7\xA8\xA9\u037A\xAB\xAC\xAD\uFFFD\u2015\xB0\xB1\xB2\xB3\u0384\u0385\u0386\xB7\u0388\u0389\u038A\xBB\u038C\xBD\u038E\u038F\u0390\u0391\u0392\u0393\u0394\u0395\u0396\u0397\u0398\u0399\u039A\u039B\u039C\u039D\u039E\u039F\u03A0\u03A1\uFFFD\u03A3\u03A4\u03A5\u03A6\u03A7\u03A8\u03A9\u03AA\u03AB\u03AC\u03AD\u03AE\u03AF\u03B0\u03B1\u03B2\u03B3\u03B4\u03B5\u03B6\u03B7\u03B8\u03B9\u03BA\u03BB\u03BC\u03BD\u03BE\u03BF\u03C0\u03C1\u03C2\u03C3\u03C4\u03C5\u03C6\u03C7\u03C8\u03C9\u03CA\u03CB\u03CC\u03CD\u03CE\uFFFD"
+ },
+ "cp28597": "iso88597",
+ "iso88598": {
+ "type": "_sbcs",
+ "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\uFFFD\xA2\xA3\xA4\xA5\xA6\xA7\xA8\xA9\xD7\xAB\xAC\xAD\xAE\xAF\xB0\xB1\xB2\xB3\xB4\xB5\xB6\xB7\xB8\xB9\xF7\xBB\xBC\xBD\xBE\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\u2017\u05D0\u05D1\u05D2\u05D3\u05D4\u05D5\u05D6\u05D7\u05D8\u05D9\u05DA\u05DB\u05DC\u05DD\u05DE\u05DF\u05E0\u05E1\u05E2\u05E3\u05E4\u05E5\u05E6\u05E7\u05E8\u05E9\u05EA\uFFFD\uFFFD\u200E\u200F\uFFFD"
+ },
+ "cp28598": "iso88598",
+ "iso88599": {
+ "type": "_sbcs",
+ "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\xA1\xA2\xA3\xA4\xA5\xA6\xA7\xA8\xA9\xAA\xAB\xAC\xAD\xAE\xAF\xB0\xB1\xB2\xB3\xB4\xB5\xB6\xB7\xB8\xB9\xBA\xBB\xBC\xBD\xBE\xBF\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF\u011E\xD1\xD2\xD3\xD4\xD5\xD6\xD7\xD8\xD9\xDA\xDB\xDC\u0130\u015E\xDF\xE0\xE1\xE2\xE3\xE4\xE5\xE6\xE7\xE8\xE9\xEA\xEB\xEC\xED\xEE\xEF\u011F\xF1\xF2\xF3\xF4\xF5\xF6\xF7\xF8\xF9\xFA\xFB\xFC\u0131\u015F\xFF"
+ },
+ "cp28599": "iso88599",
+ "iso885910": {
+ "type": "_sbcs",
+ "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\u0104\u0112\u0122\u012A\u0128\u0136\xA7\u013B\u0110\u0160\u0166\u017D\xAD\u016A\u014A\xB0\u0105\u0113\u0123\u012B\u0129\u0137\xB7\u013C\u0111\u0161\u0167\u017E\u2015\u016B\u014B\u0100\xC1\xC2\xC3\xC4\xC5\xC6\u012E\u010C\xC9\u0118\xCB\u0116\xCD\xCE\xCF\xD0\u0145\u014C\xD3\xD4\xD5\xD6\u0168\xD8\u0172\xDA\xDB\xDC\xDD\xDE\xDF\u0101\xE1\xE2\xE3\xE4\xE5\xE6\u012F\u010D\xE9\u0119\xEB\u0117\xED\xEE\xEF\xF0\u0146\u014D\xF3\xF4\xF5\xF6\u0169\xF8\u0173\xFA\xFB\xFC\xFD\xFE\u0138"
+ },
+ "cp28600": "iso885910",
+ "iso885911": {
+ "type": "_sbcs",
+ "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\u0E01\u0E02\u0E03\u0E04\u0E05\u0E06\u0E07\u0E08\u0E09\u0E0A\u0E0B\u0E0C\u0E0D\u0E0E\u0E0F\u0E10\u0E11\u0E12\u0E13\u0E14\u0E15\u0E16\u0E17\u0E18\u0E19\u0E1A\u0E1B\u0E1C\u0E1D\u0E1E\u0E1F\u0E20\u0E21\u0E22\u0E23\u0E24\u0E25\u0E26\u0E27\u0E28\u0E29\u0E2A\u0E2B\u0E2C\u0E2D\u0E2E\u0E2F\u0E30\u0E31\u0E32\u0E33\u0E34\u0E35\u0E36\u0E37\u0E38\u0E39\u0E3A\uFFFD\uFFFD\uFFFD\uFFFD\u0E3F\u0E40\u0E41\u0E42\u0E43\u0E44\u0E45\u0E46\u0E47\u0E48\u0E49\u0E4A\u0E4B\u0E4C\u0E4D\u0E4E\u0E4F\u0E50\u0E51\u0E52\u0E53\u0E54\u0E55\u0E56\u0E57\u0E58\u0E59\u0E5A\u0E5B\uFFFD\uFFFD\uFFFD\uFFFD"
+ },
+ "cp28601": "iso885911",
+ "iso885913": {
+ "type": "_sbcs",
+ "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\u201D\xA2\xA3\xA4\u201E\xA6\xA7\xD8\xA9\u0156\xAB\xAC\xAD\xAE\xC6\xB0\xB1\xB2\xB3\u201C\xB5\xB6\xB7\xF8\xB9\u0157\xBB\xBC\xBD\xBE\xE6\u0104\u012E\u0100\u0106\xC4\xC5\u0118\u0112\u010C\xC9\u0179\u0116\u0122\u0136\u012A\u013B\u0160\u0143\u0145\xD3\u014C\xD5\xD6\xD7\u0172\u0141\u015A\u016A\xDC\u017B\u017D\xDF\u0105\u012F\u0101\u0107\xE4\xE5\u0119\u0113\u010D\xE9\u017A\u0117\u0123\u0137\u012B\u013C\u0161\u0144\u0146\xF3\u014D\xF5\xF6\xF7\u0173\u0142\u015B\u016B\xFC\u017C\u017E\u2019"
+ },
+ "cp28603": "iso885913",
+ "iso885914": {
+ "type": "_sbcs",
+ "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\u1E02\u1E03\xA3\u010A\u010B\u1E0A\xA7\u1E80\xA9\u1E82\u1E0B\u1EF2\xAD\xAE\u0178\u1E1E\u1E1F\u0120\u0121\u1E40\u1E41\xB6\u1E56\u1E81\u1E57\u1E83\u1E60\u1EF3\u1E84\u1E85\u1E61\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF\u0174\xD1\xD2\xD3\xD4\xD5\xD6\u1E6A\xD8\xD9\xDA\xDB\xDC\xDD\u0176\xDF\xE0\xE1\xE2\xE3\xE4\xE5\xE6\xE7\xE8\xE9\xEA\xEB\xEC\xED\xEE\xEF\u0175\xF1\xF2\xF3\xF4\xF5\xF6\u1E6B\xF8\xF9\xFA\xFB\xFC\xFD\u0177\xFF"
+ },
+ "cp28604": "iso885914",
+ "iso885915": {
+ "type": "_sbcs",
+ "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\xA1\xA2\xA3\u20AC\xA5\u0160\xA7\u0161\xA9\xAA\xAB\xAC\xAD\xAE\xAF\xB0\xB1\xB2\xB3\u017D\xB5\xB6\xB7\u017E\xB9\xBA\xBB\u0152\u0153\u0178\xBF\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF\xD0\xD1\xD2\xD3\xD4\xD5\xD6\xD7\xD8\xD9\xDA\xDB\xDC\xDD\xDE\xDF\xE0\xE1\xE2\xE3\xE4\xE5\xE6\xE7\xE8\xE9\xEA\xEB\xEC\xED\xEE\xEF\xF0\xF1\xF2\xF3\xF4\xF5\xF6\xF7\xF8\xF9\xFA\xFB\xFC\xFD\xFE\xFF"
+ },
+ "cp28605": "iso885915",
+ "iso885916": {
+ "type": "_sbcs",
+ "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\u0104\u0105\u0141\u20AC\u201E\u0160\xA7\u0161\xA9\u0218\xAB\u0179\xAD\u017A\u017B\xB0\xB1\u010C\u0142\u017D\u201D\xB6\xB7\u017E\u010D\u0219\xBB\u0152\u0153\u0178\u017C\xC0\xC1\xC2\u0102\xC4\u0106\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF\u0110\u0143\xD2\xD3\xD4\u0150\xD6\u015A\u0170\xD9\xDA\xDB\xDC\u0118\u021A\xDF\xE0\xE1\xE2\u0103\xE4\u0107\xE6\xE7\xE8\xE9\xEA\xEB\xEC\xED\xEE\xEF\u0111\u0144\xF2\xF3\xF4\u0151\xF6\u015B\u0171\xF9\xFA\xFB\xFC\u0119\u021B\xFF"
+ },
+ "cp28606": "iso885916",
+ "cp437": {
+ "type": "_sbcs",
+ "chars": "\xC7\xFC\xE9\xE2\xE4\xE0\xE5\xE7\xEA\xEB\xE8\xEF\xEE\xEC\xC4\xC5\xC9\xE6\xC6\xF4\xF6\xF2\xFB\xF9\xFF\xD6\xDC\xA2\xA3\xA5\u20A7\u0192\xE1\xED\xF3\xFA\xF1\xD1\xAA\xBA\xBF\u2310\xAC\xBD\xBC\xA1\xAB\xBB\u2591\u2592\u2593\u2502\u2524\u2561\u2562\u2556\u2555\u2563\u2551\u2557\u255D\u255C\u255B\u2510\u2514\u2534\u252C\u251C\u2500\u253C\u255E\u255F\u255A\u2554\u2569\u2566\u2560\u2550\u256C\u2567\u2568\u2564\u2565\u2559\u2558\u2552\u2553\u256B\u256A\u2518\u250C\u2588\u2584\u258C\u2590\u2580\u03B1\xDF\u0393\u03C0\u03A3\u03C3\xB5\u03C4\u03A6\u0398\u03A9\u03B4\u221E\u03C6\u03B5\u2229\u2261\xB1\u2265\u2264\u2320\u2321\xF7\u2248\xB0\u2219\xB7\u221A\u207F\xB2\u25A0\xA0"
+ },
+ "ibm437": "cp437",
+ "csibm437": "cp437",
+ "cp737": {
+ "type": "_sbcs",
+ "chars": "\u0391\u0392\u0393\u0394\u0395\u0396\u0397\u0398\u0399\u039A\u039B\u039C\u039D\u039E\u039F\u03A0\u03A1\u03A3\u03A4\u03A5\u03A6\u03A7\u03A8\u03A9\u03B1\u03B2\u03B3\u03B4\u03B5\u03B6\u03B7\u03B8\u03B9\u03BA\u03BB\u03BC\u03BD\u03BE\u03BF\u03C0\u03C1\u03C3\u03C2\u03C4\u03C5\u03C6\u03C7\u03C8\u2591\u2592\u2593\u2502\u2524\u2561\u2562\u2556\u2555\u2563\u2551\u2557\u255D\u255C\u255B\u2510\u2514\u2534\u252C\u251C\u2500\u253C\u255E\u255F\u255A\u2554\u2569\u2566\u2560\u2550\u256C\u2567\u2568\u2564\u2565\u2559\u2558\u2552\u2553\u256B\u256A\u2518\u250C\u2588\u2584\u258C\u2590\u2580\u03C9\u03AC\u03AD\u03AE\u03CA\u03AF\u03CC\u03CD\u03CB\u03CE\u0386\u0388\u0389\u038A\u038C\u038E\u038F\xB1\u2265\u2264\u03AA\u03AB\xF7\u2248\xB0\u2219\xB7\u221A\u207F\xB2\u25A0\xA0"
+ },
+ "ibm737": "cp737",
+ "csibm737": "cp737",
+ "cp775": {
+ "type": "_sbcs",
+ "chars": "\u0106\xFC\xE9\u0101\xE4\u0123\xE5\u0107\u0142\u0113\u0156\u0157\u012B\u0179\xC4\xC5\xC9\xE6\xC6\u014D\xF6\u0122\xA2\u015A\u015B\xD6\xDC\xF8\xA3\xD8\xD7\xA4\u0100\u012A\xF3\u017B\u017C\u017A\u201D\xA6\xA9\xAE\xAC\xBD\xBC\u0141\xAB\xBB\u2591\u2592\u2593\u2502\u2524\u0104\u010C\u0118\u0116\u2563\u2551\u2557\u255D\u012E\u0160\u2510\u2514\u2534\u252C\u251C\u2500\u253C\u0172\u016A\u255A\u2554\u2569\u2566\u2560\u2550\u256C\u017D\u0105\u010D\u0119\u0117\u012F\u0161\u0173\u016B\u017E\u2518\u250C\u2588\u2584\u258C\u2590\u2580\xD3\xDF\u014C\u0143\xF5\xD5\xB5\u0144\u0136\u0137\u013B\u013C\u0146\u0112\u0145\u2019\xAD\xB1\u201C\xBE\xB6\xA7\xF7\u201E\xB0\u2219\xB7\xB9\xB3\xB2\u25A0\xA0"
+ },
+ "ibm775": "cp775",
+ "csibm775": "cp775",
+ "cp850": {
+ "type": "_sbcs",
+ "chars": "\xC7\xFC\xE9\xE2\xE4\xE0\xE5\xE7\xEA\xEB\xE8\xEF\xEE\xEC\xC4\xC5\xC9\xE6\xC6\xF4\xF6\xF2\xFB\xF9\xFF\xD6\xDC\xF8\xA3\xD8\xD7\u0192\xE1\xED\xF3\xFA\xF1\xD1\xAA\xBA\xBF\xAE\xAC\xBD\xBC\xA1\xAB\xBB\u2591\u2592\u2593\u2502\u2524\xC1\xC2\xC0\xA9\u2563\u2551\u2557\u255D\xA2\xA5\u2510\u2514\u2534\u252C\u251C\u2500\u253C\xE3\xC3\u255A\u2554\u2569\u2566\u2560\u2550\u256C\xA4\xF0\xD0\xCA\xCB\xC8\u0131\xCD\xCE\xCF\u2518\u250C\u2588\u2584\xA6\xCC\u2580\xD3\xDF\xD4\xD2\xF5\xD5\xB5\xFE\xDE\xDA\xDB\xD9\xFD\xDD\xAF\xB4\xAD\xB1\u2017\xBE\xB6\xA7\xF7\xB8\xB0\xA8\xB7\xB9\xB3\xB2\u25A0\xA0"
+ },
+ "ibm850": "cp850",
+ "csibm850": "cp850",
+ "cp852": {
+ "type": "_sbcs",
+ "chars": "\xC7\xFC\xE9\xE2\xE4\u016F\u0107\xE7\u0142\xEB\u0150\u0151\xEE\u0179\xC4\u0106\xC9\u0139\u013A\xF4\xF6\u013D\u013E\u015A\u015B\xD6\xDC\u0164\u0165\u0141\xD7\u010D\xE1\xED\xF3\xFA\u0104\u0105\u017D\u017E\u0118\u0119\xAC\u017A\u010C\u015F\xAB\xBB\u2591\u2592\u2593\u2502\u2524\xC1\xC2\u011A\u015E\u2563\u2551\u2557\u255D\u017B\u017C\u2510\u2514\u2534\u252C\u251C\u2500\u253C\u0102\u0103\u255A\u2554\u2569\u2566\u2560\u2550\u256C\xA4\u0111\u0110\u010E\xCB\u010F\u0147\xCD\xCE\u011B\u2518\u250C\u2588\u2584\u0162\u016E\u2580\xD3\xDF\xD4\u0143\u0144\u0148\u0160\u0161\u0154\xDA\u0155\u0170\xFD\xDD\u0163\xB4\xAD\u02DD\u02DB\u02C7\u02D8\xA7\xF7\xB8\xB0\xA8\u02D9\u0171\u0158\u0159\u25A0\xA0"
+ },
+ "ibm852": "cp852",
+ "csibm852": "cp852",
+ "cp855": {
+ "type": "_sbcs",
+ "chars": "\u0452\u0402\u0453\u0403\u0451\u0401\u0454\u0404\u0455\u0405\u0456\u0406\u0457\u0407\u0458\u0408\u0459\u0409\u045A\u040A\u045B\u040B\u045C\u040C\u045E\u040E\u045F\u040F\u044E\u042E\u044A\u042A\u0430\u0410\u0431\u0411\u0446\u0426\u0434\u0414\u0435\u0415\u0444\u0424\u0433\u0413\xAB\xBB\u2591\u2592\u2593\u2502\u2524\u0445\u0425\u0438\u0418\u2563\u2551\u2557\u255D\u0439\u0419\u2510\u2514\u2534\u252C\u251C\u2500\u253C\u043A\u041A\u255A\u2554\u2569\u2566\u2560\u2550\u256C\xA4\u043B\u041B\u043C\u041C\u043D\u041D\u043E\u041E\u043F\u2518\u250C\u2588\u2584\u041F\u044F\u2580\u042F\u0440\u0420\u0441\u0421\u0442\u0422\u0443\u0423\u0436\u0416\u0432\u0412\u044C\u042C\u2116\xAD\u044B\u042B\u0437\u0417\u0448\u0428\u044D\u042D\u0449\u0429\u0447\u0427\xA7\u25A0\xA0"
+ },
+ "ibm855": "cp855",
+ "csibm855": "cp855",
+ "cp856": {
+ "type": "_sbcs",
+ "chars": "\u05D0\u05D1\u05D2\u05D3\u05D4\u05D5\u05D6\u05D7\u05D8\u05D9\u05DA\u05DB\u05DC\u05DD\u05DE\u05DF\u05E0\u05E1\u05E2\u05E3\u05E4\u05E5\u05E6\u05E7\u05E8\u05E9\u05EA\uFFFD\xA3\uFFFD\xD7\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\xAE\xAC\xBD\xBC\uFFFD\xAB\xBB\u2591\u2592\u2593\u2502\u2524\uFFFD\uFFFD\uFFFD\xA9\u2563\u2551\u2557\u255D\xA2\xA5\u2510\u2514\u2534\u252C\u251C\u2500\u253C\uFFFD\uFFFD\u255A\u2554\u2569\u2566\u2560\u2550\u256C\xA4\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\u2518\u250C\u2588\u2584\xA6\uFFFD\u2580\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\xB5\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\xAF\xB4\xAD\xB1\u2017\xBE\xB6\xA7\xF7\xB8\xB0\xA8\xB7\xB9\xB3\xB2\u25A0\xA0"
+ },
+ "ibm856": "cp856",
+ "csibm856": "cp856",
+ "cp857": {
+ "type": "_sbcs",
+ "chars": "\xC7\xFC\xE9\xE2\xE4\xE0\xE5\xE7\xEA\xEB\xE8\xEF\xEE\u0131\xC4\xC5\xC9\xE6\xC6\xF4\xF6\xF2\xFB\xF9\u0130\xD6\xDC\xF8\xA3\xD8\u015E\u015F\xE1\xED\xF3\xFA\xF1\xD1\u011E\u011F\xBF\xAE\xAC\xBD\xBC\xA1\xAB\xBB\u2591\u2592\u2593\u2502\u2524\xC1\xC2\xC0\xA9\u2563\u2551\u2557\u255D\xA2\xA5\u2510\u2514\u2534\u252C\u251C\u2500\u253C\xE3\xC3\u255A\u2554\u2569\u2566\u2560\u2550\u256C\xA4\xBA\xAA\xCA\xCB\xC8\uFFFD\xCD\xCE\xCF\u2518\u250C\u2588\u2584\xA6\xCC\u2580\xD3\xDF\xD4\xD2\xF5\xD5\xB5\uFFFD\xD7\xDA\xDB\xD9\xEC\xFF\xAF\xB4\xAD\xB1\uFFFD\xBE\xB6\xA7\xF7\xB8\xB0\xA8\xB7\xB9\xB3\xB2\u25A0\xA0"
+ },
+ "ibm857": "cp857",
+ "csibm857": "cp857",
+ "cp858": {
+ "type": "_sbcs",
+ "chars": "\xC7\xFC\xE9\xE2\xE4\xE0\xE5\xE7\xEA\xEB\xE8\xEF\xEE\xEC\xC4\xC5\xC9\xE6\xC6\xF4\xF6\xF2\xFB\xF9\xFF\xD6\xDC\xF8\xA3\xD8\xD7\u0192\xE1\xED\xF3\xFA\xF1\xD1\xAA\xBA\xBF\xAE\xAC\xBD\xBC\xA1\xAB\xBB\u2591\u2592\u2593\u2502\u2524\xC1\xC2\xC0\xA9\u2563\u2551\u2557\u255D\xA2\xA5\u2510\u2514\u2534\u252C\u251C\u2500\u253C\xE3\xC3\u255A\u2554\u2569\u2566\u2560\u2550\u256C\xA4\xF0\xD0\xCA\xCB\xC8\u20AC\xCD\xCE\xCF\u2518\u250C\u2588\u2584\xA6\xCC\u2580\xD3\xDF\xD4\xD2\xF5\xD5\xB5\xFE\xDE\xDA\xDB\xD9\xFD\xDD\xAF\xB4\xAD\xB1\u2017\xBE\xB6\xA7\xF7\xB8\xB0\xA8\xB7\xB9\xB3\xB2\u25A0\xA0"
+ },
+ "ibm858": "cp858",
+ "csibm858": "cp858",
+ "cp860": {
+ "type": "_sbcs",
+ "chars": "\xC7\xFC\xE9\xE2\xE3\xE0\xC1\xE7\xEA\xCA\xE8\xCD\xD4\xEC\xC3\xC2\xC9\xC0\xC8\xF4\xF5\xF2\xDA\xF9\xCC\xD5\xDC\xA2\xA3\xD9\u20A7\xD3\xE1\xED\xF3\xFA\xF1\xD1\xAA\xBA\xBF\xD2\xAC\xBD\xBC\xA1\xAB\xBB\u2591\u2592\u2593\u2502\u2524\u2561\u2562\u2556\u2555\u2563\u2551\u2557\u255D\u255C\u255B\u2510\u2514\u2534\u252C\u251C\u2500\u253C\u255E\u255F\u255A\u2554\u2569\u2566\u2560\u2550\u256C\u2567\u2568\u2564\u2565\u2559\u2558\u2552\u2553\u256B\u256A\u2518\u250C\u2588\u2584\u258C\u2590\u2580\u03B1\xDF\u0393\u03C0\u03A3\u03C3\xB5\u03C4\u03A6\u0398\u03A9\u03B4\u221E\u03C6\u03B5\u2229\u2261\xB1\u2265\u2264\u2320\u2321\xF7\u2248\xB0\u2219\xB7\u221A\u207F\xB2\u25A0\xA0"
+ },
+ "ibm860": "cp860",
+ "csibm860": "cp860",
+ "cp861": {
+ "type": "_sbcs",
+ "chars": "\xC7\xFC\xE9\xE2\xE4\xE0\xE5\xE7\xEA\xEB\xE8\xD0\xF0\xDE\xC4\xC5\xC9\xE6\xC6\xF4\xF6\xFE\xFB\xDD\xFD\xD6\xDC\xF8\xA3\xD8\u20A7\u0192\xE1\xED\xF3\xFA\xC1\xCD\xD3\xDA\xBF\u2310\xAC\xBD\xBC\xA1\xAB\xBB\u2591\u2592\u2593\u2502\u2524\u2561\u2562\u2556\u2555\u2563\u2551\u2557\u255D\u255C\u255B\u2510\u2514\u2534\u252C\u251C\u2500\u253C\u255E\u255F\u255A\u2554\u2569\u2566\u2560\u2550\u256C\u2567\u2568\u2564\u2565\u2559\u2558\u2552\u2553\u256B\u256A\u2518\u250C\u2588\u2584\u258C\u2590\u2580\u03B1\xDF\u0393\u03C0\u03A3\u03C3\xB5\u03C4\u03A6\u0398\u03A9\u03B4\u221E\u03C6\u03B5\u2229\u2261\xB1\u2265\u2264\u2320\u2321\xF7\u2248\xB0\u2219\xB7\u221A\u207F\xB2\u25A0\xA0"
+ },
+ "ibm861": "cp861",
+ "csibm861": "cp861",
+ "cp862": {
+ "type": "_sbcs",
+ "chars": "\u05D0\u05D1\u05D2\u05D3\u05D4\u05D5\u05D6\u05D7\u05D8\u05D9\u05DA\u05DB\u05DC\u05DD\u05DE\u05DF\u05E0\u05E1\u05E2\u05E3\u05E4\u05E5\u05E6\u05E7\u05E8\u05E9\u05EA\xA2\xA3\xA5\u20A7\u0192\xE1\xED\xF3\xFA\xF1\xD1\xAA\xBA\xBF\u2310\xAC\xBD\xBC\xA1\xAB\xBB\u2591\u2592\u2593\u2502\u2524\u2561\u2562\u2556\u2555\u2563\u2551\u2557\u255D\u255C\u255B\u2510\u2514\u2534\u252C\u251C\u2500\u253C\u255E\u255F\u255A\u2554\u2569\u2566\u2560\u2550\u256C\u2567\u2568\u2564\u2565\u2559\u2558\u2552\u2553\u256B\u256A\u2518\u250C\u2588\u2584\u258C\u2590\u2580\u03B1\xDF\u0393\u03C0\u03A3\u03C3\xB5\u03C4\u03A6\u0398\u03A9\u03B4\u221E\u03C6\u03B5\u2229\u2261\xB1\u2265\u2264\u2320\u2321\xF7\u2248\xB0\u2219\xB7\u221A\u207F\xB2\u25A0\xA0"
+ },
+ "ibm862": "cp862",
+ "csibm862": "cp862",
+ "cp863": {
+ "type": "_sbcs",
+ "chars": "\xC7\xFC\xE9\xE2\xC2\xE0\xB6\xE7\xEA\xEB\xE8\xEF\xEE\u2017\xC0\xA7\xC9\xC8\xCA\xF4\xCB\xCF\xFB\xF9\xA4\xD4\xDC\xA2\xA3\xD9\xDB\u0192\xA6\xB4\xF3\xFA\xA8\xB8\xB3\xAF\xCE\u2310\xAC\xBD\xBC\xBE\xAB\xBB\u2591\u2592\u2593\u2502\u2524\u2561\u2562\u2556\u2555\u2563\u2551\u2557\u255D\u255C\u255B\u2510\u2514\u2534\u252C\u251C\u2500\u253C\u255E\u255F\u255A\u2554\u2569\u2566\u2560\u2550\u256C\u2567\u2568\u2564\u2565\u2559\u2558\u2552\u2553\u256B\u256A\u2518\u250C\u2588\u2584\u258C\u2590\u2580\u03B1\xDF\u0393\u03C0\u03A3\u03C3\xB5\u03C4\u03A6\u0398\u03A9\u03B4\u221E\u03C6\u03B5\u2229\u2261\xB1\u2265\u2264\u2320\u2321\xF7\u2248\xB0\u2219\xB7\u221A\u207F\xB2\u25A0\xA0"
+ },
+ "ibm863": "cp863",
+ "csibm863": "cp863",
+ "cp864": {
+ "type": "_sbcs",
+ "chars": "\0\x07\b \n\v\f\r\x1B !\"#$\u066A&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\x7F\xB0\xB7\u2219\u221A\u2592\u2500\u2502\u253C\u2524\u252C\u251C\u2534\u2510\u250C\u2514\u2518\u03B2\u221E\u03C6\xB1\xBD\xBC\u2248\xAB\xBB\uFEF7\uFEF8\uFFFD\uFFFD\uFEFB\uFEFC\uFFFD\xA0\xAD\uFE82\xA3\xA4\uFE84\uFFFD\uFFFD\uFE8E\uFE8F\uFE95\uFE99\u060C\uFE9D\uFEA1\uFEA5\u0660\u0661\u0662\u0663\u0664\u0665\u0666\u0667\u0668\u0669\uFED1\u061B\uFEB1\uFEB5\uFEB9\u061F\xA2\uFE80\uFE81\uFE83\uFE85\uFECA\uFE8B\uFE8D\uFE91\uFE93\uFE97\uFE9B\uFE9F\uFEA3\uFEA7\uFEA9\uFEAB\uFEAD\uFEAF\uFEB3\uFEB7\uFEBB\uFEBF\uFEC1\uFEC5\uFECB\uFECF\xA6\xAC\xF7\xD7\uFEC9\u0640\uFED3\uFED7\uFEDB\uFEDF\uFEE3\uFEE7\uFEEB\uFEED\uFEEF\uFEF3\uFEBD\uFECC\uFECE\uFECD\uFEE1\uFE7D\u0651\uFEE5\uFEE9\uFEEC\uFEF0\uFEF2\uFED0\uFED5\uFEF5\uFEF6\uFEDD\uFED9\uFEF1\u25A0\uFFFD"
+ },
+ "ibm864": "cp864",
+ "csibm864": "cp864",
+ "cp865": {
+ "type": "_sbcs",
+ "chars": "\xC7\xFC\xE9\xE2\xE4\xE0\xE5\xE7\xEA\xEB\xE8\xEF\xEE\xEC\xC4\xC5\xC9\xE6\xC6\xF4\xF6\xF2\xFB\xF9\xFF\xD6\xDC\xF8\xA3\xD8\u20A7\u0192\xE1\xED\xF3\xFA\xF1\xD1\xAA\xBA\xBF\u2310\xAC\xBD\xBC\xA1\xAB\xA4\u2591\u2592\u2593\u2502\u2524\u2561\u2562\u2556\u2555\u2563\u2551\u2557\u255D\u255C\u255B\u2510\u2514\u2534\u252C\u251C\u2500\u253C\u255E\u255F\u255A\u2554\u2569\u2566\u2560\u2550\u256C\u2567\u2568\u2564\u2565\u2559\u2558\u2552\u2553\u256B\u256A\u2518\u250C\u2588\u2584\u258C\u2590\u2580\u03B1\xDF\u0393\u03C0\u03A3\u03C3\xB5\u03C4\u03A6\u0398\u03A9\u03B4\u221E\u03C6\u03B5\u2229\u2261\xB1\u2265\u2264\u2320\u2321\xF7\u2248\xB0\u2219\xB7\u221A\u207F\xB2\u25A0\xA0"
+ },
+ "ibm865": "cp865",
+ "csibm865": "cp865",
+ "cp866": {
+ "type": "_sbcs",
+ "chars": "\u0410\u0411\u0412\u0413\u0414\u0415\u0416\u0417\u0418\u0419\u041A\u041B\u041C\u041D\u041E\u041F\u0420\u0421\u0422\u0423\u0424\u0425\u0426\u0427\u0428\u0429\u042A\u042B\u042C\u042D\u042E\u042F\u0430\u0431\u0432\u0433\u0434\u0435\u0436\u0437\u0438\u0439\u043A\u043B\u043C\u043D\u043E\u043F\u2591\u2592\u2593\u2502\u2524\u2561\u2562\u2556\u2555\u2563\u2551\u2557\u255D\u255C\u255B\u2510\u2514\u2534\u252C\u251C\u2500\u253C\u255E\u255F\u255A\u2554\u2569\u2566\u2560\u2550\u256C\u2567\u2568\u2564\u2565\u2559\u2558\u2552\u2553\u256B\u256A\u2518\u250C\u2588\u2584\u258C\u2590\u2580\u0440\u0441\u0442\u0443\u0444\u0445\u0446\u0447\u0448\u0449\u044A\u044B\u044C\u044D\u044E\u044F\u0401\u0451\u0404\u0454\u0407\u0457\u040E\u045E\xB0\u2219\xB7\u221A\u2116\xA4\u25A0\xA0"
+ },
+ "ibm866": "cp866",
+ "csibm866": "cp866",
+ "cp869": {
+ "type": "_sbcs",
+ "chars": "\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\u0386\uFFFD\xB7\xAC\xA6\u2018\u2019\u0388\u2015\u0389\u038A\u03AA\u038C\uFFFD\uFFFD\u038E\u03AB\xA9\u038F\xB2\xB3\u03AC\xA3\u03AD\u03AE\u03AF\u03CA\u0390\u03CC\u03CD\u0391\u0392\u0393\u0394\u0395\u0396\u0397\xBD\u0398\u0399\xAB\xBB\u2591\u2592\u2593\u2502\u2524\u039A\u039B\u039C\u039D\u2563\u2551\u2557\u255D\u039E\u039F\u2510\u2514\u2534\u252C\u251C\u2500\u253C\u03A0\u03A1\u255A\u2554\u2569\u2566\u2560\u2550\u256C\u03A3\u03A4\u03A5\u03A6\u03A7\u03A8\u03A9\u03B1\u03B2\u03B3\u2518\u250C\u2588\u2584\u03B4\u03B5\u2580\u03B6\u03B7\u03B8\u03B9\u03BA\u03BB\u03BC\u03BD\u03BE\u03BF\u03C0\u03C1\u03C3\u03C2\u03C4\u0384\xAD\xB1\u03C5\u03C6\u03C7\xA7\u03C8\u0385\xB0\xA8\u03C9\u03CB\u03B0\u03CE\u25A0\xA0"
+ },
+ "ibm869": "cp869",
+ "csibm869": "cp869",
+ "cp922": {
+ "type": "_sbcs",
+ "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\xA1\xA2\xA3\xA4\xA5\xA6\xA7\xA8\xA9\xAA\xAB\xAC\xAD\xAE\u203E\xB0\xB1\xB2\xB3\xB4\xB5\xB6\xB7\xB8\xB9\xBA\xBB\xBC\xBD\xBE\xBF\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF\u0160\xD1\xD2\xD3\xD4\xD5\xD6\xD7\xD8\xD9\xDA\xDB\xDC\xDD\u017D\xDF\xE0\xE1\xE2\xE3\xE4\xE5\xE6\xE7\xE8\xE9\xEA\xEB\xEC\xED\xEE\xEF\u0161\xF1\xF2\xF3\xF4\xF5\xF6\xF7\xF8\xF9\xFA\xFB\xFC\xFD\u017E\xFF"
+ },
+ "ibm922": "cp922",
+ "csibm922": "cp922",
+ "cp1046": {
+ "type": "_sbcs",
+ "chars": "\uFE88\xD7\xF7\uF8F6\uF8F5\uF8F4\uF8F7\uFE71\x88\u25A0\u2502\u2500\u2510\u250C\u2514\u2518\uFE79\uFE7B\uFE7D\uFE7F\uFE77\uFE8A\uFEF0\uFEF3\uFEF2\uFECE\uFECF\uFED0\uFEF6\uFEF8\uFEFA\uFEFC\xA0\uF8FA\uF8F9\uF8F8\xA4\uF8FB\uFE8B\uFE91\uFE97\uFE9B\uFE9F\uFEA3\u060C\xAD\uFEA7\uFEB3\u0660\u0661\u0662\u0663\u0664\u0665\u0666\u0667\u0668\u0669\uFEB7\u061B\uFEBB\uFEBF\uFECA\u061F\uFECB\u0621\u0622\u0623\u0624\u0625\u0626\u0627\u0628\u0629\u062A\u062B\u062C\u062D\u062E\u062F\u0630\u0631\u0632\u0633\u0634\u0635\u0636\u0637\uFEC7\u0639\u063A\uFECC\uFE82\uFE84\uFE8E\uFED3\u0640\u0641\u0642\u0643\u0644\u0645\u0646\u0647\u0648\u0649\u064A\u064B\u064C\u064D\u064E\u064F\u0650\u0651\u0652\uFED7\uFEDB\uFEDF\uF8FC\uFEF5\uFEF7\uFEF9\uFEFB\uFEE3\uFEE7\uFEEC\uFEE9\uFFFD"
+ },
+ "ibm1046": "cp1046",
+ "csibm1046": "cp1046",
+ "cp1124": {
+ "type": "_sbcs",
+ "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\u0401\u0402\u0490\u0404\u0405\u0406\u0407\u0408\u0409\u040A\u040B\u040C\xAD\u040E\u040F\u0410\u0411\u0412\u0413\u0414\u0415\u0416\u0417\u0418\u0419\u041A\u041B\u041C\u041D\u041E\u041F\u0420\u0421\u0422\u0423\u0424\u0425\u0426\u0427\u0428\u0429\u042A\u042B\u042C\u042D\u042E\u042F\u0430\u0431\u0432\u0433\u0434\u0435\u0436\u0437\u0438\u0439\u043A\u043B\u043C\u043D\u043E\u043F\u0440\u0441\u0442\u0443\u0444\u0445\u0446\u0447\u0448\u0449\u044A\u044B\u044C\u044D\u044E\u044F\u2116\u0451\u0452\u0491\u0454\u0455\u0456\u0457\u0458\u0459\u045A\u045B\u045C\xA7\u045E\u045F"
+ },
+ "ibm1124": "cp1124",
+ "csibm1124": "cp1124",
+ "cp1125": {
+ "type": "_sbcs",
+ "chars": "\u0410\u0411\u0412\u0413\u0414\u0415\u0416\u0417\u0418\u0419\u041A\u041B\u041C\u041D\u041E\u041F\u0420\u0421\u0422\u0423\u0424\u0425\u0426\u0427\u0428\u0429\u042A\u042B\u042C\u042D\u042E\u042F\u0430\u0431\u0432\u0433\u0434\u0435\u0436\u0437\u0438\u0439\u043A\u043B\u043C\u043D\u043E\u043F\u2591\u2592\u2593\u2502\u2524\u2561\u2562\u2556\u2555\u2563\u2551\u2557\u255D\u255C\u255B\u2510\u2514\u2534\u252C\u251C\u2500\u253C\u255E\u255F\u255A\u2554\u2569\u2566\u2560\u2550\u256C\u2567\u2568\u2564\u2565\u2559\u2558\u2552\u2553\u256B\u256A\u2518\u250C\u2588\u2584\u258C\u2590\u2580\u0440\u0441\u0442\u0443\u0444\u0445\u0446\u0447\u0448\u0449\u044A\u044B\u044C\u044D\u044E\u044F\u0401\u0451\u0490\u0491\u0404\u0454\u0406\u0456\u0407\u0457\xB7\u221A\u2116\xA4\u25A0\xA0"
+ },
+ "ibm1125": "cp1125",
+ "csibm1125": "cp1125",
+ "cp1129": {
+ "type": "_sbcs",
+ "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\xA1\xA2\xA3\xA4\xA5\xA6\xA7\u0153\xA9\xAA\xAB\xAC\xAD\xAE\xAF\xB0\xB1\xB2\xB3\u0178\xB5\xB6\xB7\u0152\xB9\xBA\xBB\xBC\xBD\xBE\xBF\xC0\xC1\xC2\u0102\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\u0300\xCD\xCE\xCF\u0110\xD1\u0309\xD3\xD4\u01A0\xD6\xD7\xD8\xD9\xDA\xDB\xDC\u01AF\u0303\xDF\xE0\xE1\xE2\u0103\xE4\xE5\xE6\xE7\xE8\xE9\xEA\xEB\u0301\xED\xEE\xEF\u0111\xF1\u0323\xF3\xF4\u01A1\xF6\xF7\xF8\xF9\xFA\xFB\xFC\u01B0\u20AB\xFF"
+ },
+ "ibm1129": "cp1129",
+ "csibm1129": "cp1129",
+ "cp1133": {
+ "type": "_sbcs",
+ "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\u0E81\u0E82\u0E84\u0E87\u0E88\u0EAA\u0E8A\u0E8D\u0E94\u0E95\u0E96\u0E97\u0E99\u0E9A\u0E9B\u0E9C\u0E9D\u0E9E\u0E9F\u0EA1\u0EA2\u0EA3\u0EA5\u0EA7\u0EAB\u0EAD\u0EAE\uFFFD\uFFFD\uFFFD\u0EAF\u0EB0\u0EB2\u0EB3\u0EB4\u0EB5\u0EB6\u0EB7\u0EB8\u0EB9\u0EBC\u0EB1\u0EBB\u0EBD\uFFFD\uFFFD\uFFFD\u0EC0\u0EC1\u0EC2\u0EC3\u0EC4\u0EC8\u0EC9\u0ECA\u0ECB\u0ECC\u0ECD\u0EC6\uFFFD\u0EDC\u0EDD\u20AD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\u0ED0\u0ED1\u0ED2\u0ED3\u0ED4\u0ED5\u0ED6\u0ED7\u0ED8\u0ED9\uFFFD\uFFFD\xA2\xAC\xA6\uFFFD"
+ },
+ "ibm1133": "cp1133",
+ "csibm1133": "cp1133",
+ "cp1161": {
+ "type": "_sbcs",
+ "chars": "\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\u0E48\u0E01\u0E02\u0E03\u0E04\u0E05\u0E06\u0E07\u0E08\u0E09\u0E0A\u0E0B\u0E0C\u0E0D\u0E0E\u0E0F\u0E10\u0E11\u0E12\u0E13\u0E14\u0E15\u0E16\u0E17\u0E18\u0E19\u0E1A\u0E1B\u0E1C\u0E1D\u0E1E\u0E1F\u0E20\u0E21\u0E22\u0E23\u0E24\u0E25\u0E26\u0E27\u0E28\u0E29\u0E2A\u0E2B\u0E2C\u0E2D\u0E2E\u0E2F\u0E30\u0E31\u0E32\u0E33\u0E34\u0E35\u0E36\u0E37\u0E38\u0E39\u0E3A\u0E49\u0E4A\u0E4B\u20AC\u0E3F\u0E40\u0E41\u0E42\u0E43\u0E44\u0E45\u0E46\u0E47\u0E48\u0E49\u0E4A\u0E4B\u0E4C\u0E4D\u0E4E\u0E4F\u0E50\u0E51\u0E52\u0E53\u0E54\u0E55\u0E56\u0E57\u0E58\u0E59\u0E5A\u0E5B\xA2\xAC\xA6\xA0"
+ },
+ "ibm1161": "cp1161",
+ "csibm1161": "cp1161",
+ "cp1162": {
+ "type": "_sbcs",
+ "chars": "\u20AC\x81\x82\x83\x84\u2026\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\u2018\u2019\u201C\u201D\u2022\u2013\u2014\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\u0E01\u0E02\u0E03\u0E04\u0E05\u0E06\u0E07\u0E08\u0E09\u0E0A\u0E0B\u0E0C\u0E0D\u0E0E\u0E0F\u0E10\u0E11\u0E12\u0E13\u0E14\u0E15\u0E16\u0E17\u0E18\u0E19\u0E1A\u0E1B\u0E1C\u0E1D\u0E1E\u0E1F\u0E20\u0E21\u0E22\u0E23\u0E24\u0E25\u0E26\u0E27\u0E28\u0E29\u0E2A\u0E2B\u0E2C\u0E2D\u0E2E\u0E2F\u0E30\u0E31\u0E32\u0E33\u0E34\u0E35\u0E36\u0E37\u0E38\u0E39\u0E3A\uFFFD\uFFFD\uFFFD\uFFFD\u0E3F\u0E40\u0E41\u0E42\u0E43\u0E44\u0E45\u0E46\u0E47\u0E48\u0E49\u0E4A\u0E4B\u0E4C\u0E4D\u0E4E\u0E4F\u0E50\u0E51\u0E52\u0E53\u0E54\u0E55\u0E56\u0E57\u0E58\u0E59\u0E5A\u0E5B\uFFFD\uFFFD\uFFFD\uFFFD"
+ },
+ "ibm1162": "cp1162",
+ "csibm1162": "cp1162",
+ "cp1163": {
+ "type": "_sbcs",
+ "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\xA1\xA2\xA3\u20AC\xA5\xA6\xA7\u0153\xA9\xAA\xAB\xAC\xAD\xAE\xAF\xB0\xB1\xB2\xB3\u0178\xB5\xB6\xB7\u0152\xB9\xBA\xBB\xBC\xBD\xBE\xBF\xC0\xC1\xC2\u0102\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\u0300\xCD\xCE\xCF\u0110\xD1\u0309\xD3\xD4\u01A0\xD6\xD7\xD8\xD9\xDA\xDB\xDC\u01AF\u0303\xDF\xE0\xE1\xE2\u0103\xE4\xE5\xE6\xE7\xE8\xE9\xEA\xEB\u0301\xED\xEE\xEF\u0111\xF1\u0323\xF3\xF4\u01A1\xF6\xF7\xF8\xF9\xFA\xFB\xFC\u01B0\u20AB\xFF"
+ },
+ "ibm1163": "cp1163",
+ "csibm1163": "cp1163",
+ "maccroatian": {
+ "type": "_sbcs",
+ "chars": "\xC4\xC5\xC7\xC9\xD1\xD6\xDC\xE1\xE0\xE2\xE4\xE3\xE5\xE7\xE9\xE8\xEA\xEB\xED\xEC\xEE\xEF\xF1\xF3\xF2\xF4\xF6\xF5\xFA\xF9\xFB\xFC\u2020\xB0\xA2\xA3\xA7\u2022\xB6\xDF\xAE\u0160\u2122\xB4\xA8\u2260\u017D\xD8\u221E\xB1\u2264\u2265\u2206\xB5\u2202\u2211\u220F\u0161\u222B\xAA\xBA\u2126\u017E\xF8\xBF\xA1\xAC\u221A\u0192\u2248\u0106\xAB\u010C\u2026\xA0\xC0\xC3\xD5\u0152\u0153\u0110\u2014\u201C\u201D\u2018\u2019\xF7\u25CA\uFFFD\xA9\u2044\xA4\u2039\u203A\xC6\xBB\u2013\xB7\u201A\u201E\u2030\xC2\u0107\xC1\u010D\xC8\xCD\xCE\xCF\xCC\xD3\xD4\u0111\xD2\xDA\xDB\xD9\u0131\u02C6\u02DC\xAF\u03C0\xCB\u02DA\xB8\xCA\xE6\u02C7"
+ },
+ "maccyrillic": {
+ "type": "_sbcs",
+ "chars": "\u0410\u0411\u0412\u0413\u0414\u0415\u0416\u0417\u0418\u0419\u041A\u041B\u041C\u041D\u041E\u041F\u0420\u0421\u0422\u0423\u0424\u0425\u0426\u0427\u0428\u0429\u042A\u042B\u042C\u042D\u042E\u042F\u2020\xB0\xA2\xA3\xA7\u2022\xB6\u0406\xAE\xA9\u2122\u0402\u0452\u2260\u0403\u0453\u221E\xB1\u2264\u2265\u0456\xB5\u2202\u0408\u0404\u0454\u0407\u0457\u0409\u0459\u040A\u045A\u0458\u0405\xAC\u221A\u0192\u2248\u2206\xAB\xBB\u2026\xA0\u040B\u045B\u040C\u045C\u0455\u2013\u2014\u201C\u201D\u2018\u2019\xF7\u201E\u040E\u045E\u040F\u045F\u2116\u0401\u0451\u044F\u0430\u0431\u0432\u0433\u0434\u0435\u0436\u0437\u0438\u0439\u043A\u043B\u043C\u043D\u043E\u043F\u0440\u0441\u0442\u0443\u0444\u0445\u0446\u0447\u0448\u0449\u044A\u044B\u044C\u044D\u044E\xA4"
+ },
+ "macgreek": {
+ "type": "_sbcs",
+ "chars": "\xC4\xB9\xB2\xC9\xB3\xD6\xDC\u0385\xE0\xE2\xE4\u0384\xA8\xE7\xE9\xE8\xEA\xEB\xA3\u2122\xEE\xEF\u2022\xBD\u2030\xF4\xF6\xA6\xAD\xF9\xFB\xFC\u2020\u0393\u0394\u0398\u039B\u039E\u03A0\xDF\xAE\xA9\u03A3\u03AA\xA7\u2260\xB0\u0387\u0391\xB1\u2264\u2265\xA5\u0392\u0395\u0396\u0397\u0399\u039A\u039C\u03A6\u03AB\u03A8\u03A9\u03AC\u039D\xAC\u039F\u03A1\u2248\u03A4\xAB\xBB\u2026\xA0\u03A5\u03A7\u0386\u0388\u0153\u2013\u2015\u201C\u201D\u2018\u2019\xF7\u0389\u038A\u038C\u038E\u03AD\u03AE\u03AF\u03CC\u038F\u03CD\u03B1\u03B2\u03C8\u03B4\u03B5\u03C6\u03B3\u03B7\u03B9\u03BE\u03BA\u03BB\u03BC\u03BD\u03BF\u03C0\u03CE\u03C1\u03C3\u03C4\u03B8\u03C9\u03C2\u03C7\u03C5\u03B6\u03CA\u03CB\u0390\u03B0\uFFFD"
+ },
+ "maciceland": {
+ "type": "_sbcs",
+ "chars": "\xC4\xC5\xC7\xC9\xD1\xD6\xDC\xE1\xE0\xE2\xE4\xE3\xE5\xE7\xE9\xE8\xEA\xEB\xED\xEC\xEE\xEF\xF1\xF3\xF2\xF4\xF6\xF5\xFA\xF9\xFB\xFC\xDD\xB0\xA2\xA3\xA7\u2022\xB6\xDF\xAE\xA9\u2122\xB4\xA8\u2260\xC6\xD8\u221E\xB1\u2264\u2265\xA5\xB5\u2202\u2211\u220F\u03C0\u222B\xAA\xBA\u2126\xE6\xF8\xBF\xA1\xAC\u221A\u0192\u2248\u2206\xAB\xBB\u2026\xA0\xC0\xC3\xD5\u0152\u0153\u2013\u2014\u201C\u201D\u2018\u2019\xF7\u25CA\xFF\u0178\u2044\xA4\xD0\xF0\xDE\xFE\xFD\xB7\u201A\u201E\u2030\xC2\xCA\xC1\xCB\xC8\xCD\xCE\xCF\xCC\xD3\xD4\uFFFD\xD2\xDA\xDB\xD9\u0131\u02C6\u02DC\xAF\u02D8\u02D9\u02DA\xB8\u02DD\u02DB\u02C7"
+ },
+ "macroman": {
+ "type": "_sbcs",
+ "chars": "\xC4\xC5\xC7\xC9\xD1\xD6\xDC\xE1\xE0\xE2\xE4\xE3\xE5\xE7\xE9\xE8\xEA\xEB\xED\xEC\xEE\xEF\xF1\xF3\xF2\xF4\xF6\xF5\xFA\xF9\xFB\xFC\u2020\xB0\xA2\xA3\xA7\u2022\xB6\xDF\xAE\xA9\u2122\xB4\xA8\u2260\xC6\xD8\u221E\xB1\u2264\u2265\xA5\xB5\u2202\u2211\u220F\u03C0\u222B\xAA\xBA\u2126\xE6\xF8\xBF\xA1\xAC\u221A\u0192\u2248\u2206\xAB\xBB\u2026\xA0\xC0\xC3\xD5\u0152\u0153\u2013\u2014\u201C\u201D\u2018\u2019\xF7\u25CA\xFF\u0178\u2044\xA4\u2039\u203A\uFB01\uFB02\u2021\xB7\u201A\u201E\u2030\xC2\xCA\xC1\xCB\xC8\xCD\xCE\xCF\xCC\xD3\xD4\uFFFD\xD2\xDA\xDB\xD9\u0131\u02C6\u02DC\xAF\u02D8\u02D9\u02DA\xB8\u02DD\u02DB\u02C7"
+ },
+ "macromania": {
+ "type": "_sbcs",
+ "chars": "\xC4\xC5\xC7\xC9\xD1\xD6\xDC\xE1\xE0\xE2\xE4\xE3\xE5\xE7\xE9\xE8\xEA\xEB\xED\xEC\xEE\xEF\xF1\xF3\xF2\xF4\xF6\xF5\xFA\xF9\xFB\xFC\u2020\xB0\xA2\xA3\xA7\u2022\xB6\xDF\xAE\xA9\u2122\xB4\xA8\u2260\u0102\u015E\u221E\xB1\u2264\u2265\xA5\xB5\u2202\u2211\u220F\u03C0\u222B\xAA\xBA\u2126\u0103\u015F\xBF\xA1\xAC\u221A\u0192\u2248\u2206\xAB\xBB\u2026\xA0\xC0\xC3\xD5\u0152\u0153\u2013\u2014\u201C\u201D\u2018\u2019\xF7\u25CA\xFF\u0178\u2044\xA4\u2039\u203A\u0162\u0163\u2021\xB7\u201A\u201E\u2030\xC2\xCA\xC1\xCB\xC8\xCD\xCE\xCF\xCC\xD3\xD4\uFFFD\xD2\xDA\xDB\xD9\u0131\u02C6\u02DC\xAF\u02D8\u02D9\u02DA\xB8\u02DD\u02DB\u02C7"
+ },
+ "macthai": {
+ "type": "_sbcs",
+ "chars": "\xAB\xBB\u2026\uF88C\uF88F\uF892\uF895\uF898\uF88B\uF88E\uF891\uF894\uF897\u201C\u201D\uF899\uFFFD\u2022\uF884\uF889\uF885\uF886\uF887\uF888\uF88A\uF88D\uF890\uF893\uF896\u2018\u2019\uFFFD\xA0\u0E01\u0E02\u0E03\u0E04\u0E05\u0E06\u0E07\u0E08\u0E09\u0E0A\u0E0B\u0E0C\u0E0D\u0E0E\u0E0F\u0E10\u0E11\u0E12\u0E13\u0E14\u0E15\u0E16\u0E17\u0E18\u0E19\u0E1A\u0E1B\u0E1C\u0E1D\u0E1E\u0E1F\u0E20\u0E21\u0E22\u0E23\u0E24\u0E25\u0E26\u0E27\u0E28\u0E29\u0E2A\u0E2B\u0E2C\u0E2D\u0E2E\u0E2F\u0E30\u0E31\u0E32\u0E33\u0E34\u0E35\u0E36\u0E37\u0E38\u0E39\u0E3A\uFEFF\u200B\u2013\u2014\u0E3F\u0E40\u0E41\u0E42\u0E43\u0E44\u0E45\u0E46\u0E47\u0E48\u0E49\u0E4A\u0E4B\u0E4C\u0E4D\u2122\u0E4F\u0E50\u0E51\u0E52\u0E53\u0E54\u0E55\u0E56\u0E57\u0E58\u0E59\xAE\xA9\uFFFD\uFFFD\uFFFD\uFFFD"
+ },
+ "macturkish": {
+ "type": "_sbcs",
+ "chars": "\xC4\xC5\xC7\xC9\xD1\xD6\xDC\xE1\xE0\xE2\xE4\xE3\xE5\xE7\xE9\xE8\xEA\xEB\xED\xEC\xEE\xEF\xF1\xF3\xF2\xF4\xF6\xF5\xFA\xF9\xFB\xFC\u2020\xB0\xA2\xA3\xA7\u2022\xB6\xDF\xAE\xA9\u2122\xB4\xA8\u2260\xC6\xD8\u221E\xB1\u2264\u2265\xA5\xB5\u2202\u2211\u220F\u03C0\u222B\xAA\xBA\u2126\xE6\xF8\xBF\xA1\xAC\u221A\u0192\u2248\u2206\xAB\xBB\u2026\xA0\xC0\xC3\xD5\u0152\u0153\u2013\u2014\u201C\u201D\u2018\u2019\xF7\u25CA\xFF\u0178\u011E\u011F\u0130\u0131\u015E\u015F\u2021\xB7\u201A\u201E\u2030\xC2\xCA\xC1\xCB\xC8\xCD\xCE\xCF\xCC\xD3\xD4\uFFFD\xD2\xDA\xDB\xD9\uFFFD\u02C6\u02DC\xAF\u02D8\u02D9\u02DA\xB8\u02DD\u02DB\u02C7"
+ },
+ "macukraine": {
+ "type": "_sbcs",
+ "chars": "\u0410\u0411\u0412\u0413\u0414\u0415\u0416\u0417\u0418\u0419\u041A\u041B\u041C\u041D\u041E\u041F\u0420\u0421\u0422\u0423\u0424\u0425\u0426\u0427\u0428\u0429\u042A\u042B\u042C\u042D\u042E\u042F\u2020\xB0\u0490\xA3\xA7\u2022\xB6\u0406\xAE\xA9\u2122\u0402\u0452\u2260\u0403\u0453\u221E\xB1\u2264\u2265\u0456\xB5\u0491\u0408\u0404\u0454\u0407\u0457\u0409\u0459\u040A\u045A\u0458\u0405\xAC\u221A\u0192\u2248\u2206\xAB\xBB\u2026\xA0\u040B\u045B\u040C\u045C\u0455\u2013\u2014\u201C\u201D\u2018\u2019\xF7\u201E\u040E\u045E\u040F\u045F\u2116\u0401\u0451\u044F\u0430\u0431\u0432\u0433\u0434\u0435\u0436\u0437\u0438\u0439\u043A\u043B\u043C\u043D\u043E\u043F\u0440\u0441\u0442\u0443\u0444\u0445\u0446\u0447\u0448\u0449\u044A\u044B\u044C\u044D\u044E\xA4"
+ },
+ "koi8r": {
+ "type": "_sbcs",
+ "chars": "\u2500\u2502\u250C\u2510\u2514\u2518\u251C\u2524\u252C\u2534\u253C\u2580\u2584\u2588\u258C\u2590\u2591\u2592\u2593\u2320\u25A0\u2219\u221A\u2248\u2264\u2265\xA0\u2321\xB0\xB2\xB7\xF7\u2550\u2551\u2552\u0451\u2553\u2554\u2555\u2556\u2557\u2558\u2559\u255A\u255B\u255C\u255D\u255E\u255F\u2560\u2561\u0401\u2562\u2563\u2564\u2565\u2566\u2567\u2568\u2569\u256A\u256B\u256C\xA9\u044E\u0430\u0431\u0446\u0434\u0435\u0444\u0433\u0445\u0438\u0439\u043A\u043B\u043C\u043D\u043E\u043F\u044F\u0440\u0441\u0442\u0443\u0436\u0432\u044C\u044B\u0437\u0448\u044D\u0449\u0447\u044A\u042E\u0410\u0411\u0426\u0414\u0415\u0424\u0413\u0425\u0418\u0419\u041A\u041B\u041C\u041D\u041E\u041F\u042F\u0420\u0421\u0422\u0423\u0416\u0412\u042C\u042B\u0417\u0428\u042D\u0429\u0427\u042A"
+ },
+ "koi8u": {
+ "type": "_sbcs",
+ "chars": "\u2500\u2502\u250C\u2510\u2514\u2518\u251C\u2524\u252C\u2534\u253C\u2580\u2584\u2588\u258C\u2590\u2591\u2592\u2593\u2320\u25A0\u2219\u221A\u2248\u2264\u2265\xA0\u2321\xB0\xB2\xB7\xF7\u2550\u2551\u2552\u0451\u0454\u2554\u0456\u0457\u2557\u2558\u2559\u255A\u255B\u0491\u255D\u255E\u255F\u2560\u2561\u0401\u0404\u2563\u0406\u0407\u2566\u2567\u2568\u2569\u256A\u0490\u256C\xA9\u044E\u0430\u0431\u0446\u0434\u0435\u0444\u0433\u0445\u0438\u0439\u043A\u043B\u043C\u043D\u043E\u043F\u044F\u0440\u0441\u0442\u0443\u0436\u0432\u044C\u044B\u0437\u0448\u044D\u0449\u0447\u044A\u042E\u0410\u0411\u0426\u0414\u0415\u0424\u0413\u0425\u0418\u0419\u041A\u041B\u041C\u041D\u041E\u041F\u042F\u0420\u0421\u0422\u0423\u0416\u0412\u042C\u042B\u0417\u0428\u042D\u0429\u0427\u042A"
+ },
+ "koi8ru": {
+ "type": "_sbcs",
+ "chars": "\u2500\u2502\u250C\u2510\u2514\u2518\u251C\u2524\u252C\u2534\u253C\u2580\u2584\u2588\u258C\u2590\u2591\u2592\u2593\u2320\u25A0\u2219\u221A\u2248\u2264\u2265\xA0\u2321\xB0\xB2\xB7\xF7\u2550\u2551\u2552\u0451\u0454\u2554\u0456\u0457\u2557\u2558\u2559\u255A\u255B\u0491\u045E\u255E\u255F\u2560\u2561\u0401\u0404\u2563\u0406\u0407\u2566\u2567\u2568\u2569\u256A\u0490\u040E\xA9\u044E\u0430\u0431\u0446\u0434\u0435\u0444\u0433\u0445\u0438\u0439\u043A\u043B\u043C\u043D\u043E\u043F\u044F\u0440\u0441\u0442\u0443\u0436\u0432\u044C\u044B\u0437\u0448\u044D\u0449\u0447\u044A\u042E\u0410\u0411\u0426\u0414\u0415\u0424\u0413\u0425\u0418\u0419\u041A\u041B\u041C\u041D\u041E\u041F\u042F\u0420\u0421\u0422\u0423\u0416\u0412\u042C\u042B\u0417\u0428\u042D\u0429\u0427\u042A"
+ },
+ "koi8t": {
+ "type": "_sbcs",
+ "chars": "\u049B\u0493\u201A\u0492\u201E\u2026\u2020\u2021\uFFFD\u2030\u04B3\u2039\u04B2\u04B7\u04B6\uFFFD\u049A\u2018\u2019\u201C\u201D\u2022\u2013\u2014\uFFFD\u2122\uFFFD\u203A\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\u04EF\u04EE\u0451\xA4\u04E3\xA6\xA7\uFFFD\uFFFD\uFFFD\xAB\xAC\xAD\xAE\uFFFD\xB0\xB1\xB2\u0401\uFFFD\u04E2\xB6\xB7\uFFFD\u2116\uFFFD\xBB\uFFFD\uFFFD\uFFFD\xA9\u044E\u0430\u0431\u0446\u0434\u0435\u0444\u0433\u0445\u0438\u0439\u043A\u043B\u043C\u043D\u043E\u043F\u044F\u0440\u0441\u0442\u0443\u0436\u0432\u044C\u044B\u0437\u0448\u044D\u0449\u0447\u044A\u042E\u0410\u0411\u0426\u0414\u0415\u0424\u0413\u0425\u0418\u0419\u041A\u041B\u041C\u041D\u041E\u041F\u042F\u0420\u0421\u0422\u0423\u0416\u0412\u042C\u042B\u0417\u0428\u042D\u0429\u0427\u042A"
+ },
+ "armscii8": {
+ "type": "_sbcs",
+ "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\uFFFD\u0587\u0589)(\xBB\xAB\u2014.\u055D,-\u058A\u2026\u055C\u055B\u055E\u0531\u0561\u0532\u0562\u0533\u0563\u0534\u0564\u0535\u0565\u0536\u0566\u0537\u0567\u0538\u0568\u0539\u0569\u053A\u056A\u053B\u056B\u053C\u056C\u053D\u056D\u053E\u056E\u053F\u056F\u0540\u0570\u0541\u0571\u0542\u0572\u0543\u0573\u0544\u0574\u0545\u0575\u0546\u0576\u0547\u0577\u0548\u0578\u0549\u0579\u054A\u057A\u054B\u057B\u054C\u057C\u054D\u057D\u054E\u057E\u054F\u057F\u0550\u0580\u0551\u0581\u0552\u0582\u0553\u0583\u0554\u0584\u0555\u0585\u0556\u0586\u055A\uFFFD"
+ },
+ "rk1048": {
+ "type": "_sbcs",
+ "chars": "\u0402\u0403\u201A\u0453\u201E\u2026\u2020\u2021\u20AC\u2030\u0409\u2039\u040A\u049A\u04BA\u040F\u0452\u2018\u2019\u201C\u201D\u2022\u2013\u2014\uFFFD\u2122\u0459\u203A\u045A\u049B\u04BB\u045F\xA0\u04B0\u04B1\u04D8\xA4\u04E8\xA6\xA7\u0401\xA9\u0492\xAB\xAC\xAD\xAE\u04AE\xB0\xB1\u0406\u0456\u04E9\xB5\xB6\xB7\u0451\u2116\u0493\xBB\u04D9\u04A2\u04A3\u04AF\u0410\u0411\u0412\u0413\u0414\u0415\u0416\u0417\u0418\u0419\u041A\u041B\u041C\u041D\u041E\u041F\u0420\u0421\u0422\u0423\u0424\u0425\u0426\u0427\u0428\u0429\u042A\u042B\u042C\u042D\u042E\u042F\u0430\u0431\u0432\u0433\u0434\u0435\u0436\u0437\u0438\u0439\u043A\u043B\u043C\u043D\u043E\u043F\u0440\u0441\u0442\u0443\u0444\u0445\u0446\u0447\u0448\u0449\u044A\u044B\u044C\u044D\u044E\u044F"
+ },
+ "tcvn": {
+ "type": "_sbcs",
+ "chars": "\0\xDA\u1EE4\u1EEA\u1EEC\u1EEE\x07\b \n\v\f\r\u1EE8\u1EF0\u1EF2\u1EF6\u1EF8\xDD\u1EF4\x1B !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\x7F\xC0\u1EA2\xC3\xC1\u1EA0\u1EB6\u1EAC\xC8\u1EBA\u1EBC\xC9\u1EB8\u1EC6\xCC\u1EC8\u0128\xCD\u1ECA\xD2\u1ECE\xD5\xD3\u1ECC\u1ED8\u1EDC\u1EDE\u1EE0\u1EDA\u1EE2\xD9\u1EE6\u0168\xA0\u0102\xC2\xCA\xD4\u01A0\u01AF\u0110\u0103\xE2\xEA\xF4\u01A1\u01B0\u0111\u1EB0\u0300\u0309\u0303\u0301\u0323\xE0\u1EA3\xE3\xE1\u1EA1\u1EB2\u1EB1\u1EB3\u1EB5\u1EAF\u1EB4\u1EAE\u1EA6\u1EA8\u1EAA\u1EA4\u1EC0\u1EB7\u1EA7\u1EA9\u1EAB\u1EA5\u1EAD\xE8\u1EC2\u1EBB\u1EBD\xE9\u1EB9\u1EC1\u1EC3\u1EC5\u1EBF\u1EC7\xEC\u1EC9\u1EC4\u1EBE\u1ED2\u0129\xED\u1ECB\xF2\u1ED4\u1ECF\xF5\xF3\u1ECD\u1ED3\u1ED5\u1ED7\u1ED1\u1ED9\u1EDD\u1EDF\u1EE1\u1EDB\u1EE3\xF9\u1ED6\u1EE7\u0169\xFA\u1EE5\u1EEB\u1EED\u1EEF\u1EE9\u1EF1\u1EF3\u1EF7\u1EF9\xFD\u1EF5\u1ED0"
+ },
+ "georgianacademy": {
+ "type": "_sbcs",
+ "chars": "\x80\x81\u201A\u0192\u201E\u2026\u2020\u2021\u02C6\u2030\u0160\u2039\u0152\x8D\x8E\x8F\x90\u2018\u2019\u201C\u201D\u2022\u2013\u2014\u02DC\u2122\u0161\u203A\u0153\x9D\x9E\u0178\xA0\xA1\xA2\xA3\xA4\xA5\xA6\xA7\xA8\xA9\xAA\xAB\xAC\xAD\xAE\xAF\xB0\xB1\xB2\xB3\xB4\xB5\xB6\xB7\xB8\xB9\xBA\xBB\xBC\xBD\xBE\xBF\u10D0\u10D1\u10D2\u10D3\u10D4\u10D5\u10D6\u10D7\u10D8\u10D9\u10DA\u10DB\u10DC\u10DD\u10DE\u10DF\u10E0\u10E1\u10E2\u10E3\u10E4\u10E5\u10E6\u10E7\u10E8\u10E9\u10EA\u10EB\u10EC\u10ED\u10EE\u10EF\u10F0\u10F1\u10F2\u10F3\u10F4\u10F5\u10F6\xE7\xE8\xE9\xEA\xEB\xEC\xED\xEE\xEF\xF0\xF1\xF2\xF3\xF4\xF5\xF6\xF7\xF8\xF9\xFA\xFB\xFC\xFD\xFE\xFF"
+ },
+ "georgianps": {
+ "type": "_sbcs",
+ "chars": "\x80\x81\u201A\u0192\u201E\u2026\u2020\u2021\u02C6\u2030\u0160\u2039\u0152\x8D\x8E\x8F\x90\u2018\u2019\u201C\u201D\u2022\u2013\u2014\u02DC\u2122\u0161\u203A\u0153\x9D\x9E\u0178\xA0\xA1\xA2\xA3\xA4\xA5\xA6\xA7\xA8\xA9\xAA\xAB\xAC\xAD\xAE\xAF\xB0\xB1\xB2\xB3\xB4\xB5\xB6\xB7\xB8\xB9\xBA\xBB\xBC\xBD\xBE\xBF\u10D0\u10D1\u10D2\u10D3\u10D4\u10D5\u10D6\u10F1\u10D7\u10D8\u10D9\u10DA\u10DB\u10DC\u10F2\u10DD\u10DE\u10DF\u10E0\u10E1\u10E2\u10F3\u10E3\u10E4\u10E5\u10E6\u10E7\u10E8\u10E9\u10EA\u10EB\u10EC\u10ED\u10EE\u10F4\u10EF\u10F0\u10F5\xE6\xE7\xE8\xE9\xEA\xEB\xEC\xED\xEE\xEF\xF0\xF1\xF2\xF3\xF4\xF5\xF6\xF7\xF8\xF9\xFA\xFB\xFC\xFD\xFE\xFF"
+ },
+ "pt154": {
+ "type": "_sbcs",
+ "chars": "\u0496\u0492\u04EE\u0493\u201E\u2026\u04B6\u04AE\u04B2\u04AF\u04A0\u04E2\u04A2\u049A\u04BA\u04B8\u0497\u2018\u2019\u201C\u201D\u2022\u2013\u2014\u04B3\u04B7\u04A1\u04E3\u04A3\u049B\u04BB\u04B9\xA0\u040E\u045E\u0408\u04E8\u0498\u04B0\xA7\u0401\xA9\u04D8\xAB\xAC\u04EF\xAE\u049C\xB0\u04B1\u0406\u0456\u0499\u04E9\xB6\xB7\u0451\u2116\u04D9\xBB\u0458\u04AA\u04AB\u049D\u0410\u0411\u0412\u0413\u0414\u0415\u0416\u0417\u0418\u0419\u041A\u041B\u041C\u041D\u041E\u041F\u0420\u0421\u0422\u0423\u0424\u0425\u0426\u0427\u0428\u0429\u042A\u042B\u042C\u042D\u042E\u042F\u0430\u0431\u0432\u0433\u0434\u0435\u0436\u0437\u0438\u0439\u043A\u043B\u043C\u043D\u043E\u043F\u0440\u0441\u0442\u0443\u0444\u0445\u0446\u0447\u0448\u0449\u044A\u044B\u044C\u044D\u044E\u044F"
+ },
+ "viscii": {
+ "type": "_sbcs",
+ "chars": "\0\u1EB2\u1EB4\u1EAA\x07\b \n\v\f\r\u1EF6\u1EF8\x1B \u1EF4 !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\x7F\u1EA0\u1EAE\u1EB0\u1EB6\u1EA4\u1EA6\u1EA8\u1EAC\u1EBC\u1EB8\u1EBE\u1EC0\u1EC2\u1EC4\u1EC6\u1ED0\u1ED2\u1ED4\u1ED6\u1ED8\u1EE2\u1EDA\u1EDC\u1EDE\u1ECA\u1ECE\u1ECC\u1EC8\u1EE6\u0168\u1EE4\u1EF2\xD5\u1EAF\u1EB1\u1EB7\u1EA5\u1EA7\u1EA9\u1EAD\u1EBD\u1EB9\u1EBF\u1EC1\u1EC3\u1EC5\u1EC7\u1ED1\u1ED3\u1ED5\u1ED7\u1EE0\u01A0\u1ED9\u1EDD\u1EDF\u1ECB\u1EF0\u1EE8\u1EEA\u1EEC\u01A1\u1EDB\u01AF\xC0\xC1\xC2\xC3\u1EA2\u0102\u1EB3\u1EB5\xC8\xC9\xCA\u1EBA\xCC\xCD\u0128\u1EF3\u0110\u1EE9\xD2\xD3\xD4\u1EA1\u1EF7\u1EEB\u1EED\xD9\xDA\u1EF9\u1EF5\xDD\u1EE1\u01B0\xE0\xE1\xE2\xE3\u1EA3\u0103\u1EEF\u1EAB\xE8\xE9\xEA\u1EBB\xEC\xED\u0129\u1EC9\u0111\u1EF1\xF2\xF3\xF4\xF5\u1ECF\u1ECD\u1EE5\xF9\xFA\u0169\u1EE7\xFD\u1EE3\u1EEE"
+ },
+ "iso646cn": {
+ "type": "_sbcs",
+ "chars": "\0\x07\b \n\v\f\r\x1B !\"#\xA5%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}\u203E\x7F\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD"
+ },
+ "iso646jp": {
+ "type": "_sbcs",
+ "chars": "\0\x07\b \n\v\f\r\x1B !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\xA5]^_`abcdefghijklmnopqrstuvwxyz{|}\u203E\x7F\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD"
+ },
+ "hproman8": {
+ "type": "_sbcs",
+ "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\xC0\xC2\xC8\xCA\xCB\xCE\xCF\xB4\u02CB\u02C6\xA8\u02DC\xD9\xDB\u20A4\xAF\xDD\xFD\xB0\xC7\xE7\xD1\xF1\xA1\xBF\xA4\xA3\xA5\xA7\u0192\xA2\xE2\xEA\xF4\xFB\xE1\xE9\xF3\xFA\xE0\xE8\xF2\xF9\xE4\xEB\xF6\xFC\xC5\xEE\xD8\xC6\xE5\xED\xF8\xE6\xC4\xEC\xD6\xDC\xC9\xEF\xDF\xD4\xC1\xC3\xE3\xD0\xF0\xCD\xCC\xD3\xD2\xD5\xF5\u0160\u0161\xDA\u0178\xFF\xDE\xFE\xB7\xB5\xB6\xBE\u2014\xBC\xBD\xAA\xBA\xAB\u25A0\xBB\xB1\uFFFD"
+ },
+ "macintosh": {
+ "type": "_sbcs",
+ "chars": "\xC4\xC5\xC7\xC9\xD1\xD6\xDC\xE1\xE0\xE2\xE4\xE3\xE5\xE7\xE9\xE8\xEA\xEB\xED\xEC\xEE\xEF\xF1\xF3\xF2\xF4\xF6\xF5\xFA\xF9\xFB\xFC\u2020\xB0\xA2\xA3\xA7\u2022\xB6\xDF\xAE\xA9\u2122\xB4\xA8\u2260\xC6\xD8\u221E\xB1\u2264\u2265\xA5\xB5\u2202\u2211\u220F\u03C0\u222B\xAA\xBA\u2126\xE6\xF8\xBF\xA1\xAC\u221A\u0192\u2248\u2206\xAB\xBB\u2026\xA0\xC0\xC3\xD5\u0152\u0153\u2013\u2014\u201C\u201D\u2018\u2019\xF7\u25CA\xFF\u0178\u2044\xA4\u2039\u203A\uFB01\uFB02\u2021\xB7\u201A\u201E\u2030\xC2\xCA\xC1\xCB\xC8\xCD\xCE\xCF\xCC\xD3\xD4\uFFFD\xD2\xDA\xDB\xD9\u0131\u02C6\u02DC\xAF\u02D8\u02D9\u02DA\xB8\u02DD\u02DB\u02C7"
+ },
+ "ascii": {
+ "type": "_sbcs",
+ "chars": "\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD"
+ },
+ "tis620": {
+ "type": "_sbcs",
+ "chars": "\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\u0E01\u0E02\u0E03\u0E04\u0E05\u0E06\u0E07\u0E08\u0E09\u0E0A\u0E0B\u0E0C\u0E0D\u0E0E\u0E0F\u0E10\u0E11\u0E12\u0E13\u0E14\u0E15\u0E16\u0E17\u0E18\u0E19\u0E1A\u0E1B\u0E1C\u0E1D\u0E1E\u0E1F\u0E20\u0E21\u0E22\u0E23\u0E24\u0E25\u0E26\u0E27\u0E28\u0E29\u0E2A\u0E2B\u0E2C\u0E2D\u0E2E\u0E2F\u0E30\u0E31\u0E32\u0E33\u0E34\u0E35\u0E36\u0E37\u0E38\u0E39\u0E3A\uFFFD\uFFFD\uFFFD\uFFFD\u0E3F\u0E40\u0E41\u0E42\u0E43\u0E44\u0E45\u0E46\u0E47\u0E48\u0E49\u0E4A\u0E4B\u0E4C\u0E4D\u0E4E\u0E4F\u0E50\u0E51\u0E52\u0E53\u0E54\u0E55\u0E56\u0E57\u0E58\u0E59\u0E5A\u0E5B\uFFFD\uFFFD\uFFFD\uFFFD"
+ }
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/encodings/dbcs-codec.js
+var require_dbcs_codec = __commonJS({
+ "../../node_modules/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/encodings/dbcs-codec.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ var Buffer3 = 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]);
+ 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);
+ if (typeof codecOptions.gb18030 === "function") {
+ this.gb18030 = codecOptions.gb18030();
+ var thirdByteNodeIdx = this.decodeTables.length;
+ var thirdByteNode = this.decodeTables[thirdByteNodeIdx] = UNASSIGNED_NODE.slice(0);
+ var fourthByteNodeIdx = this.decodeTables.length;
+ var fourthByteNode = this.decodeTables[fourthByteNodeIdx] = UNASSIGNED_NODE.slice(0);
+ for (var i2 = 129; i2 <= 254; i2++) {
+ var secondByteNodeIdx = NODE_START - this.decodeTables[0][i2];
+ var secondByteNode = this.decodeTables[secondByteNodeIdx];
+ for (var j = 48; j <= 57; j++)
+ secondByteNode[j] = NODE_START - thirdByteNodeIdx;
+ }
+ for (var i2 = 129; i2 <= 254; i2++)
+ thirdByteNode[i2] = NODE_START - fourthByteNodeIdx;
+ for (var i2 = 48; i2 <= 57; i2++)
+ fourthByteNode[i2] = GB18030_CODE;
+ }
+ }
+ __name(DBCSCodec, "DBCSCodec");
+ 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];
+ 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);
+ else if (uCode <= NODE_START)
+ this._fillEncodeTable(NODE_START - uCode, mbCode << 8, skipEncodeChars);
+ else if (uCode <= SEQ_START)
+ this._setEncodeSequence(this.decodeTableSeq[SEQ_START - uCode], mbCode);
+ }
+ };
+ function DBCSEncoder(options14, codec) {
+ this.leadSurrogate = -1;
+ this.seqObj = void 0;
+ this.encodeTable = codec.encodeTable;
+ this.encodeTableSeq = codec.encodeTableSeq;
+ this.defaultCharSingleByte = codec.defCharSB;
+ this.gb18030 = codec.gb18030;
+ }
+ __name(DBCSEncoder, "DBCSEncoder");
+ DBCSEncoder.prototype.write = function(str) {
+ var newBuf = Buffer3.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 {
+ newBuf[j++] = dbcsCode >> 16;
+ 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 = Buffer3.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(options14, codec) {
+ this.nodeIdx = 0;
+ this.prevBuf = Buffer3.alloc(0);
+ this.decodeTables = codec.decodeTables;
+ this.decodeTableSeq = codec.decodeTableSeq;
+ this.defaultCharUnicode = codec.defaultCharUnicode;
+ this.gb18030 = codec.gb18030;
+ }
+ __name(DBCSDecoder, "DBCSDecoder");
+ DBCSDecoder.prototype.write = function(buf) {
+ var newBuf = Buffer3.alloc(buf.length * 2), nodeIdx = this.nodeIdx, prevBuf = this.prevBuf, prevBufOffset = this.prevBuf.length, seqStart = -this.prevBuf.length, uCode;
+ if (prevBufOffset > 0)
+ prevBuf = Buffer3.concat([prevBuf, buf.slice(0, 10)]);
+ for (var i2 = 0, j = 0; i2 < buf.length; i2++) {
+ var curByte = i2 >= 0 ? buf[i2] : prevBuf[i2 + prevBufOffset];
+ var uCode = this.decodeTables[nodeIdx][curByte];
+ if (uCode >= 0) {
+ } else if (uCode === UNASSIGNED) {
+ i2 = seqStart;
+ uCode = this.defaultCharUnicode.charCodeAt(0);
+ } else if (uCode === GB18030_CODE) {
+ var curSeq = seqStart >= 0 ? buf.slice(seqStart, i2 + 1) : prevBuf.slice(seqStart + prevBufOffset, i2 + 1 + prevBufOffset);
+ var ptr = (curSeq[0] - 129) * 12600 + (curSeq[1] - 48) * 1260 + (curSeq[2] - 129) * 10 + (curSeq[3] - 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 > 65535) {
+ uCode -= 65536;
+ var uCodeLead = 55296 + Math.floor(uCode / 1024);
+ newBuf[j++] = uCodeLead & 255;
+ newBuf[j++] = uCodeLead >> 8;
+ uCode = 56320 + uCode % 1024;
+ }
+ newBuf[j++] = uCode & 255;
+ newBuf[j++] = uCode >> 8;
+ nodeIdx = 0;
+ seqStart = i2 + 1;
+ }
+ this.nodeIdx = nodeIdx;
+ this.prevBuf = seqStart >= 0 ? buf.slice(seqStart) : prevBuf.slice(seqStart + prevBufOffset);
+ return newBuf.slice(0, j).toString("ucs2");
+ };
+ DBCSDecoder.prototype.end = function() {
+ var ret = "";
+ while (this.prevBuf.length > 0) {
+ ret += this.defaultCharUnicode;
+ var buf = this.prevBuf.slice(1);
+ this.prevBuf = Buffer3.alloc(0);
+ this.nodeIdx = 0;
+ if (buf.length > 0)
+ ret += this.write(buf);
+ }
+ 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 + Math.floor((r - l + 1) / 2);
+ if (table[mid] <= val)
+ l = mid;
+ else
+ r = mid;
+ }
+ return l;
+ }
+ __name(findIdx, "findIdx");
+ }
+});
+
+// ../../node_modules/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/encodings/tables/shiftjis.json
+var require_shiftjis = __commonJS({
+ "../../node_modules/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/encodings/tables/shiftjis.json"(exports2, module2) {
+ module2.exports = [
+ ["0", "\0", 128],
+ ["a1", "\uFF61", 62],
+ ["8140", "\u3000\u3001\u3002\uFF0C\uFF0E\u30FB\uFF1A\uFF1B\uFF1F\uFF01\u309B\u309C\xB4\uFF40\xA8\uFF3E\uFFE3\uFF3F\u30FD\u30FE\u309D\u309E\u3003\u4EDD\u3005\u3006\u3007\u30FC\u2015\u2010\uFF0F\uFF3C\uFF5E\u2225\uFF5C\u2026\u2025\u2018\u2019\u201C\u201D\uFF08\uFF09\u3014\u3015\uFF3B\uFF3D\uFF5B\uFF5D\u3008", 9, "\uFF0B\uFF0D\xB1\xD7"],
+ ["8180", "\xF7\uFF1D\u2260\uFF1C\uFF1E\u2266\u2267\u221E\u2234\u2642\u2640\xB0\u2032\u2033\u2103\uFFE5\uFF04\uFFE0\uFFE1\uFF05\uFF03\uFF06\uFF0A\uFF20\xA7\u2606\u2605\u25CB\u25CF\u25CE\u25C7\u25C6\u25A1\u25A0\u25B3\u25B2\u25BD\u25BC\u203B\u3012\u2192\u2190\u2191\u2193\u3013"],
+ ["81b8", "\u2208\u220B\u2286\u2287\u2282\u2283\u222A\u2229"],
+ ["81c8", "\u2227\u2228\uFFE2\u21D2\u21D4\u2200\u2203"],
+ ["81da", "\u2220\u22A5\u2312\u2202\u2207\u2261\u2252\u226A\u226B\u221A\u223D\u221D\u2235\u222B\u222C"],
+ ["81f0", "\u212B\u2030\u266F\u266D\u266A\u2020\u2021\xB6"],
+ ["81fc", "\u25EF"],
+ ["824f", "\uFF10", 9],
+ ["8260", "\uFF21", 25],
+ ["8281", "\uFF41", 25],
+ ["829f", "\u3041", 82],
+ ["8340", "\u30A1", 62],
+ ["8380", "\u30E0", 22],
+ ["839f", "\u0391", 16, "\u03A3", 6],
+ ["83bf", "\u03B1", 16, "\u03C3", 6],
+ ["8440", "\u0410", 5, "\u0401\u0416", 25],
+ ["8470", "\u0430", 5, "\u0451\u0436", 7],
+ ["8480", "\u043E", 17],
+ ["849f", "\u2500\u2502\u250C\u2510\u2518\u2514\u251C\u252C\u2524\u2534\u253C\u2501\u2503\u250F\u2513\u251B\u2517\u2523\u2533\u252B\u253B\u254B\u2520\u252F\u2528\u2537\u253F\u251D\u2530\u2525\u2538\u2542"],
+ ["8740", "\u2460", 19, "\u2160", 9],
+ ["875f", "\u3349\u3314\u3322\u334D\u3318\u3327\u3303\u3336\u3351\u3357\u330D\u3326\u3323\u332B\u334A\u333B\u339C\u339D\u339E\u338E\u338F\u33C4\u33A1"],
+ ["877e", "\u337B"],
+ ["8780", "\u301D\u301F\u2116\u33CD\u2121\u32A4", 4, "\u3231\u3232\u3239\u337E\u337D\u337C\u2252\u2261\u222B\u222E\u2211\u221A\u22A5\u2220\u221F\u22BF\u2235\u2229\u222A"],
+ ["889f", "\u4E9C\u5516\u5A03\u963F\u54C0\u611B\u6328\u59F6\u9022\u8475\u831C\u7A50\u60AA\u63E1\u6E25\u65ED\u8466\u82A6\u9BF5\u6893\u5727\u65A1\u6271\u5B9B\u59D0\u867B\u98F4\u7D62\u7DBE\u9B8E\u6216\u7C9F\u88B7\u5B89\u5EB5\u6309\u6697\u6848\u95C7\u978D\u674F\u4EE5\u4F0A\u4F4D\u4F9D\u5049\u56F2\u5937\u59D4\u5A01\u5C09\u60DF\u610F\u6170\u6613\u6905\u70BA\u754F\u7570\u79FB\u7DAD\u7DEF\u80C3\u840E\u8863\u8B02\u9055\u907A\u533B\u4E95\u4EA5\u57DF\u80B2\u90C1\u78EF\u4E00\u58F1\u6EA2\u9038\u7A32\u8328\u828B\u9C2F\u5141\u5370\u54BD\u54E1\u56E0\u59FB\u5F15\u98F2\u6DEB\u80E4\u852D"],
+ ["8940", "\u9662\u9670\u96A0\u97FB\u540B\u53F3\u5B87\u70CF\u7FBD\u8FC2\u96E8\u536F\u9D5C\u7ABA\u4E11\u7893\u81FC\u6E26\u5618\u5504\u6B1D\u851A\u9C3B\u59E5\u53A9\u6D66\u74DC\u958F\u5642\u4E91\u904B\u96F2\u834F\u990C\u53E1\u55B6\u5B30\u5F71\u6620\u66F3\u6804\u6C38\u6CF3\u6D29\u745B\u76C8\u7A4E\u9834\u82F1\u885B\u8A60\u92ED\u6DB2\u75AB\u76CA\u99C5\u60A6\u8B01\u8D8A\u95B2\u698E\u53AD\u5186"],
+ ["8980", "\u5712\u5830\u5944\u5BB4\u5EF6\u6028\u63A9\u63F4\u6CBF\u6F14\u708E\u7114\u7159\u71D5\u733F\u7E01\u8276\u82D1\u8597\u9060\u925B\u9D1B\u5869\u65BC\u6C5A\u7525\u51F9\u592E\u5965\u5F80\u5FDC\u62BC\u65FA\u6A2A\u6B27\u6BB4\u738B\u7FC1\u8956\u9D2C\u9D0E\u9EC4\u5CA1\u6C96\u837B\u5104\u5C4B\u61B6\u81C6\u6876\u7261\u4E59\u4FFA\u5378\u6069\u6E29\u7A4F\u97F3\u4E0B\u5316\u4EEE\u4F55\u4F3D\u4FA1\u4F73\u52A0\u53EF\u5609\u590F\u5AC1\u5BB6\u5BE1\u79D1\u6687\u679C\u67B6\u6B4C\u6CB3\u706B\u73C2\u798D\u79BE\u7A3C\u7B87\u82B1\u82DB\u8304\u8377\u83EF\u83D3\u8766\u8AB2\u5629\u8CA8\u8FE6\u904E\u971E\u868A\u4FC4\u5CE8\u6211\u7259\u753B\u81E5\u82BD\u86FE\u8CC0\u96C5\u9913\u99D5\u4ECB\u4F1A\u89E3\u56DE\u584A\u58CA\u5EFB\u5FEB\u602A\u6094\u6062\u61D0\u6212\u62D0\u6539"],
+ ["8a40", "\u9B41\u6666\u68B0\u6D77\u7070\u754C\u7686\u7D75\u82A5\u87F9\u958B\u968E\u8C9D\u51F1\u52BE\u5916\u54B3\u5BB3\u5D16\u6168\u6982\u6DAF\u788D\u84CB\u8857\u8A72\u93A7\u9AB8\u6D6C\u99A8\u86D9\u57A3\u67FF\u86CE\u920E\u5283\u5687\u5404\u5ED3\u62E1\u64B9\u683C\u6838\u6BBB\u7372\u78BA\u7A6B\u899A\u89D2\u8D6B\u8F03\u90ED\u95A3\u9694\u9769\u5B66\u5CB3\u697D\u984D\u984E\u639B\u7B20\u6A2B"],
+ ["8a80", "\u6A7F\u68B6\u9C0D\u6F5F\u5272\u559D\u6070\u62EC\u6D3B\u6E07\u6ED1\u845B\u8910\u8F44\u4E14\u9C39\u53F6\u691B\u6A3A\u9784\u682A\u515C\u7AC3\u84B2\u91DC\u938C\u565B\u9D28\u6822\u8305\u8431\u7CA5\u5208\u82C5\u74E6\u4E7E\u4F83\u51A0\u5BD2\u520A\u52D8\u52E7\u5DFB\u559A\u582A\u59E6\u5B8C\u5B98\u5BDB\u5E72\u5E79\u60A3\u611F\u6163\u61BE\u63DB\u6562\u67D1\u6853\u68FA\u6B3E\u6B53\u6C57\u6F22\u6F97\u6F45\u74B0\u7518\u76E3\u770B\u7AFF\u7BA1\u7C21\u7DE9\u7F36\u7FF0\u809D\u8266\u839E\u89B3\u8ACC\u8CAB\u9084\u9451\u9593\u9591\u95A2\u9665\u97D3\u9928\u8218\u4E38\u542B\u5CB8\u5DCC\u73A9\u764C\u773C\u5CA9\u7FEB\u8D0B\u96C1\u9811\u9854\u9858\u4F01\u4F0E\u5371\u559C\u5668\u57FA\u5947\u5B09\u5BC4\u5C90\u5E0C\u5E7E\u5FCC\u63EE\u673A\u65D7\u65E2\u671F\u68CB\u68C4"],
+ ["8b40", "\u6A5F\u5E30\u6BC5\u6C17\u6C7D\u757F\u7948\u5B63\u7A00\u7D00\u5FBD\u898F\u8A18\u8CB4\u8D77\u8ECC\u8F1D\u98E2\u9A0E\u9B3C\u4E80\u507D\u5100\u5993\u5B9C\u622F\u6280\u64EC\u6B3A\u72A0\u7591\u7947\u7FA9\u87FB\u8ABC\u8B70\u63AC\u83CA\u97A0\u5409\u5403\u55AB\u6854\u6A58\u8A70\u7827\u6775\u9ECD\u5374\u5BA2\u811A\u8650\u9006\u4E18\u4E45\u4EC7\u4F11\u53CA\u5438\u5BAE\u5F13\u6025\u6551"],
+ ["8b80", "\u673D\u6C42\u6C72\u6CE3\u7078\u7403\u7A76\u7AAE\u7B08\u7D1A\u7CFE\u7D66\u65E7\u725B\u53BB\u5C45\u5DE8\u62D2\u62E0\u6319\u6E20\u865A\u8A31\u8DDD\u92F8\u6F01\u79A6\u9B5A\u4EA8\u4EAB\u4EAC\u4F9B\u4FA0\u50D1\u5147\u7AF6\u5171\u51F6\u5354\u5321\u537F\u53EB\u55AC\u5883\u5CE1\u5F37\u5F4A\u602F\u6050\u606D\u631F\u6559\u6A4B\u6CC1\u72C2\u72ED\u77EF\u80F8\u8105\u8208\u854E\u90F7\u93E1\u97FF\u9957\u9A5A\u4EF0\u51DD\u5C2D\u6681\u696D\u5C40\u66F2\u6975\u7389\u6850\u7C81\u50C5\u52E4\u5747\u5DFE\u9326\u65A4\u6B23\u6B3D\u7434\u7981\u79BD\u7B4B\u7DCA\u82B9\u83CC\u887F\u895F\u8B39\u8FD1\u91D1\u541F\u9280\u4E5D\u5036\u53E5\u533A\u72D7\u7396\u77E9\u82E6\u8EAF\u99C6\u99C8\u99D2\u5177\u611A\u865E\u55B0\u7A7A\u5076\u5BD3\u9047\u9685\u4E32\u6ADB\u91E7\u5C51\u5C48"],
+ ["8c40", "\u6398\u7A9F\u6C93\u9774\u8F61\u7AAA\u718A\u9688\u7C82\u6817\u7E70\u6851\u936C\u52F2\u541B\u85AB\u8A13\u7FA4\u8ECD\u90E1\u5366\u8888\u7941\u4FC2\u50BE\u5211\u5144\u5553\u572D\u73EA\u578B\u5951\u5F62\u5F84\u6075\u6176\u6167\u61A9\u63B2\u643A\u656C\u666F\u6842\u6E13\u7566\u7A3D\u7CFB\u7D4C\u7D99\u7E4B\u7F6B\u830E\u834A\u86CD\u8A08\u8A63\u8B66\u8EFD\u981A\u9D8F\u82B8\u8FCE\u9BE8"],
+ ["8c80", "\u5287\u621F\u6483\u6FC0\u9699\u6841\u5091\u6B20\u6C7A\u6F54\u7A74\u7D50\u8840\u8A23\u6708\u4EF6\u5039\u5026\u5065\u517C\u5238\u5263\u55A7\u570F\u5805\u5ACC\u5EFA\u61B2\u61F8\u62F3\u6372\u691C\u6A29\u727D\u72AC\u732E\u7814\u786F\u7D79\u770C\u80A9\u898B\u8B19\u8CE2\u8ED2\u9063\u9375\u967A\u9855\u9A13\u9E78\u5143\u539F\u53B3\u5E7B\u5F26\u6E1B\u6E90\u7384\u73FE\u7D43\u8237\u8A00\u8AFA\u9650\u4E4E\u500B\u53E4\u547C\u56FA\u59D1\u5B64\u5DF1\u5EAB\u5F27\u6238\u6545\u67AF\u6E56\u72D0\u7CCA\u88B4\u80A1\u80E1\u83F0\u864E\u8A87\u8DE8\u9237\u96C7\u9867\u9F13\u4E94\u4E92\u4F0D\u5348\u5449\u543E\u5A2F\u5F8C\u5FA1\u609F\u68A7\u6A8E\u745A\u7881\u8A9E\u8AA4\u8B77\u9190\u4E5E\u9BC9\u4EA4\u4F7C\u4FAF\u5019\u5016\u5149\u516C\u529F\u52B9\u52FE\u539A\u53E3\u5411"],
+ ["8d40", "\u540E\u5589\u5751\u57A2\u597D\u5B54\u5B5D\u5B8F\u5DE5\u5DE7\u5DF7\u5E78\u5E83\u5E9A\u5EB7\u5F18\u6052\u614C\u6297\u62D8\u63A7\u653B\u6602\u6643\u66F4\u676D\u6821\u6897\u69CB\u6C5F\u6D2A\u6D69\u6E2F\u6E9D\u7532\u7687\u786C\u7A3F\u7CE0\u7D05\u7D18\u7D5E\u7DB1\u8015\u8003\u80AF\u80B1\u8154\u818F\u822A\u8352\u884C\u8861\u8B1B\u8CA2\u8CFC\u90CA\u9175\u9271\u783F\u92FC\u95A4\u964D"],
+ ["8d80", "\u9805\u9999\u9AD8\u9D3B\u525B\u52AB\u53F7\u5408\u58D5\u62F7\u6FE0\u8C6A\u8F5F\u9EB9\u514B\u523B\u544A\u56FD\u7A40\u9177\u9D60\u9ED2\u7344\u6F09\u8170\u7511\u5FFD\u60DA\u9AA8\u72DB\u8FBC\u6B64\u9803\u4ECA\u56F0\u5764\u58BE\u5A5A\u6068\u61C7\u660F\u6606\u6839\u68B1\u6DF7\u75D5\u7D3A\u826E\u9B42\u4E9B\u4F50\u53C9\u5506\u5D6F\u5DE6\u5DEE\u67FB\u6C99\u7473\u7802\u8A50\u9396\u88DF\u5750\u5EA7\u632B\u50B5\u50AC\u518D\u6700\u54C9\u585E\u59BB\u5BB0\u5F69\u624D\u63A1\u683D\u6B73\u6E08\u707D\u91C7\u7280\u7815\u7826\u796D\u658E\u7D30\u83DC\u88C1\u8F09\u969B\u5264\u5728\u6750\u7F6A\u8CA1\u51B4\u5742\u962A\u583A\u698A\u80B4\u54B2\u5D0E\u57FC\u7895\u9DFA\u4F5C\u524A\u548B\u643E\u6628\u6714\u67F5\u7A84\u7B56\u7D22\u932F\u685C\u9BAD\u7B39\u5319\u518A\u5237"],
+ ["8e40", "\u5BDF\u62F6\u64AE\u64E6\u672D\u6BBA\u85A9\u96D1\u7690\u9BD6\u634C\u9306\u9BAB\u76BF\u6652\u4E09\u5098\u53C2\u5C71\u60E8\u6492\u6563\u685F\u71E6\u73CA\u7523\u7B97\u7E82\u8695\u8B83\u8CDB\u9178\u9910\u65AC\u66AB\u6B8B\u4ED5\u4ED4\u4F3A\u4F7F\u523A\u53F8\u53F2\u55E3\u56DB\u58EB\u59CB\u59C9\u59FF\u5B50\u5C4D\u5E02\u5E2B\u5FD7\u601D\u6307\u652F\u5B5C\u65AF\u65BD\u65E8\u679D\u6B62"],
+ ["8e80", "\u6B7B\u6C0F\u7345\u7949\u79C1\u7CF8\u7D19\u7D2B\u80A2\u8102\u81F3\u8996\u8A5E\u8A69\u8A66\u8A8C\u8AEE\u8CC7\u8CDC\u96CC\u98FC\u6B6F\u4E8B\u4F3C\u4F8D\u5150\u5B57\u5BFA\u6148\u6301\u6642\u6B21\u6ECB\u6CBB\u723E\u74BD\u75D4\u78C1\u793A\u800C\u8033\u81EA\u8494\u8F9E\u6C50\u9E7F\u5F0F\u8B58\u9D2B\u7AFA\u8EF8\u5B8D\u96EB\u4E03\u53F1\u57F7\u5931\u5AC9\u5BA4\u6089\u6E7F\u6F06\u75BE\u8CEA\u5B9F\u8500\u7BE0\u5072\u67F4\u829D\u5C61\u854A\u7E1E\u820E\u5199\u5C04\u6368\u8D66\u659C\u716E\u793E\u7D17\u8005\u8B1D\u8ECA\u906E\u86C7\u90AA\u501F\u52FA\u5C3A\u6753\u707C\u7235\u914C\u91C8\u932B\u82E5\u5BC2\u5F31\u60F9\u4E3B\u53D6\u5B88\u624B\u6731\u6B8A\u72E9\u73E0\u7A2E\u816B\u8DA3\u9152\u9996\u5112\u53D7\u546A\u5BFF\u6388\u6A39\u7DAC\u9700\u56DA\u53CE\u5468"],
+ ["8f40", "\u5B97\u5C31\u5DDE\u4FEE\u6101\u62FE\u6D32\u79C0\u79CB\u7D42\u7E4D\u7FD2\u81ED\u821F\u8490\u8846\u8972\u8B90\u8E74\u8F2F\u9031\u914B\u916C\u96C6\u919C\u4EC0\u4F4F\u5145\u5341\u5F93\u620E\u67D4\u6C41\u6E0B\u7363\u7E26\u91CD\u9283\u53D4\u5919\u5BBF\u6DD1\u795D\u7E2E\u7C9B\u587E\u719F\u51FA\u8853\u8FF0\u4FCA\u5CFB\u6625\u77AC\u7AE3\u821C\u99FF\u51C6\u5FAA\u65EC\u696F\u6B89\u6DF3"],
+ ["8f80", "\u6E96\u6F64\u76FE\u7D14\u5DE1\u9075\u9187\u9806\u51E6\u521D\u6240\u6691\u66D9\u6E1A\u5EB6\u7DD2\u7F72\u66F8\u85AF\u85F7\u8AF8\u52A9\u53D9\u5973\u5E8F\u5F90\u6055\u92E4\u9664\u50B7\u511F\u52DD\u5320\u5347\u53EC\u54E8\u5546\u5531\u5617\u5968\u59BE\u5A3C\u5BB5\u5C06\u5C0F\u5C11\u5C1A\u5E84\u5E8A\u5EE0\u5F70\u627F\u6284\u62DB\u638C\u6377\u6607\u660C\u662D\u6676\u677E\u68A2\u6A1F\u6A35\u6CBC\u6D88\u6E09\u6E58\u713C\u7126\u7167\u75C7\u7701\u785D\u7901\u7965\u79F0\u7AE0\u7B11\u7CA7\u7D39\u8096\u83D6\u848B\u8549\u885D\u88F3\u8A1F\u8A3C\u8A54\u8A73\u8C61\u8CDE\u91A4\u9266\u937E\u9418\u969C\u9798\u4E0A\u4E08\u4E1E\u4E57\u5197\u5270\u57CE\u5834\u58CC\u5B22\u5E38\u60C5\u64FE\u6761\u6756\u6D44\u72B6\u7573\u7A63\u84B8\u8B72\u91B8\u9320\u5631\u57F4\u98FE"],
+ ["9040", "\u62ED\u690D\u6B96\u71ED\u7E54\u8077\u8272\u89E6\u98DF\u8755\u8FB1\u5C3B\u4F38\u4FE1\u4FB5\u5507\u5A20\u5BDD\u5BE9\u5FC3\u614E\u632F\u65B0\u664B\u68EE\u699B\u6D78\u6DF1\u7533\u75B9\u771F\u795E\u79E6\u7D33\u81E3\u82AF\u85AA\u89AA\u8A3A\u8EAB\u8F9B\u9032\u91DD\u9707\u4EBA\u4EC1\u5203\u5875\u58EC\u5C0B\u751A\u5C3D\u814E\u8A0A\u8FC5\u9663\u976D\u7B25\u8ACF\u9808\u9162\u56F3\u53A8"],
+ ["9080", "\u9017\u5439\u5782\u5E25\u63A8\u6C34\u708A\u7761\u7C8B\u7FE0\u8870\u9042\u9154\u9310\u9318\u968F\u745E\u9AC4\u5D07\u5D69\u6570\u67A2\u8DA8\u96DB\u636E\u6749\u6919\u83C5\u9817\u96C0\u88FE\u6F84\u647A\u5BF8\u4E16\u702C\u755D\u662F\u51C4\u5236\u52E2\u59D3\u5F81\u6027\u6210\u653F\u6574\u661F\u6674\u68F2\u6816\u6B63\u6E05\u7272\u751F\u76DB\u7CBE\u8056\u58F0\u88FD\u897F\u8AA0\u8A93\u8ACB\u901D\u9192\u9752\u9759\u6589\u7A0E\u8106\u96BB\u5E2D\u60DC\u621A\u65A5\u6614\u6790\u77F3\u7A4D\u7C4D\u7E3E\u810A\u8CAC\u8D64\u8DE1\u8E5F\u78A9\u5207\u62D9\u63A5\u6442\u6298\u8A2D\u7A83\u7BC0\u8AAC\u96EA\u7D76\u820C\u8749\u4ED9\u5148\u5343\u5360\u5BA3\u5C02\u5C16\u5DDD\u6226\u6247\u64B0\u6813\u6834\u6CC9\u6D45\u6D17\u67D3\u6F5C\u714E\u717D\u65CB\u7A7F\u7BAD\u7DDA"],
+ ["9140", "\u7E4A\u7FA8\u817A\u821B\u8239\u85A6\u8A6E\u8CCE\u8DF5\u9078\u9077\u92AD\u9291\u9583\u9BAE\u524D\u5584\u6F38\u7136\u5168\u7985\u7E55\u81B3\u7CCE\u564C\u5851\u5CA8\u63AA\u66FE\u66FD\u695A\u72D9\u758F\u758E\u790E\u7956\u79DF\u7C97\u7D20\u7D44\u8607\u8A34\u963B\u9061\u9F20\u50E7\u5275\u53CC\u53E2\u5009\u55AA\u58EE\u594F\u723D\u5B8B\u5C64\u531D\u60E3\u60F3\u635C\u6383\u633F\u63BB"],
+ ["9180", "\u64CD\u65E9\u66F9\u5DE3\u69CD\u69FD\u6F15\u71E5\u4E89\u75E9\u76F8\u7A93\u7CDF\u7DCF\u7D9C\u8061\u8349\u8358\u846C\u84BC\u85FB\u88C5\u8D70\u9001\u906D\u9397\u971C\u9A12\u50CF\u5897\u618E\u81D3\u8535\u8D08\u9020\u4FC3\u5074\u5247\u5373\u606F\u6349\u675F\u6E2C\u8DB3\u901F\u4FD7\u5C5E\u8CCA\u65CF\u7D9A\u5352\u8896\u5176\u63C3\u5B58\u5B6B\u5C0A\u640D\u6751\u905C\u4ED6\u591A\u592A\u6C70\u8A51\u553E\u5815\u59A5\u60F0\u6253\u67C1\u8235\u6955\u9640\u99C4\u9A28\u4F53\u5806\u5BFE\u8010\u5CB1\u5E2F\u5F85\u6020\u614B\u6234\u66FF\u6CF0\u6EDE\u80CE\u817F\u82D4\u888B\u8CB8\u9000\u902E\u968A\u9EDB\u9BDB\u4EE3\u53F0\u5927\u7B2C\u918D\u984C\u9DF9\u6EDD\u7027\u5353\u5544\u5B85\u6258\u629E\u62D3\u6CA2\u6FEF\u7422\u8A17\u9438\u6FC1\u8AFE\u8338\u51E7\u86F8\u53EA"],
+ ["9240", "\u53E9\u4F46\u9054\u8FB0\u596A\u8131\u5DFD\u7AEA\u8FBF\u68DA\u8C37\u72F8\u9C48\u6A3D\u8AB0\u4E39\u5358\u5606\u5766\u62C5\u63A2\u65E6\u6B4E\u6DE1\u6E5B\u70AD\u77ED\u7AEF\u7BAA\u7DBB\u803D\u80C6\u86CB\u8A95\u935B\u56E3\u58C7\u5F3E\u65AD\u6696\u6A80\u6BB5\u7537\u8AC7\u5024\u77E5\u5730\u5F1B\u6065\u667A\u6C60\u75F4\u7A1A\u7F6E\u81F4\u8718\u9045\u99B3\u7BC9\u755C\u7AF9\u7B51\u84C4"],
+ ["9280", "\u9010\u79E9\u7A92\u8336\u5AE1\u7740\u4E2D\u4EF2\u5B99\u5FE0\u62BD\u663C\u67F1\u6CE8\u866B\u8877\u8A3B\u914E\u92F3\u99D0\u6A17\u7026\u732A\u82E7\u8457\u8CAF\u4E01\u5146\u51CB\u558B\u5BF5\u5E16\u5E33\u5E81\u5F14\u5F35\u5F6B\u5FB4\u61F2\u6311\u66A2\u671D\u6F6E\u7252\u753A\u773A\u8074\u8139\u8178\u8776\u8ABF\u8ADC\u8D85\u8DF3\u929A\u9577\u9802\u9CE5\u52C5\u6357\u76F4\u6715\u6C88\u73CD\u8CC3\u93AE\u9673\u6D25\u589C\u690E\u69CC\u8FFD\u939A\u75DB\u901A\u585A\u6802\u63B4\u69FB\u4F43\u6F2C\u67D8\u8FBB\u8526\u7DB4\u9354\u693F\u6F70\u576A\u58F7\u5B2C\u7D2C\u722A\u540A\u91E3\u9DB4\u4EAD\u4F4E\u505C\u5075\u5243\u8C9E\u5448\u5824\u5B9A\u5E1D\u5E95\u5EAD\u5EF7\u5F1F\u608C\u62B5\u633A\u63D0\u68AF\u6C40\u7887\u798E\u7A0B\u7DE0\u8247\u8A02\u8AE6\u8E44\u9013"],
+ ["9340", "\u90B8\u912D\u91D8\u9F0E\u6CE5\u6458\u64E2\u6575\u6EF4\u7684\u7B1B\u9069\u93D1\u6EBA\u54F2\u5FB9\u64A4\u8F4D\u8FED\u9244\u5178\u586B\u5929\u5C55\u5E97\u6DFB\u7E8F\u751C\u8CBC\u8EE2\u985B\u70B9\u4F1D\u6BBF\u6FB1\u7530\u96FB\u514E\u5410\u5835\u5857\u59AC\u5C60\u5F92\u6597\u675C\u6E21\u767B\u83DF\u8CED\u9014\u90FD\u934D\u7825\u783A\u52AA\u5EA6\u571F\u5974\u6012\u5012\u515A\u51AC"],
+ ["9380", "\u51CD\u5200\u5510\u5854\u5858\u5957\u5B95\u5CF6\u5D8B\u60BC\u6295\u642D\u6771\u6843\u68BC\u68DF\u76D7\u6DD8\u6E6F\u6D9B\u706F\u71C8\u5F53\u75D8\u7977\u7B49\u7B54\u7B52\u7CD6\u7D71\u5230\u8463\u8569\u85E4\u8A0E\u8B04\u8C46\u8E0F\u9003\u900F\u9419\u9676\u982D\u9A30\u95D8\u50CD\u52D5\u540C\u5802\u5C0E\u61A7\u649E\u6D1E\u77B3\u7AE5\u80F4\u8404\u9053\u9285\u5CE0\u9D07\u533F\u5F97\u5FB3\u6D9C\u7279\u7763\u79BF\u7BE4\u6BD2\u72EC\u8AAD\u6803\u6A61\u51F8\u7A81\u6934\u5C4A\u9CF6\u82EB\u5BC5\u9149\u701E\u5678\u5C6F\u60C7\u6566\u6C8C\u8C5A\u9041\u9813\u5451\u66C7\u920D\u5948\u90A3\u5185\u4E4D\u51EA\u8599\u8B0E\u7058\u637A\u934B\u6962\u99B4\u7E04\u7577\u5357\u6960\u8EDF\u96E3\u6C5D\u4E8C\u5C3C\u5F10\u8FE9\u5302\u8CD1\u8089\u8679\u5EFF\u65E5\u4E73\u5165"],
+ ["9440", "\u5982\u5C3F\u97EE\u4EFB\u598A\u5FCD\u8A8D\u6FE1\u79B0\u7962\u5BE7\u8471\u732B\u71B1\u5E74\u5FF5\u637B\u649A\u71C3\u7C98\u4E43\u5EFC\u4E4B\u57DC\u56A2\u60A9\u6FC3\u7D0D\u80FD\u8133\u81BF\u8FB2\u8997\u86A4\u5DF4\u628A\u64AD\u8987\u6777\u6CE2\u6D3E\u7436\u7834\u5A46\u7F75\u82AD\u99AC\u4FF3\u5EC3\u62DD\u6392\u6557\u676F\u76C3\u724C\u80CC\u80BA\u8F29\u914D\u500D\u57F9\u5A92\u6885"],
+ ["9480", "\u6973\u7164\u72FD\u8CB7\u58F2\u8CE0\u966A\u9019\u877F\u79E4\u77E7\u8429\u4F2F\u5265\u535A\u62CD\u67CF\u6CCA\u767D\u7B94\u7C95\u8236\u8584\u8FEB\u66DD\u6F20\u7206\u7E1B\u83AB\u99C1\u9EA6\u51FD\u7BB1\u7872\u7BB8\u8087\u7B48\u6AE8\u5E61\u808C\u7551\u7560\u516B\u9262\u6E8C\u767A\u9197\u9AEA\u4F10\u7F70\u629C\u7B4F\u95A5\u9CE9\u567A\u5859\u86E4\u96BC\u4F34\u5224\u534A\u53CD\u53DB\u5E06\u642C\u6591\u677F\u6C3E\u6C4E\u7248\u72AF\u73ED\u7554\u7E41\u822C\u85E9\u8CA9\u7BC4\u91C6\u7169\u9812\u98EF\u633D\u6669\u756A\u76E4\u78D0\u8543\u86EE\u532A\u5351\u5426\u5983\u5E87\u5F7C\u60B2\u6249\u6279\u62AB\u6590\u6BD4\u6CCC\u75B2\u76AE\u7891\u79D8\u7DCB\u7F77\u80A5\u88AB\u8AB9\u8CBB\u907F\u975E\u98DB\u6A0B\u7C38\u5099\u5C3E\u5FAE\u6787\u6BD8\u7435\u7709\u7F8E"],
+ ["9540", "\u9F3B\u67CA\u7A17\u5339\u758B\u9AED\u5F66\u819D\u83F1\u8098\u5F3C\u5FC5\u7562\u7B46\u903C\u6867\u59EB\u5A9B\u7D10\u767E\u8B2C\u4FF5\u5F6A\u6A19\u6C37\u6F02\u74E2\u7968\u8868\u8A55\u8C79\u5EDF\u63CF\u75C5\u79D2\u82D7\u9328\u92F2\u849C\u86ED\u9C2D\u54C1\u5F6C\u658C\u6D5C\u7015\u8CA7\u8CD3\u983B\u654F\u74F6\u4E0D\u4ED8\u57E0\u592B\u5A66\u5BCC\u51A8\u5E03\u5E9C\u6016\u6276\u6577"],
+ ["9580", "\u65A7\u666E\u6D6E\u7236\u7B26\u8150\u819A\u8299\u8B5C\u8CA0\u8CE6\u8D74\u961C\u9644\u4FAE\u64AB\u6B66\u821E\u8461\u856A\u90E8\u5C01\u6953\u98A8\u847A\u8557\u4F0F\u526F\u5FA9\u5E45\u670D\u798F\u8179\u8907\u8986\u6DF5\u5F17\u6255\u6CB8\u4ECF\u7269\u9B92\u5206\u543B\u5674\u58B3\u61A4\u626E\u711A\u596E\u7C89\u7CDE\u7D1B\u96F0\u6587\u805E\u4E19\u4F75\u5175\u5840\u5E63\u5E73\u5F0A\u67C4\u4E26\u853D\u9589\u965B\u7C73\u9801\u50FB\u58C1\u7656\u78A7\u5225\u77A5\u8511\u7B86\u504F\u5909\u7247\u7BC7\u7DE8\u8FBA\u8FD4\u904D\u4FBF\u52C9\u5A29\u5F01\u97AD\u4FDD\u8217\u92EA\u5703\u6355\u6B69\u752B\u88DC\u8F14\u7A42\u52DF\u5893\u6155\u620A\u66AE\u6BCD\u7C3F\u83E9\u5023\u4FF8\u5305\u5446\u5831\u5949\u5B9D\u5CF0\u5CEF\u5D29\u5E96\u62B1\u6367\u653E\u65B9\u670B"],
+ ["9640", "\u6CD5\u6CE1\u70F9\u7832\u7E2B\u80DE\u82B3\u840C\u84EC\u8702\u8912\u8A2A\u8C4A\u90A6\u92D2\u98FD\u9CF3\u9D6C\u4E4F\u4EA1\u508D\u5256\u574A\u59A8\u5E3D\u5FD8\u5FD9\u623F\u66B4\u671B\u67D0\u68D2\u5192\u7D21\u80AA\u81A8\u8B00\u8C8C\u8CBF\u927E\u9632\u5420\u982C\u5317\u50D5\u535C\u58A8\u64B2\u6734\u7267\u7766\u7A46\u91E6\u52C3\u6CA1\u6B86\u5800\u5E4C\u5954\u672C\u7FFB\u51E1\u76C6"],
+ ["9680", "\u6469\u78E8\u9B54\u9EBB\u57CB\u59B9\u6627\u679A\u6BCE\u54E9\u69D9\u5E55\u819C\u6795\u9BAA\u67FE\u9C52\u685D\u4EA6\u4FE3\u53C8\u62B9\u672B\u6CAB\u8FC4\u4FAD\u7E6D\u9EBF\u4E07\u6162\u6E80\u6F2B\u8513\u5473\u672A\u9B45\u5DF3\u7B95\u5CAC\u5BC6\u871C\u6E4A\u84D1\u7A14\u8108\u5999\u7C8D\u6C11\u7720\u52D9\u5922\u7121\u725F\u77DB\u9727\u9D61\u690B\u5A7F\u5A18\u51A5\u540D\u547D\u660E\u76DF\u8FF7\u9298\u9CF4\u59EA\u725D\u6EC5\u514D\u68C9\u7DBF\u7DEC\u9762\u9EBA\u6478\u6A21\u8302\u5984\u5B5F\u6BDB\u731B\u76F2\u7DB2\u8017\u8499\u5132\u6728\u9ED9\u76EE\u6762\u52FF\u9905\u5C24\u623B\u7C7E\u8CB0\u554F\u60B6\u7D0B\u9580\u5301\u4E5F\u51B6\u591C\u723A\u8036\u91CE\u5F25\u77E2\u5384\u5F79\u7D04\u85AC\u8A33\u8E8D\u9756\u67F3\u85AE\u9453\u6109\u6108\u6CB9\u7652"],
+ ["9740", "\u8AED\u8F38\u552F\u4F51\u512A\u52C7\u53CB\u5BA5\u5E7D\u60A0\u6182\u63D6\u6709\u67DA\u6E67\u6D8C\u7336\u7337\u7531\u7950\u88D5\u8A98\u904A\u9091\u90F5\u96C4\u878D\u5915\u4E88\u4F59\u4E0E\u8A89\u8F3F\u9810\u50AD\u5E7C\u5996\u5BB9\u5EB8\u63DA\u63FA\u64C1\u66DC\u694A\u69D8\u6D0B\u6EB6\u7194\u7528\u7AAF\u7F8A\u8000\u8449\u84C9\u8981\u8B21\u8E0A\u9065\u967D\u990A\u617E\u6291\u6B32"],
+ ["9780", "\u6C83\u6D74\u7FCC\u7FFC\u6DC0\u7F85\u87BA\u88F8\u6765\u83B1\u983C\u96F7\u6D1B\u7D61\u843D\u916A\u4E71\u5375\u5D50\u6B04\u6FEB\u85CD\u862D\u89A7\u5229\u540F\u5C65\u674E\u68A8\u7406\u7483\u75E2\u88CF\u88E1\u91CC\u96E2\u9678\u5F8B\u7387\u7ACB\u844E\u63A0\u7565\u5289\u6D41\u6E9C\u7409\u7559\u786B\u7C92\u9686\u7ADC\u9F8D\u4FB6\u616E\u65C5\u865C\u4E86\u4EAE\u50DA\u4E21\u51CC\u5BEE\u6599\u6881\u6DBC\u731F\u7642\u77AD\u7A1C\u7CE7\u826F\u8AD2\u907C\u91CF\u9675\u9818\u529B\u7DD1\u502B\u5398\u6797\u6DCB\u71D0\u7433\u81E8\u8F2A\u96A3\u9C57\u9E9F\u7460\u5841\u6D99\u7D2F\u985E\u4EE4\u4F36\u4F8B\u51B7\u52B1\u5DBA\u601C\u73B2\u793C\u82D3\u9234\u96B7\u96F6\u970A\u9E97\u9F62\u66A6\u6B74\u5217\u52A3\u70C8\u88C2\u5EC9\u604B\u6190\u6F23\u7149\u7C3E\u7DF4\u806F"],
+ ["9840", "\u84EE\u9023\u932C\u5442\u9B6F\u6AD3\u7089\u8CC2\u8DEF\u9732\u52B4\u5A41\u5ECA\u5F04\u6717\u697C\u6994\u6D6A\u6F0F\u7262\u72FC\u7BED\u8001\u807E\u874B\u90CE\u516D\u9E93\u7984\u808B\u9332\u8AD6\u502D\u548C\u8A71\u6B6A\u8CC4\u8107\u60D1\u67A0\u9DF2\u4E99\u4E98\u9C10\u8A6B\u85C1\u8568\u6900\u6E7E\u7897\u8155"],
+ ["989f", "\u5F0C\u4E10\u4E15\u4E2A\u4E31\u4E36\u4E3C\u4E3F\u4E42\u4E56\u4E58\u4E82\u4E85\u8C6B\u4E8A\u8212\u5F0D\u4E8E\u4E9E\u4E9F\u4EA0\u4EA2\u4EB0\u4EB3\u4EB6\u4ECE\u4ECD\u4EC4\u4EC6\u4EC2\u4ED7\u4EDE\u4EED\u4EDF\u4EF7\u4F09\u4F5A\u4F30\u4F5B\u4F5D\u4F57\u4F47\u4F76\u4F88\u4F8F\u4F98\u4F7B\u4F69\u4F70\u4F91\u4F6F\u4F86\u4F96\u5118\u4FD4\u4FDF\u4FCE\u4FD8\u4FDB\u4FD1\u4FDA\u4FD0\u4FE4\u4FE5\u501A\u5028\u5014\u502A\u5025\u5005\u4F1C\u4FF6\u5021\u5029\u502C\u4FFE\u4FEF\u5011\u5006\u5043\u5047\u6703\u5055\u5050\u5048\u505A\u5056\u506C\u5078\u5080\u509A\u5085\u50B4\u50B2"],
+ ["9940", "\u50C9\u50CA\u50B3\u50C2\u50D6\u50DE\u50E5\u50ED\u50E3\u50EE\u50F9\u50F5\u5109\u5101\u5102\u5116\u5115\u5114\u511A\u5121\u513A\u5137\u513C\u513B\u513F\u5140\u5152\u514C\u5154\u5162\u7AF8\u5169\u516A\u516E\u5180\u5182\u56D8\u518C\u5189\u518F\u5191\u5193\u5195\u5196\u51A4\u51A6\u51A2\u51A9\u51AA\u51AB\u51B3\u51B1\u51B2\u51B0\u51B5\u51BD\u51C5\u51C9\u51DB\u51E0\u8655\u51E9\u51ED"],
+ ["9980", "\u51F0\u51F5\u51FE\u5204\u520B\u5214\u520E\u5227\u522A\u522E\u5233\u5239\u524F\u5244\u524B\u524C\u525E\u5254\u526A\u5274\u5269\u5273\u527F\u527D\u528D\u5294\u5292\u5271\u5288\u5291\u8FA8\u8FA7\u52AC\u52AD\u52BC\u52B5\u52C1\u52CD\u52D7\u52DE\u52E3\u52E6\u98ED\u52E0\u52F3\u52F5\u52F8\u52F9\u5306\u5308\u7538\u530D\u5310\u530F\u5315\u531A\u5323\u532F\u5331\u5333\u5338\u5340\u5346\u5345\u4E17\u5349\u534D\u51D6\u535E\u5369\u536E\u5918\u537B\u5377\u5382\u5396\u53A0\u53A6\u53A5\u53AE\u53B0\u53B6\u53C3\u7C12\u96D9\u53DF\u66FC\u71EE\u53EE\u53E8\u53ED\u53FA\u5401\u543D\u5440\u542C\u542D\u543C\u542E\u5436\u5429\u541D\u544E\u548F\u5475\u548E\u545F\u5471\u5477\u5470\u5492\u547B\u5480\u5476\u5484\u5490\u5486\u54C7\u54A2\u54B8\u54A5\u54AC\u54C4\u54C8\u54A8"],
+ ["9a40", "\u54AB\u54C2\u54A4\u54BE\u54BC\u54D8\u54E5\u54E6\u550F\u5514\u54FD\u54EE\u54ED\u54FA\u54E2\u5539\u5540\u5563\u554C\u552E\u555C\u5545\u5556\u5557\u5538\u5533\u555D\u5599\u5580\u54AF\u558A\u559F\u557B\u557E\u5598\u559E\u55AE\u557C\u5583\u55A9\u5587\u55A8\u55DA\u55C5\u55DF\u55C4\u55DC\u55E4\u55D4\u5614\u55F7\u5616\u55FE\u55FD\u561B\u55F9\u564E\u5650\u71DF\u5634\u5636\u5632\u5638"],
+ ["9a80", "\u566B\u5664\u562F\u566C\u566A\u5686\u5680\u568A\u56A0\u5694\u568F\u56A5\u56AE\u56B6\u56B4\u56C2\u56BC\u56C1\u56C3\u56C0\u56C8\u56CE\u56D1\u56D3\u56D7\u56EE\u56F9\u5700\u56FF\u5704\u5709\u5708\u570B\u570D\u5713\u5718\u5716\u55C7\u571C\u5726\u5737\u5738\u574E\u573B\u5740\u574F\u5769\u57C0\u5788\u5761\u577F\u5789\u5793\u57A0\u57B3\u57A4\u57AA\u57B0\u57C3\u57C6\u57D4\u57D2\u57D3\u580A\u57D6\u57E3\u580B\u5819\u581D\u5872\u5821\u5862\u584B\u5870\u6BC0\u5852\u583D\u5879\u5885\u58B9\u589F\u58AB\u58BA\u58DE\u58BB\u58B8\u58AE\u58C5\u58D3\u58D1\u58D7\u58D9\u58D8\u58E5\u58DC\u58E4\u58DF\u58EF\u58FA\u58F9\u58FB\u58FC\u58FD\u5902\u590A\u5910\u591B\u68A6\u5925\u592C\u592D\u5932\u5938\u593E\u7AD2\u5955\u5950\u594E\u595A\u5958\u5962\u5960\u5967\u596C\u5969"],
+ ["9b40", "\u5978\u5981\u599D\u4F5E\u4FAB\u59A3\u59B2\u59C6\u59E8\u59DC\u598D\u59D9\u59DA\u5A25\u5A1F\u5A11\u5A1C\u5A09\u5A1A\u5A40\u5A6C\u5A49\u5A35\u5A36\u5A62\u5A6A\u5A9A\u5ABC\u5ABE\u5ACB\u5AC2\u5ABD\u5AE3\u5AD7\u5AE6\u5AE9\u5AD6\u5AFA\u5AFB\u5B0C\u5B0B\u5B16\u5B32\u5AD0\u5B2A\u5B36\u5B3E\u5B43\u5B45\u5B40\u5B51\u5B55\u5B5A\u5B5B\u5B65\u5B69\u5B70\u5B73\u5B75\u5B78\u6588\u5B7A\u5B80"],
+ ["9b80", "\u5B83\u5BA6\u5BB8\u5BC3\u5BC7\u5BC9\u5BD4\u5BD0\u5BE4\u5BE6\u5BE2\u5BDE\u5BE5\u5BEB\u5BF0\u5BF6\u5BF3\u5C05\u5C07\u5C08\u5C0D\u5C13\u5C20\u5C22\u5C28\u5C38\u5C39\u5C41\u5C46\u5C4E\u5C53\u5C50\u5C4F\u5B71\u5C6C\u5C6E\u4E62\u5C76\u5C79\u5C8C\u5C91\u5C94\u599B\u5CAB\u5CBB\u5CB6\u5CBC\u5CB7\u5CC5\u5CBE\u5CC7\u5CD9\u5CE9\u5CFD\u5CFA\u5CED\u5D8C\u5CEA\u5D0B\u5D15\u5D17\u5D5C\u5D1F\u5D1B\u5D11\u5D14\u5D22\u5D1A\u5D19\u5D18\u5D4C\u5D52\u5D4E\u5D4B\u5D6C\u5D73\u5D76\u5D87\u5D84\u5D82\u5DA2\u5D9D\u5DAC\u5DAE\u5DBD\u5D90\u5DB7\u5DBC\u5DC9\u5DCD\u5DD3\u5DD2\u5DD6\u5DDB\u5DEB\u5DF2\u5DF5\u5E0B\u5E1A\u5E19\u5E11\u5E1B\u5E36\u5E37\u5E44\u5E43\u5E40\u5E4E\u5E57\u5E54\u5E5F\u5E62\u5E64\u5E47\u5E75\u5E76\u5E7A\u9EBC\u5E7F\u5EA0\u5EC1\u5EC2\u5EC8\u5ED0\u5ECF"],
+ ["9c40", "\u5ED6\u5EE3\u5EDD\u5EDA\u5EDB\u5EE2\u5EE1\u5EE8\u5EE9\u5EEC\u5EF1\u5EF3\u5EF0\u5EF4\u5EF8\u5EFE\u5F03\u5F09\u5F5D\u5F5C\u5F0B\u5F11\u5F16\u5F29\u5F2D\u5F38\u5F41\u5F48\u5F4C\u5F4E\u5F2F\u5F51\u5F56\u5F57\u5F59\u5F61\u5F6D\u5F73\u5F77\u5F83\u5F82\u5F7F\u5F8A\u5F88\u5F91\u5F87\u5F9E\u5F99\u5F98\u5FA0\u5FA8\u5FAD\u5FBC\u5FD6\u5FFB\u5FE4\u5FF8\u5FF1\u5FDD\u60B3\u5FFF\u6021\u6060"],
+ ["9c80", "\u6019\u6010\u6029\u600E\u6031\u601B\u6015\u602B\u6026\u600F\u603A\u605A\u6041\u606A\u6077\u605F\u604A\u6046\u604D\u6063\u6043\u6064\u6042\u606C\u606B\u6059\u6081\u608D\u60E7\u6083\u609A\u6084\u609B\u6096\u6097\u6092\u60A7\u608B\u60E1\u60B8\u60E0\u60D3\u60B4\u5FF0\u60BD\u60C6\u60B5\u60D8\u614D\u6115\u6106\u60F6\u60F7\u6100\u60F4\u60FA\u6103\u6121\u60FB\u60F1\u610D\u610E\u6147\u613E\u6128\u6127\u614A\u613F\u613C\u612C\u6134\u613D\u6142\u6144\u6173\u6177\u6158\u6159\u615A\u616B\u6174\u616F\u6165\u6171\u615F\u615D\u6153\u6175\u6199\u6196\u6187\u61AC\u6194\u619A\u618A\u6191\u61AB\u61AE\u61CC\u61CA\u61C9\u61F7\u61C8\u61C3\u61C6\u61BA\u61CB\u7F79\u61CD\u61E6\u61E3\u61F6\u61FA\u61F4\u61FF\u61FD\u61FC\u61FE\u6200\u6208\u6209\u620D\u620C\u6214\u621B"],
+ ["9d40", "\u621E\u6221\u622A\u622E\u6230\u6232\u6233\u6241\u624E\u625E\u6263\u625B\u6260\u6268\u627C\u6282\u6289\u627E\u6292\u6293\u6296\u62D4\u6283\u6294\u62D7\u62D1\u62BB\u62CF\u62FF\u62C6\u64D4\u62C8\u62DC\u62CC\u62CA\u62C2\u62C7\u629B\u62C9\u630C\u62EE\u62F1\u6327\u6302\u6308\u62EF\u62F5\u6350\u633E\u634D\u641C\u634F\u6396\u638E\u6380\u63AB\u6376\u63A3\u638F\u6389\u639F\u63B5\u636B"],
+ ["9d80", "\u6369\u63BE\u63E9\u63C0\u63C6\u63E3\u63C9\u63D2\u63F6\u63C4\u6416\u6434\u6406\u6413\u6426\u6436\u651D\u6417\u6428\u640F\u6467\u646F\u6476\u644E\u652A\u6495\u6493\u64A5\u64A9\u6488\u64BC\u64DA\u64D2\u64C5\u64C7\u64BB\u64D8\u64C2\u64F1\u64E7\u8209\u64E0\u64E1\u62AC\u64E3\u64EF\u652C\u64F6\u64F4\u64F2\u64FA\u6500\u64FD\u6518\u651C\u6505\u6524\u6523\u652B\u6534\u6535\u6537\u6536\u6538\u754B\u6548\u6556\u6555\u654D\u6558\u655E\u655D\u6572\u6578\u6582\u6583\u8B8A\u659B\u659F\u65AB\u65B7\u65C3\u65C6\u65C1\u65C4\u65CC\u65D2\u65DB\u65D9\u65E0\u65E1\u65F1\u6772\u660A\u6603\u65FB\u6773\u6635\u6636\u6634\u661C\u664F\u6644\u6649\u6641\u665E\u665D\u6664\u6667\u6668\u665F\u6662\u6670\u6683\u6688\u668E\u6689\u6684\u6698\u669D\u66C1\u66B9\u66C9\u66BE\u66BC"],
+ ["9e40", "\u66C4\u66B8\u66D6\u66DA\u66E0\u663F\u66E6\u66E9\u66F0\u66F5\u66F7\u670F\u6716\u671E\u6726\u6727\u9738\u672E\u673F\u6736\u6741\u6738\u6737\u6746\u675E\u6760\u6759\u6763\u6764\u6789\u6770\u67A9\u677C\u676A\u678C\u678B\u67A6\u67A1\u6785\u67B7\u67EF\u67B4\u67EC\u67B3\u67E9\u67B8\u67E4\u67DE\u67DD\u67E2\u67EE\u67B9\u67CE\u67C6\u67E7\u6A9C\u681E\u6846\u6829\u6840\u684D\u6832\u684E"],
+ ["9e80", "\u68B3\u682B\u6859\u6863\u6877\u687F\u689F\u688F\u68AD\u6894\u689D\u689B\u6883\u6AAE\u68B9\u6874\u68B5\u68A0\u68BA\u690F\u688D\u687E\u6901\u68CA\u6908\u68D8\u6922\u6926\u68E1\u690C\u68CD\u68D4\u68E7\u68D5\u6936\u6912\u6904\u68D7\u68E3\u6925\u68F9\u68E0\u68EF\u6928\u692A\u691A\u6923\u6921\u68C6\u6979\u6977\u695C\u6978\u696B\u6954\u697E\u696E\u6939\u6974\u693D\u6959\u6930\u6961\u695E\u695D\u6981\u696A\u69B2\u69AE\u69D0\u69BF\u69C1\u69D3\u69BE\u69CE\u5BE8\u69CA\u69DD\u69BB\u69C3\u69A7\u6A2E\u6991\u69A0\u699C\u6995\u69B4\u69DE\u69E8\u6A02\u6A1B\u69FF\u6B0A\u69F9\u69F2\u69E7\u6A05\u69B1\u6A1E\u69ED\u6A14\u69EB\u6A0A\u6A12\u6AC1\u6A23\u6A13\u6A44\u6A0C\u6A72\u6A36\u6A78\u6A47\u6A62\u6A59\u6A66\u6A48\u6A38\u6A22\u6A90\u6A8D\u6AA0\u6A84\u6AA2\u6AA3"],
+ ["9f40", "\u6A97\u8617\u6ABB\u6AC3\u6AC2\u6AB8\u6AB3\u6AAC\u6ADE\u6AD1\u6ADF\u6AAA\u6ADA\u6AEA\u6AFB\u6B05\u8616\u6AFA\u6B12\u6B16\u9B31\u6B1F\u6B38\u6B37\u76DC\u6B39\u98EE\u6B47\u6B43\u6B49\u6B50\u6B59\u6B54\u6B5B\u6B5F\u6B61\u6B78\u6B79\u6B7F\u6B80\u6B84\u6B83\u6B8D\u6B98\u6B95\u6B9E\u6BA4\u6BAA\u6BAB\u6BAF\u6BB2\u6BB1\u6BB3\u6BB7\u6BBC\u6BC6\u6BCB\u6BD3\u6BDF\u6BEC\u6BEB\u6BF3\u6BEF"],
+ ["9f80", "\u9EBE\u6C08\u6C13\u6C14\u6C1B\u6C24\u6C23\u6C5E\u6C55\u6C62\u6C6A\u6C82\u6C8D\u6C9A\u6C81\u6C9B\u6C7E\u6C68\u6C73\u6C92\u6C90\u6CC4\u6CF1\u6CD3\u6CBD\u6CD7\u6CC5\u6CDD\u6CAE\u6CB1\u6CBE\u6CBA\u6CDB\u6CEF\u6CD9\u6CEA\u6D1F\u884D\u6D36\u6D2B\u6D3D\u6D38\u6D19\u6D35\u6D33\u6D12\u6D0C\u6D63\u6D93\u6D64\u6D5A\u6D79\u6D59\u6D8E\u6D95\u6FE4\u6D85\u6DF9\u6E15\u6E0A\u6DB5\u6DC7\u6DE6\u6DB8\u6DC6\u6DEC\u6DDE\u6DCC\u6DE8\u6DD2\u6DC5\u6DFA\u6DD9\u6DE4\u6DD5\u6DEA\u6DEE\u6E2D\u6E6E\u6E2E\u6E19\u6E72\u6E5F\u6E3E\u6E23\u6E6B\u6E2B\u6E76\u6E4D\u6E1F\u6E43\u6E3A\u6E4E\u6E24\u6EFF\u6E1D\u6E38\u6E82\u6EAA\u6E98\u6EC9\u6EB7\u6ED3\u6EBD\u6EAF\u6EC4\u6EB2\u6ED4\u6ED5\u6E8F\u6EA5\u6EC2\u6E9F\u6F41\u6F11\u704C\u6EEC\u6EF8\u6EFE\u6F3F\u6EF2\u6F31\u6EEF\u6F32\u6ECC"],
+ ["e040", "\u6F3E\u6F13\u6EF7\u6F86\u6F7A\u6F78\u6F81\u6F80\u6F6F\u6F5B\u6FF3\u6F6D\u6F82\u6F7C\u6F58\u6F8E\u6F91\u6FC2\u6F66\u6FB3\u6FA3\u6FA1\u6FA4\u6FB9\u6FC6\u6FAA\u6FDF\u6FD5\u6FEC\u6FD4\u6FD8\u6FF1\u6FEE\u6FDB\u7009\u700B\u6FFA\u7011\u7001\u700F\u6FFE\u701B\u701A\u6F74\u701D\u7018\u701F\u7030\u703E\u7032\u7051\u7063\u7099\u7092\u70AF\u70F1\u70AC\u70B8\u70B3\u70AE\u70DF\u70CB\u70DD"],
+ ["e080", "\u70D9\u7109\u70FD\u711C\u7119\u7165\u7155\u7188\u7166\u7162\u714C\u7156\u716C\u718F\u71FB\u7184\u7195\u71A8\u71AC\u71D7\u71B9\u71BE\u71D2\u71C9\u71D4\u71CE\u71E0\u71EC\u71E7\u71F5\u71FC\u71F9\u71FF\u720D\u7210\u721B\u7228\u722D\u722C\u7230\u7232\u723B\u723C\u723F\u7240\u7246\u724B\u7258\u7274\u727E\u7282\u7281\u7287\u7292\u7296\u72A2\u72A7\u72B9\u72B2\u72C3\u72C6\u72C4\u72CE\u72D2\u72E2\u72E0\u72E1\u72F9\u72F7\u500F\u7317\u730A\u731C\u7316\u731D\u7334\u732F\u7329\u7325\u733E\u734E\u734F\u9ED8\u7357\u736A\u7368\u7370\u7378\u7375\u737B\u737A\u73C8\u73B3\u73CE\u73BB\u73C0\u73E5\u73EE\u73DE\u74A2\u7405\u746F\u7425\u73F8\u7432\u743A\u7455\u743F\u745F\u7459\u7441\u745C\u7469\u7470\u7463\u746A\u7476\u747E\u748B\u749E\u74A7\u74CA\u74CF\u74D4\u73F1"],
+ ["e140", "\u74E0\u74E3\u74E7\u74E9\u74EE\u74F2\u74F0\u74F1\u74F8\u74F7\u7504\u7503\u7505\u750C\u750E\u750D\u7515\u7513\u751E\u7526\u752C\u753C\u7544\u754D\u754A\u7549\u755B\u7546\u755A\u7569\u7564\u7567\u756B\u756D\u7578\u7576\u7586\u7587\u7574\u758A\u7589\u7582\u7594\u759A\u759D\u75A5\u75A3\u75C2\u75B3\u75C3\u75B5\u75BD\u75B8\u75BC\u75B1\u75CD\u75CA\u75D2\u75D9\u75E3\u75DE\u75FE\u75FF"],
+ ["e180", "\u75FC\u7601\u75F0\u75FA\u75F2\u75F3\u760B\u760D\u7609\u761F\u7627\u7620\u7621\u7622\u7624\u7634\u7630\u763B\u7647\u7648\u7646\u765C\u7658\u7661\u7662\u7668\u7669\u766A\u7667\u766C\u7670\u7672\u7676\u7678\u767C\u7680\u7683\u7688\u768B\u768E\u7696\u7693\u7699\u769A\u76B0\u76B4\u76B8\u76B9\u76BA\u76C2\u76CD\u76D6\u76D2\u76DE\u76E1\u76E5\u76E7\u76EA\u862F\u76FB\u7708\u7707\u7704\u7729\u7724\u771E\u7725\u7726\u771B\u7737\u7738\u7747\u775A\u7768\u776B\u775B\u7765\u777F\u777E\u7779\u778E\u778B\u7791\u77A0\u779E\u77B0\u77B6\u77B9\u77BF\u77BC\u77BD\u77BB\u77C7\u77CD\u77D7\u77DA\u77DC\u77E3\u77EE\u77FC\u780C\u7812\u7926\u7820\u792A\u7845\u788E\u7874\u7886\u787C\u789A\u788C\u78A3\u78B5\u78AA\u78AF\u78D1\u78C6\u78CB\u78D4\u78BE\u78BC\u78C5\u78CA\u78EC"],
+ ["e240", "\u78E7\u78DA\u78FD\u78F4\u7907\u7912\u7911\u7919\u792C\u792B\u7940\u7960\u7957\u795F\u795A\u7955\u7953\u797A\u797F\u798A\u799D\u79A7\u9F4B\u79AA\u79AE\u79B3\u79B9\u79BA\u79C9\u79D5\u79E7\u79EC\u79E1\u79E3\u7A08\u7A0D\u7A18\u7A19\u7A20\u7A1F\u7980\u7A31\u7A3B\u7A3E\u7A37\u7A43\u7A57\u7A49\u7A61\u7A62\u7A69\u9F9D\u7A70\u7A79\u7A7D\u7A88\u7A97\u7A95\u7A98\u7A96\u7AA9\u7AC8\u7AB0"],
+ ["e280", "\u7AB6\u7AC5\u7AC4\u7ABF\u9083\u7AC7\u7ACA\u7ACD\u7ACF\u7AD5\u7AD3\u7AD9\u7ADA\u7ADD\u7AE1\u7AE2\u7AE6\u7AED\u7AF0\u7B02\u7B0F\u7B0A\u7B06\u7B33\u7B18\u7B19\u7B1E\u7B35\u7B28\u7B36\u7B50\u7B7A\u7B04\u7B4D\u7B0B\u7B4C\u7B45\u7B75\u7B65\u7B74\u7B67\u7B70\u7B71\u7B6C\u7B6E\u7B9D\u7B98\u7B9F\u7B8D\u7B9C\u7B9A\u7B8B\u7B92\u7B8F\u7B5D\u7B99\u7BCB\u7BC1\u7BCC\u7BCF\u7BB4\u7BC6\u7BDD\u7BE9\u7C11\u7C14\u7BE6\u7BE5\u7C60\u7C00\u7C07\u7C13\u7BF3\u7BF7\u7C17\u7C0D\u7BF6\u7C23\u7C27\u7C2A\u7C1F\u7C37\u7C2B\u7C3D\u7C4C\u7C43\u7C54\u7C4F\u7C40\u7C50\u7C58\u7C5F\u7C64\u7C56\u7C65\u7C6C\u7C75\u7C83\u7C90\u7CA4\u7CAD\u7CA2\u7CAB\u7CA1\u7CA8\u7CB3\u7CB2\u7CB1\u7CAE\u7CB9\u7CBD\u7CC0\u7CC5\u7CC2\u7CD8\u7CD2\u7CDC\u7CE2\u9B3B\u7CEF\u7CF2\u7CF4\u7CF6\u7CFA\u7D06"],
+ ["e340", "\u7D02\u7D1C\u7D15\u7D0A\u7D45\u7D4B\u7D2E\u7D32\u7D3F\u7D35\u7D46\u7D73\u7D56\u7D4E\u7D72\u7D68\u7D6E\u7D4F\u7D63\u7D93\u7D89\u7D5B\u7D8F\u7D7D\u7D9B\u7DBA\u7DAE\u7DA3\u7DB5\u7DC7\u7DBD\u7DAB\u7E3D\u7DA2\u7DAF\u7DDC\u7DB8\u7D9F\u7DB0\u7DD8\u7DDD\u7DE4\u7DDE\u7DFB\u7DF2\u7DE1\u7E05\u7E0A\u7E23\u7E21\u7E12\u7E31\u7E1F\u7E09\u7E0B\u7E22\u7E46\u7E66\u7E3B\u7E35\u7E39\u7E43\u7E37"],
+ ["e380", "\u7E32\u7E3A\u7E67\u7E5D\u7E56\u7E5E\u7E59\u7E5A\u7E79\u7E6A\u7E69\u7E7C\u7E7B\u7E83\u7DD5\u7E7D\u8FAE\u7E7F\u7E88\u7E89\u7E8C\u7E92\u7E90\u7E93\u7E94\u7E96\u7E8E\u7E9B\u7E9C\u7F38\u7F3A\u7F45\u7F4C\u7F4D\u7F4E\u7F50\u7F51\u7F55\u7F54\u7F58\u7F5F\u7F60\u7F68\u7F69\u7F67\u7F78\u7F82\u7F86\u7F83\u7F88\u7F87\u7F8C\u7F94\u7F9E\u7F9D\u7F9A\u7FA3\u7FAF\u7FB2\u7FB9\u7FAE\u7FB6\u7FB8\u8B71\u7FC5\u7FC6\u7FCA\u7FD5\u7FD4\u7FE1\u7FE6\u7FE9\u7FF3\u7FF9\u98DC\u8006\u8004\u800B\u8012\u8018\u8019\u801C\u8021\u8028\u803F\u803B\u804A\u8046\u8052\u8058\u805A\u805F\u8062\u8068\u8073\u8072\u8070\u8076\u8079\u807D\u807F\u8084\u8086\u8085\u809B\u8093\u809A\u80AD\u5190\u80AC\u80DB\u80E5\u80D9\u80DD\u80C4\u80DA\u80D6\u8109\u80EF\u80F1\u811B\u8129\u8123\u812F\u814B"],
+ ["e440", "\u968B\u8146\u813E\u8153\u8151\u80FC\u8171\u816E\u8165\u8166\u8174\u8183\u8188\u818A\u8180\u8182\u81A0\u8195\u81A4\u81A3\u815F\u8193\u81A9\u81B0\u81B5\u81BE\u81B8\u81BD\u81C0\u81C2\u81BA\u81C9\u81CD\u81D1\u81D9\u81D8\u81C8\u81DA\u81DF\u81E0\u81E7\u81FA\u81FB\u81FE\u8201\u8202\u8205\u8207\u820A\u820D\u8210\u8216\u8229\u822B\u8238\u8233\u8240\u8259\u8258\u825D\u825A\u825F\u8264"],
+ ["e480", "\u8262\u8268\u826A\u826B\u822E\u8271\u8277\u8278\u827E\u828D\u8292\u82AB\u829F\u82BB\u82AC\u82E1\u82E3\u82DF\u82D2\u82F4\u82F3\u82FA\u8393\u8303\u82FB\u82F9\u82DE\u8306\u82DC\u8309\u82D9\u8335\u8334\u8316\u8332\u8331\u8340\u8339\u8350\u8345\u832F\u832B\u8317\u8318\u8385\u839A\u83AA\u839F\u83A2\u8396\u8323\u838E\u8387\u838A\u837C\u83B5\u8373\u8375\u83A0\u8389\u83A8\u83F4\u8413\u83EB\u83CE\u83FD\u8403\u83D8\u840B\u83C1\u83F7\u8407\u83E0\u83F2\u840D\u8422\u8420\u83BD\u8438\u8506\u83FB\u846D\u842A\u843C\u855A\u8484\u8477\u846B\u84AD\u846E\u8482\u8469\u8446\u842C\u846F\u8479\u8435\u84CA\u8462\u84B9\u84BF\u849F\u84D9\u84CD\u84BB\u84DA\u84D0\u84C1\u84C6\u84D6\u84A1\u8521\u84FF\u84F4\u8517\u8518\u852C\u851F\u8515\u8514\u84FC\u8540\u8563\u8558\u8548"],
+ ["e540", "\u8541\u8602\u854B\u8555\u8580\u85A4\u8588\u8591\u858A\u85A8\u856D\u8594\u859B\u85EA\u8587\u859C\u8577\u857E\u8590\u85C9\u85BA\u85CF\u85B9\u85D0\u85D5\u85DD\u85E5\u85DC\u85F9\u860A\u8613\u860B\u85FE\u85FA\u8606\u8622\u861A\u8630\u863F\u864D\u4E55\u8654\u865F\u8667\u8671\u8693\u86A3\u86A9\u86AA\u868B\u868C\u86B6\u86AF\u86C4\u86C6\u86B0\u86C9\u8823\u86AB\u86D4\u86DE\u86E9\u86EC"],
+ ["e580", "\u86DF\u86DB\u86EF\u8712\u8706\u8708\u8700\u8703\u86FB\u8711\u8709\u870D\u86F9\u870A\u8734\u873F\u8737\u873B\u8725\u8729\u871A\u8760\u875F\u8778\u874C\u874E\u8774\u8757\u8768\u876E\u8759\u8753\u8763\u876A\u8805\u87A2\u879F\u8782\u87AF\u87CB\u87BD\u87C0\u87D0\u96D6\u87AB\u87C4\u87B3\u87C7\u87C6\u87BB\u87EF\u87F2\u87E0\u880F\u880D\u87FE\u87F6\u87F7\u880E\u87D2\u8811\u8816\u8815\u8822\u8821\u8831\u8836\u8839\u8827\u883B\u8844\u8842\u8852\u8859\u885E\u8862\u886B\u8881\u887E\u889E\u8875\u887D\u88B5\u8872\u8882\u8897\u8892\u88AE\u8899\u88A2\u888D\u88A4\u88B0\u88BF\u88B1\u88C3\u88C4\u88D4\u88D8\u88D9\u88DD\u88F9\u8902\u88FC\u88F4\u88E8\u88F2\u8904\u890C\u890A\u8913\u8943\u891E\u8925\u892A\u892B\u8941\u8944\u893B\u8936\u8938\u894C\u891D\u8960\u895E"],
+ ["e640", "\u8966\u8964\u896D\u896A\u896F\u8974\u8977\u897E\u8983\u8988\u898A\u8993\u8998\u89A1\u89A9\u89A6\u89AC\u89AF\u89B2\u89BA\u89BD\u89BF\u89C0\u89DA\u89DC\u89DD\u89E7\u89F4\u89F8\u8A03\u8A16\u8A10\u8A0C\u8A1B\u8A1D\u8A25\u8A36\u8A41\u8A5B\u8A52\u8A46\u8A48\u8A7C\u8A6D\u8A6C\u8A62\u8A85\u8A82\u8A84\u8AA8\u8AA1\u8A91\u8AA5\u8AA6\u8A9A\u8AA3\u8AC4\u8ACD\u8AC2\u8ADA\u8AEB\u8AF3\u8AE7"],
+ ["e680", "\u8AE4\u8AF1\u8B14\u8AE0\u8AE2\u8AF7\u8ADE\u8ADB\u8B0C\u8B07\u8B1A\u8AE1\u8B16\u8B10\u8B17\u8B20\u8B33\u97AB\u8B26\u8B2B\u8B3E\u8B28\u8B41\u8B4C\u8B4F\u8B4E\u8B49\u8B56\u8B5B\u8B5A\u8B6B\u8B5F\u8B6C\u8B6F\u8B74\u8B7D\u8B80\u8B8C\u8B8E\u8B92\u8B93\u8B96\u8B99\u8B9A\u8C3A\u8C41\u8C3F\u8C48\u8C4C\u8C4E\u8C50\u8C55\u8C62\u8C6C\u8C78\u8C7A\u8C82\u8C89\u8C85\u8C8A\u8C8D\u8C8E\u8C94\u8C7C\u8C98\u621D\u8CAD\u8CAA\u8CBD\u8CB2\u8CB3\u8CAE\u8CB6\u8CC8\u8CC1\u8CE4\u8CE3\u8CDA\u8CFD\u8CFA\u8CFB\u8D04\u8D05\u8D0A\u8D07\u8D0F\u8D0D\u8D10\u9F4E\u8D13\u8CCD\u8D14\u8D16\u8D67\u8D6D\u8D71\u8D73\u8D81\u8D99\u8DC2\u8DBE\u8DBA\u8DCF\u8DDA\u8DD6\u8DCC\u8DDB\u8DCB\u8DEA\u8DEB\u8DDF\u8DE3\u8DFC\u8E08\u8E09\u8DFF\u8E1D\u8E1E\u8E10\u8E1F\u8E42\u8E35\u8E30\u8E34\u8E4A"],
+ ["e740", "\u8E47\u8E49\u8E4C\u8E50\u8E48\u8E59\u8E64\u8E60\u8E2A\u8E63\u8E55\u8E76\u8E72\u8E7C\u8E81\u8E87\u8E85\u8E84\u8E8B\u8E8A\u8E93\u8E91\u8E94\u8E99\u8EAA\u8EA1\u8EAC\u8EB0\u8EC6\u8EB1\u8EBE\u8EC5\u8EC8\u8ECB\u8EDB\u8EE3\u8EFC\u8EFB\u8EEB\u8EFE\u8F0A\u8F05\u8F15\u8F12\u8F19\u8F13\u8F1C\u8F1F\u8F1B\u8F0C\u8F26\u8F33\u8F3B\u8F39\u8F45\u8F42\u8F3E\u8F4C\u8F49\u8F46\u8F4E\u8F57\u8F5C"],
+ ["e780", "\u8F62\u8F63\u8F64\u8F9C\u8F9F\u8FA3\u8FAD\u8FAF\u8FB7\u8FDA\u8FE5\u8FE2\u8FEA\u8FEF\u9087\u8FF4\u9005\u8FF9\u8FFA\u9011\u9015\u9021\u900D\u901E\u9016\u900B\u9027\u9036\u9035\u9039\u8FF8\u904F\u9050\u9051\u9052\u900E\u9049\u903E\u9056\u9058\u905E\u9068\u906F\u9076\u96A8\u9072\u9082\u907D\u9081\u9080\u908A\u9089\u908F\u90A8\u90AF\u90B1\u90B5\u90E2\u90E4\u6248\u90DB\u9102\u9112\u9119\u9132\u9130\u914A\u9156\u9158\u9163\u9165\u9169\u9173\u9172\u918B\u9189\u9182\u91A2\u91AB\u91AF\u91AA\u91B5\u91B4\u91BA\u91C0\u91C1\u91C9\u91CB\u91D0\u91D6\u91DF\u91E1\u91DB\u91FC\u91F5\u91F6\u921E\u91FF\u9214\u922C\u9215\u9211\u925E\u9257\u9245\u9249\u9264\u9248\u9295\u923F\u924B\u9250\u929C\u9296\u9293\u929B\u925A\u92CF\u92B9\u92B7\u92E9\u930F\u92FA\u9344\u932E"],
+ ["e840", "\u9319\u9322\u931A\u9323\u933A\u9335\u933B\u935C\u9360\u937C\u936E\u9356\u93B0\u93AC\u93AD\u9394\u93B9\u93D6\u93D7\u93E8\u93E5\u93D8\u93C3\u93DD\u93D0\u93C8\u93E4\u941A\u9414\u9413\u9403\u9407\u9410\u9436\u942B\u9435\u9421\u943A\u9441\u9452\u9444\u945B\u9460\u9462\u945E\u946A\u9229\u9470\u9475\u9477\u947D\u945A\u947C\u947E\u9481\u947F\u9582\u9587\u958A\u9594\u9596\u9598\u9599"],
+ ["e880", "\u95A0\u95A8\u95A7\u95AD\u95BC\u95BB\u95B9\u95BE\u95CA\u6FF6\u95C3\u95CD\u95CC\u95D5\u95D4\u95D6\u95DC\u95E1\u95E5\u95E2\u9621\u9628\u962E\u962F\u9642\u964C\u964F\u964B\u9677\u965C\u965E\u965D\u965F\u9666\u9672\u966C\u968D\u9698\u9695\u9697\u96AA\u96A7\u96B1\u96B2\u96B0\u96B4\u96B6\u96B8\u96B9\u96CE\u96CB\u96C9\u96CD\u894D\u96DC\u970D\u96D5\u96F9\u9704\u9706\u9708\u9713\u970E\u9711\u970F\u9716\u9719\u9724\u972A\u9730\u9739\u973D\u973E\u9744\u9746\u9748\u9742\u9749\u975C\u9760\u9764\u9766\u9768\u52D2\u976B\u9771\u9779\u9785\u977C\u9781\u977A\u9786\u978B\u978F\u9790\u979C\u97A8\u97A6\u97A3\u97B3\u97B4\u97C3\u97C6\u97C8\u97CB\u97DC\u97ED\u9F4F\u97F2\u7ADF\u97F6\u97F5\u980F\u980C\u9838\u9824\u9821\u9837\u983D\u9846\u984F\u984B\u986B\u986F\u9870"],
+ ["e940", "\u9871\u9874\u9873\u98AA\u98AF\u98B1\u98B6\u98C4\u98C3\u98C6\u98E9\u98EB\u9903\u9909\u9912\u9914\u9918\u9921\u991D\u991E\u9924\u9920\u992C\u992E\u993D\u993E\u9942\u9949\u9945\u9950\u994B\u9951\u9952\u994C\u9955\u9997\u9998\u99A5\u99AD\u99AE\u99BC\u99DF\u99DB\u99DD\u99D8\u99D1\u99ED\u99EE\u99F1\u99F2\u99FB\u99F8\u9A01\u9A0F\u9A05\u99E2\u9A19\u9A2B\u9A37\u9A45\u9A42\u9A40\u9A43"],
+ ["e980", "\u9A3E\u9A55\u9A4D\u9A5B\u9A57\u9A5F\u9A62\u9A65\u9A64\u9A69\u9A6B\u9A6A\u9AAD\u9AB0\u9ABC\u9AC0\u9ACF\u9AD1\u9AD3\u9AD4\u9ADE\u9ADF\u9AE2\u9AE3\u9AE6\u9AEF\u9AEB\u9AEE\u9AF4\u9AF1\u9AF7\u9AFB\u9B06\u9B18\u9B1A\u9B1F\u9B22\u9B23\u9B25\u9B27\u9B28\u9B29\u9B2A\u9B2E\u9B2F\u9B32\u9B44\u9B43\u9B4F\u9B4D\u9B4E\u9B51\u9B58\u9B74\u9B93\u9B83\u9B91\u9B96\u9B97\u9B9F\u9BA0\u9BA8\u9BB4\u9BC0\u9BCA\u9BB9\u9BC6\u9BCF\u9BD1\u9BD2\u9BE3\u9BE2\u9BE4\u9BD4\u9BE1\u9C3A\u9BF2\u9BF1\u9BF0\u9C15\u9C14\u9C09\u9C13\u9C0C\u9C06\u9C08\u9C12\u9C0A\u9C04\u9C2E\u9C1B\u9C25\u9C24\u9C21\u9C30\u9C47\u9C32\u9C46\u9C3E\u9C5A\u9C60\u9C67\u9C76\u9C78\u9CE7\u9CEC\u9CF0\u9D09\u9D08\u9CEB\u9D03\u9D06\u9D2A\u9D26\u9DAF\u9D23\u9D1F\u9D44\u9D15\u9D12\u9D41\u9D3F\u9D3E\u9D46\u9D48"],
+ ["ea40", "\u9D5D\u9D5E\u9D64\u9D51\u9D50\u9D59\u9D72\u9D89\u9D87\u9DAB\u9D6F\u9D7A\u9D9A\u9DA4\u9DA9\u9DB2\u9DC4\u9DC1\u9DBB\u9DB8\u9DBA\u9DC6\u9DCF\u9DC2\u9DD9\u9DD3\u9DF8\u9DE6\u9DED\u9DEF\u9DFD\u9E1A\u9E1B\u9E1E\u9E75\u9E79\u9E7D\u9E81\u9E88\u9E8B\u9E8C\u9E92\u9E95\u9E91\u9E9D\u9EA5\u9EA9\u9EB8\u9EAA\u9EAD\u9761\u9ECC\u9ECE\u9ECF\u9ED0\u9ED4\u9EDC\u9EDE\u9EDD\u9EE0\u9EE5\u9EE8\u9EEF"],
+ ["ea80", "\u9EF4\u9EF6\u9EF7\u9EF9\u9EFB\u9EFC\u9EFD\u9F07\u9F08\u76B7\u9F15\u9F21\u9F2C\u9F3E\u9F4A\u9F52\u9F54\u9F63\u9F5F\u9F60\u9F61\u9F66\u9F67\u9F6C\u9F6A\u9F77\u9F72\u9F76\u9F95\u9F9C\u9FA0\u582F\u69C7\u9059\u7464\u51DC\u7199"],
+ ["ed40", "\u7E8A\u891C\u9348\u9288\u84DC\u4FC9\u70BB\u6631\u68C8\u92F9\u66FB\u5F45\u4E28\u4EE1\u4EFC\u4F00\u4F03\u4F39\u4F56\u4F92\u4F8A\u4F9A\u4F94\u4FCD\u5040\u5022\u4FFF\u501E\u5046\u5070\u5042\u5094\u50F4\u50D8\u514A\u5164\u519D\u51BE\u51EC\u5215\u529C\u52A6\u52C0\u52DB\u5300\u5307\u5324\u5372\u5393\u53B2\u53DD\uFA0E\u549C\u548A\u54A9\u54FF\u5586\u5759\u5765\u57AC\u57C8\u57C7\uFA0F"],
+ ["ed80", "\uFA10\u589E\u58B2\u590B\u5953\u595B\u595D\u5963\u59A4\u59BA\u5B56\u5BC0\u752F\u5BD8\u5BEC\u5C1E\u5CA6\u5CBA\u5CF5\u5D27\u5D53\uFA11\u5D42\u5D6D\u5DB8\u5DB9\u5DD0\u5F21\u5F34\u5F67\u5FB7\u5FDE\u605D\u6085\u608A\u60DE\u60D5\u6120\u60F2\u6111\u6137\u6130\u6198\u6213\u62A6\u63F5\u6460\u649D\u64CE\u654E\u6600\u6615\u663B\u6609\u662E\u661E\u6624\u6665\u6657\u6659\uFA12\u6673\u6699\u66A0\u66B2\u66BF\u66FA\u670E\uF929\u6766\u67BB\u6852\u67C0\u6801\u6844\u68CF\uFA13\u6968\uFA14\u6998\u69E2\u6A30\u6A6B\u6A46\u6A73\u6A7E\u6AE2\u6AE4\u6BD6\u6C3F\u6C5C\u6C86\u6C6F\u6CDA\u6D04\u6D87\u6D6F\u6D96\u6DAC\u6DCF\u6DF8\u6DF2\u6DFC\u6E39\u6E5C\u6E27\u6E3C\u6EBF\u6F88\u6FB5\u6FF5\u7005\u7007\u7028\u7085\u70AB\u710F\u7104\u715C\u7146\u7147\uFA15\u71C1\u71FE\u72B1"],
+ ["ee40", "\u72BE\u7324\uFA16\u7377\u73BD\u73C9\u73D6\u73E3\u73D2\u7407\u73F5\u7426\u742A\u7429\u742E\u7462\u7489\u749F\u7501\u756F\u7682\u769C\u769E\u769B\u76A6\uFA17\u7746\u52AF\u7821\u784E\u7864\u787A\u7930\uFA18\uFA19\uFA1A\u7994\uFA1B\u799B\u7AD1\u7AE7\uFA1C\u7AEB\u7B9E\uFA1D\u7D48\u7D5C\u7DB7\u7DA0\u7DD6\u7E52\u7F47\u7FA1\uFA1E\u8301\u8362\u837F\u83C7\u83F6\u8448\u84B4\u8553\u8559"],
+ ["ee80", "\u856B\uFA1F\u85B0\uFA20\uFA21\u8807\u88F5\u8A12\u8A37\u8A79\u8AA7\u8ABE\u8ADF\uFA22\u8AF6\u8B53\u8B7F\u8CF0\u8CF4\u8D12\u8D76\uFA23\u8ECF\uFA24\uFA25\u9067\u90DE\uFA26\u9115\u9127\u91DA\u91D7\u91DE\u91ED\u91EE\u91E4\u91E5\u9206\u9210\u920A\u923A\u9240\u923C\u924E\u9259\u9251\u9239\u9267\u92A7\u9277\u9278\u92E7\u92D7\u92D9\u92D0\uFA27\u92D5\u92E0\u92D3\u9325\u9321\u92FB\uFA28\u931E\u92FF\u931D\u9302\u9370\u9357\u93A4\u93C6\u93DE\u93F8\u9431\u9445\u9448\u9592\uF9DC\uFA29\u969D\u96AF\u9733\u973B\u9743\u974D\u974F\u9751\u9755\u9857\u9865\uFA2A\uFA2B\u9927\uFA2C\u999E\u9A4E\u9AD9\u9ADC\u9B75\u9B72\u9B8F\u9BB1\u9BBB\u9C00\u9D70\u9D6B\uFA2D\u9E19\u9ED1"],
+ ["eeef", "\u2170", 9, "\uFFE2\uFFE4\uFF07\uFF02"],
+ ["f040", "\uE000", 62],
+ ["f080", "\uE03F", 124],
+ ["f140", "\uE0BC", 62],
+ ["f180", "\uE0FB", 124],
+ ["f240", "\uE178", 62],
+ ["f280", "\uE1B7", 124],
+ ["f340", "\uE234", 62],
+ ["f380", "\uE273", 124],
+ ["f440", "\uE2F0", 62],
+ ["f480", "\uE32F", 124],
+ ["f540", "\uE3AC", 62],
+ ["f580", "\uE3EB", 124],
+ ["f640", "\uE468", 62],
+ ["f680", "\uE4A7", 124],
+ ["f740", "\uE524", 62],
+ ["f780", "\uE563", 124],
+ ["f840", "\uE5E0", 62],
+ ["f880", "\uE61F", 124],
+ ["f940", "\uE69C"],
+ ["fa40", "\u2170", 9, "\u2160", 9, "\uFFE2\uFFE4\uFF07\uFF02\u3231\u2116\u2121\u2235\u7E8A\u891C\u9348\u9288\u84DC\u4FC9\u70BB\u6631\u68C8\u92F9\u66FB\u5F45\u4E28\u4EE1\u4EFC\u4F00\u4F03\u4F39\u4F56\u4F92\u4F8A\u4F9A\u4F94\u4FCD\u5040\u5022\u4FFF\u501E\u5046\u5070\u5042\u5094\u50F4\u50D8\u514A"],
+ ["fa80", "\u5164\u519D\u51BE\u51EC\u5215\u529C\u52A6\u52C0\u52DB\u5300\u5307\u5324\u5372\u5393\u53B2\u53DD\uFA0E\u549C\u548A\u54A9\u54FF\u5586\u5759\u5765\u57AC\u57C8\u57C7\uFA0F\uFA10\u589E\u58B2\u590B\u5953\u595B\u595D\u5963\u59A4\u59BA\u5B56\u5BC0\u752F\u5BD8\u5BEC\u5C1E\u5CA6\u5CBA\u5CF5\u5D27\u5D53\uFA11\u5D42\u5D6D\u5DB8\u5DB9\u5DD0\u5F21\u5F34\u5F67\u5FB7\u5FDE\u605D\u6085\u608A\u60DE\u60D5\u6120\u60F2\u6111\u6137\u6130\u6198\u6213\u62A6\u63F5\u6460\u649D\u64CE\u654E\u6600\u6615\u663B\u6609\u662E\u661E\u6624\u6665\u6657\u6659\uFA12\u6673\u6699\u66A0\u66B2\u66BF\u66FA\u670E\uF929\u6766\u67BB\u6852\u67C0\u6801\u6844\u68CF\uFA13\u6968\uFA14\u6998\u69E2\u6A30\u6A6B\u6A46\u6A73\u6A7E\u6AE2\u6AE4\u6BD6\u6C3F\u6C5C\u6C86\u6C6F\u6CDA\u6D04\u6D87\u6D6F"],
+ ["fb40", "\u6D96\u6DAC\u6DCF\u6DF8\u6DF2\u6DFC\u6E39\u6E5C\u6E27\u6E3C\u6EBF\u6F88\u6FB5\u6FF5\u7005\u7007\u7028\u7085\u70AB\u710F\u7104\u715C\u7146\u7147\uFA15\u71C1\u71FE\u72B1\u72BE\u7324\uFA16\u7377\u73BD\u73C9\u73D6\u73E3\u73D2\u7407\u73F5\u7426\u742A\u7429\u742E\u7462\u7489\u749F\u7501\u756F\u7682\u769C\u769E\u769B\u76A6\uFA17\u7746\u52AF\u7821\u784E\u7864\u787A\u7930\uFA18\uFA19"],
+ ["fb80", "\uFA1A\u7994\uFA1B\u799B\u7AD1\u7AE7\uFA1C\u7AEB\u7B9E\uFA1D\u7D48\u7D5C\u7DB7\u7DA0\u7DD6\u7E52\u7F47\u7FA1\uFA1E\u8301\u8362\u837F\u83C7\u83F6\u8448\u84B4\u8553\u8559\u856B\uFA1F\u85B0\uFA20\uFA21\u8807\u88F5\u8A12\u8A37\u8A79\u8AA7\u8ABE\u8ADF\uFA22\u8AF6\u8B53\u8B7F\u8CF0\u8CF4\u8D12\u8D76\uFA23\u8ECF\uFA24\uFA25\u9067\u90DE\uFA26\u9115\u9127\u91DA\u91D7\u91DE\u91ED\u91EE\u91E4\u91E5\u9206\u9210\u920A\u923A\u9240\u923C\u924E\u9259\u9251\u9239\u9267\u92A7\u9277\u9278\u92E7\u92D7\u92D9\u92D0\uFA27\u92D5\u92E0\u92D3\u9325\u9321\u92FB\uFA28\u931E\u92FF\u931D\u9302\u9370\u9357\u93A4\u93C6\u93DE\u93F8\u9431\u9445\u9448\u9592\uF9DC\uFA29\u969D\u96AF\u9733\u973B\u9743\u974D\u974F\u9751\u9755\u9857\u9865\uFA2A\uFA2B\u9927\uFA2C\u999E\u9A4E\u9AD9"],
+ ["fc40", "\u9ADC\u9B75\u9B72\u9B8F\u9BB1\u9BBB\u9C00\u9D70\u9D6B\uFA2D\u9E19\u9ED1"]
+ ];
+ }
+});
+
+// ../../node_modules/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/encodings/tables/eucjp.json
+var require_eucjp = __commonJS({
+ "../../node_modules/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/encodings/tables/eucjp.json"(exports2, module2) {
+ module2.exports = [
+ ["0", "\0", 127],
+ ["8ea1", "\uFF61", 62],
+ ["a1a1", "\u3000\u3001\u3002\uFF0C\uFF0E\u30FB\uFF1A\uFF1B\uFF1F\uFF01\u309B\u309C\xB4\uFF40\xA8\uFF3E\uFFE3\uFF3F\u30FD\u30FE\u309D\u309E\u3003\u4EDD\u3005\u3006\u3007\u30FC\u2015\u2010\uFF0F\uFF3C\uFF5E\u2225\uFF5C\u2026\u2025\u2018\u2019\u201C\u201D\uFF08\uFF09\u3014\u3015\uFF3B\uFF3D\uFF5B\uFF5D\u3008", 9, "\uFF0B\uFF0D\xB1\xD7\xF7\uFF1D\u2260\uFF1C\uFF1E\u2266\u2267\u221E\u2234\u2642\u2640\xB0\u2032\u2033\u2103\uFFE5\uFF04\uFFE0\uFFE1\uFF05\uFF03\uFF06\uFF0A\uFF20\xA7\u2606\u2605\u25CB\u25CF\u25CE\u25C7"],
+ ["a2a1", "\u25C6\u25A1\u25A0\u25B3\u25B2\u25BD\u25BC\u203B\u3012\u2192\u2190\u2191\u2193\u3013"],
+ ["a2ba", "\u2208\u220B\u2286\u2287\u2282\u2283\u222A\u2229"],
+ ["a2ca", "\u2227\u2228\uFFE2\u21D2\u21D4\u2200\u2203"],
+ ["a2dc", "\u2220\u22A5\u2312\u2202\u2207\u2261\u2252\u226A\u226B\u221A\u223D\u221D\u2235\u222B\u222C"],
+ ["a2f2", "\u212B\u2030\u266F\u266D\u266A\u2020\u2021\xB6"],
+ ["a2fe", "\u25EF"],
+ ["a3b0", "\uFF10", 9],
+ ["a3c1", "\uFF21", 25],
+ ["a3e1", "\uFF41", 25],
+ ["a4a1", "\u3041", 82],
+ ["a5a1", "\u30A1", 85],
+ ["a6a1", "\u0391", 16, "\u03A3", 6],
+ ["a6c1", "\u03B1", 16, "\u03C3", 6],
+ ["a7a1", "\u0410", 5, "\u0401\u0416", 25],
+ ["a7d1", "\u0430", 5, "\u0451\u0436", 25],
+ ["a8a1", "\u2500\u2502\u250C\u2510\u2518\u2514\u251C\u252C\u2524\u2534\u253C\u2501\u2503\u250F\u2513\u251B\u2517\u2523\u2533\u252B\u253B\u254B\u2520\u252F\u2528\u2537\u253F\u251D\u2530\u2525\u2538\u2542"],
+ ["ada1", "\u2460", 19, "\u2160", 9],
+ ["adc0", "\u3349\u3314\u3322\u334D\u3318\u3327\u3303\u3336\u3351\u3357\u330D\u3326\u3323\u332B\u334A\u333B\u339C\u339D\u339E\u338E\u338F\u33C4\u33A1"],
+ ["addf", "\u337B\u301D\u301F\u2116\u33CD\u2121\u32A4", 4, "\u3231\u3232\u3239\u337E\u337D\u337C\u2252\u2261\u222B\u222E\u2211\u221A\u22A5\u2220\u221F\u22BF\u2235\u2229\u222A"],
+ ["b0a1", "\u4E9C\u5516\u5A03\u963F\u54C0\u611B\u6328\u59F6\u9022\u8475\u831C\u7A50\u60AA\u63E1\u6E25\u65ED\u8466\u82A6\u9BF5\u6893\u5727\u65A1\u6271\u5B9B\u59D0\u867B\u98F4\u7D62\u7DBE\u9B8E\u6216\u7C9F\u88B7\u5B89\u5EB5\u6309\u6697\u6848\u95C7\u978D\u674F\u4EE5\u4F0A\u4F4D\u4F9D\u5049\u56F2\u5937\u59D4\u5A01\u5C09\u60DF\u610F\u6170\u6613\u6905\u70BA\u754F\u7570\u79FB\u7DAD\u7DEF\u80C3\u840E\u8863\u8B02\u9055\u907A\u533B\u4E95\u4EA5\u57DF\u80B2\u90C1\u78EF\u4E00\u58F1\u6EA2\u9038\u7A32\u8328\u828B\u9C2F\u5141\u5370\u54BD\u54E1\u56E0\u59FB\u5F15\u98F2\u6DEB\u80E4\u852D"],
+ ["b1a1", "\u9662\u9670\u96A0\u97FB\u540B\u53F3\u5B87\u70CF\u7FBD\u8FC2\u96E8\u536F\u9D5C\u7ABA\u4E11\u7893\u81FC\u6E26\u5618\u5504\u6B1D\u851A\u9C3B\u59E5\u53A9\u6D66\u74DC\u958F\u5642\u4E91\u904B\u96F2\u834F\u990C\u53E1\u55B6\u5B30\u5F71\u6620\u66F3\u6804\u6C38\u6CF3\u6D29\u745B\u76C8\u7A4E\u9834\u82F1\u885B\u8A60\u92ED\u6DB2\u75AB\u76CA\u99C5\u60A6\u8B01\u8D8A\u95B2\u698E\u53AD\u5186\u5712\u5830\u5944\u5BB4\u5EF6\u6028\u63A9\u63F4\u6CBF\u6F14\u708E\u7114\u7159\u71D5\u733F\u7E01\u8276\u82D1\u8597\u9060\u925B\u9D1B\u5869\u65BC\u6C5A\u7525\u51F9\u592E\u5965\u5F80\u5FDC"],
+ ["b2a1", "\u62BC\u65FA\u6A2A\u6B27\u6BB4\u738B\u7FC1\u8956\u9D2C\u9D0E\u9EC4\u5CA1\u6C96\u837B\u5104\u5C4B\u61B6\u81C6\u6876\u7261\u4E59\u4FFA\u5378\u6069\u6E29\u7A4F\u97F3\u4E0B\u5316\u4EEE\u4F55\u4F3D\u4FA1\u4F73\u52A0\u53EF\u5609\u590F\u5AC1\u5BB6\u5BE1\u79D1\u6687\u679C\u67B6\u6B4C\u6CB3\u706B\u73C2\u798D\u79BE\u7A3C\u7B87\u82B1\u82DB\u8304\u8377\u83EF\u83D3\u8766\u8AB2\u5629\u8CA8\u8FE6\u904E\u971E\u868A\u4FC4\u5CE8\u6211\u7259\u753B\u81E5\u82BD\u86FE\u8CC0\u96C5\u9913\u99D5\u4ECB\u4F1A\u89E3\u56DE\u584A\u58CA\u5EFB\u5FEB\u602A\u6094\u6062\u61D0\u6212\u62D0\u6539"],
+ ["b3a1", "\u9B41\u6666\u68B0\u6D77\u7070\u754C\u7686\u7D75\u82A5\u87F9\u958B\u968E\u8C9D\u51F1\u52BE\u5916\u54B3\u5BB3\u5D16\u6168\u6982\u6DAF\u788D\u84CB\u8857\u8A72\u93A7\u9AB8\u6D6C\u99A8\u86D9\u57A3\u67FF\u86CE\u920E\u5283\u5687\u5404\u5ED3\u62E1\u64B9\u683C\u6838\u6BBB\u7372\u78BA\u7A6B\u899A\u89D2\u8D6B\u8F03\u90ED\u95A3\u9694\u9769\u5B66\u5CB3\u697D\u984D\u984E\u639B\u7B20\u6A2B\u6A7F\u68B6\u9C0D\u6F5F\u5272\u559D\u6070\u62EC\u6D3B\u6E07\u6ED1\u845B\u8910\u8F44\u4E14\u9C39\u53F6\u691B\u6A3A\u9784\u682A\u515C\u7AC3\u84B2\u91DC\u938C\u565B\u9D28\u6822\u8305\u8431"],
+ ["b4a1", "\u7CA5\u5208\u82C5\u74E6\u4E7E\u4F83\u51A0\u5BD2\u520A\u52D8\u52E7\u5DFB\u559A\u582A\u59E6\u5B8C\u5B98\u5BDB\u5E72\u5E79\u60A3\u611F\u6163\u61BE\u63DB\u6562\u67D1\u6853\u68FA\u6B3E\u6B53\u6C57\u6F22\u6F97\u6F45\u74B0\u7518\u76E3\u770B\u7AFF\u7BA1\u7C21\u7DE9\u7F36\u7FF0\u809D\u8266\u839E\u89B3\u8ACC\u8CAB\u9084\u9451\u9593\u9591\u95A2\u9665\u97D3\u9928\u8218\u4E38\u542B\u5CB8\u5DCC\u73A9\u764C\u773C\u5CA9\u7FEB\u8D0B\u96C1\u9811\u9854\u9858\u4F01\u4F0E\u5371\u559C\u5668\u57FA\u5947\u5B09\u5BC4\u5C90\u5E0C\u5E7E\u5FCC\u63EE\u673A\u65D7\u65E2\u671F\u68CB\u68C4"],
+ ["b5a1", "\u6A5F\u5E30\u6BC5\u6C17\u6C7D\u757F\u7948\u5B63\u7A00\u7D00\u5FBD\u898F\u8A18\u8CB4\u8D77\u8ECC\u8F1D\u98E2\u9A0E\u9B3C\u4E80\u507D\u5100\u5993\u5B9C\u622F\u6280\u64EC\u6B3A\u72A0\u7591\u7947\u7FA9\u87FB\u8ABC\u8B70\u63AC\u83CA\u97A0\u5409\u5403\u55AB\u6854\u6A58\u8A70\u7827\u6775\u9ECD\u5374\u5BA2\u811A\u8650\u9006\u4E18\u4E45\u4EC7\u4F11\u53CA\u5438\u5BAE\u5F13\u6025\u6551\u673D\u6C42\u6C72\u6CE3\u7078\u7403\u7A76\u7AAE\u7B08\u7D1A\u7CFE\u7D66\u65E7\u725B\u53BB\u5C45\u5DE8\u62D2\u62E0\u6319\u6E20\u865A\u8A31\u8DDD\u92F8\u6F01\u79A6\u9B5A\u4EA8\u4EAB\u4EAC"],
+ ["b6a1", "\u4F9B\u4FA0\u50D1\u5147\u7AF6\u5171\u51F6\u5354\u5321\u537F\u53EB\u55AC\u5883\u5CE1\u5F37\u5F4A\u602F\u6050\u606D\u631F\u6559\u6A4B\u6CC1\u72C2\u72ED\u77EF\u80F8\u8105\u8208\u854E\u90F7\u93E1\u97FF\u9957\u9A5A\u4EF0\u51DD\u5C2D\u6681\u696D\u5C40\u66F2\u6975\u7389\u6850\u7C81\u50C5\u52E4\u5747\u5DFE\u9326\u65A4\u6B23\u6B3D\u7434\u7981\u79BD\u7B4B\u7DCA\u82B9\u83CC\u887F\u895F\u8B39\u8FD1\u91D1\u541F\u9280\u4E5D\u5036\u53E5\u533A\u72D7\u7396\u77E9\u82E6\u8EAF\u99C6\u99C8\u99D2\u5177\u611A\u865E\u55B0\u7A7A\u5076\u5BD3\u9047\u9685\u4E32\u6ADB\u91E7\u5C51\u5C48"],
+ ["b7a1", "\u6398\u7A9F\u6C93\u9774\u8F61\u7AAA\u718A\u9688\u7C82\u6817\u7E70\u6851\u936C\u52F2\u541B\u85AB\u8A13\u7FA4\u8ECD\u90E1\u5366\u8888\u7941\u4FC2\u50BE\u5211\u5144\u5553\u572D\u73EA\u578B\u5951\u5F62\u5F84\u6075\u6176\u6167\u61A9\u63B2\u643A\u656C\u666F\u6842\u6E13\u7566\u7A3D\u7CFB\u7D4C\u7D99\u7E4B\u7F6B\u830E\u834A\u86CD\u8A08\u8A63\u8B66\u8EFD\u981A\u9D8F\u82B8\u8FCE\u9BE8\u5287\u621F\u6483\u6FC0\u9699\u6841\u5091\u6B20\u6C7A\u6F54\u7A74\u7D50\u8840\u8A23\u6708\u4EF6\u5039\u5026\u5065\u517C\u5238\u5263\u55A7\u570F\u5805\u5ACC\u5EFA\u61B2\u61F8\u62F3\u6372"],
+ ["b8a1", "\u691C\u6A29\u727D\u72AC\u732E\u7814\u786F\u7D79\u770C\u80A9\u898B\u8B19\u8CE2\u8ED2\u9063\u9375\u967A\u9855\u9A13\u9E78\u5143\u539F\u53B3\u5E7B\u5F26\u6E1B\u6E90\u7384\u73FE\u7D43\u8237\u8A00\u8AFA\u9650\u4E4E\u500B\u53E4\u547C\u56FA\u59D1\u5B64\u5DF1\u5EAB\u5F27\u6238\u6545\u67AF\u6E56\u72D0\u7CCA\u88B4\u80A1\u80E1\u83F0\u864E\u8A87\u8DE8\u9237\u96C7\u9867\u9F13\u4E94\u4E92\u4F0D\u5348\u5449\u543E\u5A2F\u5F8C\u5FA1\u609F\u68A7\u6A8E\u745A\u7881\u8A9E\u8AA4\u8B77\u9190\u4E5E\u9BC9\u4EA4\u4F7C\u4FAF\u5019\u5016\u5149\u516C\u529F\u52B9\u52FE\u539A\u53E3\u5411"],
+ ["b9a1", "\u540E\u5589\u5751\u57A2\u597D\u5B54\u5B5D\u5B8F\u5DE5\u5DE7\u5DF7\u5E78\u5E83\u5E9A\u5EB7\u5F18\u6052\u614C\u6297\u62D8\u63A7\u653B\u6602\u6643\u66F4\u676D\u6821\u6897\u69CB\u6C5F\u6D2A\u6D69\u6E2F\u6E9D\u7532\u7687\u786C\u7A3F\u7CE0\u7D05\u7D18\u7D5E\u7DB1\u8015\u8003\u80AF\u80B1\u8154\u818F\u822A\u8352\u884C\u8861\u8B1B\u8CA2\u8CFC\u90CA\u9175\u9271\u783F\u92FC\u95A4\u964D\u9805\u9999\u9AD8\u9D3B\u525B\u52AB\u53F7\u5408\u58D5\u62F7\u6FE0\u8C6A\u8F5F\u9EB9\u514B\u523B\u544A\u56FD\u7A40\u9177\u9D60\u9ED2\u7344\u6F09\u8170\u7511\u5FFD\u60DA\u9AA8\u72DB\u8FBC"],
+ ["baa1", "\u6B64\u9803\u4ECA\u56F0\u5764\u58BE\u5A5A\u6068\u61C7\u660F\u6606\u6839\u68B1\u6DF7\u75D5\u7D3A\u826E\u9B42\u4E9B\u4F50\u53C9\u5506\u5D6F\u5DE6\u5DEE\u67FB\u6C99\u7473\u7802\u8A50\u9396\u88DF\u5750\u5EA7\u632B\u50B5\u50AC\u518D\u6700\u54C9\u585E\u59BB\u5BB0\u5F69\u624D\u63A1\u683D\u6B73\u6E08\u707D\u91C7\u7280\u7815\u7826\u796D\u658E\u7D30\u83DC\u88C1\u8F09\u969B\u5264\u5728\u6750\u7F6A\u8CA1\u51B4\u5742\u962A\u583A\u698A\u80B4\u54B2\u5D0E\u57FC\u7895\u9DFA\u4F5C\u524A\u548B\u643E\u6628\u6714\u67F5\u7A84\u7B56\u7D22\u932F\u685C\u9BAD\u7B39\u5319\u518A\u5237"],
+ ["bba1", "\u5BDF\u62F6\u64AE\u64E6\u672D\u6BBA\u85A9\u96D1\u7690\u9BD6\u634C\u9306\u9BAB\u76BF\u6652\u4E09\u5098\u53C2\u5C71\u60E8\u6492\u6563\u685F\u71E6\u73CA\u7523\u7B97\u7E82\u8695\u8B83\u8CDB\u9178\u9910\u65AC\u66AB\u6B8B\u4ED5\u4ED4\u4F3A\u4F7F\u523A\u53F8\u53F2\u55E3\u56DB\u58EB\u59CB\u59C9\u59FF\u5B50\u5C4D\u5E02\u5E2B\u5FD7\u601D\u6307\u652F\u5B5C\u65AF\u65BD\u65E8\u679D\u6B62\u6B7B\u6C0F\u7345\u7949\u79C1\u7CF8\u7D19\u7D2B\u80A2\u8102\u81F3\u8996\u8A5E\u8A69\u8A66\u8A8C\u8AEE\u8CC7\u8CDC\u96CC\u98FC\u6B6F\u4E8B\u4F3C\u4F8D\u5150\u5B57\u5BFA\u6148\u6301\u6642"],
+ ["bca1", "\u6B21\u6ECB\u6CBB\u723E\u74BD\u75D4\u78C1\u793A\u800C\u8033\u81EA\u8494\u8F9E\u6C50\u9E7F\u5F0F\u8B58\u9D2B\u7AFA\u8EF8\u5B8D\u96EB\u4E03\u53F1\u57F7\u5931\u5AC9\u5BA4\u6089\u6E7F\u6F06\u75BE\u8CEA\u5B9F\u8500\u7BE0\u5072\u67F4\u829D\u5C61\u854A\u7E1E\u820E\u5199\u5C04\u6368\u8D66\u659C\u716E\u793E\u7D17\u8005\u8B1D\u8ECA\u906E\u86C7\u90AA\u501F\u52FA\u5C3A\u6753\u707C\u7235\u914C\u91C8\u932B\u82E5\u5BC2\u5F31\u60F9\u4E3B\u53D6\u5B88\u624B\u6731\u6B8A\u72E9\u73E0\u7A2E\u816B\u8DA3\u9152\u9996\u5112\u53D7\u546A\u5BFF\u6388\u6A39\u7DAC\u9700\u56DA\u53CE\u5468"],
+ ["bda1", "\u5B97\u5C31\u5DDE\u4FEE\u6101\u62FE\u6D32\u79C0\u79CB\u7D42\u7E4D\u7FD2\u81ED\u821F\u8490\u8846\u8972\u8B90\u8E74\u8F2F\u9031\u914B\u916C\u96C6\u919C\u4EC0\u4F4F\u5145\u5341\u5F93\u620E\u67D4\u6C41\u6E0B\u7363\u7E26\u91CD\u9283\u53D4\u5919\u5BBF\u6DD1\u795D\u7E2E\u7C9B\u587E\u719F\u51FA\u8853\u8FF0\u4FCA\u5CFB\u6625\u77AC\u7AE3\u821C\u99FF\u51C6\u5FAA\u65EC\u696F\u6B89\u6DF3\u6E96\u6F64\u76FE\u7D14\u5DE1\u9075\u9187\u9806\u51E6\u521D\u6240\u6691\u66D9\u6E1A\u5EB6\u7DD2\u7F72\u66F8\u85AF\u85F7\u8AF8\u52A9\u53D9\u5973\u5E8F\u5F90\u6055\u92E4\u9664\u50B7\u511F"],
+ ["bea1", "\u52DD\u5320\u5347\u53EC\u54E8\u5546\u5531\u5617\u5968\u59BE\u5A3C\u5BB5\u5C06\u5C0F\u5C11\u5C1A\u5E84\u5E8A\u5EE0\u5F70\u627F\u6284\u62DB\u638C\u6377\u6607\u660C\u662D\u6676\u677E\u68A2\u6A1F\u6A35\u6CBC\u6D88\u6E09\u6E58\u713C\u7126\u7167\u75C7\u7701\u785D\u7901\u7965\u79F0\u7AE0\u7B11\u7CA7\u7D39\u8096\u83D6\u848B\u8549\u885D\u88F3\u8A1F\u8A3C\u8A54\u8A73\u8C61\u8CDE\u91A4\u9266\u937E\u9418\u969C\u9798\u4E0A\u4E08\u4E1E\u4E57\u5197\u5270\u57CE\u5834\u58CC\u5B22\u5E38\u60C5\u64FE\u6761\u6756\u6D44\u72B6\u7573\u7A63\u84B8\u8B72\u91B8\u9320\u5631\u57F4\u98FE"],
+ ["bfa1", "\u62ED\u690D\u6B96\u71ED\u7E54\u8077\u8272\u89E6\u98DF\u8755\u8FB1\u5C3B\u4F38\u4FE1\u4FB5\u5507\u5A20\u5BDD\u5BE9\u5FC3\u614E\u632F\u65B0\u664B\u68EE\u699B\u6D78\u6DF1\u7533\u75B9\u771F\u795E\u79E6\u7D33\u81E3\u82AF\u85AA\u89AA\u8A3A\u8EAB\u8F9B\u9032\u91DD\u9707\u4EBA\u4EC1\u5203\u5875\u58EC\u5C0B\u751A\u5C3D\u814E\u8A0A\u8FC5\u9663\u976D\u7B25\u8ACF\u9808\u9162\u56F3\u53A8\u9017\u5439\u5782\u5E25\u63A8\u6C34\u708A\u7761\u7C8B\u7FE0\u8870\u9042\u9154\u9310\u9318\u968F\u745E\u9AC4\u5D07\u5D69\u6570\u67A2\u8DA8\u96DB\u636E\u6749\u6919\u83C5\u9817\u96C0\u88FE"],
+ ["c0a1", "\u6F84\u647A\u5BF8\u4E16\u702C\u755D\u662F\u51C4\u5236\u52E2\u59D3\u5F81\u6027\u6210\u653F\u6574\u661F\u6674\u68F2\u6816\u6B63\u6E05\u7272\u751F\u76DB\u7CBE\u8056\u58F0\u88FD\u897F\u8AA0\u8A93\u8ACB\u901D\u9192\u9752\u9759\u6589\u7A0E\u8106\u96BB\u5E2D\u60DC\u621A\u65A5\u6614\u6790\u77F3\u7A4D\u7C4D\u7E3E\u810A\u8CAC\u8D64\u8DE1\u8E5F\u78A9\u5207\u62D9\u63A5\u6442\u6298\u8A2D\u7A83\u7BC0\u8AAC\u96EA\u7D76\u820C\u8749\u4ED9\u5148\u5343\u5360\u5BA3\u5C02\u5C16\u5DDD\u6226\u6247\u64B0\u6813\u6834\u6CC9\u6D45\u6D17\u67D3\u6F5C\u714E\u717D\u65CB\u7A7F\u7BAD\u7DDA"],
+ ["c1a1", "\u7E4A\u7FA8\u817A\u821B\u8239\u85A6\u8A6E\u8CCE\u8DF5\u9078\u9077\u92AD\u9291\u9583\u9BAE\u524D\u5584\u6F38\u7136\u5168\u7985\u7E55\u81B3\u7CCE\u564C\u5851\u5CA8\u63AA\u66FE\u66FD\u695A\u72D9\u758F\u758E\u790E\u7956\u79DF\u7C97\u7D20\u7D44\u8607\u8A34\u963B\u9061\u9F20\u50E7\u5275\u53CC\u53E2\u5009\u55AA\u58EE\u594F\u723D\u5B8B\u5C64\u531D\u60E3\u60F3\u635C\u6383\u633F\u63BB\u64CD\u65E9\u66F9\u5DE3\u69CD\u69FD\u6F15\u71E5\u4E89\u75E9\u76F8\u7A93\u7CDF\u7DCF\u7D9C\u8061\u8349\u8358\u846C\u84BC\u85FB\u88C5\u8D70\u9001\u906D\u9397\u971C\u9A12\u50CF\u5897\u618E"],
+ ["c2a1", "\u81D3\u8535\u8D08\u9020\u4FC3\u5074\u5247\u5373\u606F\u6349\u675F\u6E2C\u8DB3\u901F\u4FD7\u5C5E\u8CCA\u65CF\u7D9A\u5352\u8896\u5176\u63C3\u5B58\u5B6B\u5C0A\u640D\u6751\u905C\u4ED6\u591A\u592A\u6C70\u8A51\u553E\u5815\u59A5\u60F0\u6253\u67C1\u8235\u6955\u9640\u99C4\u9A28\u4F53\u5806\u5BFE\u8010\u5CB1\u5E2F\u5F85\u6020\u614B\u6234\u66FF\u6CF0\u6EDE\u80CE\u817F\u82D4\u888B\u8CB8\u9000\u902E\u968A\u9EDB\u9BDB\u4EE3\u53F0\u5927\u7B2C\u918D\u984C\u9DF9\u6EDD\u7027\u5353\u5544\u5B85\u6258\u629E\u62D3\u6CA2\u6FEF\u7422\u8A17\u9438\u6FC1\u8AFE\u8338\u51E7\u86F8\u53EA"],
+ ["c3a1", "\u53E9\u4F46\u9054\u8FB0\u596A\u8131\u5DFD\u7AEA\u8FBF\u68DA\u8C37\u72F8\u9C48\u6A3D\u8AB0\u4E39\u5358\u5606\u5766\u62C5\u63A2\u65E6\u6B4E\u6DE1\u6E5B\u70AD\u77ED\u7AEF\u7BAA\u7DBB\u803D\u80C6\u86CB\u8A95\u935B\u56E3\u58C7\u5F3E\u65AD\u6696\u6A80\u6BB5\u7537\u8AC7\u5024\u77E5\u5730\u5F1B\u6065\u667A\u6C60\u75F4\u7A1A\u7F6E\u81F4\u8718\u9045\u99B3\u7BC9\u755C\u7AF9\u7B51\u84C4\u9010\u79E9\u7A92\u8336\u5AE1\u7740\u4E2D\u4EF2\u5B99\u5FE0\u62BD\u663C\u67F1\u6CE8\u866B\u8877\u8A3B\u914E\u92F3\u99D0\u6A17\u7026\u732A\u82E7\u8457\u8CAF\u4E01\u5146\u51CB\u558B\u5BF5"],
+ ["c4a1", "\u5E16\u5E33\u5E81\u5F14\u5F35\u5F6B\u5FB4\u61F2\u6311\u66A2\u671D\u6F6E\u7252\u753A\u773A\u8074\u8139\u8178\u8776\u8ABF\u8ADC\u8D85\u8DF3\u929A\u9577\u9802\u9CE5\u52C5\u6357\u76F4\u6715\u6C88\u73CD\u8CC3\u93AE\u9673\u6D25\u589C\u690E\u69CC\u8FFD\u939A\u75DB\u901A\u585A\u6802\u63B4\u69FB\u4F43\u6F2C\u67D8\u8FBB\u8526\u7DB4\u9354\u693F\u6F70\u576A\u58F7\u5B2C\u7D2C\u722A\u540A\u91E3\u9DB4\u4EAD\u4F4E\u505C\u5075\u5243\u8C9E\u5448\u5824\u5B9A\u5E1D\u5E95\u5EAD\u5EF7\u5F1F\u608C\u62B5\u633A\u63D0\u68AF\u6C40\u7887\u798E\u7A0B\u7DE0\u8247\u8A02\u8AE6\u8E44\u9013"],
+ ["c5a1", "\u90B8\u912D\u91D8\u9F0E\u6CE5\u6458\u64E2\u6575\u6EF4\u7684\u7B1B\u9069\u93D1\u6EBA\u54F2\u5FB9\u64A4\u8F4D\u8FED\u9244\u5178\u586B\u5929\u5C55\u5E97\u6DFB\u7E8F\u751C\u8CBC\u8EE2\u985B\u70B9\u4F1D\u6BBF\u6FB1\u7530\u96FB\u514E\u5410\u5835\u5857\u59AC\u5C60\u5F92\u6597\u675C\u6E21\u767B\u83DF\u8CED\u9014\u90FD\u934D\u7825\u783A\u52AA\u5EA6\u571F\u5974\u6012\u5012\u515A\u51AC\u51CD\u5200\u5510\u5854\u5858\u5957\u5B95\u5CF6\u5D8B\u60BC\u6295\u642D\u6771\u6843\u68BC\u68DF\u76D7\u6DD8\u6E6F\u6D9B\u706F\u71C8\u5F53\u75D8\u7977\u7B49\u7B54\u7B52\u7CD6\u7D71\u5230"],
+ ["c6a1", "\u8463\u8569\u85E4\u8A0E\u8B04\u8C46\u8E0F\u9003\u900F\u9419\u9676\u982D\u9A30\u95D8\u50CD\u52D5\u540C\u5802\u5C0E\u61A7\u649E\u6D1E\u77B3\u7AE5\u80F4\u8404\u9053\u9285\u5CE0\u9D07\u533F\u5F97\u5FB3\u6D9C\u7279\u7763\u79BF\u7BE4\u6BD2\u72EC\u8AAD\u6803\u6A61\u51F8\u7A81\u6934\u5C4A\u9CF6\u82EB\u5BC5\u9149\u701E\u5678\u5C6F\u60C7\u6566\u6C8C\u8C5A\u9041\u9813\u5451\u66C7\u920D\u5948\u90A3\u5185\u4E4D\u51EA\u8599\u8B0E\u7058\u637A\u934B\u6962\u99B4\u7E04\u7577\u5357\u6960\u8EDF\u96E3\u6C5D\u4E8C\u5C3C\u5F10\u8FE9\u5302\u8CD1\u8089\u8679\u5EFF\u65E5\u4E73\u5165"],
+ ["c7a1", "\u5982\u5C3F\u97EE\u4EFB\u598A\u5FCD\u8A8D\u6FE1\u79B0\u7962\u5BE7\u8471\u732B\u71B1\u5E74\u5FF5\u637B\u649A\u71C3\u7C98\u4E43\u5EFC\u4E4B\u57DC\u56A2\u60A9\u6FC3\u7D0D\u80FD\u8133\u81BF\u8FB2\u8997\u86A4\u5DF4\u628A\u64AD\u8987\u6777\u6CE2\u6D3E\u7436\u7834\u5A46\u7F75\u82AD\u99AC\u4FF3\u5EC3\u62DD\u6392\u6557\u676F\u76C3\u724C\u80CC\u80BA\u8F29\u914D\u500D\u57F9\u5A92\u6885\u6973\u7164\u72FD\u8CB7\u58F2\u8CE0\u966A\u9019\u877F\u79E4\u77E7\u8429\u4F2F\u5265\u535A\u62CD\u67CF\u6CCA\u767D\u7B94\u7C95\u8236\u8584\u8FEB\u66DD\u6F20\u7206\u7E1B\u83AB\u99C1\u9EA6"],
+ ["c8a1", "\u51FD\u7BB1\u7872\u7BB8\u8087\u7B48\u6AE8\u5E61\u808C\u7551\u7560\u516B\u9262\u6E8C\u767A\u9197\u9AEA\u4F10\u7F70\u629C\u7B4F\u95A5\u9CE9\u567A\u5859\u86E4\u96BC\u4F34\u5224\u534A\u53CD\u53DB\u5E06\u642C\u6591\u677F\u6C3E\u6C4E\u7248\u72AF\u73ED\u7554\u7E41\u822C\u85E9\u8CA9\u7BC4\u91C6\u7169\u9812\u98EF\u633D\u6669\u756A\u76E4\u78D0\u8543\u86EE\u532A\u5351\u5426\u5983\u5E87\u5F7C\u60B2\u6249\u6279\u62AB\u6590\u6BD4\u6CCC\u75B2\u76AE\u7891\u79D8\u7DCB\u7F77\u80A5\u88AB\u8AB9\u8CBB\u907F\u975E\u98DB\u6A0B\u7C38\u5099\u5C3E\u5FAE\u6787\u6BD8\u7435\u7709\u7F8E"],
+ ["c9a1", "\u9F3B\u67CA\u7A17\u5339\u758B\u9AED\u5F66\u819D\u83F1\u8098\u5F3C\u5FC5\u7562\u7B46\u903C\u6867\u59EB\u5A9B\u7D10\u767E\u8B2C\u4FF5\u5F6A\u6A19\u6C37\u6F02\u74E2\u7968\u8868\u8A55\u8C79\u5EDF\u63CF\u75C5\u79D2\u82D7\u9328\u92F2\u849C\u86ED\u9C2D\u54C1\u5F6C\u658C\u6D5C\u7015\u8CA7\u8CD3\u983B\u654F\u74F6\u4E0D\u4ED8\u57E0\u592B\u5A66\u5BCC\u51A8\u5E03\u5E9C\u6016\u6276\u6577\u65A7\u666E\u6D6E\u7236\u7B26\u8150\u819A\u8299\u8B5C\u8CA0\u8CE6\u8D74\u961C\u9644\u4FAE\u64AB\u6B66\u821E\u8461\u856A\u90E8\u5C01\u6953\u98A8\u847A\u8557\u4F0F\u526F\u5FA9\u5E45\u670D"],
+ ["caa1", "\u798F\u8179\u8907\u8986\u6DF5\u5F17\u6255\u6CB8\u4ECF\u7269\u9B92\u5206\u543B\u5674\u58B3\u61A4\u626E\u711A\u596E\u7C89\u7CDE\u7D1B\u96F0\u6587\u805E\u4E19\u4F75\u5175\u5840\u5E63\u5E73\u5F0A\u67C4\u4E26\u853D\u9589\u965B\u7C73\u9801\u50FB\u58C1\u7656\u78A7\u5225\u77A5\u8511\u7B86\u504F\u5909\u7247\u7BC7\u7DE8\u8FBA\u8FD4\u904D\u4FBF\u52C9\u5A29\u5F01\u97AD\u4FDD\u8217\u92EA\u5703\u6355\u6B69\u752B\u88DC\u8F14\u7A42\u52DF\u5893\u6155\u620A\u66AE\u6BCD\u7C3F\u83E9\u5023\u4FF8\u5305\u5446\u5831\u5949\u5B9D\u5CF0\u5CEF\u5D29\u5E96\u62B1\u6367\u653E\u65B9\u670B"],
+ ["cba1", "\u6CD5\u6CE1\u70F9\u7832\u7E2B\u80DE\u82B3\u840C\u84EC\u8702\u8912\u8A2A\u8C4A\u90A6\u92D2\u98FD\u9CF3\u9D6C\u4E4F\u4EA1\u508D\u5256\u574A\u59A8\u5E3D\u5FD8\u5FD9\u623F\u66B4\u671B\u67D0\u68D2\u5192\u7D21\u80AA\u81A8\u8B00\u8C8C\u8CBF\u927E\u9632\u5420\u982C\u5317\u50D5\u535C\u58A8\u64B2\u6734\u7267\u7766\u7A46\u91E6\u52C3\u6CA1\u6B86\u5800\u5E4C\u5954\u672C\u7FFB\u51E1\u76C6\u6469\u78E8\u9B54\u9EBB\u57CB\u59B9\u6627\u679A\u6BCE\u54E9\u69D9\u5E55\u819C\u6795\u9BAA\u67FE\u9C52\u685D\u4EA6\u4FE3\u53C8\u62B9\u672B\u6CAB\u8FC4\u4FAD\u7E6D\u9EBF\u4E07\u6162\u6E80"],
+ ["cca1", "\u6F2B\u8513\u5473\u672A\u9B45\u5DF3\u7B95\u5CAC\u5BC6\u871C\u6E4A\u84D1\u7A14\u8108\u5999\u7C8D\u6C11\u7720\u52D9\u5922\u7121\u725F\u77DB\u9727\u9D61\u690B\u5A7F\u5A18\u51A5\u540D\u547D\u660E\u76DF\u8FF7\u9298\u9CF4\u59EA\u725D\u6EC5\u514D\u68C9\u7DBF\u7DEC\u9762\u9EBA\u6478\u6A21\u8302\u5984\u5B5F\u6BDB\u731B\u76F2\u7DB2\u8017\u8499\u5132\u6728\u9ED9\u76EE\u6762\u52FF\u9905\u5C24\u623B\u7C7E\u8CB0\u554F\u60B6\u7D0B\u9580\u5301\u4E5F\u51B6\u591C\u723A\u8036\u91CE\u5F25\u77E2\u5384\u5F79\u7D04\u85AC\u8A33\u8E8D\u9756\u67F3\u85AE\u9453\u6109\u6108\u6CB9\u7652"],
+ ["cda1", "\u8AED\u8F38\u552F\u4F51\u512A\u52C7\u53CB\u5BA5\u5E7D\u60A0\u6182\u63D6\u6709\u67DA\u6E67\u6D8C\u7336\u7337\u7531\u7950\u88D5\u8A98\u904A\u9091\u90F5\u96C4\u878D\u5915\u4E88\u4F59\u4E0E\u8A89\u8F3F\u9810\u50AD\u5E7C\u5996\u5BB9\u5EB8\u63DA\u63FA\u64C1\u66DC\u694A\u69D8\u6D0B\u6EB6\u7194\u7528\u7AAF\u7F8A\u8000\u8449\u84C9\u8981\u8B21\u8E0A\u9065\u967D\u990A\u617E\u6291\u6B32\u6C83\u6D74\u7FCC\u7FFC\u6DC0\u7F85\u87BA\u88F8\u6765\u83B1\u983C\u96F7\u6D1B\u7D61\u843D\u916A\u4E71\u5375\u5D50\u6B04\u6FEB\u85CD\u862D\u89A7\u5229\u540F\u5C65\u674E\u68A8\u7406\u7483"],
+ ["cea1", "\u75E2\u88CF\u88E1\u91CC\u96E2\u9678\u5F8B\u7387\u7ACB\u844E\u63A0\u7565\u5289\u6D41\u6E9C\u7409\u7559\u786B\u7C92\u9686\u7ADC\u9F8D\u4FB6\u616E\u65C5\u865C\u4E86\u4EAE\u50DA\u4E21\u51CC\u5BEE\u6599\u6881\u6DBC\u731F\u7642\u77AD\u7A1C\u7CE7\u826F\u8AD2\u907C\u91CF\u9675\u9818\u529B\u7DD1\u502B\u5398\u6797\u6DCB\u71D0\u7433\u81E8\u8F2A\u96A3\u9C57\u9E9F\u7460\u5841\u6D99\u7D2F\u985E\u4EE4\u4F36\u4F8B\u51B7\u52B1\u5DBA\u601C\u73B2\u793C\u82D3\u9234\u96B7\u96F6\u970A\u9E97\u9F62\u66A6\u6B74\u5217\u52A3\u70C8\u88C2\u5EC9\u604B\u6190\u6F23\u7149\u7C3E\u7DF4\u806F"],
+ ["cfa1", "\u84EE\u9023\u932C\u5442\u9B6F\u6AD3\u7089\u8CC2\u8DEF\u9732\u52B4\u5A41\u5ECA\u5F04\u6717\u697C\u6994\u6D6A\u6F0F\u7262\u72FC\u7BED\u8001\u807E\u874B\u90CE\u516D\u9E93\u7984\u808B\u9332\u8AD6\u502D\u548C\u8A71\u6B6A\u8CC4\u8107\u60D1\u67A0\u9DF2\u4E99\u4E98\u9C10\u8A6B\u85C1\u8568\u6900\u6E7E\u7897\u8155"],
+ ["d0a1", "\u5F0C\u4E10\u4E15\u4E2A\u4E31\u4E36\u4E3C\u4E3F\u4E42\u4E56\u4E58\u4E82\u4E85\u8C6B\u4E8A\u8212\u5F0D\u4E8E\u4E9E\u4E9F\u4EA0\u4EA2\u4EB0\u4EB3\u4EB6\u4ECE\u4ECD\u4EC4\u4EC6\u4EC2\u4ED7\u4EDE\u4EED\u4EDF\u4EF7\u4F09\u4F5A\u4F30\u4F5B\u4F5D\u4F57\u4F47\u4F76\u4F88\u4F8F\u4F98\u4F7B\u4F69\u4F70\u4F91\u4F6F\u4F86\u4F96\u5118\u4FD4\u4FDF\u4FCE\u4FD8\u4FDB\u4FD1\u4FDA\u4FD0\u4FE4\u4FE5\u501A\u5028\u5014\u502A\u5025\u5005\u4F1C\u4FF6\u5021\u5029\u502C\u4FFE\u4FEF\u5011\u5006\u5043\u5047\u6703\u5055\u5050\u5048\u505A\u5056\u506C\u5078\u5080\u509A\u5085\u50B4\u50B2"],
+ ["d1a1", "\u50C9\u50CA\u50B3\u50C2\u50D6\u50DE\u50E5\u50ED\u50E3\u50EE\u50F9\u50F5\u5109\u5101\u5102\u5116\u5115\u5114\u511A\u5121\u513A\u5137\u513C\u513B\u513F\u5140\u5152\u514C\u5154\u5162\u7AF8\u5169\u516A\u516E\u5180\u5182\u56D8\u518C\u5189\u518F\u5191\u5193\u5195\u5196\u51A4\u51A6\u51A2\u51A9\u51AA\u51AB\u51B3\u51B1\u51B2\u51B0\u51B5\u51BD\u51C5\u51C9\u51DB\u51E0\u8655\u51E9\u51ED\u51F0\u51F5\u51FE\u5204\u520B\u5214\u520E\u5227\u522A\u522E\u5233\u5239\u524F\u5244\u524B\u524C\u525E\u5254\u526A\u5274\u5269\u5273\u527F\u527D\u528D\u5294\u5292\u5271\u5288\u5291\u8FA8"],
+ ["d2a1", "\u8FA7\u52AC\u52AD\u52BC\u52B5\u52C1\u52CD\u52D7\u52DE\u52E3\u52E6\u98ED\u52E0\u52F3\u52F5\u52F8\u52F9\u5306\u5308\u7538\u530D\u5310\u530F\u5315\u531A\u5323\u532F\u5331\u5333\u5338\u5340\u5346\u5345\u4E17\u5349\u534D\u51D6\u535E\u5369\u536E\u5918\u537B\u5377\u5382\u5396\u53A0\u53A6\u53A5\u53AE\u53B0\u53B6\u53C3\u7C12\u96D9\u53DF\u66FC\u71EE\u53EE\u53E8\u53ED\u53FA\u5401\u543D\u5440\u542C\u542D\u543C\u542E\u5436\u5429\u541D\u544E\u548F\u5475\u548E\u545F\u5471\u5477\u5470\u5492\u547B\u5480\u5476\u5484\u5490\u5486\u54C7\u54A2\u54B8\u54A5\u54AC\u54C4\u54C8\u54A8"],
+ ["d3a1", "\u54AB\u54C2\u54A4\u54BE\u54BC\u54D8\u54E5\u54E6\u550F\u5514\u54FD\u54EE\u54ED\u54FA\u54E2\u5539\u5540\u5563\u554C\u552E\u555C\u5545\u5556\u5557\u5538\u5533\u555D\u5599\u5580\u54AF\u558A\u559F\u557B\u557E\u5598\u559E\u55AE\u557C\u5583\u55A9\u5587\u55A8\u55DA\u55C5\u55DF\u55C4\u55DC\u55E4\u55D4\u5614\u55F7\u5616\u55FE\u55FD\u561B\u55F9\u564E\u5650\u71DF\u5634\u5636\u5632\u5638\u566B\u5664\u562F\u566C\u566A\u5686\u5680\u568A\u56A0\u5694\u568F\u56A5\u56AE\u56B6\u56B4\u56C2\u56BC\u56C1\u56C3\u56C0\u56C8\u56CE\u56D1\u56D3\u56D7\u56EE\u56F9\u5700\u56FF\u5704\u5709"],
+ ["d4a1", "\u5708\u570B\u570D\u5713\u5718\u5716\u55C7\u571C\u5726\u5737\u5738\u574E\u573B\u5740\u574F\u5769\u57C0\u5788\u5761\u577F\u5789\u5793\u57A0\u57B3\u57A4\u57AA\u57B0\u57C3\u57C6\u57D4\u57D2\u57D3\u580A\u57D6\u57E3\u580B\u5819\u581D\u5872\u5821\u5862\u584B\u5870\u6BC0\u5852\u583D\u5879\u5885\u58B9\u589F\u58AB\u58BA\u58DE\u58BB\u58B8\u58AE\u58C5\u58D3\u58D1\u58D7\u58D9\u58D8\u58E5\u58DC\u58E4\u58DF\u58EF\u58FA\u58F9\u58FB\u58FC\u58FD\u5902\u590A\u5910\u591B\u68A6\u5925\u592C\u592D\u5932\u5938\u593E\u7AD2\u5955\u5950\u594E\u595A\u5958\u5962\u5960\u5967\u596C\u5969"],
+ ["d5a1", "\u5978\u5981\u599D\u4F5E\u4FAB\u59A3\u59B2\u59C6\u59E8\u59DC\u598D\u59D9\u59DA\u5A25\u5A1F\u5A11\u5A1C\u5A09\u5A1A\u5A40\u5A6C\u5A49\u5A35\u5A36\u5A62\u5A6A\u5A9A\u5ABC\u5ABE\u5ACB\u5AC2\u5ABD\u5AE3\u5AD7\u5AE6\u5AE9\u5AD6\u5AFA\u5AFB\u5B0C\u5B0B\u5B16\u5B32\u5AD0\u5B2A\u5B36\u5B3E\u5B43\u5B45\u5B40\u5B51\u5B55\u5B5A\u5B5B\u5B65\u5B69\u5B70\u5B73\u5B75\u5B78\u6588\u5B7A\u5B80\u5B83\u5BA6\u5BB8\u5BC3\u5BC7\u5BC9\u5BD4\u5BD0\u5BE4\u5BE6\u5BE2\u5BDE\u5BE5\u5BEB\u5BF0\u5BF6\u5BF3\u5C05\u5C07\u5C08\u5C0D\u5C13\u5C20\u5C22\u5C28\u5C38\u5C39\u5C41\u5C46\u5C4E\u5C53"],
+ ["d6a1", "\u5C50\u5C4F\u5B71\u5C6C\u5C6E\u4E62\u5C76\u5C79\u5C8C\u5C91\u5C94\u599B\u5CAB\u5CBB\u5CB6\u5CBC\u5CB7\u5CC5\u5CBE\u5CC7\u5CD9\u5CE9\u5CFD\u5CFA\u5CED\u5D8C\u5CEA\u5D0B\u5D15\u5D17\u5D5C\u5D1F\u5D1B\u5D11\u5D14\u5D22\u5D1A\u5D19\u5D18\u5D4C\u5D52\u5D4E\u5D4B\u5D6C\u5D73\u5D76\u5D87\u5D84\u5D82\u5DA2\u5D9D\u5DAC\u5DAE\u5DBD\u5D90\u5DB7\u5DBC\u5DC9\u5DCD\u5DD3\u5DD2\u5DD6\u5DDB\u5DEB\u5DF2\u5DF5\u5E0B\u5E1A\u5E19\u5E11\u5E1B\u5E36\u5E37\u5E44\u5E43\u5E40\u5E4E\u5E57\u5E54\u5E5F\u5E62\u5E64\u5E47\u5E75\u5E76\u5E7A\u9EBC\u5E7F\u5EA0\u5EC1\u5EC2\u5EC8\u5ED0\u5ECF"],
+ ["d7a1", "\u5ED6\u5EE3\u5EDD\u5EDA\u5EDB\u5EE2\u5EE1\u5EE8\u5EE9\u5EEC\u5EF1\u5EF3\u5EF0\u5EF4\u5EF8\u5EFE\u5F03\u5F09\u5F5D\u5F5C\u5F0B\u5F11\u5F16\u5F29\u5F2D\u5F38\u5F41\u5F48\u5F4C\u5F4E\u5F2F\u5F51\u5F56\u5F57\u5F59\u5F61\u5F6D\u5F73\u5F77\u5F83\u5F82\u5F7F\u5F8A\u5F88\u5F91\u5F87\u5F9E\u5F99\u5F98\u5FA0\u5FA8\u5FAD\u5FBC\u5FD6\u5FFB\u5FE4\u5FF8\u5FF1\u5FDD\u60B3\u5FFF\u6021\u6060\u6019\u6010\u6029\u600E\u6031\u601B\u6015\u602B\u6026\u600F\u603A\u605A\u6041\u606A\u6077\u605F\u604A\u6046\u604D\u6063\u6043\u6064\u6042\u606C\u606B\u6059\u6081\u608D\u60E7\u6083\u609A"],
+ ["d8a1", "\u6084\u609B\u6096\u6097\u6092\u60A7\u608B\u60E1\u60B8\u60E0\u60D3\u60B4\u5FF0\u60BD\u60C6\u60B5\u60D8\u614D\u6115\u6106\u60F6\u60F7\u6100\u60F4\u60FA\u6103\u6121\u60FB\u60F1\u610D\u610E\u6147\u613E\u6128\u6127\u614A\u613F\u613C\u612C\u6134\u613D\u6142\u6144\u6173\u6177\u6158\u6159\u615A\u616B\u6174\u616F\u6165\u6171\u615F\u615D\u6153\u6175\u6199\u6196\u6187\u61AC\u6194\u619A\u618A\u6191\u61AB\u61AE\u61CC\u61CA\u61C9\u61F7\u61C8\u61C3\u61C6\u61BA\u61CB\u7F79\u61CD\u61E6\u61E3\u61F6\u61FA\u61F4\u61FF\u61FD\u61FC\u61FE\u6200\u6208\u6209\u620D\u620C\u6214\u621B"],
+ ["d9a1", "\u621E\u6221\u622A\u622E\u6230\u6232\u6233\u6241\u624E\u625E\u6263\u625B\u6260\u6268\u627C\u6282\u6289\u627E\u6292\u6293\u6296\u62D4\u6283\u6294\u62D7\u62D1\u62BB\u62CF\u62FF\u62C6\u64D4\u62C8\u62DC\u62CC\u62CA\u62C2\u62C7\u629B\u62C9\u630C\u62EE\u62F1\u6327\u6302\u6308\u62EF\u62F5\u6350\u633E\u634D\u641C\u634F\u6396\u638E\u6380\u63AB\u6376\u63A3\u638F\u6389\u639F\u63B5\u636B\u6369\u63BE\u63E9\u63C0\u63C6\u63E3\u63C9\u63D2\u63F6\u63C4\u6416\u6434\u6406\u6413\u6426\u6436\u651D\u6417\u6428\u640F\u6467\u646F\u6476\u644E\u652A\u6495\u6493\u64A5\u64A9\u6488\u64BC"],
+ ["daa1", "\u64DA\u64D2\u64C5\u64C7\u64BB\u64D8\u64C2\u64F1\u64E7\u8209\u64E0\u64E1\u62AC\u64E3\u64EF\u652C\u64F6\u64F4\u64F2\u64FA\u6500\u64FD\u6518\u651C\u6505\u6524\u6523\u652B\u6534\u6535\u6537\u6536\u6538\u754B\u6548\u6556\u6555\u654D\u6558\u655E\u655D\u6572\u6578\u6582\u6583\u8B8A\u659B\u659F\u65AB\u65B7\u65C3\u65C6\u65C1\u65C4\u65CC\u65D2\u65DB\u65D9\u65E0\u65E1\u65F1\u6772\u660A\u6603\u65FB\u6773\u6635\u6636\u6634\u661C\u664F\u6644\u6649\u6641\u665E\u665D\u6664\u6667\u6668\u665F\u6662\u6670\u6683\u6688\u668E\u6689\u6684\u6698\u669D\u66C1\u66B9\u66C9\u66BE\u66BC"],
+ ["dba1", "\u66C4\u66B8\u66D6\u66DA\u66E0\u663F\u66E6\u66E9\u66F0\u66F5\u66F7\u670F\u6716\u671E\u6726\u6727\u9738\u672E\u673F\u6736\u6741\u6738\u6737\u6746\u675E\u6760\u6759\u6763\u6764\u6789\u6770\u67A9\u677C\u676A\u678C\u678B\u67A6\u67A1\u6785\u67B7\u67EF\u67B4\u67EC\u67B3\u67E9\u67B8\u67E4\u67DE\u67DD\u67E2\u67EE\u67B9\u67CE\u67C6\u67E7\u6A9C\u681E\u6846\u6829\u6840\u684D\u6832\u684E\u68B3\u682B\u6859\u6863\u6877\u687F\u689F\u688F\u68AD\u6894\u689D\u689B\u6883\u6AAE\u68B9\u6874\u68B5\u68A0\u68BA\u690F\u688D\u687E\u6901\u68CA\u6908\u68D8\u6922\u6926\u68E1\u690C\u68CD"],
+ ["dca1", "\u68D4\u68E7\u68D5\u6936\u6912\u6904\u68D7\u68E3\u6925\u68F9\u68E0\u68EF\u6928\u692A\u691A\u6923\u6921\u68C6\u6979\u6977\u695C\u6978\u696B\u6954\u697E\u696E\u6939\u6974\u693D\u6959\u6930\u6961\u695E\u695D\u6981\u696A\u69B2\u69AE\u69D0\u69BF\u69C1\u69D3\u69BE\u69CE\u5BE8\u69CA\u69DD\u69BB\u69C3\u69A7\u6A2E\u6991\u69A0\u699C\u6995\u69B4\u69DE\u69E8\u6A02\u6A1B\u69FF\u6B0A\u69F9\u69F2\u69E7\u6A05\u69B1\u6A1E\u69ED\u6A14\u69EB\u6A0A\u6A12\u6AC1\u6A23\u6A13\u6A44\u6A0C\u6A72\u6A36\u6A78\u6A47\u6A62\u6A59\u6A66\u6A48\u6A38\u6A22\u6A90\u6A8D\u6AA0\u6A84\u6AA2\u6AA3"],
+ ["dda1", "\u6A97\u8617\u6ABB\u6AC3\u6AC2\u6AB8\u6AB3\u6AAC\u6ADE\u6AD1\u6ADF\u6AAA\u6ADA\u6AEA\u6AFB\u6B05\u8616\u6AFA\u6B12\u6B16\u9B31\u6B1F\u6B38\u6B37\u76DC\u6B39\u98EE\u6B47\u6B43\u6B49\u6B50\u6B59\u6B54\u6B5B\u6B5F\u6B61\u6B78\u6B79\u6B7F\u6B80\u6B84\u6B83\u6B8D\u6B98\u6B95\u6B9E\u6BA4\u6BAA\u6BAB\u6BAF\u6BB2\u6BB1\u6BB3\u6BB7\u6BBC\u6BC6\u6BCB\u6BD3\u6BDF\u6BEC\u6BEB\u6BF3\u6BEF\u9EBE\u6C08\u6C13\u6C14\u6C1B\u6C24\u6C23\u6C5E\u6C55\u6C62\u6C6A\u6C82\u6C8D\u6C9A\u6C81\u6C9B\u6C7E\u6C68\u6C73\u6C92\u6C90\u6CC4\u6CF1\u6CD3\u6CBD\u6CD7\u6CC5\u6CDD\u6CAE\u6CB1\u6CBE"],
+ ["dea1", "\u6CBA\u6CDB\u6CEF\u6CD9\u6CEA\u6D1F\u884D\u6D36\u6D2B\u6D3D\u6D38\u6D19\u6D35\u6D33\u6D12\u6D0C\u6D63\u6D93\u6D64\u6D5A\u6D79\u6D59\u6D8E\u6D95\u6FE4\u6D85\u6DF9\u6E15\u6E0A\u6DB5\u6DC7\u6DE6\u6DB8\u6DC6\u6DEC\u6DDE\u6DCC\u6DE8\u6DD2\u6DC5\u6DFA\u6DD9\u6DE4\u6DD5\u6DEA\u6DEE\u6E2D\u6E6E\u6E2E\u6E19\u6E72\u6E5F\u6E3E\u6E23\u6E6B\u6E2B\u6E76\u6E4D\u6E1F\u6E43\u6E3A\u6E4E\u6E24\u6EFF\u6E1D\u6E38\u6E82\u6EAA\u6E98\u6EC9\u6EB7\u6ED3\u6EBD\u6EAF\u6EC4\u6EB2\u6ED4\u6ED5\u6E8F\u6EA5\u6EC2\u6E9F\u6F41\u6F11\u704C\u6EEC\u6EF8\u6EFE\u6F3F\u6EF2\u6F31\u6EEF\u6F32\u6ECC"],
+ ["dfa1", "\u6F3E\u6F13\u6EF7\u6F86\u6F7A\u6F78\u6F81\u6F80\u6F6F\u6F5B\u6FF3\u6F6D\u6F82\u6F7C\u6F58\u6F8E\u6F91\u6FC2\u6F66\u6FB3\u6FA3\u6FA1\u6FA4\u6FB9\u6FC6\u6FAA\u6FDF\u6FD5\u6FEC\u6FD4\u6FD8\u6FF1\u6FEE\u6FDB\u7009\u700B\u6FFA\u7011\u7001\u700F\u6FFE\u701B\u701A\u6F74\u701D\u7018\u701F\u7030\u703E\u7032\u7051\u7063\u7099\u7092\u70AF\u70F1\u70AC\u70B8\u70B3\u70AE\u70DF\u70CB\u70DD\u70D9\u7109\u70FD\u711C\u7119\u7165\u7155\u7188\u7166\u7162\u714C\u7156\u716C\u718F\u71FB\u7184\u7195\u71A8\u71AC\u71D7\u71B9\u71BE\u71D2\u71C9\u71D4\u71CE\u71E0\u71EC\u71E7\u71F5\u71FC"],
+ ["e0a1", "\u71F9\u71FF\u720D\u7210\u721B\u7228\u722D\u722C\u7230\u7232\u723B\u723C\u723F\u7240\u7246\u724B\u7258\u7274\u727E\u7282\u7281\u7287\u7292\u7296\u72A2\u72A7\u72B9\u72B2\u72C3\u72C6\u72C4\u72CE\u72D2\u72E2\u72E0\u72E1\u72F9\u72F7\u500F\u7317\u730A\u731C\u7316\u731D\u7334\u732F\u7329\u7325\u733E\u734E\u734F\u9ED8\u7357\u736A\u7368\u7370\u7378\u7375\u737B\u737A\u73C8\u73B3\u73CE\u73BB\u73C0\u73E5\u73EE\u73DE\u74A2\u7405\u746F\u7425\u73F8\u7432\u743A\u7455\u743F\u745F\u7459\u7441\u745C\u7469\u7470\u7463\u746A\u7476\u747E\u748B\u749E\u74A7\u74CA\u74CF\u74D4\u73F1"],
+ ["e1a1", "\u74E0\u74E3\u74E7\u74E9\u74EE\u74F2\u74F0\u74F1\u74F8\u74F7\u7504\u7503\u7505\u750C\u750E\u750D\u7515\u7513\u751E\u7526\u752C\u753C\u7544\u754D\u754A\u7549\u755B\u7546\u755A\u7569\u7564\u7567\u756B\u756D\u7578\u7576\u7586\u7587\u7574\u758A\u7589\u7582\u7594\u759A\u759D\u75A5\u75A3\u75C2\u75B3\u75C3\u75B5\u75BD\u75B8\u75BC\u75B1\u75CD\u75CA\u75D2\u75D9\u75E3\u75DE\u75FE\u75FF\u75FC\u7601\u75F0\u75FA\u75F2\u75F3\u760B\u760D\u7609\u761F\u7627\u7620\u7621\u7622\u7624\u7634\u7630\u763B\u7647\u7648\u7646\u765C\u7658\u7661\u7662\u7668\u7669\u766A\u7667\u766C\u7670"],
+ ["e2a1", "\u7672\u7676\u7678\u767C\u7680\u7683\u7688\u768B\u768E\u7696\u7693\u7699\u769A\u76B0\u76B4\u76B8\u76B9\u76BA\u76C2\u76CD\u76D6\u76D2\u76DE\u76E1\u76E5\u76E7\u76EA\u862F\u76FB\u7708\u7707\u7704\u7729\u7724\u771E\u7725\u7726\u771B\u7737\u7738\u7747\u775A\u7768\u776B\u775B\u7765\u777F\u777E\u7779\u778E\u778B\u7791\u77A0\u779E\u77B0\u77B6\u77B9\u77BF\u77BC\u77BD\u77BB\u77C7\u77CD\u77D7\u77DA\u77DC\u77E3\u77EE\u77FC\u780C\u7812\u7926\u7820\u792A\u7845\u788E\u7874\u7886\u787C\u789A\u788C\u78A3\u78B5\u78AA\u78AF\u78D1\u78C6\u78CB\u78D4\u78BE\u78BC\u78C5\u78CA\u78EC"],
+ ["e3a1", "\u78E7\u78DA\u78FD\u78F4\u7907\u7912\u7911\u7919\u792C\u792B\u7940\u7960\u7957\u795F\u795A\u7955\u7953\u797A\u797F\u798A\u799D\u79A7\u9F4B\u79AA\u79AE\u79B3\u79B9\u79BA\u79C9\u79D5\u79E7\u79EC\u79E1\u79E3\u7A08\u7A0D\u7A18\u7A19\u7A20\u7A1F\u7980\u7A31\u7A3B\u7A3E\u7A37\u7A43\u7A57\u7A49\u7A61\u7A62\u7A69\u9F9D\u7A70\u7A79\u7A7D\u7A88\u7A97\u7A95\u7A98\u7A96\u7AA9\u7AC8\u7AB0\u7AB6\u7AC5\u7AC4\u7ABF\u9083\u7AC7\u7ACA\u7ACD\u7ACF\u7AD5\u7AD3\u7AD9\u7ADA\u7ADD\u7AE1\u7AE2\u7AE6\u7AED\u7AF0\u7B02\u7B0F\u7B0A\u7B06\u7B33\u7B18\u7B19\u7B1E\u7B35\u7B28\u7B36\u7B50"],
+ ["e4a1", "\u7B7A\u7B04\u7B4D\u7B0B\u7B4C\u7B45\u7B75\u7B65\u7B74\u7B67\u7B70\u7B71\u7B6C\u7B6E\u7B9D\u7B98\u7B9F\u7B8D\u7B9C\u7B9A\u7B8B\u7B92\u7B8F\u7B5D\u7B99\u7BCB\u7BC1\u7BCC\u7BCF\u7BB4\u7BC6\u7BDD\u7BE9\u7C11\u7C14\u7BE6\u7BE5\u7C60\u7C00\u7C07\u7C13\u7BF3\u7BF7\u7C17\u7C0D\u7BF6\u7C23\u7C27\u7C2A\u7C1F\u7C37\u7C2B\u7C3D\u7C4C\u7C43\u7C54\u7C4F\u7C40\u7C50\u7C58\u7C5F\u7C64\u7C56\u7C65\u7C6C\u7C75\u7C83\u7C90\u7CA4\u7CAD\u7CA2\u7CAB\u7CA1\u7CA8\u7CB3\u7CB2\u7CB1\u7CAE\u7CB9\u7CBD\u7CC0\u7CC5\u7CC2\u7CD8\u7CD2\u7CDC\u7CE2\u9B3B\u7CEF\u7CF2\u7CF4\u7CF6\u7CFA\u7D06"],
+ ["e5a1", "\u7D02\u7D1C\u7D15\u7D0A\u7D45\u7D4B\u7D2E\u7D32\u7D3F\u7D35\u7D46\u7D73\u7D56\u7D4E\u7D72\u7D68\u7D6E\u7D4F\u7D63\u7D93\u7D89\u7D5B\u7D8F\u7D7D\u7D9B\u7DBA\u7DAE\u7DA3\u7DB5\u7DC7\u7DBD\u7DAB\u7E3D\u7DA2\u7DAF\u7DDC\u7DB8\u7D9F\u7DB0\u7DD8\u7DDD\u7DE4\u7DDE\u7DFB\u7DF2\u7DE1\u7E05\u7E0A\u7E23\u7E21\u7E12\u7E31\u7E1F\u7E09\u7E0B\u7E22\u7E46\u7E66\u7E3B\u7E35\u7E39\u7E43\u7E37\u7E32\u7E3A\u7E67\u7E5D\u7E56\u7E5E\u7E59\u7E5A\u7E79\u7E6A\u7E69\u7E7C\u7E7B\u7E83\u7DD5\u7E7D\u8FAE\u7E7F\u7E88\u7E89\u7E8C\u7E92\u7E90\u7E93\u7E94\u7E96\u7E8E\u7E9B\u7E9C\u7F38\u7F3A"],
+ ["e6a1", "\u7F45\u7F4C\u7F4D\u7F4E\u7F50\u7F51\u7F55\u7F54\u7F58\u7F5F\u7F60\u7F68\u7F69\u7F67\u7F78\u7F82\u7F86\u7F83\u7F88\u7F87\u7F8C\u7F94\u7F9E\u7F9D\u7F9A\u7FA3\u7FAF\u7FB2\u7FB9\u7FAE\u7FB6\u7FB8\u8B71\u7FC5\u7FC6\u7FCA\u7FD5\u7FD4\u7FE1\u7FE6\u7FE9\u7FF3\u7FF9\u98DC\u8006\u8004\u800B\u8012\u8018\u8019\u801C\u8021\u8028\u803F\u803B\u804A\u8046\u8052\u8058\u805A\u805F\u8062\u8068\u8073\u8072\u8070\u8076\u8079\u807D\u807F\u8084\u8086\u8085\u809B\u8093\u809A\u80AD\u5190\u80AC\u80DB\u80E5\u80D9\u80DD\u80C4\u80DA\u80D6\u8109\u80EF\u80F1\u811B\u8129\u8123\u812F\u814B"],
+ ["e7a1", "\u968B\u8146\u813E\u8153\u8151\u80FC\u8171\u816E\u8165\u8166\u8174\u8183\u8188\u818A\u8180\u8182\u81A0\u8195\u81A4\u81A3\u815F\u8193\u81A9\u81B0\u81B5\u81BE\u81B8\u81BD\u81C0\u81C2\u81BA\u81C9\u81CD\u81D1\u81D9\u81D8\u81C8\u81DA\u81DF\u81E0\u81E7\u81FA\u81FB\u81FE\u8201\u8202\u8205\u8207\u820A\u820D\u8210\u8216\u8229\u822B\u8238\u8233\u8240\u8259\u8258\u825D\u825A\u825F\u8264\u8262\u8268\u826A\u826B\u822E\u8271\u8277\u8278\u827E\u828D\u8292\u82AB\u829F\u82BB\u82AC\u82E1\u82E3\u82DF\u82D2\u82F4\u82F3\u82FA\u8393\u8303\u82FB\u82F9\u82DE\u8306\u82DC\u8309\u82D9"],
+ ["e8a1", "\u8335\u8334\u8316\u8332\u8331\u8340\u8339\u8350\u8345\u832F\u832B\u8317\u8318\u8385\u839A\u83AA\u839F\u83A2\u8396\u8323\u838E\u8387\u838A\u837C\u83B5\u8373\u8375\u83A0\u8389\u83A8\u83F4\u8413\u83EB\u83CE\u83FD\u8403\u83D8\u840B\u83C1\u83F7\u8407\u83E0\u83F2\u840D\u8422\u8420\u83BD\u8438\u8506\u83FB\u846D\u842A\u843C\u855A\u8484\u8477\u846B\u84AD\u846E\u8482\u8469\u8446\u842C\u846F\u8479\u8435\u84CA\u8462\u84B9\u84BF\u849F\u84D9\u84CD\u84BB\u84DA\u84D0\u84C1\u84C6\u84D6\u84A1\u8521\u84FF\u84F4\u8517\u8518\u852C\u851F\u8515\u8514\u84FC\u8540\u8563\u8558\u8548"],
+ ["e9a1", "\u8541\u8602\u854B\u8555\u8580\u85A4\u8588\u8591\u858A\u85A8\u856D\u8594\u859B\u85EA\u8587\u859C\u8577\u857E\u8590\u85C9\u85BA\u85CF\u85B9\u85D0\u85D5\u85DD\u85E5\u85DC\u85F9\u860A\u8613\u860B\u85FE\u85FA\u8606\u8622\u861A\u8630\u863F\u864D\u4E55\u8654\u865F\u8667\u8671\u8693\u86A3\u86A9\u86AA\u868B\u868C\u86B6\u86AF\u86C4\u86C6\u86B0\u86C9\u8823\u86AB\u86D4\u86DE\u86E9\u86EC\u86DF\u86DB\u86EF\u8712\u8706\u8708\u8700\u8703\u86FB\u8711\u8709\u870D\u86F9\u870A\u8734\u873F\u8737\u873B\u8725\u8729\u871A\u8760\u875F\u8778\u874C\u874E\u8774\u8757\u8768\u876E\u8759"],
+ ["eaa1", "\u8753\u8763\u876A\u8805\u87A2\u879F\u8782\u87AF\u87CB\u87BD\u87C0\u87D0\u96D6\u87AB\u87C4\u87B3\u87C7\u87C6\u87BB\u87EF\u87F2\u87E0\u880F\u880D\u87FE\u87F6\u87F7\u880E\u87D2\u8811\u8816\u8815\u8822\u8821\u8831\u8836\u8839\u8827\u883B\u8844\u8842\u8852\u8859\u885E\u8862\u886B\u8881\u887E\u889E\u8875\u887D\u88B5\u8872\u8882\u8897\u8892\u88AE\u8899\u88A2\u888D\u88A4\u88B0\u88BF\u88B1\u88C3\u88C4\u88D4\u88D8\u88D9\u88DD\u88F9\u8902\u88FC\u88F4\u88E8\u88F2\u8904\u890C\u890A\u8913\u8943\u891E\u8925\u892A\u892B\u8941\u8944\u893B\u8936\u8938\u894C\u891D\u8960\u895E"],
+ ["eba1", "\u8966\u8964\u896D\u896A\u896F\u8974\u8977\u897E\u8983\u8988\u898A\u8993\u8998\u89A1\u89A9\u89A6\u89AC\u89AF\u89B2\u89BA\u89BD\u89BF\u89C0\u89DA\u89DC\u89DD\u89E7\u89F4\u89F8\u8A03\u8A16\u8A10\u8A0C\u8A1B\u8A1D\u8A25\u8A36\u8A41\u8A5B\u8A52\u8A46\u8A48\u8A7C\u8A6D\u8A6C\u8A62\u8A85\u8A82\u8A84\u8AA8\u8AA1\u8A91\u8AA5\u8AA6\u8A9A\u8AA3\u8AC4\u8ACD\u8AC2\u8ADA\u8AEB\u8AF3\u8AE7\u8AE4\u8AF1\u8B14\u8AE0\u8AE2\u8AF7\u8ADE\u8ADB\u8B0C\u8B07\u8B1A\u8AE1\u8B16\u8B10\u8B17\u8B20\u8B33\u97AB\u8B26\u8B2B\u8B3E\u8B28\u8B41\u8B4C\u8B4F\u8B4E\u8B49\u8B56\u8B5B\u8B5A\u8B6B"],
+ ["eca1", "\u8B5F\u8B6C\u8B6F\u8B74\u8B7D\u8B80\u8B8C\u8B8E\u8B92\u8B93\u8B96\u8B99\u8B9A\u8C3A\u8C41\u8C3F\u8C48\u8C4C\u8C4E\u8C50\u8C55\u8C62\u8C6C\u8C78\u8C7A\u8C82\u8C89\u8C85\u8C8A\u8C8D\u8C8E\u8C94\u8C7C\u8C98\u621D\u8CAD\u8CAA\u8CBD\u8CB2\u8CB3\u8CAE\u8CB6\u8CC8\u8CC1\u8CE4\u8CE3\u8CDA\u8CFD\u8CFA\u8CFB\u8D04\u8D05\u8D0A\u8D07\u8D0F\u8D0D\u8D10\u9F4E\u8D13\u8CCD\u8D14\u8D16\u8D67\u8D6D\u8D71\u8D73\u8D81\u8D99\u8DC2\u8DBE\u8DBA\u8DCF\u8DDA\u8DD6\u8DCC\u8DDB\u8DCB\u8DEA\u8DEB\u8DDF\u8DE3\u8DFC\u8E08\u8E09\u8DFF\u8E1D\u8E1E\u8E10\u8E1F\u8E42\u8E35\u8E30\u8E34\u8E4A"],
+ ["eda1", "\u8E47\u8E49\u8E4C\u8E50\u8E48\u8E59\u8E64\u8E60\u8E2A\u8E63\u8E55\u8E76\u8E72\u8E7C\u8E81\u8E87\u8E85\u8E84\u8E8B\u8E8A\u8E93\u8E91\u8E94\u8E99\u8EAA\u8EA1\u8EAC\u8EB0\u8EC6\u8EB1\u8EBE\u8EC5\u8EC8\u8ECB\u8EDB\u8EE3\u8EFC\u8EFB\u8EEB\u8EFE\u8F0A\u8F05\u8F15\u8F12\u8F19\u8F13\u8F1C\u8F1F\u8F1B\u8F0C\u8F26\u8F33\u8F3B\u8F39\u8F45\u8F42\u8F3E\u8F4C\u8F49\u8F46\u8F4E\u8F57\u8F5C\u8F62\u8F63\u8F64\u8F9C\u8F9F\u8FA3\u8FAD\u8FAF\u8FB7\u8FDA\u8FE5\u8FE2\u8FEA\u8FEF\u9087\u8FF4\u9005\u8FF9\u8FFA\u9011\u9015\u9021\u900D\u901E\u9016\u900B\u9027\u9036\u9035\u9039\u8FF8"],
+ ["eea1", "\u904F\u9050\u9051\u9052\u900E\u9049\u903E\u9056\u9058\u905E\u9068\u906F\u9076\u96A8\u9072\u9082\u907D\u9081\u9080\u908A\u9089\u908F\u90A8\u90AF\u90B1\u90B5\u90E2\u90E4\u6248\u90DB\u9102\u9112\u9119\u9132\u9130\u914A\u9156\u9158\u9163\u9165\u9169\u9173\u9172\u918B\u9189\u9182\u91A2\u91AB\u91AF\u91AA\u91B5\u91B4\u91BA\u91C0\u91C1\u91C9\u91CB\u91D0\u91D6\u91DF\u91E1\u91DB\u91FC\u91F5\u91F6\u921E\u91FF\u9214\u922C\u9215\u9211\u925E\u9257\u9245\u9249\u9264\u9248\u9295\u923F\u924B\u9250\u929C\u9296\u9293\u929B\u925A\u92CF\u92B9\u92B7\u92E9\u930F\u92FA\u9344\u932E"],
+ ["efa1", "\u9319\u9322\u931A\u9323\u933A\u9335\u933B\u935C\u9360\u937C\u936E\u9356\u93B0\u93AC\u93AD\u9394\u93B9\u93D6\u93D7\u93E8\u93E5\u93D8\u93C3\u93DD\u93D0\u93C8\u93E4\u941A\u9414\u9413\u9403\u9407\u9410\u9436\u942B\u9435\u9421\u943A\u9441\u9452\u9444\u945B\u9460\u9462\u945E\u946A\u9229\u9470\u9475\u9477\u947D\u945A\u947C\u947E\u9481\u947F\u9582\u9587\u958A\u9594\u9596\u9598\u9599\u95A0\u95A8\u95A7\u95AD\u95BC\u95BB\u95B9\u95BE\u95CA\u6FF6\u95C3\u95CD\u95CC\u95D5\u95D4\u95D6\u95DC\u95E1\u95E5\u95E2\u9621\u9628\u962E\u962F\u9642\u964C\u964F\u964B\u9677\u965C\u965E"],
+ ["f0a1", "\u965D\u965F\u9666\u9672\u966C\u968D\u9698\u9695\u9697\u96AA\u96A7\u96B1\u96B2\u96B0\u96B4\u96B6\u96B8\u96B9\u96CE\u96CB\u96C9\u96CD\u894D\u96DC\u970D\u96D5\u96F9\u9704\u9706\u9708\u9713\u970E\u9711\u970F\u9716\u9719\u9724\u972A\u9730\u9739\u973D\u973E\u9744\u9746\u9748\u9742\u9749\u975C\u9760\u9764\u9766\u9768\u52D2\u976B\u9771\u9779\u9785\u977C\u9781\u977A\u9786\u978B\u978F\u9790\u979C\u97A8\u97A6\u97A3\u97B3\u97B4\u97C3\u97C6\u97C8\u97CB\u97DC\u97ED\u9F4F\u97F2\u7ADF\u97F6\u97F5\u980F\u980C\u9838\u9824\u9821\u9837\u983D\u9846\u984F\u984B\u986B\u986F\u9870"],
+ ["f1a1", "\u9871\u9874\u9873\u98AA\u98AF\u98B1\u98B6\u98C4\u98C3\u98C6\u98E9\u98EB\u9903\u9909\u9912\u9914\u9918\u9921\u991D\u991E\u9924\u9920\u992C\u992E\u993D\u993E\u9942\u9949\u9945\u9950\u994B\u9951\u9952\u994C\u9955\u9997\u9998\u99A5\u99AD\u99AE\u99BC\u99DF\u99DB\u99DD\u99D8\u99D1\u99ED\u99EE\u99F1\u99F2\u99FB\u99F8\u9A01\u9A0F\u9A05\u99E2\u9A19\u9A2B\u9A37\u9A45\u9A42\u9A40\u9A43\u9A3E\u9A55\u9A4D\u9A5B\u9A57\u9A5F\u9A62\u9A65\u9A64\u9A69\u9A6B\u9A6A\u9AAD\u9AB0\u9ABC\u9AC0\u9ACF\u9AD1\u9AD3\u9AD4\u9ADE\u9ADF\u9AE2\u9AE3\u9AE6\u9AEF\u9AEB\u9AEE\u9AF4\u9AF1\u9AF7"],
+ ["f2a1", "\u9AFB\u9B06\u9B18\u9B1A\u9B1F\u9B22\u9B23\u9B25\u9B27\u9B28\u9B29\u9B2A\u9B2E\u9B2F\u9B32\u9B44\u9B43\u9B4F\u9B4D\u9B4E\u9B51\u9B58\u9B74\u9B93\u9B83\u9B91\u9B96\u9B97\u9B9F\u9BA0\u9BA8\u9BB4\u9BC0\u9BCA\u9BB9\u9BC6\u9BCF\u9BD1\u9BD2\u9BE3\u9BE2\u9BE4\u9BD4\u9BE1\u9C3A\u9BF2\u9BF1\u9BF0\u9C15\u9C14\u9C09\u9C13\u9C0C\u9C06\u9C08\u9C12\u9C0A\u9C04\u9C2E\u9C1B\u9C25\u9C24\u9C21\u9C30\u9C47\u9C32\u9C46\u9C3E\u9C5A\u9C60\u9C67\u9C76\u9C78\u9CE7\u9CEC\u9CF0\u9D09\u9D08\u9CEB\u9D03\u9D06\u9D2A\u9D26\u9DAF\u9D23\u9D1F\u9D44\u9D15\u9D12\u9D41\u9D3F\u9D3E\u9D46\u9D48"],
+ ["f3a1", "\u9D5D\u9D5E\u9D64\u9D51\u9D50\u9D59\u9D72\u9D89\u9D87\u9DAB\u9D6F\u9D7A\u9D9A\u9DA4\u9DA9\u9DB2\u9DC4\u9DC1\u9DBB\u9DB8\u9DBA\u9DC6\u9DCF\u9DC2\u9DD9\u9DD3\u9DF8\u9DE6\u9DED\u9DEF\u9DFD\u9E1A\u9E1B\u9E1E\u9E75\u9E79\u9E7D\u9E81\u9E88\u9E8B\u9E8C\u9E92\u9E95\u9E91\u9E9D\u9EA5\u9EA9\u9EB8\u9EAA\u9EAD\u9761\u9ECC\u9ECE\u9ECF\u9ED0\u9ED4\u9EDC\u9EDE\u9EDD\u9EE0\u9EE5\u9EE8\u9EEF\u9EF4\u9EF6\u9EF7\u9EF9\u9EFB\u9EFC\u9EFD\u9F07\u9F08\u76B7\u9F15\u9F21\u9F2C\u9F3E\u9F4A\u9F52\u9F54\u9F63\u9F5F\u9F60\u9F61\u9F66\u9F67\u9F6C\u9F6A\u9F77\u9F72\u9F76\u9F95\u9F9C\u9FA0"],
+ ["f4a1", "\u582F\u69C7\u9059\u7464\u51DC\u7199"],
+ ["f9a1", "\u7E8A\u891C\u9348\u9288\u84DC\u4FC9\u70BB\u6631\u68C8\u92F9\u66FB\u5F45\u4E28\u4EE1\u4EFC\u4F00\u4F03\u4F39\u4F56\u4F92\u4F8A\u4F9A\u4F94\u4FCD\u5040\u5022\u4FFF\u501E\u5046\u5070\u5042\u5094\u50F4\u50D8\u514A\u5164\u519D\u51BE\u51EC\u5215\u529C\u52A6\u52C0\u52DB\u5300\u5307\u5324\u5372\u5393\u53B2\u53DD\uFA0E\u549C\u548A\u54A9\u54FF\u5586\u5759\u5765\u57AC\u57C8\u57C7\uFA0F\uFA10\u589E\u58B2\u590B\u5953\u595B\u595D\u5963\u59A4\u59BA\u5B56\u5BC0\u752F\u5BD8\u5BEC\u5C1E\u5CA6\u5CBA\u5CF5\u5D27\u5D53\uFA11\u5D42\u5D6D\u5DB8\u5DB9\u5DD0\u5F21\u5F34\u5F67\u5FB7"],
+ ["faa1", "\u5FDE\u605D\u6085\u608A\u60DE\u60D5\u6120\u60F2\u6111\u6137\u6130\u6198\u6213\u62A6\u63F5\u6460\u649D\u64CE\u654E\u6600\u6615\u663B\u6609\u662E\u661E\u6624\u6665\u6657\u6659\uFA12\u6673\u6699\u66A0\u66B2\u66BF\u66FA\u670E\uF929\u6766\u67BB\u6852\u67C0\u6801\u6844\u68CF\uFA13\u6968\uFA14\u6998\u69E2\u6A30\u6A6B\u6A46\u6A73\u6A7E\u6AE2\u6AE4\u6BD6\u6C3F\u6C5C\u6C86\u6C6F\u6CDA\u6D04\u6D87\u6D6F\u6D96\u6DAC\u6DCF\u6DF8\u6DF2\u6DFC\u6E39\u6E5C\u6E27\u6E3C\u6EBF\u6F88\u6FB5\u6FF5\u7005\u7007\u7028\u7085\u70AB\u710F\u7104\u715C\u7146\u7147\uFA15\u71C1\u71FE\u72B1"],
+ ["fba1", "\u72BE\u7324\uFA16\u7377\u73BD\u73C9\u73D6\u73E3\u73D2\u7407\u73F5\u7426\u742A\u7429\u742E\u7462\u7489\u749F\u7501\u756F\u7682\u769C\u769E\u769B\u76A6\uFA17\u7746\u52AF\u7821\u784E\u7864\u787A\u7930\uFA18\uFA19\uFA1A\u7994\uFA1B\u799B\u7AD1\u7AE7\uFA1C\u7AEB\u7B9E\uFA1D\u7D48\u7D5C\u7DB7\u7DA0\u7DD6\u7E52\u7F47\u7FA1\uFA1E\u8301\u8362\u837F\u83C7\u83F6\u8448\u84B4\u8553\u8559\u856B\uFA1F\u85B0\uFA20\uFA21\u8807\u88F5\u8A12\u8A37\u8A79\u8AA7\u8ABE\u8ADF\uFA22\u8AF6\u8B53\u8B7F\u8CF0\u8CF4\u8D12\u8D76\uFA23\u8ECF\uFA24\uFA25\u9067\u90DE\uFA26\u9115\u9127\u91DA"],
+ ["fca1", "\u91D7\u91DE\u91ED\u91EE\u91E4\u91E5\u9206\u9210\u920A\u923A\u9240\u923C\u924E\u9259\u9251\u9239\u9267\u92A7\u9277\u9278\u92E7\u92D7\u92D9\u92D0\uFA27\u92D5\u92E0\u92D3\u9325\u9321\u92FB\uFA28\u931E\u92FF\u931D\u9302\u9370\u9357\u93A4\u93C6\u93DE\u93F8\u9431\u9445\u9448\u9592\uF9DC\uFA29\u969D\u96AF\u9733\u973B\u9743\u974D\u974F\u9751\u9755\u9857\u9865\uFA2A\uFA2B\u9927\uFA2C\u999E\u9A4E\u9AD9\u9ADC\u9B75\u9B72\u9B8F\u9BB1\u9BBB\u9C00\u9D70\u9D6B\uFA2D\u9E19\u9ED1"],
+ ["fcf1", "\u2170", 9, "\uFFE2\uFFE4\uFF07\uFF02"],
+ ["8fa2af", "\u02D8\u02C7\xB8\u02D9\u02DD\xAF\u02DB\u02DA\uFF5E\u0384\u0385"],
+ ["8fa2c2", "\xA1\xA6\xBF"],
+ ["8fa2eb", "\xBA\xAA\xA9\xAE\u2122\xA4\u2116"],
+ ["8fa6e1", "\u0386\u0388\u0389\u038A\u03AA"],
+ ["8fa6e7", "\u038C"],
+ ["8fa6e9", "\u038E\u03AB"],
+ ["8fa6ec", "\u038F"],
+ ["8fa6f1", "\u03AC\u03AD\u03AE\u03AF\u03CA\u0390\u03CC\u03C2\u03CD\u03CB\u03B0\u03CE"],
+ ["8fa7c2", "\u0402", 10, "\u040E\u040F"],
+ ["8fa7f2", "\u0452", 10, "\u045E\u045F"],
+ ["8fa9a1", "\xC6\u0110"],
+ ["8fa9a4", "\u0126"],
+ ["8fa9a6", "\u0132"],
+ ["8fa9a8", "\u0141\u013F"],
+ ["8fa9ab", "\u014A\xD8\u0152"],
+ ["8fa9af", "\u0166\xDE"],
+ ["8fa9c1", "\xE6\u0111\xF0\u0127\u0131\u0133\u0138\u0142\u0140\u0149\u014B\xF8\u0153\xDF\u0167\xFE"],
+ ["8faaa1", "\xC1\xC0\xC4\xC2\u0102\u01CD\u0100\u0104\xC5\xC3\u0106\u0108\u010C\xC7\u010A\u010E\xC9\xC8\xCB\xCA\u011A\u0116\u0112\u0118"],
+ ["8faaba", "\u011C\u011E\u0122\u0120\u0124\xCD\xCC\xCF\xCE\u01CF\u0130\u012A\u012E\u0128\u0134\u0136\u0139\u013D\u013B\u0143\u0147\u0145\xD1\xD3\xD2\xD6\xD4\u01D1\u0150\u014C\xD5\u0154\u0158\u0156\u015A\u015C\u0160\u015E\u0164\u0162\xDA\xD9\xDC\xDB\u016C\u01D3\u0170\u016A\u0172\u016E\u0168\u01D7\u01DB\u01D9\u01D5\u0174\xDD\u0178\u0176\u0179\u017D\u017B"],
+ ["8faba1", "\xE1\xE0\xE4\xE2\u0103\u01CE\u0101\u0105\xE5\xE3\u0107\u0109\u010D\xE7\u010B\u010F\xE9\xE8\xEB\xEA\u011B\u0117\u0113\u0119\u01F5\u011D\u011F"],
+ ["8fabbd", "\u0121\u0125\xED\xEC\xEF\xEE\u01D0"],
+ ["8fabc5", "\u012B\u012F\u0129\u0135\u0137\u013A\u013E\u013C\u0144\u0148\u0146\xF1\xF3\xF2\xF6\xF4\u01D2\u0151\u014D\xF5\u0155\u0159\u0157\u015B\u015D\u0161\u015F\u0165\u0163\xFA\xF9\xFC\xFB\u016D\u01D4\u0171\u016B\u0173\u016F\u0169\u01D8\u01DC\u01DA\u01D6\u0175\xFD\xFF\u0177\u017A\u017E\u017C"],
+ ["8fb0a1", "\u4E02\u4E04\u4E05\u4E0C\u4E12\u4E1F\u4E23\u4E24\u4E28\u4E2B\u4E2E\u4E2F\u4E30\u4E35\u4E40\u4E41\u4E44\u4E47\u4E51\u4E5A\u4E5C\u4E63\u4E68\u4E69\u4E74\u4E75\u4E79\u4E7F\u4E8D\u4E96\u4E97\u4E9D\u4EAF\u4EB9\u4EC3\u4ED0\u4EDA\u4EDB\u4EE0\u4EE1\u4EE2\u4EE8\u4EEF\u4EF1\u4EF3\u4EF5\u4EFD\u4EFE\u4EFF\u4F00\u4F02\u4F03\u4F08\u4F0B\u4F0C\u4F12\u4F15\u4F16\u4F17\u4F19\u4F2E\u4F31\u4F60\u4F33\u4F35\u4F37\u4F39\u4F3B\u4F3E\u4F40\u4F42\u4F48\u4F49\u4F4B\u4F4C\u4F52\u4F54\u4F56\u4F58\u4F5F\u4F63\u4F6A\u4F6C\u4F6E\u4F71\u4F77\u4F78\u4F79\u4F7A\u4F7D\u4F7E\u4F81\u4F82\u4F84"],
+ ["8fb1a1", "\u4F85\u4F89\u4F8A\u4F8C\u4F8E\u4F90\u4F92\u4F93\u4F94\u4F97\u4F99\u4F9A\u4F9E\u4F9F\u4FB2\u4FB7\u4FB9\u4FBB\u4FBC\u4FBD\u4FBE\u4FC0\u4FC1\u4FC5\u4FC6\u4FC8\u4FC9\u4FCB\u4FCC\u4FCD\u4FCF\u4FD2\u4FDC\u4FE0\u4FE2\u4FF0\u4FF2\u4FFC\u4FFD\u4FFF\u5000\u5001\u5004\u5007\u500A\u500C\u500E\u5010\u5013\u5017\u5018\u501B\u501C\u501D\u501E\u5022\u5027\u502E\u5030\u5032\u5033\u5035\u5040\u5041\u5042\u5045\u5046\u504A\u504C\u504E\u5051\u5052\u5053\u5057\u5059\u505F\u5060\u5062\u5063\u5066\u5067\u506A\u506D\u5070\u5071\u503B\u5081\u5083\u5084\u5086\u508A\u508E\u508F\u5090"],
+ ["8fb2a1", "\u5092\u5093\u5094\u5096\u509B\u509C\u509E", 4, "\u50AA\u50AF\u50B0\u50B9\u50BA\u50BD\u50C0\u50C3\u50C4\u50C7\u50CC\u50CE\u50D0\u50D3\u50D4\u50D8\u50DC\u50DD\u50DF\u50E2\u50E4\u50E6\u50E8\u50E9\u50EF\u50F1\u50F6\u50FA\u50FE\u5103\u5106\u5107\u5108\u510B\u510C\u510D\u510E\u50F2\u5110\u5117\u5119\u511B\u511C\u511D\u511E\u5123\u5127\u5128\u512C\u512D\u512F\u5131\u5133\u5134\u5135\u5138\u5139\u5142\u514A\u514F\u5153\u5155\u5157\u5158\u515F\u5164\u5166\u517E\u5183\u5184\u518B\u518E\u5198\u519D\u51A1\u51A3\u51AD\u51B8\u51BA\u51BC\u51BE\u51BF\u51C2"],
+ ["8fb3a1", "\u51C8\u51CF\u51D1\u51D2\u51D3\u51D5\u51D8\u51DE\u51E2\u51E5\u51EE\u51F2\u51F3\u51F4\u51F7\u5201\u5202\u5205\u5212\u5213\u5215\u5216\u5218\u5222\u5228\u5231\u5232\u5235\u523C\u5245\u5249\u5255\u5257\u5258\u525A\u525C\u525F\u5260\u5261\u5266\u526E\u5277\u5278\u5279\u5280\u5282\u5285\u528A\u528C\u5293\u5295\u5296\u5297\u5298\u529A\u529C\u52A4\u52A5\u52A6\u52A7\u52AF\u52B0\u52B6\u52B7\u52B8\u52BA\u52BB\u52BD\u52C0\u52C4\u52C6\u52C8\u52CC\u52CF\u52D1\u52D4\u52D6\u52DB\u52DC\u52E1\u52E5\u52E8\u52E9\u52EA\u52EC\u52F0\u52F1\u52F4\u52F6\u52F7\u5300\u5303\u530A\u530B"],
+ ["8fb4a1", "\u530C\u5311\u5313\u5318\u531B\u531C\u531E\u531F\u5325\u5327\u5328\u5329\u532B\u532C\u532D\u5330\u5332\u5335\u533C\u533D\u533E\u5342\u534C\u534B\u5359\u535B\u5361\u5363\u5365\u536C\u536D\u5372\u5379\u537E\u5383\u5387\u5388\u538E\u5393\u5394\u5399\u539D\u53A1\u53A4\u53AA\u53AB\u53AF\u53B2\u53B4\u53B5\u53B7\u53B8\u53BA\u53BD\u53C0\u53C5\u53CF\u53D2\u53D3\u53D5\u53DA\u53DD\u53DE\u53E0\u53E6\u53E7\u53F5\u5402\u5413\u541A\u5421\u5427\u5428\u542A\u542F\u5431\u5434\u5435\u5443\u5444\u5447\u544D\u544F\u545E\u5462\u5464\u5466\u5467\u5469\u546B\u546D\u546E\u5474\u547F"],
+ ["8fb5a1", "\u5481\u5483\u5485\u5488\u5489\u548D\u5491\u5495\u5496\u549C\u549F\u54A1\u54A6\u54A7\u54A9\u54AA\u54AD\u54AE\u54B1\u54B7\u54B9\u54BA\u54BB\u54BF\u54C6\u54CA\u54CD\u54CE\u54E0\u54EA\u54EC\u54EF\u54F6\u54FC\u54FE\u54FF\u5500\u5501\u5505\u5508\u5509\u550C\u550D\u550E\u5515\u552A\u552B\u5532\u5535\u5536\u553B\u553C\u553D\u5541\u5547\u5549\u554A\u554D\u5550\u5551\u5558\u555A\u555B\u555E\u5560\u5561\u5564\u5566\u557F\u5581\u5582\u5586\u5588\u558E\u558F\u5591\u5592\u5593\u5594\u5597\u55A3\u55A4\u55AD\u55B2\u55BF\u55C1\u55C3\u55C6\u55C9\u55CB\u55CC\u55CE\u55D1\u55D2"],
+ ["8fb6a1", "\u55D3\u55D7\u55D8\u55DB\u55DE\u55E2\u55E9\u55F6\u55FF\u5605\u5608\u560A\u560D", 5, "\u5619\u562C\u5630\u5633\u5635\u5637\u5639\u563B\u563C\u563D\u563F\u5640\u5641\u5643\u5644\u5646\u5649\u564B\u564D\u564F\u5654\u565E\u5660\u5661\u5662\u5663\u5666\u5669\u566D\u566F\u5671\u5672\u5675\u5684\u5685\u5688\u568B\u568C\u5695\u5699\u569A\u569D\u569E\u569F\u56A6\u56A7\u56A8\u56A9\u56AB\u56AC\u56AD\u56B1\u56B3\u56B7\u56BE\u56C5\u56C9\u56CA\u56CB\u56CF\u56D0\u56CC\u56CD\u56D9\u56DC\u56DD\u56DF\u56E1\u56E4", 4, "\u56F1\u56EB\u56ED"],
+ ["8fb7a1", "\u56F6\u56F7\u5701\u5702\u5707\u570A\u570C\u5711\u5715\u571A\u571B\u571D\u5720\u5722\u5723\u5724\u5725\u5729\u572A\u572C\u572E\u572F\u5733\u5734\u573D\u573E\u573F\u5745\u5746\u574C\u574D\u5752\u5762\u5765\u5767\u5768\u576B\u576D", 4, "\u5773\u5774\u5775\u5777\u5779\u577A\u577B\u577C\u577E\u5781\u5783\u578C\u5794\u5797\u5799\u579A\u579C\u579D\u579E\u579F\u57A1\u5795\u57A7\u57A8\u57A9\u57AC\u57B8\u57BD\u57C7\u57C8\u57CC\u57CF\u57D5\u57DD\u57DE\u57E4\u57E6\u57E7\u57E9\u57ED\u57F0\u57F5\u57F6\u57F8\u57FD\u57FE\u57FF\u5803\u5804\u5808\u5809\u57E1"],
+ ["8fb8a1", "\u580C\u580D\u581B\u581E\u581F\u5820\u5826\u5827\u582D\u5832\u5839\u583F\u5849\u584C\u584D\u584F\u5850\u5855\u585F\u5861\u5864\u5867\u5868\u5878\u587C\u587F\u5880\u5881\u5887\u5888\u5889\u588A\u588C\u588D\u588F\u5890\u5894\u5896\u589D\u58A0\u58A1\u58A2\u58A6\u58A9\u58B1\u58B2\u58C4\u58BC\u58C2\u58C8\u58CD\u58CE\u58D0\u58D2\u58D4\u58D6\u58DA\u58DD\u58E1\u58E2\u58E9\u58F3\u5905\u5906\u590B\u590C\u5912\u5913\u5914\u8641\u591D\u5921\u5923\u5924\u5928\u592F\u5930\u5933\u5935\u5936\u593F\u5943\u5946\u5952\u5953\u5959\u595B\u595D\u595E\u595F\u5961\u5963\u596B\u596D"],
+ ["8fb9a1", "\u596F\u5972\u5975\u5976\u5979\u597B\u597C\u598B\u598C\u598E\u5992\u5995\u5997\u599F\u59A4\u59A7\u59AD\u59AE\u59AF\u59B0\u59B3\u59B7\u59BA\u59BC\u59C1\u59C3\u59C4\u59C8\u59CA\u59CD\u59D2\u59DD\u59DE\u59DF\u59E3\u59E4\u59E7\u59EE\u59EF\u59F1\u59F2\u59F4\u59F7\u5A00\u5A04\u5A0C\u5A0D\u5A0E\u5A12\u5A13\u5A1E\u5A23\u5A24\u5A27\u5A28\u5A2A\u5A2D\u5A30\u5A44\u5A45\u5A47\u5A48\u5A4C\u5A50\u5A55\u5A5E\u5A63\u5A65\u5A67\u5A6D\u5A77\u5A7A\u5A7B\u5A7E\u5A8B\u5A90\u5A93\u5A96\u5A99\u5A9C\u5A9E\u5A9F\u5AA0\u5AA2\u5AA7\u5AAC\u5AB1\u5AB2\u5AB3\u5AB5\u5AB8\u5ABA\u5ABB\u5ABF"],
+ ["8fbaa1", "\u5AC4\u5AC6\u5AC8\u5ACF\u5ADA\u5ADC\u5AE0\u5AE5\u5AEA\u5AEE\u5AF5\u5AF6\u5AFD\u5B00\u5B01\u5B08\u5B17\u5B34\u5B19\u5B1B\u5B1D\u5B21\u5B25\u5B2D\u5B38\u5B41\u5B4B\u5B4C\u5B52\u5B56\u5B5E\u5B68\u5B6E\u5B6F\u5B7C\u5B7D\u5B7E\u5B7F\u5B81\u5B84\u5B86\u5B8A\u5B8E\u5B90\u5B91\u5B93\u5B94\u5B96\u5BA8\u5BA9\u5BAC\u5BAD\u5BAF\u5BB1\u5BB2\u5BB7\u5BBA\u5BBC\u5BC0\u5BC1\u5BCD\u5BCF\u5BD6", 4, "\u5BE0\u5BEF\u5BF1\u5BF4\u5BFD\u5C0C\u5C17\u5C1E\u5C1F\u5C23\u5C26\u5C29\u5C2B\u5C2C\u5C2E\u5C30\u5C32\u5C35\u5C36\u5C59\u5C5A\u5C5C\u5C62\u5C63\u5C67\u5C68\u5C69"],
+ ["8fbba1", "\u5C6D\u5C70\u5C74\u5C75\u5C7A\u5C7B\u5C7C\u5C7D\u5C87\u5C88\u5C8A\u5C8F\u5C92\u5C9D\u5C9F\u5CA0\u5CA2\u5CA3\u5CA6\u5CAA\u5CB2\u5CB4\u5CB5\u5CBA\u5CC9\u5CCB\u5CD2\u5CDD\u5CD7\u5CEE\u5CF1\u5CF2\u5CF4\u5D01\u5D06\u5D0D\u5D12\u5D2B\u5D23\u5D24\u5D26\u5D27\u5D31\u5D34\u5D39\u5D3D\u5D3F\u5D42\u5D43\u5D46\u5D48\u5D55\u5D51\u5D59\u5D4A\u5D5F\u5D60\u5D61\u5D62\u5D64\u5D6A\u5D6D\u5D70\u5D79\u5D7A\u5D7E\u5D7F\u5D81\u5D83\u5D88\u5D8A\u5D92\u5D93\u5D94\u5D95\u5D99\u5D9B\u5D9F\u5DA0\u5DA7\u5DAB\u5DB0\u5DB4\u5DB8\u5DB9\u5DC3\u5DC7\u5DCB\u5DD0\u5DCE\u5DD8\u5DD9\u5DE0\u5DE4"],
+ ["8fbca1", "\u5DE9\u5DF8\u5DF9\u5E00\u5E07\u5E0D\u5E12\u5E14\u5E15\u5E18\u5E1F\u5E20\u5E2E\u5E28\u5E32\u5E35\u5E3E\u5E4B\u5E50\u5E49\u5E51\u5E56\u5E58\u5E5B\u5E5C\u5E5E\u5E68\u5E6A", 4, "\u5E70\u5E80\u5E8B\u5E8E\u5EA2\u5EA4\u5EA5\u5EA8\u5EAA\u5EAC\u5EB1\u5EB3\u5EBD\u5EBE\u5EBF\u5EC6\u5ECC\u5ECB\u5ECE\u5ED1\u5ED2\u5ED4\u5ED5\u5EDC\u5EDE\u5EE5\u5EEB\u5F02\u5F06\u5F07\u5F08\u5F0E\u5F19\u5F1C\u5F1D\u5F21\u5F22\u5F23\u5F24\u5F28\u5F2B\u5F2C\u5F2E\u5F30\u5F34\u5F36\u5F3B\u5F3D\u5F3F\u5F40\u5F44\u5F45\u5F47\u5F4D\u5F50\u5F54\u5F58\u5F5B\u5F60\u5F63\u5F64\u5F67"],
+ ["8fbda1", "\u5F6F\u5F72\u5F74\u5F75\u5F78\u5F7A\u5F7D\u5F7E\u5F89\u5F8D\u5F8F\u5F96\u5F9C\u5F9D\u5FA2\u5FA7\u5FAB\u5FA4\u5FAC\u5FAF\u5FB0\u5FB1\u5FB8\u5FC4\u5FC7\u5FC8\u5FC9\u5FCB\u5FD0", 4, "\u5FDE\u5FE1\u5FE2\u5FE8\u5FE9\u5FEA\u5FEC\u5FED\u5FEE\u5FEF\u5FF2\u5FF3\u5FF6\u5FFA\u5FFC\u6007\u600A\u600D\u6013\u6014\u6017\u6018\u601A\u601F\u6024\u602D\u6033\u6035\u6040\u6047\u6048\u6049\u604C\u6051\u6054\u6056\u6057\u605D\u6061\u6067\u6071\u607E\u607F\u6082\u6086\u6088\u608A\u608E\u6091\u6093\u6095\u6098\u609D\u609E\u60A2\u60A4\u60A5\u60A8\u60B0\u60B1\u60B7"],
+ ["8fbea1", "\u60BB\u60BE\u60C2\u60C4\u60C8\u60C9\u60CA\u60CB\u60CE\u60CF\u60D4\u60D5\u60D9\u60DB\u60DD\u60DE\u60E2\u60E5\u60F2\u60F5\u60F8\u60FC\u60FD\u6102\u6107\u610A\u610C\u6110", 4, "\u6116\u6117\u6119\u611C\u611E\u6122\u612A\u612B\u6130\u6131\u6135\u6136\u6137\u6139\u6141\u6145\u6146\u6149\u615E\u6160\u616C\u6172\u6178\u617B\u617C\u617F\u6180\u6181\u6183\u6184\u618B\u618D\u6192\u6193\u6197\u6198\u619C\u619D\u619F\u61A0\u61A5\u61A8\u61AA\u61AD\u61B8\u61B9\u61BC\u61C0\u61C1\u61C2\u61CE\u61CF\u61D5\u61DC\u61DD\u61DE\u61DF\u61E1\u61E2\u61E7\u61E9\u61E5"],
+ ["8fbfa1", "\u61EC\u61ED\u61EF\u6201\u6203\u6204\u6207\u6213\u6215\u621C\u6220\u6222\u6223\u6227\u6229\u622B\u6239\u623D\u6242\u6243\u6244\u6246\u624C\u6250\u6251\u6252\u6254\u6256\u625A\u625C\u6264\u626D\u626F\u6273\u627A\u627D\u628D\u628E\u628F\u6290\u62A6\u62A8\u62B3\u62B6\u62B7\u62BA\u62BE\u62BF\u62C4\u62CE\u62D5\u62D6\u62DA\u62EA\u62F2\u62F4\u62FC\u62FD\u6303\u6304\u630A\u630B\u630D\u6310\u6313\u6316\u6318\u6329\u632A\u632D\u6335\u6336\u6339\u633C\u6341\u6342\u6343\u6344\u6346\u634A\u634B\u634E\u6352\u6353\u6354\u6358\u635B\u6365\u6366\u636C\u636D\u6371\u6374\u6375"],
+ ["8fc0a1", "\u6378\u637C\u637D\u637F\u6382\u6384\u6387\u638A\u6390\u6394\u6395\u6399\u639A\u639E\u63A4\u63A6\u63AD\u63AE\u63AF\u63BD\u63C1\u63C5\u63C8\u63CE\u63D1\u63D3\u63D4\u63D5\u63DC\u63E0\u63E5\u63EA\u63EC\u63F2\u63F3\u63F5\u63F8\u63F9\u6409\u640A\u6410\u6412\u6414\u6418\u641E\u6420\u6422\u6424\u6425\u6429\u642A\u642F\u6430\u6435\u643D\u643F\u644B\u644F\u6451\u6452\u6453\u6454\u645A\u645B\u645C\u645D\u645F\u6460\u6461\u6463\u646D\u6473\u6474\u647B\u647D\u6485\u6487\u648F\u6490\u6491\u6498\u6499\u649B\u649D\u649F\u64A1\u64A3\u64A6\u64A8\u64AC\u64B3\u64BD\u64BE\u64BF"],
+ ["8fc1a1", "\u64C4\u64C9\u64CA\u64CB\u64CC\u64CE\u64D0\u64D1\u64D5\u64D7\u64E4\u64E5\u64E9\u64EA\u64ED\u64F0\u64F5\u64F7\u64FB\u64FF\u6501\u6504\u6508\u6509\u650A\u650F\u6513\u6514\u6516\u6519\u651B\u651E\u651F\u6522\u6526\u6529\u652E\u6531\u653A\u653C\u653D\u6543\u6547\u6549\u6550\u6552\u6554\u655F\u6560\u6567\u656B\u657A\u657D\u6581\u6585\u658A\u6592\u6595\u6598\u659D\u65A0\u65A3\u65A6\u65AE\u65B2\u65B3\u65B4\u65BF\u65C2\u65C8\u65C9\u65CE\u65D0\u65D4\u65D6\u65D8\u65DF\u65F0\u65F2\u65F4\u65F5\u65F9\u65FE\u65FF\u6600\u6604\u6608\u6609\u660D\u6611\u6612\u6615\u6616\u661D"],
+ ["8fc2a1", "\u661E\u6621\u6622\u6623\u6624\u6626\u6629\u662A\u662B\u662C\u662E\u6630\u6631\u6633\u6639\u6637\u6640\u6645\u6646\u664A\u664C\u6651\u664E\u6657\u6658\u6659\u665B\u665C\u6660\u6661\u66FB\u666A\u666B\u666C\u667E\u6673\u6675\u667F\u6677\u6678\u6679\u667B\u6680\u667C\u668B\u668C\u668D\u6690\u6692\u6699\u669A\u669B\u669C\u669F\u66A0\u66A4\u66AD\u66B1\u66B2\u66B5\u66BB\u66BF\u66C0\u66C2\u66C3\u66C8\u66CC\u66CE\u66CF\u66D4\u66DB\u66DF\u66E8\u66EB\u66EC\u66EE\u66FA\u6705\u6707\u670E\u6713\u6719\u671C\u6720\u6722\u6733\u673E\u6745\u6747\u6748\u674C\u6754\u6755\u675D"],
+ ["8fc3a1", "\u6766\u676C\u676E\u6774\u6776\u677B\u6781\u6784\u678E\u678F\u6791\u6793\u6796\u6798\u6799\u679B\u67B0\u67B1\u67B2\u67B5\u67BB\u67BC\u67BD\u67F9\u67C0\u67C2\u67C3\u67C5\u67C8\u67C9\u67D2\u67D7\u67D9\u67DC\u67E1\u67E6\u67F0\u67F2\u67F6\u67F7\u6852\u6814\u6819\u681D\u681F\u6828\u6827\u682C\u682D\u682F\u6830\u6831\u6833\u683B\u683F\u6844\u6845\u684A\u684C\u6855\u6857\u6858\u685B\u686B\u686E", 4, "\u6875\u6879\u687A\u687B\u687C\u6882\u6884\u6886\u6888\u6896\u6898\u689A\u689C\u68A1\u68A3\u68A5\u68A9\u68AA\u68AE\u68B2\u68BB\u68C5\u68C8\u68CC\u68CF"],
+ ["8fc4a1", "\u68D0\u68D1\u68D3\u68D6\u68D9\u68DC\u68DD\u68E5\u68E8\u68EA\u68EB\u68EC\u68ED\u68F0\u68F1\u68F5\u68F6\u68FB\u68FC\u68FD\u6906\u6909\u690A\u6910\u6911\u6913\u6916\u6917\u6931\u6933\u6935\u6938\u693B\u6942\u6945\u6949\u694E\u6957\u695B\u6963\u6964\u6965\u6966\u6968\u6969\u696C\u6970\u6971\u6972\u697A\u697B\u697F\u6980\u698D\u6992\u6996\u6998\u69A1\u69A5\u69A6\u69A8\u69AB\u69AD\u69AF\u69B7\u69B8\u69BA\u69BC\u69C5\u69C8\u69D1\u69D6\u69D7\u69E2\u69E5\u69EE\u69EF\u69F1\u69F3\u69F5\u69FE\u6A00\u6A01\u6A03\u6A0F\u6A11\u6A15\u6A1A\u6A1D\u6A20\u6A24\u6A28\u6A30\u6A32"],
+ ["8fc5a1", "\u6A34\u6A37\u6A3B\u6A3E\u6A3F\u6A45\u6A46\u6A49\u6A4A\u6A4E\u6A50\u6A51\u6A52\u6A55\u6A56\u6A5B\u6A64\u6A67\u6A6A\u6A71\u6A73\u6A7E\u6A81\u6A83\u6A86\u6A87\u6A89\u6A8B\u6A91\u6A9B\u6A9D\u6A9E\u6A9F\u6AA5\u6AAB\u6AAF\u6AB0\u6AB1\u6AB4\u6ABD\u6ABE\u6ABF\u6AC6\u6AC9\u6AC8\u6ACC\u6AD0\u6AD4\u6AD5\u6AD6\u6ADC\u6ADD\u6AE4\u6AE7\u6AEC\u6AF0\u6AF1\u6AF2\u6AFC\u6AFD\u6B02\u6B03\u6B06\u6B07\u6B09\u6B0F\u6B10\u6B11\u6B17\u6B1B\u6B1E\u6B24\u6B28\u6B2B\u6B2C\u6B2F\u6B35\u6B36\u6B3B\u6B3F\u6B46\u6B4A\u6B4D\u6B52\u6B56\u6B58\u6B5D\u6B60\u6B67\u6B6B\u6B6E\u6B70\u6B75\u6B7D"],
+ ["8fc6a1", "\u6B7E\u6B82\u6B85\u6B97\u6B9B\u6B9F\u6BA0\u6BA2\u6BA3\u6BA8\u6BA9\u6BAC\u6BAD\u6BAE\u6BB0\u6BB8\u6BB9\u6BBD\u6BBE\u6BC3\u6BC4\u6BC9\u6BCC\u6BD6\u6BDA\u6BE1\u6BE3\u6BE6\u6BE7\u6BEE\u6BF1\u6BF7\u6BF9\u6BFF\u6C02\u6C04\u6C05\u6C09\u6C0D\u6C0E\u6C10\u6C12\u6C19\u6C1F\u6C26\u6C27\u6C28\u6C2C\u6C2E\u6C33\u6C35\u6C36\u6C3A\u6C3B\u6C3F\u6C4A\u6C4B\u6C4D\u6C4F\u6C52\u6C54\u6C59\u6C5B\u6C5C\u6C6B\u6C6D\u6C6F\u6C74\u6C76\u6C78\u6C79\u6C7B\u6C85\u6C86\u6C87\u6C89\u6C94\u6C95\u6C97\u6C98\u6C9C\u6C9F\u6CB0\u6CB2\u6CB4\u6CC2\u6CC6\u6CCD\u6CCF\u6CD0\u6CD1\u6CD2\u6CD4\u6CD6"],
+ ["8fc7a1", "\u6CDA\u6CDC\u6CE0\u6CE7\u6CE9\u6CEB\u6CEC\u6CEE\u6CF2\u6CF4\u6D04\u6D07\u6D0A\u6D0E\u6D0F\u6D11\u6D13\u6D1A\u6D26\u6D27\u6D28\u6C67\u6D2E\u6D2F\u6D31\u6D39\u6D3C\u6D3F\u6D57\u6D5E\u6D5F\u6D61\u6D65\u6D67\u6D6F\u6D70\u6D7C\u6D82\u6D87\u6D91\u6D92\u6D94\u6D96\u6D97\u6D98\u6DAA\u6DAC\u6DB4\u6DB7\u6DB9\u6DBD\u6DBF\u6DC4\u6DC8\u6DCA\u6DCE\u6DCF\u6DD6\u6DDB\u6DDD\u6DDF\u6DE0\u6DE2\u6DE5\u6DE9\u6DEF\u6DF0\u6DF4\u6DF6\u6DFC\u6E00\u6E04\u6E1E\u6E22\u6E27\u6E32\u6E36\u6E39\u6E3B\u6E3C\u6E44\u6E45\u6E48\u6E49\u6E4B\u6E4F\u6E51\u6E52\u6E53\u6E54\u6E57\u6E5C\u6E5D\u6E5E"],
+ ["8fc8a1", "\u6E62\u6E63\u6E68\u6E73\u6E7B\u6E7D\u6E8D\u6E93\u6E99\u6EA0\u6EA7\u6EAD\u6EAE\u6EB1\u6EB3\u6EBB\u6EBF\u6EC0\u6EC1\u6EC3\u6EC7\u6EC8\u6ECA\u6ECD\u6ECE\u6ECF\u6EEB\u6EED\u6EEE\u6EF9\u6EFB\u6EFD\u6F04\u6F08\u6F0A\u6F0C\u6F0D\u6F16\u6F18\u6F1A\u6F1B\u6F26\u6F29\u6F2A\u6F2F\u6F30\u6F33\u6F36\u6F3B\u6F3C\u6F2D\u6F4F\u6F51\u6F52\u6F53\u6F57\u6F59\u6F5A\u6F5D\u6F5E\u6F61\u6F62\u6F68\u6F6C\u6F7D\u6F7E\u6F83\u6F87\u6F88\u6F8B\u6F8C\u6F8D\u6F90\u6F92\u6F93\u6F94\u6F96\u6F9A\u6F9F\u6FA0\u6FA5\u6FA6\u6FA7\u6FA8\u6FAE\u6FAF\u6FB0\u6FB5\u6FB6\u6FBC\u6FC5\u6FC7\u6FC8\u6FCA"],
+ ["8fc9a1", "\u6FDA\u6FDE\u6FE8\u6FE9\u6FF0\u6FF5\u6FF9\u6FFC\u6FFD\u7000\u7005\u7006\u7007\u700D\u7017\u7020\u7023\u702F\u7034\u7037\u7039\u703C\u7043\u7044\u7048\u7049\u704A\u704B\u7054\u7055\u705D\u705E\u704E\u7064\u7065\u706C\u706E\u7075\u7076\u707E\u7081\u7085\u7086\u7094", 4, "\u709B\u70A4\u70AB\u70B0\u70B1\u70B4\u70B7\u70CA\u70D1\u70D3\u70D4\u70D5\u70D6\u70D8\u70DC\u70E4\u70FA\u7103", 4, "\u710B\u710C\u710F\u711E\u7120\u712B\u712D\u712F\u7130\u7131\u7138\u7141\u7145\u7146\u7147\u714A\u714B\u7150\u7152\u7157\u715A\u715C\u715E\u7160"],
+ ["8fcaa1", "\u7168\u7179\u7180\u7185\u7187\u718C\u7192\u719A\u719B\u71A0\u71A2\u71AF\u71B0\u71B2\u71B3\u71BA\u71BF\u71C0\u71C1\u71C4\u71CB\u71CC\u71D3\u71D6\u71D9\u71DA\u71DC\u71F8\u71FE\u7200\u7207\u7208\u7209\u7213\u7217\u721A\u721D\u721F\u7224\u722B\u722F\u7234\u7238\u7239\u7241\u7242\u7243\u7245\u724E\u724F\u7250\u7253\u7255\u7256\u725A\u725C\u725E\u7260\u7263\u7268\u726B\u726E\u726F\u7271\u7277\u7278\u727B\u727C\u727F\u7284\u7289\u728D\u728E\u7293\u729B\u72A8\u72AD\u72AE\u72B1\u72B4\u72BE\u72C1\u72C7\u72C9\u72CC\u72D5\u72D6\u72D8\u72DF\u72E5\u72F3\u72F4\u72FA\u72FB"],
+ ["8fcba1", "\u72FE\u7302\u7304\u7305\u7307\u730B\u730D\u7312\u7313\u7318\u7319\u731E\u7322\u7324\u7327\u7328\u732C\u7331\u7332\u7335\u733A\u733B\u733D\u7343\u734D\u7350\u7352\u7356\u7358\u735D\u735E\u735F\u7360\u7366\u7367\u7369\u736B\u736C\u736E\u736F\u7371\u7377\u7379\u737C\u7380\u7381\u7383\u7385\u7386\u738E\u7390\u7393\u7395\u7397\u7398\u739C\u739E\u739F\u73A0\u73A2\u73A5\u73A6\u73AA\u73AB\u73AD\u73B5\u73B7\u73B9\u73BC\u73BD\u73BF\u73C5\u73C6\u73C9\u73CB\u73CC\u73CF\u73D2\u73D3\u73D6\u73D9\u73DD\u73E1\u73E3\u73E6\u73E7\u73E9\u73F4\u73F5\u73F7\u73F9\u73FA\u73FB\u73FD"],
+ ["8fcca1", "\u73FF\u7400\u7401\u7404\u7407\u740A\u7411\u741A\u741B\u7424\u7426\u7428", 9, "\u7439\u7440\u7443\u7444\u7446\u7447\u744B\u744D\u7451\u7452\u7457\u745D\u7462\u7466\u7467\u7468\u746B\u746D\u746E\u7471\u7472\u7480\u7481\u7485\u7486\u7487\u7489\u748F\u7490\u7491\u7492\u7498\u7499\u749A\u749C\u749F\u74A0\u74A1\u74A3\u74A6\u74A8\u74A9\u74AA\u74AB\u74AE\u74AF\u74B1\u74B2\u74B5\u74B9\u74BB\u74BF\u74C8\u74C9\u74CC\u74D0\u74D3\u74D8\u74DA\u74DB\u74DE\u74DF\u74E4\u74E8\u74EA\u74EB\u74EF\u74F4\u74FA\u74FB\u74FC\u74FF\u7506"],
+ ["8fcda1", "\u7512\u7516\u7517\u7520\u7521\u7524\u7527\u7529\u752A\u752F\u7536\u7539\u753D\u753E\u753F\u7540\u7543\u7547\u7548\u754E\u7550\u7552\u7557\u755E\u755F\u7561\u756F\u7571\u7579", 5, "\u7581\u7585\u7590\u7592\u7593\u7595\u7599\u759C\u75A2\u75A4\u75B4\u75BA\u75BF\u75C0\u75C1\u75C4\u75C6\u75CC\u75CE\u75CF\u75D7\u75DC\u75DF\u75E0\u75E1\u75E4\u75E7\u75EC\u75EE\u75EF\u75F1\u75F9\u7600\u7602\u7603\u7604\u7607\u7608\u760A\u760C\u760F\u7612\u7613\u7615\u7616\u7619\u761B\u761C\u761D\u761E\u7623\u7625\u7626\u7629\u762D\u7632\u7633\u7635\u7638\u7639"],
+ ["8fcea1", "\u763A\u763C\u764A\u7640\u7641\u7643\u7644\u7645\u7649\u764B\u7655\u7659\u765F\u7664\u7665\u766D\u766E\u766F\u7671\u7674\u7681\u7685\u768C\u768D\u7695\u769B\u769C\u769D\u769F\u76A0\u76A2", 6, "\u76AA\u76AD\u76BD\u76C1\u76C5\u76C9\u76CB\u76CC\u76CE\u76D4\u76D9\u76E0\u76E6\u76E8\u76EC\u76F0\u76F1\u76F6\u76F9\u76FC\u7700\u7706\u770A\u770E\u7712\u7714\u7715\u7717\u7719\u771A\u771C\u7722\u7728\u772D\u772E\u772F\u7734\u7735\u7736\u7739\u773D\u773E\u7742\u7745\u7746\u774A\u774D\u774E\u774F\u7752\u7756\u7757\u775C\u775E\u775F\u7760\u7762"],
+ ["8fcfa1", "\u7764\u7767\u776A\u776C\u7770\u7772\u7773\u7774\u777A\u777D\u7780\u7784\u778C\u778D\u7794\u7795\u7796\u779A\u779F\u77A2\u77A7\u77AA\u77AE\u77AF\u77B1\u77B5\u77BE\u77C3\u77C9\u77D1\u77D2\u77D5\u77D9\u77DE\u77DF\u77E0\u77E4\u77E6\u77EA\u77EC\u77F0\u77F1\u77F4\u77F8\u77FB\u7805\u7806\u7809\u780D\u780E\u7811\u781D\u7821\u7822\u7823\u782D\u782E\u7830\u7835\u7837\u7843\u7844\u7847\u7848\u784C\u784E\u7852\u785C\u785E\u7860\u7861\u7863\u7864\u7868\u786A\u786E\u787A\u787E\u788A\u788F\u7894\u7898\u78A1\u789D\u789E\u789F\u78A4\u78A8\u78AC\u78AD\u78B0\u78B1\u78B2\u78B3"],
+ ["8fd0a1", "\u78BB\u78BD\u78BF\u78C7\u78C8\u78C9\u78CC\u78CE\u78D2\u78D3\u78D5\u78D6\u78E4\u78DB\u78DF\u78E0\u78E1\u78E6\u78EA\u78F2\u78F3\u7900\u78F6\u78F7\u78FA\u78FB\u78FF\u7906\u790C\u7910\u791A\u791C\u791E\u791F\u7920\u7925\u7927\u7929\u792D\u7931\u7934\u7935\u793B\u793D\u793F\u7944\u7945\u7946\u794A\u794B\u794F\u7951\u7954\u7958\u795B\u795C\u7967\u7969\u796B\u7972\u7979\u797B\u797C\u797E\u798B\u798C\u7991\u7993\u7994\u7995\u7996\u7998\u799B\u799C\u79A1\u79A8\u79A9\u79AB\u79AF\u79B1\u79B4\u79B8\u79BB\u79C2\u79C4\u79C7\u79C8\u79CA\u79CF\u79D4\u79D6\u79DA\u79DD\u79DE"],
+ ["8fd1a1", "\u79E0\u79E2\u79E5\u79EA\u79EB\u79ED\u79F1\u79F8\u79FC\u7A02\u7A03\u7A07\u7A09\u7A0A\u7A0C\u7A11\u7A15\u7A1B\u7A1E\u7A21\u7A27\u7A2B\u7A2D\u7A2F\u7A30\u7A34\u7A35\u7A38\u7A39\u7A3A\u7A44\u7A45\u7A47\u7A48\u7A4C\u7A55\u7A56\u7A59\u7A5C\u7A5D\u7A5F\u7A60\u7A65\u7A67\u7A6A\u7A6D\u7A75\u7A78\u7A7E\u7A80\u7A82\u7A85\u7A86\u7A8A\u7A8B\u7A90\u7A91\u7A94\u7A9E\u7AA0\u7AA3\u7AAC\u7AB3\u7AB5\u7AB9\u7ABB\u7ABC\u7AC6\u7AC9\u7ACC\u7ACE\u7AD1\u7ADB\u7AE8\u7AE9\u7AEB\u7AEC\u7AF1\u7AF4\u7AFB\u7AFD\u7AFE\u7B07\u7B14\u7B1F\u7B23\u7B27\u7B29\u7B2A\u7B2B\u7B2D\u7B2E\u7B2F\u7B30"],
+ ["8fd2a1", "\u7B31\u7B34\u7B3D\u7B3F\u7B40\u7B41\u7B47\u7B4E\u7B55\u7B60\u7B64\u7B66\u7B69\u7B6A\u7B6D\u7B6F\u7B72\u7B73\u7B77\u7B84\u7B89\u7B8E\u7B90\u7B91\u7B96\u7B9B\u7B9E\u7BA0\u7BA5\u7BAC\u7BAF\u7BB0\u7BB2\u7BB5\u7BB6\u7BBA\u7BBB\u7BBC\u7BBD\u7BC2\u7BC5\u7BC8\u7BCA\u7BD4\u7BD6\u7BD7\u7BD9\u7BDA\u7BDB\u7BE8\u7BEA\u7BF2\u7BF4\u7BF5\u7BF8\u7BF9\u7BFA\u7BFC\u7BFE\u7C01\u7C02\u7C03\u7C04\u7C06\u7C09\u7C0B\u7C0C\u7C0E\u7C0F\u7C19\u7C1B\u7C20\u7C25\u7C26\u7C28\u7C2C\u7C31\u7C33\u7C34\u7C36\u7C39\u7C3A\u7C46\u7C4A\u7C55\u7C51\u7C52\u7C53\u7C59", 5],
+ ["8fd3a1", "\u7C61\u7C63\u7C67\u7C69\u7C6D\u7C6E\u7C70\u7C72\u7C79\u7C7C\u7C7D\u7C86\u7C87\u7C8F\u7C94\u7C9E\u7CA0\u7CA6\u7CB0\u7CB6\u7CB7\u7CBA\u7CBB\u7CBC\u7CBF\u7CC4\u7CC7\u7CC8\u7CC9\u7CCD\u7CCF\u7CD3\u7CD4\u7CD5\u7CD7\u7CD9\u7CDA\u7CDD\u7CE6\u7CE9\u7CEB\u7CF5\u7D03\u7D07\u7D08\u7D09\u7D0F\u7D11\u7D12\u7D13\u7D16\u7D1D\u7D1E\u7D23\u7D26\u7D2A\u7D2D\u7D31\u7D3C\u7D3D\u7D3E\u7D40\u7D41\u7D47\u7D48\u7D4D\u7D51\u7D53\u7D57\u7D59\u7D5A\u7D5C\u7D5D\u7D65\u7D67\u7D6A\u7D70\u7D78\u7D7A\u7D7B\u7D7F\u7D81\u7D82\u7D83\u7D85\u7D86\u7D88\u7D8B\u7D8C\u7D8D\u7D91\u7D96\u7D97\u7D9D"],
+ ["8fd4a1", "\u7D9E\u7DA6\u7DA7\u7DAA\u7DB3\u7DB6\u7DB7\u7DB9\u7DC2", 4, "\u7DCC\u7DCD\u7DCE\u7DD7\u7DD9\u7E00\u7DE2\u7DE5\u7DE6\u7DEA\u7DEB\u7DED\u7DF1\u7DF5\u7DF6\u7DF9\u7DFA\u7E08\u7E10\u7E11\u7E15\u7E17\u7E1C\u7E1D\u7E20\u7E27\u7E28\u7E2C\u7E2D\u7E2F\u7E33\u7E36\u7E3F\u7E44\u7E45\u7E47\u7E4E\u7E50\u7E52\u7E58\u7E5F\u7E61\u7E62\u7E65\u7E6B\u7E6E\u7E6F\u7E73\u7E78\u7E7E\u7E81\u7E86\u7E87\u7E8A\u7E8D\u7E91\u7E95\u7E98\u7E9A\u7E9D\u7E9E\u7F3C\u7F3B\u7F3D\u7F3E\u7F3F\u7F43\u7F44\u7F47\u7F4F\u7F52\u7F53\u7F5B\u7F5C\u7F5D\u7F61\u7F63\u7F64\u7F65\u7F66\u7F6D"],
+ ["8fd5a1", "\u7F71\u7F7D\u7F7E\u7F7F\u7F80\u7F8B\u7F8D\u7F8F\u7F90\u7F91\u7F96\u7F97\u7F9C\u7FA1\u7FA2\u7FA6\u7FAA\u7FAD\u7FB4\u7FBC\u7FBF\u7FC0\u7FC3\u7FC8\u7FCE\u7FCF\u7FDB\u7FDF\u7FE3\u7FE5\u7FE8\u7FEC\u7FEE\u7FEF\u7FF2\u7FFA\u7FFD\u7FFE\u7FFF\u8007\u8008\u800A\u800D\u800E\u800F\u8011\u8013\u8014\u8016\u801D\u801E\u801F\u8020\u8024\u8026\u802C\u802E\u8030\u8034\u8035\u8037\u8039\u803A\u803C\u803E\u8040\u8044\u8060\u8064\u8066\u806D\u8071\u8075\u8081\u8088\u808E\u809C\u809E\u80A6\u80A7\u80AB\u80B8\u80B9\u80C8\u80CD\u80CF\u80D2\u80D4\u80D5\u80D7\u80D8\u80E0\u80ED\u80EE"],
+ ["8fd6a1", "\u80F0\u80F2\u80F3\u80F6\u80F9\u80FA\u80FE\u8103\u810B\u8116\u8117\u8118\u811C\u811E\u8120\u8124\u8127\u812C\u8130\u8135\u813A\u813C\u8145\u8147\u814A\u814C\u8152\u8157\u8160\u8161\u8167\u8168\u8169\u816D\u816F\u8177\u8181\u8190\u8184\u8185\u8186\u818B\u818E\u8196\u8198\u819B\u819E\u81A2\u81AE\u81B2\u81B4\u81BB\u81CB\u81C3\u81C5\u81CA\u81CE\u81CF\u81D5\u81D7\u81DB\u81DD\u81DE\u81E1\u81E4\u81EB\u81EC\u81F0\u81F1\u81F2\u81F5\u81F6\u81F8\u81F9\u81FD\u81FF\u8200\u8203\u820F\u8213\u8214\u8219\u821A\u821D\u8221\u8222\u8228\u8232\u8234\u823A\u8243\u8244\u8245\u8246"],
+ ["8fd7a1", "\u824B\u824E\u824F\u8251\u8256\u825C\u8260\u8263\u8267\u826D\u8274\u827B\u827D\u827F\u8280\u8281\u8283\u8284\u8287\u8289\u828A\u828E\u8291\u8294\u8296\u8298\u829A\u829B\u82A0\u82A1\u82A3\u82A4\u82A7\u82A8\u82A9\u82AA\u82AE\u82B0\u82B2\u82B4\u82B7\u82BA\u82BC\u82BE\u82BF\u82C6\u82D0\u82D5\u82DA\u82E0\u82E2\u82E4\u82E8\u82EA\u82ED\u82EF\u82F6\u82F7\u82FD\u82FE\u8300\u8301\u8307\u8308\u830A\u830B\u8354\u831B\u831D\u831E\u831F\u8321\u8322\u832C\u832D\u832E\u8330\u8333\u8337\u833A\u833C\u833D\u8342\u8343\u8344\u8347\u834D\u834E\u8351\u8355\u8356\u8357\u8370\u8378"],
+ ["8fd8a1", "\u837D\u837F\u8380\u8382\u8384\u8386\u838D\u8392\u8394\u8395\u8398\u8399\u839B\u839C\u839D\u83A6\u83A7\u83A9\u83AC\u83BE\u83BF\u83C0\u83C7\u83C9\u83CF\u83D0\u83D1\u83D4\u83DD\u8353\u83E8\u83EA\u83F6\u83F8\u83F9\u83FC\u8401\u8406\u840A\u840F\u8411\u8415\u8419\u83AD\u842F\u8439\u8445\u8447\u8448\u844A\u844D\u844F\u8451\u8452\u8456\u8458\u8459\u845A\u845C\u8460\u8464\u8465\u8467\u846A\u8470\u8473\u8474\u8476\u8478\u847C\u847D\u8481\u8485\u8492\u8493\u8495\u849E\u84A6\u84A8\u84A9\u84AA\u84AF\u84B1\u84B4\u84BA\u84BD\u84BE\u84C0\u84C2\u84C7\u84C8\u84CC\u84CF\u84D3"],
+ ["8fd9a1", "\u84DC\u84E7\u84EA\u84EF\u84F0\u84F1\u84F2\u84F7\u8532\u84FA\u84FB\u84FD\u8502\u8503\u8507\u850C\u850E\u8510\u851C\u851E\u8522\u8523\u8524\u8525\u8527\u852A\u852B\u852F\u8533\u8534\u8536\u853F\u8546\u854F", 4, "\u8556\u8559\u855C", 6, "\u8564\u856B\u856F\u8579\u857A\u857B\u857D\u857F\u8581\u8585\u8586\u8589\u858B\u858C\u858F\u8593\u8598\u859D\u859F\u85A0\u85A2\u85A5\u85A7\u85B4\u85B6\u85B7\u85B8\u85BC\u85BD\u85BE\u85BF\u85C2\u85C7\u85CA\u85CB\u85CE\u85AD\u85D8\u85DA\u85DF\u85E0\u85E6\u85E8\u85ED\u85F3\u85F6\u85FC"],
+ ["8fdaa1", "\u85FF\u8600\u8604\u8605\u860D\u860E\u8610\u8611\u8612\u8618\u8619\u861B\u861E\u8621\u8627\u8629\u8636\u8638\u863A\u863C\u863D\u8640\u8642\u8646\u8652\u8653\u8656\u8657\u8658\u8659\u865D\u8660", 4, "\u8669\u866C\u866F\u8675\u8676\u8677\u867A\u868D\u8691\u8696\u8698\u869A\u869C\u86A1\u86A6\u86A7\u86A8\u86AD\u86B1\u86B3\u86B4\u86B5\u86B7\u86B8\u86B9\u86BF\u86C0\u86C1\u86C3\u86C5\u86D1\u86D2\u86D5\u86D7\u86DA\u86DC\u86E0\u86E3\u86E5\u86E7\u8688\u86FA\u86FC\u86FD\u8704\u8705\u8707\u870B\u870E\u870F\u8710\u8713\u8714\u8719\u871E\u871F\u8721\u8723"],
+ ["8fdba1", "\u8728\u872E\u872F\u8731\u8732\u8739\u873A\u873C\u873D\u873E\u8740\u8743\u8745\u874D\u8758\u875D\u8761\u8764\u8765\u876F\u8771\u8772\u877B\u8783", 6, "\u878B\u878C\u8790\u8793\u8795\u8797\u8798\u8799\u879E\u87A0\u87A3\u87A7\u87AC\u87AD\u87AE\u87B1\u87B5\u87BE\u87BF\u87C1\u87C8\u87C9\u87CA\u87CE\u87D5\u87D6\u87D9\u87DA\u87DC\u87DF\u87E2\u87E3\u87E4\u87EA\u87EB\u87ED\u87F1\u87F3\u87F8\u87FA\u87FF\u8801\u8803\u8806\u8809\u880A\u880B\u8810\u8819\u8812\u8813\u8814\u8818\u881A\u881B\u881C\u881E\u881F\u8828\u882D\u882E\u8830\u8832\u8835"],
+ ["8fdca1", "\u883A\u883C\u8841\u8843\u8845\u8848\u8849\u884A\u884B\u884E\u8851\u8855\u8856\u8858\u885A\u885C\u885F\u8860\u8864\u8869\u8871\u8879\u887B\u8880\u8898\u889A\u889B\u889C\u889F\u88A0\u88A8\u88AA\u88BA\u88BD\u88BE\u88C0\u88CA", 4, "\u88D1\u88D2\u88D3\u88DB\u88DE\u88E7\u88EF\u88F0\u88F1\u88F5\u88F7\u8901\u8906\u890D\u890E\u890F\u8915\u8916\u8918\u8919\u891A\u891C\u8920\u8926\u8927\u8928\u8930\u8931\u8932\u8935\u8939\u893A\u893E\u8940\u8942\u8945\u8946\u8949\u894F\u8952\u8957\u895A\u895B\u895C\u8961\u8962\u8963\u896B\u896E\u8970\u8973\u8975\u897A"],
+ ["8fdda1", "\u897B\u897C\u897D\u8989\u898D\u8990\u8994\u8995\u899B\u899C\u899F\u89A0\u89A5\u89B0\u89B4\u89B5\u89B6\u89B7\u89BC\u89D4", 4, "\u89E5\u89E9\u89EB\u89ED\u89F1\u89F3\u89F6\u89F9\u89FD\u89FF\u8A04\u8A05\u8A07\u8A0F\u8A11\u8A12\u8A14\u8A15\u8A1E\u8A20\u8A22\u8A24\u8A26\u8A2B\u8A2C\u8A2F\u8A35\u8A37\u8A3D\u8A3E\u8A40\u8A43\u8A45\u8A47\u8A49\u8A4D\u8A4E\u8A53\u8A56\u8A57\u8A58\u8A5C\u8A5D\u8A61\u8A65\u8A67\u8A75\u8A76\u8A77\u8A79\u8A7A\u8A7B\u8A7E\u8A7F\u8A80\u8A83\u8A86\u8A8B\u8A8F\u8A90\u8A92\u8A96\u8A97\u8A99\u8A9F\u8AA7\u8AA9\u8AAE\u8AAF\u8AB3"],
+ ["8fdea1", "\u8AB6\u8AB7\u8ABB\u8ABE\u8AC3\u8AC6\u8AC8\u8AC9\u8ACA\u8AD1\u8AD3\u8AD4\u8AD5\u8AD7\u8ADD\u8ADF\u8AEC\u8AF0\u8AF4\u8AF5\u8AF6\u8AFC\u8AFF\u8B05\u8B06\u8B0B\u8B11\u8B1C\u8B1E\u8B1F\u8B0A\u8B2D\u8B30\u8B37\u8B3C\u8B42", 4, "\u8B48\u8B52\u8B53\u8B54\u8B59\u8B4D\u8B5E\u8B63\u8B6D\u8B76\u8B78\u8B79\u8B7C\u8B7E\u8B81\u8B84\u8B85\u8B8B\u8B8D\u8B8F\u8B94\u8B95\u8B9C\u8B9E\u8B9F\u8C38\u8C39\u8C3D\u8C3E\u8C45\u8C47\u8C49\u8C4B\u8C4F\u8C51\u8C53\u8C54\u8C57\u8C58\u8C5B\u8C5D\u8C59\u8C63\u8C64\u8C66\u8C68\u8C69\u8C6D\u8C73\u8C75\u8C76\u8C7B\u8C7E\u8C86"],
+ ["8fdfa1", "\u8C87\u8C8B\u8C90\u8C92\u8C93\u8C99\u8C9B\u8C9C\u8CA4\u8CB9\u8CBA\u8CC5\u8CC6\u8CC9\u8CCB\u8CCF\u8CD6\u8CD5\u8CD9\u8CDD\u8CE1\u8CE8\u8CEC\u8CEF\u8CF0\u8CF2\u8CF5\u8CF7\u8CF8\u8CFE\u8CFF\u8D01\u8D03\u8D09\u8D12\u8D17\u8D1B\u8D65\u8D69\u8D6C\u8D6E\u8D7F\u8D82\u8D84\u8D88\u8D8D\u8D90\u8D91\u8D95\u8D9E\u8D9F\u8DA0\u8DA6\u8DAB\u8DAC\u8DAF\u8DB2\u8DB5\u8DB7\u8DB9\u8DBB\u8DC0\u8DC5\u8DC6\u8DC7\u8DC8\u8DCA\u8DCE\u8DD1\u8DD4\u8DD5\u8DD7\u8DD9\u8DE4\u8DE5\u8DE7\u8DEC\u8DF0\u8DBC\u8DF1\u8DF2\u8DF4\u8DFD\u8E01\u8E04\u8E05\u8E06\u8E0B\u8E11\u8E14\u8E16\u8E20\u8E21\u8E22"],
+ ["8fe0a1", "\u8E23\u8E26\u8E27\u8E31\u8E33\u8E36\u8E37\u8E38\u8E39\u8E3D\u8E40\u8E41\u8E4B\u8E4D\u8E4E\u8E4F\u8E54\u8E5B\u8E5C\u8E5D\u8E5E\u8E61\u8E62\u8E69\u8E6C\u8E6D\u8E6F\u8E70\u8E71\u8E79\u8E7A\u8E7B\u8E82\u8E83\u8E89\u8E90\u8E92\u8E95\u8E9A\u8E9B\u8E9D\u8E9E\u8EA2\u8EA7\u8EA9\u8EAD\u8EAE\u8EB3\u8EB5\u8EBA\u8EBB\u8EC0\u8EC1\u8EC3\u8EC4\u8EC7\u8ECF\u8ED1\u8ED4\u8EDC\u8EE8\u8EEE\u8EF0\u8EF1\u8EF7\u8EF9\u8EFA\u8EED\u8F00\u8F02\u8F07\u8F08\u8F0F\u8F10\u8F16\u8F17\u8F18\u8F1E\u8F20\u8F21\u8F23\u8F25\u8F27\u8F28\u8F2C\u8F2D\u8F2E\u8F34\u8F35\u8F36\u8F37\u8F3A\u8F40\u8F41"],
+ ["8fe1a1", "\u8F43\u8F47\u8F4F\u8F51", 4, "\u8F58\u8F5D\u8F5E\u8F65\u8F9D\u8FA0\u8FA1\u8FA4\u8FA5\u8FA6\u8FB5\u8FB6\u8FB8\u8FBE\u8FC0\u8FC1\u8FC6\u8FCA\u8FCB\u8FCD\u8FD0\u8FD2\u8FD3\u8FD5\u8FE0\u8FE3\u8FE4\u8FE8\u8FEE\u8FF1\u8FF5\u8FF6\u8FFB\u8FFE\u9002\u9004\u9008\u900C\u9018\u901B\u9028\u9029\u902F\u902A\u902C\u902D\u9033\u9034\u9037\u903F\u9043\u9044\u904C\u905B\u905D\u9062\u9066\u9067\u906C\u9070\u9074\u9079\u9085\u9088\u908B\u908C\u908E\u9090\u9095\u9097\u9098\u9099\u909B\u90A0\u90A1\u90A2\u90A5\u90B0\u90B2\u90B3\u90B4\u90B6\u90BD\u90CC\u90BE\u90C3"],
+ ["8fe2a1", "\u90C4\u90C5\u90C7\u90C8\u90D5\u90D7\u90D8\u90D9\u90DC\u90DD\u90DF\u90E5\u90D2\u90F6\u90EB\u90EF\u90F0\u90F4\u90FE\u90FF\u9100\u9104\u9105\u9106\u9108\u910D\u9110\u9114\u9116\u9117\u9118\u911A\u911C\u911E\u9120\u9125\u9122\u9123\u9127\u9129\u912E\u912F\u9131\u9134\u9136\u9137\u9139\u913A\u913C\u913D\u9143\u9147\u9148\u914F\u9153\u9157\u9159\u915A\u915B\u9161\u9164\u9167\u916D\u9174\u9179\u917A\u917B\u9181\u9183\u9185\u9186\u918A\u918E\u9191\u9193\u9194\u9195\u9198\u919E\u91A1\u91A6\u91A8\u91AC\u91AD\u91AE\u91B0\u91B1\u91B2\u91B3\u91B6\u91BB\u91BC\u91BD\u91BF"],
+ ["8fe3a1", "\u91C2\u91C3\u91C5\u91D3\u91D4\u91D7\u91D9\u91DA\u91DE\u91E4\u91E5\u91E9\u91EA\u91EC", 5, "\u91F7\u91F9\u91FB\u91FD\u9200\u9201\u9204\u9205\u9206\u9207\u9209\u920A\u920C\u9210\u9212\u9213\u9216\u9218\u921C\u921D\u9223\u9224\u9225\u9226\u9228\u922E\u922F\u9230\u9233\u9235\u9236\u9238\u9239\u923A\u923C\u923E\u9240\u9242\u9243\u9246\u9247\u924A\u924D\u924E\u924F\u9251\u9258\u9259\u925C\u925D\u9260\u9261\u9265\u9267\u9268\u9269\u926E\u926F\u9270\u9275", 4, "\u927B\u927C\u927D\u927F\u9288\u9289\u928A\u928D\u928E\u9292\u9297"],
+ ["8fe4a1", "\u9299\u929F\u92A0\u92A4\u92A5\u92A7\u92A8\u92AB\u92AF\u92B2\u92B6\u92B8\u92BA\u92BB\u92BC\u92BD\u92BF", 4, "\u92C5\u92C6\u92C7\u92C8\u92CB\u92CC\u92CD\u92CE\u92D0\u92D3\u92D5\u92D7\u92D8\u92D9\u92DC\u92DD\u92DF\u92E0\u92E1\u92E3\u92E5\u92E7\u92E8\u92EC\u92EE\u92F0\u92F9\u92FB\u92FF\u9300\u9302\u9308\u930D\u9311\u9314\u9315\u931C\u931D\u931E\u931F\u9321\u9324\u9325\u9327\u9329\u932A\u9333\u9334\u9336\u9337\u9347\u9348\u9349\u9350\u9351\u9352\u9355\u9357\u9358\u935A\u935E\u9364\u9365\u9367\u9369\u936A\u936D\u936F\u9370\u9371\u9373\u9374\u9376"],
+ ["8fe5a1", "\u937A\u937D\u937F\u9380\u9381\u9382\u9388\u938A\u938B\u938D\u938F\u9392\u9395\u9398\u939B\u939E\u93A1\u93A3\u93A4\u93A6\u93A8\u93AB\u93B4\u93B5\u93B6\u93BA\u93A9\u93C1\u93C4\u93C5\u93C6\u93C7\u93C9", 4, "\u93D3\u93D9\u93DC\u93DE\u93DF\u93E2\u93E6\u93E7\u93F9\u93F7\u93F8\u93FA\u93FB\u93FD\u9401\u9402\u9404\u9408\u9409\u940D\u940E\u940F\u9415\u9416\u9417\u941F\u942E\u942F\u9431\u9432\u9433\u9434\u943B\u943F\u943D\u9443\u9445\u9448\u944A\u944C\u9455\u9459\u945C\u945F\u9461\u9463\u9468\u946B\u946D\u946E\u946F\u9471\u9472\u9484\u9483\u9578\u9579"],
+ ["8fe6a1", "\u957E\u9584\u9588\u958C\u958D\u958E\u959D\u959E\u959F\u95A1\u95A6\u95A9\u95AB\u95AC\u95B4\u95B6\u95BA\u95BD\u95BF\u95C6\u95C8\u95C9\u95CB\u95D0\u95D1\u95D2\u95D3\u95D9\u95DA\u95DD\u95DE\u95DF\u95E0\u95E4\u95E6\u961D\u961E\u9622\u9624\u9625\u9626\u962C\u9631\u9633\u9637\u9638\u9639\u963A\u963C\u963D\u9641\u9652\u9654\u9656\u9657\u9658\u9661\u966E\u9674\u967B\u967C\u967E\u967F\u9681\u9682\u9683\u9684\u9689\u9691\u9696\u969A\u969D\u969F\u96A4\u96A5\u96A6\u96A9\u96AE\u96AF\u96B3\u96BA\u96CA\u96D2\u5DB2\u96D8\u96DA\u96DD\u96DE\u96DF\u96E9\u96EF\u96F1\u96FA\u9702"],
+ ["8fe7a1", "\u9703\u9705\u9709\u971A\u971B\u971D\u9721\u9722\u9723\u9728\u9731\u9733\u9741\u9743\u974A\u974E\u974F\u9755\u9757\u9758\u975A\u975B\u9763\u9767\u976A\u976E\u9773\u9776\u9777\u9778\u977B\u977D\u977F\u9780\u9789\u9795\u9796\u9797\u9799\u979A\u979E\u979F\u97A2\u97AC\u97AE\u97B1\u97B2\u97B5\u97B6\u97B8\u97B9\u97BA\u97BC\u97BE\u97BF\u97C1\u97C4\u97C5\u97C7\u97C9\u97CA\u97CC\u97CD\u97CE\u97D0\u97D1\u97D4\u97D7\u97D8\u97D9\u97DD\u97DE\u97E0\u97DB\u97E1\u97E4\u97EF\u97F1\u97F4\u97F7\u97F8\u97FA\u9807\u980A\u9819\u980D\u980E\u9814\u9816\u981C\u981E\u9820\u9823\u9826"],
+ ["8fe8a1", "\u982B\u982E\u982F\u9830\u9832\u9833\u9835\u9825\u983E\u9844\u9847\u984A\u9851\u9852\u9853\u9856\u9857\u9859\u985A\u9862\u9863\u9865\u9866\u986A\u986C\u98AB\u98AD\u98AE\u98B0\u98B4\u98B7\u98B8\u98BA\u98BB\u98BF\u98C2\u98C5\u98C8\u98CC\u98E1\u98E3\u98E5\u98E6\u98E7\u98EA\u98F3\u98F6\u9902\u9907\u9908\u9911\u9915\u9916\u9917\u991A\u991B\u991C\u991F\u9922\u9926\u9927\u992B\u9931", 4, "\u9939\u993A\u993B\u993C\u9940\u9941\u9946\u9947\u9948\u994D\u994E\u9954\u9958\u9959\u995B\u995C\u995E\u995F\u9960\u999B\u999D\u999F\u99A6\u99B0\u99B1\u99B2\u99B5"],
+ ["8fe9a1", "\u99B9\u99BA\u99BD\u99BF\u99C3\u99C9\u99D3\u99D4\u99D9\u99DA\u99DC\u99DE\u99E7\u99EA\u99EB\u99EC\u99F0\u99F4\u99F5\u99F9\u99FD\u99FE\u9A02\u9A03\u9A04\u9A0B\u9A0C\u9A10\u9A11\u9A16\u9A1E\u9A20\u9A22\u9A23\u9A24\u9A27\u9A2D\u9A2E\u9A33\u9A35\u9A36\u9A38\u9A47\u9A41\u9A44\u9A4A\u9A4B\u9A4C\u9A4E\u9A51\u9A54\u9A56\u9A5D\u9AAA\u9AAC\u9AAE\u9AAF\u9AB2\u9AB4\u9AB5\u9AB6\u9AB9\u9ABB\u9ABE\u9ABF\u9AC1\u9AC3\u9AC6\u9AC8\u9ACE\u9AD0\u9AD2\u9AD5\u9AD6\u9AD7\u9ADB\u9ADC\u9AE0\u9AE4\u9AE5\u9AE7\u9AE9\u9AEC\u9AF2\u9AF3\u9AF5\u9AF9\u9AFA\u9AFD\u9AFF", 4],
+ ["8feaa1", "\u9B04\u9B05\u9B08\u9B09\u9B0B\u9B0C\u9B0D\u9B0E\u9B10\u9B12\u9B16\u9B19\u9B1B\u9B1C\u9B20\u9B26\u9B2B\u9B2D\u9B33\u9B34\u9B35\u9B37\u9B39\u9B3A\u9B3D\u9B48\u9B4B\u9B4C\u9B55\u9B56\u9B57\u9B5B\u9B5E\u9B61\u9B63\u9B65\u9B66\u9B68\u9B6A", 4, "\u9B73\u9B75\u9B77\u9B78\u9B79\u9B7F\u9B80\u9B84\u9B85\u9B86\u9B87\u9B89\u9B8A\u9B8B\u9B8D\u9B8F\u9B90\u9B94\u9B9A\u9B9D\u9B9E\u9BA6\u9BA7\u9BA9\u9BAC\u9BB0\u9BB1\u9BB2\u9BB7\u9BB8\u9BBB\u9BBC\u9BBE\u9BBF\u9BC1\u9BC7\u9BC8\u9BCE\u9BD0\u9BD7\u9BD8\u9BDD\u9BDF\u9BE5\u9BE7\u9BEA\u9BEB\u9BEF\u9BF3\u9BF7\u9BF8"],
+ ["8feba1", "\u9BF9\u9BFA\u9BFD\u9BFF\u9C00\u9C02\u9C0B\u9C0F\u9C11\u9C16\u9C18\u9C19\u9C1A\u9C1C\u9C1E\u9C22\u9C23\u9C26", 4, "\u9C31\u9C35\u9C36\u9C37\u9C3D\u9C41\u9C43\u9C44\u9C45\u9C49\u9C4A\u9C4E\u9C4F\u9C50\u9C53\u9C54\u9C56\u9C58\u9C5B\u9C5D\u9C5E\u9C5F\u9C63\u9C69\u9C6A\u9C5C\u9C6B\u9C68\u9C6E\u9C70\u9C72\u9C75\u9C77\u9C7B\u9CE6\u9CF2\u9CF7\u9CF9\u9D0B\u9D02\u9D11\u9D17\u9D18\u9D1C\u9D1D\u9D1E\u9D2F\u9D30\u9D32\u9D33\u9D34\u9D3A\u9D3C\u9D45\u9D3D\u9D42\u9D43\u9D47\u9D4A\u9D53\u9D54\u9D5F\u9D63\u9D62\u9D65\u9D69\u9D6A\u9D6B\u9D70\u9D76\u9D77\u9D7B"],
+ ["8feca1", "\u9D7C\u9D7E\u9D83\u9D84\u9D86\u9D8A\u9D8D\u9D8E\u9D92\u9D93\u9D95\u9D96\u9D97\u9D98\u9DA1\u9DAA\u9DAC\u9DAE\u9DB1\u9DB5\u9DB9\u9DBC\u9DBF\u9DC3\u9DC7\u9DC9\u9DCA\u9DD4\u9DD5\u9DD6\u9DD7\u9DDA\u9DDE\u9DDF\u9DE0\u9DE5\u9DE7\u9DE9\u9DEB\u9DEE\u9DF0\u9DF3\u9DF4\u9DFE\u9E0A\u9E02\u9E07\u9E0E\u9E10\u9E11\u9E12\u9E15\u9E16\u9E19\u9E1C\u9E1D\u9E7A\u9E7B\u9E7C\u9E80\u9E82\u9E83\u9E84\u9E85\u9E87\u9E8E\u9E8F\u9E96\u9E98\u9E9B\u9E9E\u9EA4\u9EA8\u9EAC\u9EAE\u9EAF\u9EB0\u9EB3\u9EB4\u9EB5\u9EC6\u9EC8\u9ECB\u9ED5\u9EDF\u9EE4\u9EE7\u9EEC\u9EED\u9EEE\u9EF0\u9EF1\u9EF2\u9EF5"],
+ ["8feda1", "\u9EF8\u9EFF\u9F02\u9F03\u9F09\u9F0F\u9F10\u9F11\u9F12\u9F14\u9F16\u9F17\u9F19\u9F1A\u9F1B\u9F1F\u9F22\u9F26\u9F2A\u9F2B\u9F2F\u9F31\u9F32\u9F34\u9F37\u9F39\u9F3A\u9F3C\u9F3D\u9F3F\u9F41\u9F43", 4, "\u9F53\u9F55\u9F56\u9F57\u9F58\u9F5A\u9F5D\u9F5E\u9F68\u9F69\u9F6D", 4, "\u9F73\u9F75\u9F7A\u9F7D\u9F8F\u9F90\u9F91\u9F92\u9F94\u9F96\u9F97\u9F9E\u9FA1\u9FA2\u9FA3\u9FA5"]
+ ];
+ }
+});
+
+// ../../node_modules/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/encodings/tables/cp936.json
+var require_cp936 = __commonJS({
+ "../../node_modules/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/encodings/tables/cp936.json"(exports2, module2) {
+ module2.exports = [
+ ["0", "\0", 127, "\u20AC"],
+ ["8140", "\u4E02\u4E04\u4E05\u4E06\u4E0F\u4E12\u4E17\u4E1F\u4E20\u4E21\u4E23\u4E26\u4E29\u4E2E\u4E2F\u4E31\u4E33\u4E35\u4E37\u4E3C\u4E40\u4E41\u4E42\u4E44\u4E46\u4E4A\u4E51\u4E55\u4E57\u4E5A\u4E5B\u4E62\u4E63\u4E64\u4E65\u4E67\u4E68\u4E6A", 5, "\u4E72\u4E74", 9, "\u4E7F", 6, "\u4E87\u4E8A"],
+ ["8180", "\u4E90\u4E96\u4E97\u4E99\u4E9C\u4E9D\u4E9E\u4EA3\u4EAA\u4EAF\u4EB0\u4EB1\u4EB4\u4EB6\u4EB7\u4EB8\u4EB9\u4EBC\u4EBD\u4EBE\u4EC8\u4ECC\u4ECF\u4ED0\u4ED2\u4EDA\u4EDB\u4EDC\u4EE0\u4EE2\u4EE6\u4EE7\u4EE9\u4EED\u4EEE\u4EEF\u4EF1\u4EF4\u4EF8\u4EF9\u4EFA\u4EFC\u4EFE\u4F00\u4F02", 6, "\u4F0B\u4F0C\u4F12", 4, "\u4F1C\u4F1D\u4F21\u4F23\u4F28\u4F29\u4F2C\u4F2D\u4F2E\u4F31\u4F33\u4F35\u4F37\u4F39\u4F3B\u4F3E", 4, "\u4F44\u4F45\u4F47", 5, "\u4F52\u4F54\u4F56\u4F61\u4F62\u4F66\u4F68\u4F6A\u4F6B\u4F6D\u4F6E\u4F71\u4F72\u4F75\u4F77\u4F78\u4F79\u4F7A\u4F7D\u4F80\u4F81\u4F82\u4F85\u4F86\u4F87\u4F8A\u4F8C\u4F8E\u4F90\u4F92\u4F93\u4F95\u4F96\u4F98\u4F99\u4F9A\u4F9C\u4F9E\u4F9F\u4FA1\u4FA2"],
+ ["8240", "\u4FA4\u4FAB\u4FAD\u4FB0", 4, "\u4FB6", 8, "\u4FC0\u4FC1\u4FC2\u4FC6\u4FC7\u4FC8\u4FC9\u4FCB\u4FCC\u4FCD\u4FD2", 4, "\u4FD9\u4FDB\u4FE0\u4FE2\u4FE4\u4FE5\u4FE7\u4FEB\u4FEC\u4FF0\u4FF2\u4FF4\u4FF5\u4FF6\u4FF7\u4FF9\u4FFB\u4FFC\u4FFD\u4FFF", 11],
+ ["8280", "\u500B\u500E\u5010\u5011\u5013\u5015\u5016\u5017\u501B\u501D\u501E\u5020\u5022\u5023\u5024\u5027\u502B\u502F", 10, "\u503B\u503D\u503F\u5040\u5041\u5042\u5044\u5045\u5046\u5049\u504A\u504B\u504D\u5050", 4, "\u5056\u5057\u5058\u5059\u505B\u505D", 7, "\u5066", 5, "\u506D", 8, "\u5078\u5079\u507A\u507C\u507D\u5081\u5082\u5083\u5084\u5086\u5087\u5089\u508A\u508B\u508C\u508E", 20, "\u50A4\u50A6\u50AA\u50AB\u50AD", 4, "\u50B3", 6, "\u50BC"],
+ ["8340", "\u50BD", 17, "\u50D0", 5, "\u50D7\u50D8\u50D9\u50DB", 10, "\u50E8\u50E9\u50EA\u50EB\u50EF\u50F0\u50F1\u50F2\u50F4\u50F6", 4, "\u50FC", 9, "\u5108"],
+ ["8380", "\u5109\u510A\u510C", 5, "\u5113", 13, "\u5122", 28, "\u5142\u5147\u514A\u514C\u514E\u514F\u5150\u5152\u5153\u5157\u5158\u5159\u515B\u515D", 4, "\u5163\u5164\u5166\u5167\u5169\u516A\u516F\u5172\u517A\u517E\u517F\u5183\u5184\u5186\u5187\u518A\u518B\u518E\u518F\u5190\u5191\u5193\u5194\u5198\u519A\u519D\u519E\u519F\u51A1\u51A3\u51A6", 4, "\u51AD\u51AE\u51B4\u51B8\u51B9\u51BA\u51BE\u51BF\u51C1\u51C2\u51C3\u51C5\u51C8\u51CA\u51CD\u51CE\u51D0\u51D2", 5],
+ ["8440", "\u51D8\u51D9\u51DA\u51DC\u51DE\u51DF\u51E2\u51E3\u51E5", 5, "\u51EC\u51EE\u51F1\u51F2\u51F4\u51F7\u51FE\u5204\u5205\u5209\u520B\u520C\u520F\u5210\u5213\u5214\u5215\u521C\u521E\u521F\u5221\u5222\u5223\u5225\u5226\u5227\u522A\u522C\u522F\u5231\u5232\u5234\u5235\u523C\u523E\u5244", 5, "\u524B\u524E\u524F\u5252\u5253\u5255\u5257\u5258"],
+ ["8480", "\u5259\u525A\u525B\u525D\u525F\u5260\u5262\u5263\u5264\u5266\u5268\u526B\u526C\u526D\u526E\u5270\u5271\u5273", 9, "\u527E\u5280\u5283", 4, "\u5289", 6, "\u5291\u5292\u5294", 6, "\u529C\u52A4\u52A5\u52A6\u52A7\u52AE\u52AF\u52B0\u52B4", 9, "\u52C0\u52C1\u52C2\u52C4\u52C5\u52C6\u52C8\u52CA\u52CC\u52CD\u52CE\u52CF\u52D1\u52D3\u52D4\u52D5\u52D7\u52D9", 5, "\u52E0\u52E1\u52E2\u52E3\u52E5", 10, "\u52F1", 7, "\u52FB\u52FC\u52FD\u5301\u5302\u5303\u5304\u5307\u5309\u530A\u530B\u530C\u530E"],
+ ["8540", "\u5311\u5312\u5313\u5314\u5318\u531B\u531C\u531E\u531F\u5322\u5324\u5325\u5327\u5328\u5329\u532B\u532C\u532D\u532F", 9, "\u533C\u533D\u5340\u5342\u5344\u5346\u534B\u534C\u534D\u5350\u5354\u5358\u5359\u535B\u535D\u5365\u5368\u536A\u536C\u536D\u5372\u5376\u5379\u537B\u537C\u537D\u537E\u5380\u5381\u5383\u5387\u5388\u538A\u538E\u538F"],
+ ["8580", "\u5390", 4, "\u5396\u5397\u5399\u539B\u539C\u539E\u53A0\u53A1\u53A4\u53A7\u53AA\u53AB\u53AC\u53AD\u53AF", 6, "\u53B7\u53B8\u53B9\u53BA\u53BC\u53BD\u53BE\u53C0\u53C3", 4, "\u53CE\u53CF\u53D0\u53D2\u53D3\u53D5\u53DA\u53DC\u53DD\u53DE\u53E1\u53E2\u53E7\u53F4\u53FA\u53FE\u53FF\u5400\u5402\u5405\u5407\u540B\u5414\u5418\u5419\u541A\u541C\u5422\u5424\u5425\u542A\u5430\u5433\u5436\u5437\u543A\u543D\u543F\u5441\u5442\u5444\u5445\u5447\u5449\u544C\u544D\u544E\u544F\u5451\u545A\u545D", 4, "\u5463\u5465\u5467\u5469", 7, "\u5474\u5479\u547A\u547E\u547F\u5481\u5483\u5485\u5487\u5488\u5489\u548A\u548D\u5491\u5493\u5497\u5498\u549C\u549E\u549F\u54A0\u54A1"],
+ ["8640", "\u54A2\u54A5\u54AE\u54B0\u54B2\u54B5\u54B6\u54B7\u54B9\u54BA\u54BC\u54BE\u54C3\u54C5\u54CA\u54CB\u54D6\u54D8\u54DB\u54E0", 4, "\u54EB\u54EC\u54EF\u54F0\u54F1\u54F4", 5, "\u54FB\u54FE\u5500\u5502\u5503\u5504\u5505\u5508\u550A", 4, "\u5512\u5513\u5515", 5, "\u551C\u551D\u551E\u551F\u5521\u5525\u5526"],
+ ["8680", "\u5528\u5529\u552B\u552D\u5532\u5534\u5535\u5536\u5538\u5539\u553A\u553B\u553D\u5540\u5542\u5545\u5547\u5548\u554B", 4, "\u5551\u5552\u5553\u5554\u5557", 4, "\u555D\u555E\u555F\u5560\u5562\u5563\u5568\u5569\u556B\u556F", 5, "\u5579\u557A\u557D\u557F\u5585\u5586\u558C\u558D\u558E\u5590\u5592\u5593\u5595\u5596\u5597\u559A\u559B\u559E\u55A0", 6, "\u55A8", 8, "\u55B2\u55B4\u55B6\u55B8\u55BA\u55BC\u55BF", 4, "\u55C6\u55C7\u55C8\u55CA\u55CB\u55CE\u55CF\u55D0\u55D5\u55D7", 4, "\u55DE\u55E0\u55E2\u55E7\u55E9\u55ED\u55EE\u55F0\u55F1\u55F4\u55F6\u55F8", 4, "\u55FF\u5602\u5603\u5604\u5605"],
+ ["8740", "\u5606\u5607\u560A\u560B\u560D\u5610", 7, "\u5619\u561A\u561C\u561D\u5620\u5621\u5622\u5625\u5626\u5628\u5629\u562A\u562B\u562E\u562F\u5630\u5633\u5635\u5637\u5638\u563A\u563C\u563D\u563E\u5640", 11, "\u564F", 4, "\u5655\u5656\u565A\u565B\u565D", 4],
+ ["8780", "\u5663\u5665\u5666\u5667\u566D\u566E\u566F\u5670\u5672\u5673\u5674\u5675\u5677\u5678\u5679\u567A\u567D", 7, "\u5687", 6, "\u5690\u5691\u5692\u5694", 14, "\u56A4", 10, "\u56B0", 6, "\u56B8\u56B9\u56BA\u56BB\u56BD", 12, "\u56CB", 8, "\u56D5\u56D6\u56D8\u56D9\u56DC\u56E3\u56E5", 5, "\u56EC\u56EE\u56EF\u56F2\u56F3\u56F6\u56F7\u56F8\u56FB\u56FC\u5700\u5701\u5702\u5705\u5707\u570B", 6],
+ ["8840", "\u5712", 9, "\u571D\u571E\u5720\u5721\u5722\u5724\u5725\u5726\u5727\u572B\u5731\u5732\u5734", 4, "\u573C\u573D\u573F\u5741\u5743\u5744\u5745\u5746\u5748\u5749\u574B\u5752", 4, "\u5758\u5759\u5762\u5763\u5765\u5767\u576C\u576E\u5770\u5771\u5772\u5774\u5775\u5778\u5779\u577A\u577D\u577E\u577F\u5780"],
+ ["8880", "\u5781\u5787\u5788\u5789\u578A\u578D", 4, "\u5794", 6, "\u579C\u579D\u579E\u579F\u57A5\u57A8\u57AA\u57AC\u57AF\u57B0\u57B1\u57B3\u57B5\u57B6\u57B7\u57B9", 8, "\u57C4", 6, "\u57CC\u57CD\u57D0\u57D1\u57D3\u57D6\u57D7\u57DB\u57DC\u57DE\u57E1\u57E2\u57E3\u57E5", 7, "\u57EE\u57F0\u57F1\u57F2\u57F3\u57F5\u57F6\u57F7\u57FB\u57FC\u57FE\u57FF\u5801\u5803\u5804\u5805\u5808\u5809\u580A\u580C\u580E\u580F\u5810\u5812\u5813\u5814\u5816\u5817\u5818\u581A\u581B\u581C\u581D\u581F\u5822\u5823\u5825", 4, "\u582B", 4, "\u5831\u5832\u5833\u5834\u5836", 7],
+ ["8940", "\u583E", 5, "\u5845", 6, "\u584E\u584F\u5850\u5852\u5853\u5855\u5856\u5857\u5859", 4, "\u585F", 5, "\u5866", 4, "\u586D", 16, "\u587F\u5882\u5884\u5886\u5887\u5888\u588A\u588B\u588C"],
+ ["8980", "\u588D", 4, "\u5894", 4, "\u589B\u589C\u589D\u58A0", 7, "\u58AA", 17, "\u58BD\u58BE\u58BF\u58C0\u58C2\u58C3\u58C4\u58C6", 10, "\u58D2\u58D3\u58D4\u58D6", 13, "\u58E5", 5, "\u58ED\u58EF\u58F1\u58F2\u58F4\u58F5\u58F7\u58F8\u58FA", 7, "\u5903\u5905\u5906\u5908", 4, "\u590E\u5910\u5911\u5912\u5913\u5917\u5918\u591B\u591D\u591E\u5920\u5921\u5922\u5923\u5926\u5928\u592C\u5930\u5932\u5933\u5935\u5936\u593B"],
+ ["8a40", "\u593D\u593E\u593F\u5940\u5943\u5945\u5946\u594A\u594C\u594D\u5950\u5952\u5953\u5959\u595B", 4, "\u5961\u5963\u5964\u5966", 12, "\u5975\u5977\u597A\u597B\u597C\u597E\u597F\u5980\u5985\u5989\u598B\u598C\u598E\u598F\u5990\u5991\u5994\u5995\u5998\u599A\u599B\u599C\u599D\u599F\u59A0\u59A1\u59A2\u59A6"],
+ ["8a80", "\u59A7\u59AC\u59AD\u59B0\u59B1\u59B3", 5, "\u59BA\u59BC\u59BD\u59BF", 6, "\u59C7\u59C8\u59C9\u59CC\u59CD\u59CE\u59CF\u59D5\u59D6\u59D9\u59DB\u59DE", 4, "\u59E4\u59E6\u59E7\u59E9\u59EA\u59EB\u59ED", 11, "\u59FA\u59FC\u59FD\u59FE\u5A00\u5A02\u5A0A\u5A0B\u5A0D\u5A0E\u5A0F\u5A10\u5A12\u5A14\u5A15\u5A16\u5A17\u5A19\u5A1A\u5A1B\u5A1D\u5A1E\u5A21\u5A22\u5A24\u5A26\u5A27\u5A28\u5A2A", 6, "\u5A33\u5A35\u5A37", 4, "\u5A3D\u5A3E\u5A3F\u5A41", 4, "\u5A47\u5A48\u5A4B", 9, "\u5A56\u5A57\u5A58\u5A59\u5A5B", 5],
+ ["8b40", "\u5A61\u5A63\u5A64\u5A65\u5A66\u5A68\u5A69\u5A6B", 8, "\u5A78\u5A79\u5A7B\u5A7C\u5A7D\u5A7E\u5A80", 17, "\u5A93", 6, "\u5A9C", 13, "\u5AAB\u5AAC"],
+ ["8b80", "\u5AAD", 4, "\u5AB4\u5AB6\u5AB7\u5AB9", 4, "\u5ABF\u5AC0\u5AC3", 5, "\u5ACA\u5ACB\u5ACD", 4, "\u5AD3\u5AD5\u5AD7\u5AD9\u5ADA\u5ADB\u5ADD\u5ADE\u5ADF\u5AE2\u5AE4\u5AE5\u5AE7\u5AE8\u5AEA\u5AEC", 4, "\u5AF2", 22, "\u5B0A", 11, "\u5B18", 25, "\u5B33\u5B35\u5B36\u5B38", 7, "\u5B41", 6],
+ ["8c40", "\u5B48", 7, "\u5B52\u5B56\u5B5E\u5B60\u5B61\u5B67\u5B68\u5B6B\u5B6D\u5B6E\u5B6F\u5B72\u5B74\u5B76\u5B77\u5B78\u5B79\u5B7B\u5B7C\u5B7E\u5B7F\u5B82\u5B86\u5B8A\u5B8D\u5B8E\u5B90\u5B91\u5B92\u5B94\u5B96\u5B9F\u5BA7\u5BA8\u5BA9\u5BAC\u5BAD\u5BAE\u5BAF\u5BB1\u5BB2\u5BB7\u5BBA\u5BBB\u5BBC\u5BC0\u5BC1\u5BC3\u5BC8\u5BC9\u5BCA\u5BCB\u5BCD\u5BCE\u5BCF"],
+ ["8c80", "\u5BD1\u5BD4", 8, "\u5BE0\u5BE2\u5BE3\u5BE6\u5BE7\u5BE9", 4, "\u5BEF\u5BF1", 6, "\u5BFD\u5BFE\u5C00\u5C02\u5C03\u5C05\u5C07\u5C08\u5C0B\u5C0C\u5C0D\u5C0E\u5C10\u5C12\u5C13\u5C17\u5C19\u5C1B\u5C1E\u5C1F\u5C20\u5C21\u5C23\u5C26\u5C28\u5C29\u5C2A\u5C2B\u5C2D\u5C2E\u5C2F\u5C30\u5C32\u5C33\u5C35\u5C36\u5C37\u5C43\u5C44\u5C46\u5C47\u5C4C\u5C4D\u5C52\u5C53\u5C54\u5C56\u5C57\u5C58\u5C5A\u5C5B\u5C5C\u5C5D\u5C5F\u5C62\u5C64\u5C67", 6, "\u5C70\u5C72", 6, "\u5C7B\u5C7C\u5C7D\u5C7E\u5C80\u5C83", 4, "\u5C89\u5C8A\u5C8B\u5C8E\u5C8F\u5C92\u5C93\u5C95\u5C9D", 4, "\u5CA4", 4],
+ ["8d40", "\u5CAA\u5CAE\u5CAF\u5CB0\u5CB2\u5CB4\u5CB6\u5CB9\u5CBA\u5CBB\u5CBC\u5CBE\u5CC0\u5CC2\u5CC3\u5CC5", 5, "\u5CCC", 5, "\u5CD3", 5, "\u5CDA", 6, "\u5CE2\u5CE3\u5CE7\u5CE9\u5CEB\u5CEC\u5CEE\u5CEF\u5CF1", 9, "\u5CFC", 4],
+ ["8d80", "\u5D01\u5D04\u5D05\u5D08", 5, "\u5D0F", 4, "\u5D15\u5D17\u5D18\u5D19\u5D1A\u5D1C\u5D1D\u5D1F", 4, "\u5D25\u5D28\u5D2A\u5D2B\u5D2C\u5D2F", 4, "\u5D35", 7, "\u5D3F", 7, "\u5D48\u5D49\u5D4D", 10, "\u5D59\u5D5A\u5D5C\u5D5E", 10, "\u5D6A\u5D6D\u5D6E\u5D70\u5D71\u5D72\u5D73\u5D75", 12, "\u5D83", 21, "\u5D9A\u5D9B\u5D9C\u5D9E\u5D9F\u5DA0"],
+ ["8e40", "\u5DA1", 21, "\u5DB8", 12, "\u5DC6", 6, "\u5DCE", 12, "\u5DDC\u5DDF\u5DE0\u5DE3\u5DE4\u5DEA\u5DEC\u5DED"],
+ ["8e80", "\u5DF0\u5DF5\u5DF6\u5DF8", 4, "\u5DFF\u5E00\u5E04\u5E07\u5E09\u5E0A\u5E0B\u5E0D\u5E0E\u5E12\u5E13\u5E17\u5E1E", 7, "\u5E28", 4, "\u5E2F\u5E30\u5E32", 4, "\u5E39\u5E3A\u5E3E\u5E3F\u5E40\u5E41\u5E43\u5E46", 5, "\u5E4D", 6, "\u5E56", 4, "\u5E5C\u5E5D\u5E5F\u5E60\u5E63", 14, "\u5E75\u5E77\u5E79\u5E7E\u5E81\u5E82\u5E83\u5E85\u5E88\u5E89\u5E8C\u5E8D\u5E8E\u5E92\u5E98\u5E9B\u5E9D\u5EA1\u5EA2\u5EA3\u5EA4\u5EA8", 4, "\u5EAE", 4, "\u5EB4\u5EBA\u5EBB\u5EBC\u5EBD\u5EBF", 6],
+ ["8f40", "\u5EC6\u5EC7\u5EC8\u5ECB", 5, "\u5ED4\u5ED5\u5ED7\u5ED8\u5ED9\u5EDA\u5EDC", 11, "\u5EE9\u5EEB", 8, "\u5EF5\u5EF8\u5EF9\u5EFB\u5EFC\u5EFD\u5F05\u5F06\u5F07\u5F09\u5F0C\u5F0D\u5F0E\u5F10\u5F12\u5F14\u5F16\u5F19\u5F1A\u5F1C\u5F1D\u5F1E\u5F21\u5F22\u5F23\u5F24"],
+ ["8f80", "\u5F28\u5F2B\u5F2C\u5F2E\u5F30\u5F32", 6, "\u5F3B\u5F3D\u5F3E\u5F3F\u5F41", 14, "\u5F51\u5F54\u5F59\u5F5A\u5F5B\u5F5C\u5F5E\u5F5F\u5F60\u5F63\u5F65\u5F67\u5F68\u5F6B\u5F6E\u5F6F\u5F72\u5F74\u5F75\u5F76\u5F78\u5F7A\u5F7D\u5F7E\u5F7F\u5F83\u5F86\u5F8D\u5F8E\u5F8F\u5F91\u5F93\u5F94\u5F96\u5F9A\u5F9B\u5F9D\u5F9E\u5F9F\u5FA0\u5FA2", 5, "\u5FA9\u5FAB\u5FAC\u5FAF", 5, "\u5FB6\u5FB8\u5FB9\u5FBA\u5FBB\u5FBE", 4, "\u5FC7\u5FC8\u5FCA\u5FCB\u5FCE\u5FD3\u5FD4\u5FD5\u5FDA\u5FDB\u5FDC\u5FDE\u5FDF\u5FE2\u5FE3\u5FE5\u5FE6\u5FE8\u5FE9\u5FEC\u5FEF\u5FF0\u5FF2\u5FF3\u5FF4\u5FF6\u5FF7\u5FF9\u5FFA\u5FFC\u6007"],
+ ["9040", "\u6008\u6009\u600B\u600C\u6010\u6011\u6013\u6017\u6018\u601A\u601E\u601F\u6022\u6023\u6024\u602C\u602D\u602E\u6030", 4, "\u6036", 4, "\u603D\u603E\u6040\u6044", 6, "\u604C\u604E\u604F\u6051\u6053\u6054\u6056\u6057\u6058\u605B\u605C\u605E\u605F\u6060\u6061\u6065\u6066\u606E\u6071\u6072\u6074\u6075\u6077\u607E\u6080"],
+ ["9080", "\u6081\u6082\u6085\u6086\u6087\u6088\u608A\u608B\u608E\u608F\u6090\u6091\u6093\u6095\u6097\u6098\u6099\u609C\u609E\u60A1\u60A2\u60A4\u60A5\u60A7\u60A9\u60AA\u60AE\u60B0\u60B3\u60B5\u60B6\u60B7\u60B9\u60BA\u60BD", 7, "\u60C7\u60C8\u60C9\u60CC", 4, "\u60D2\u60D3\u60D4\u60D6\u60D7\u60D9\u60DB\u60DE\u60E1", 4, "\u60EA\u60F1\u60F2\u60F5\u60F7\u60F8\u60FB", 4, "\u6102\u6103\u6104\u6105\u6107\u610A\u610B\u610C\u6110", 4, "\u6116\u6117\u6118\u6119\u611B\u611C\u611D\u611E\u6121\u6122\u6125\u6128\u6129\u612A\u612C", 18, "\u6140", 6],
+ ["9140", "\u6147\u6149\u614B\u614D\u614F\u6150\u6152\u6153\u6154\u6156", 6, "\u615E\u615F\u6160\u6161\u6163\u6164\u6165\u6166\u6169", 6, "\u6171\u6172\u6173\u6174\u6176\u6178", 18, "\u618C\u618D\u618F", 4, "\u6195"],
+ ["9180", "\u6196", 6, "\u619E", 8, "\u61AA\u61AB\u61AD", 9, "\u61B8", 5, "\u61BF\u61C0\u61C1\u61C3", 4, "\u61C9\u61CC", 4, "\u61D3\u61D5", 16, "\u61E7", 13, "\u61F6", 8, "\u6200", 5, "\u6207\u6209\u6213\u6214\u6219\u621C\u621D\u621E\u6220\u6223\u6226\u6227\u6228\u6229\u622B\u622D\u622F\u6230\u6231\u6232\u6235\u6236\u6238", 4, "\u6242\u6244\u6245\u6246\u624A"],
+ ["9240", "\u624F\u6250\u6255\u6256\u6257\u6259\u625A\u625C", 6, "\u6264\u6265\u6268\u6271\u6272\u6274\u6275\u6277\u6278\u627A\u627B\u627D\u6281\u6282\u6283\u6285\u6286\u6287\u6288\u628B", 5, "\u6294\u6299\u629C\u629D\u629E\u62A3\u62A6\u62A7\u62A9\u62AA\u62AD\u62AE\u62AF\u62B0\u62B2\u62B3\u62B4\u62B6\u62B7\u62B8\u62BA\u62BE\u62C0\u62C1"],
+ ["9280", "\u62C3\u62CB\u62CF\u62D1\u62D5\u62DD\u62DE\u62E0\u62E1\u62E4\u62EA\u62EB\u62F0\u62F2\u62F5\u62F8\u62F9\u62FA\u62FB\u6300\u6303\u6304\u6305\u6306\u630A\u630B\u630C\u630D\u630F\u6310\u6312\u6313\u6314\u6315\u6317\u6318\u6319\u631C\u6326\u6327\u6329\u632C\u632D\u632E\u6330\u6331\u6333", 5, "\u633B\u633C\u633E\u633F\u6340\u6341\u6344\u6347\u6348\u634A\u6351\u6352\u6353\u6354\u6356", 7, "\u6360\u6364\u6365\u6366\u6368\u636A\u636B\u636C\u636F\u6370\u6372\u6373\u6374\u6375\u6378\u6379\u637C\u637D\u637E\u637F\u6381\u6383\u6384\u6385\u6386\u638B\u638D\u6391\u6393\u6394\u6395\u6397\u6399", 6, "\u63A1\u63A4\u63A6\u63AB\u63AF\u63B1\u63B2\u63B5\u63B6\u63B9\u63BB\u63BD\u63BF\u63C0"],
+ ["9340", "\u63C1\u63C2\u63C3\u63C5\u63C7\u63C8\u63CA\u63CB\u63CC\u63D1\u63D3\u63D4\u63D5\u63D7", 6, "\u63DF\u63E2\u63E4", 4, "\u63EB\u63EC\u63EE\u63EF\u63F0\u63F1\u63F3\u63F5\u63F7\u63F9\u63FA\u63FB\u63FC\u63FE\u6403\u6404\u6406", 4, "\u640D\u640E\u6411\u6412\u6415", 5, "\u641D\u641F\u6422\u6423\u6424"],
+ ["9380", "\u6425\u6427\u6428\u6429\u642B\u642E", 5, "\u6435", 4, "\u643B\u643C\u643E\u6440\u6442\u6443\u6449\u644B", 6, "\u6453\u6455\u6456\u6457\u6459", 4, "\u645F", 7, "\u6468\u646A\u646B\u646C\u646E", 9, "\u647B", 6, "\u6483\u6486\u6488", 8, "\u6493\u6494\u6497\u6498\u649A\u649B\u649C\u649D\u649F", 4, "\u64A5\u64A6\u64A7\u64A8\u64AA\u64AB\u64AF\u64B1\u64B2\u64B3\u64B4\u64B6\u64B9\u64BB\u64BD\u64BE\u64BF\u64C1\u64C3\u64C4\u64C6", 6, "\u64CF\u64D1\u64D3\u64D4\u64D5\u64D6\u64D9\u64DA"],
+ ["9440", "\u64DB\u64DC\u64DD\u64DF\u64E0\u64E1\u64E3\u64E5\u64E7", 24, "\u6501", 7, "\u650A", 7, "\u6513", 4, "\u6519", 8],
+ ["9480", "\u6522\u6523\u6524\u6526", 4, "\u652C\u652D\u6530\u6531\u6532\u6533\u6537\u653A\u653C\u653D\u6540", 4, "\u6546\u6547\u654A\u654B\u654D\u654E\u6550\u6552\u6553\u6554\u6557\u6558\u655A\u655C\u655F\u6560\u6561\u6564\u6565\u6567\u6568\u6569\u656A\u656D\u656E\u656F\u6571\u6573\u6575\u6576\u6578", 14, "\u6588\u6589\u658A\u658D\u658E\u658F\u6592\u6594\u6595\u6596\u6598\u659A\u659D\u659E\u65A0\u65A2\u65A3\u65A6\u65A8\u65AA\u65AC\u65AE\u65B1", 7, "\u65BA\u65BB\u65BE\u65BF\u65C0\u65C2\u65C7\u65C8\u65C9\u65CA\u65CD\u65D0\u65D1\u65D3\u65D4\u65D5\u65D8", 7, "\u65E1\u65E3\u65E4\u65EA\u65EB"],
+ ["9540", "\u65F2\u65F3\u65F4\u65F5\u65F8\u65F9\u65FB", 4, "\u6601\u6604\u6605\u6607\u6608\u6609\u660B\u660D\u6610\u6611\u6612\u6616\u6617\u6618\u661A\u661B\u661C\u661E\u6621\u6622\u6623\u6624\u6626\u6629\u662A\u662B\u662C\u662E\u6630\u6632\u6633\u6637", 4, "\u663D\u663F\u6640\u6642\u6644", 6, "\u664D\u664E\u6650\u6651\u6658"],
+ ["9580", "\u6659\u665B\u665C\u665D\u665E\u6660\u6662\u6663\u6665\u6667\u6669", 4, "\u6671\u6672\u6673\u6675\u6678\u6679\u667B\u667C\u667D\u667F\u6680\u6681\u6683\u6685\u6686\u6688\u6689\u668A\u668B\u668D\u668E\u668F\u6690\u6692\u6693\u6694\u6695\u6698", 4, "\u669E", 8, "\u66A9", 4, "\u66AF", 4, "\u66B5\u66B6\u66B7\u66B8\u66BA\u66BB\u66BC\u66BD\u66BF", 25, "\u66DA\u66DE", 7, "\u66E7\u66E8\u66EA", 5, "\u66F1\u66F5\u66F6\u66F8\u66FA\u66FB\u66FD\u6701\u6702\u6703"],
+ ["9640", "\u6704\u6705\u6706\u6707\u670C\u670E\u670F\u6711\u6712\u6713\u6716\u6718\u6719\u671A\u671C\u671E\u6720", 5, "\u6727\u6729\u672E\u6730\u6732\u6733\u6736\u6737\u6738\u6739\u673B\u673C\u673E\u673F\u6741\u6744\u6745\u6747\u674A\u674B\u674D\u6752\u6754\u6755\u6757", 4, "\u675D\u6762\u6763\u6764\u6766\u6767\u676B\u676C\u676E\u6771\u6774\u6776"],
+ ["9680", "\u6778\u6779\u677A\u677B\u677D\u6780\u6782\u6783\u6785\u6786\u6788\u678A\u678C\u678D\u678E\u678F\u6791\u6792\u6793\u6794\u6796\u6799\u679B\u679F\u67A0\u67A1\u67A4\u67A6\u67A9\u67AC\u67AE\u67B1\u67B2\u67B4\u67B9", 7, "\u67C2\u67C5", 9, "\u67D5\u67D6\u67D7\u67DB\u67DF\u67E1\u67E3\u67E4\u67E6\u67E7\u67E8\u67EA\u67EB\u67ED\u67EE\u67F2\u67F5", 7, "\u67FE\u6801\u6802\u6803\u6804\u6806\u680D\u6810\u6812\u6814\u6815\u6818", 4, "\u681E\u681F\u6820\u6822", 6, "\u682B", 6, "\u6834\u6835\u6836\u683A\u683B\u683F\u6847\u684B\u684D\u684F\u6852\u6856", 5],
+ ["9740", "\u685C\u685D\u685E\u685F\u686A\u686C", 7, "\u6875\u6878", 8, "\u6882\u6884\u6887", 7, "\u6890\u6891\u6892\u6894\u6895\u6896\u6898", 9, "\u68A3\u68A4\u68A5\u68A9\u68AA\u68AB\u68AC\u68AE\u68B1\u68B2\u68B4\u68B6\u68B7\u68B8"],
+ ["9780", "\u68B9", 6, "\u68C1\u68C3", 5, "\u68CA\u68CC\u68CE\u68CF\u68D0\u68D1\u68D3\u68D4\u68D6\u68D7\u68D9\u68DB", 4, "\u68E1\u68E2\u68E4", 9, "\u68EF\u68F2\u68F3\u68F4\u68F6\u68F7\u68F8\u68FB\u68FD\u68FE\u68FF\u6900\u6902\u6903\u6904\u6906", 4, "\u690C\u690F\u6911\u6913", 11, "\u6921\u6922\u6923\u6925", 7, "\u692E\u692F\u6931\u6932\u6933\u6935\u6936\u6937\u6938\u693A\u693B\u693C\u693E\u6940\u6941\u6943", 16, "\u6955\u6956\u6958\u6959\u695B\u695C\u695F"],
+ ["9840", "\u6961\u6962\u6964\u6965\u6967\u6968\u6969\u696A\u696C\u696D\u696F\u6970\u6972", 4, "\u697A\u697B\u697D\u697E\u697F\u6981\u6983\u6985\u698A\u698B\u698C\u698E", 5, "\u6996\u6997\u6999\u699A\u699D", 9, "\u69A9\u69AA\u69AC\u69AE\u69AF\u69B0\u69B2\u69B3\u69B5\u69B6\u69B8\u69B9\u69BA\u69BC\u69BD"],
+ ["9880", "\u69BE\u69BF\u69C0\u69C2", 7, "\u69CB\u69CD\u69CF\u69D1\u69D2\u69D3\u69D5", 5, "\u69DC\u69DD\u69DE\u69E1", 11, "\u69EE\u69EF\u69F0\u69F1\u69F3", 9, "\u69FE\u6A00", 9, "\u6A0B", 11, "\u6A19", 5, "\u6A20\u6A22", 5, "\u6A29\u6A2B\u6A2C\u6A2D\u6A2E\u6A30\u6A32\u6A33\u6A34\u6A36", 6, "\u6A3F", 4, "\u6A45\u6A46\u6A48", 7, "\u6A51", 6, "\u6A5A"],
+ ["9940", "\u6A5C", 4, "\u6A62\u6A63\u6A64\u6A66", 10, "\u6A72", 6, "\u6A7A\u6A7B\u6A7D\u6A7E\u6A7F\u6A81\u6A82\u6A83\u6A85", 8, "\u6A8F\u6A92", 4, "\u6A98", 7, "\u6AA1", 5],
+ ["9980", "\u6AA7\u6AA8\u6AAA\u6AAD", 114, "\u6B25\u6B26\u6B28", 6],
+ ["9a40", "\u6B2F\u6B30\u6B31\u6B33\u6B34\u6B35\u6B36\u6B38\u6B3B\u6B3C\u6B3D\u6B3F\u6B40\u6B41\u6B42\u6B44\u6B45\u6B48\u6B4A\u6B4B\u6B4D", 11, "\u6B5A", 7, "\u6B68\u6B69\u6B6B", 13, "\u6B7A\u6B7D\u6B7E\u6B7F\u6B80\u6B85\u6B88"],
+ ["9a80", "\u6B8C\u6B8E\u6B8F\u6B90\u6B91\u6B94\u6B95\u6B97\u6B98\u6B99\u6B9C", 4, "\u6BA2", 7, "\u6BAB", 7, "\u6BB6\u6BB8", 6, "\u6BC0\u6BC3\u6BC4\u6BC6", 4, "\u6BCC\u6BCE\u6BD0\u6BD1\u6BD8\u6BDA\u6BDC", 4, "\u6BE2", 7, "\u6BEC\u6BED\u6BEE\u6BF0\u6BF1\u6BF2\u6BF4\u6BF6\u6BF7\u6BF8\u6BFA\u6BFB\u6BFC\u6BFE", 6, "\u6C08", 4, "\u6C0E\u6C12\u6C17\u6C1C\u6C1D\u6C1E\u6C20\u6C23\u6C25\u6C2B\u6C2C\u6C2D\u6C31\u6C33\u6C36\u6C37\u6C39\u6C3A\u6C3B\u6C3C\u6C3E\u6C3F\u6C43\u6C44\u6C45\u6C48\u6C4B", 4, "\u6C51\u6C52\u6C53\u6C56\u6C58"],
+ ["9b40", "\u6C59\u6C5A\u6C62\u6C63\u6C65\u6C66\u6C67\u6C6B", 4, "\u6C71\u6C73\u6C75\u6C77\u6C78\u6C7A\u6C7B\u6C7C\u6C7F\u6C80\u6C84\u6C87\u6C8A\u6C8B\u6C8D\u6C8E\u6C91\u6C92\u6C95\u6C96\u6C97\u6C98\u6C9A\u6C9C\u6C9D\u6C9E\u6CA0\u6CA2\u6CA8\u6CAC\u6CAF\u6CB0\u6CB4\u6CB5\u6CB6\u6CB7\u6CBA\u6CC0\u6CC1\u6CC2\u6CC3\u6CC6\u6CC7\u6CC8\u6CCB\u6CCD\u6CCE\u6CCF\u6CD1\u6CD2\u6CD8"],
+ ["9b80", "\u6CD9\u6CDA\u6CDC\u6CDD\u6CDF\u6CE4\u6CE6\u6CE7\u6CE9\u6CEC\u6CED\u6CF2\u6CF4\u6CF9\u6CFF\u6D00\u6D02\u6D03\u6D05\u6D06\u6D08\u6D09\u6D0A\u6D0D\u6D0F\u6D10\u6D11\u6D13\u6D14\u6D15\u6D16\u6D18\u6D1C\u6D1D\u6D1F", 5, "\u6D26\u6D28\u6D29\u6D2C\u6D2D\u6D2F\u6D30\u6D34\u6D36\u6D37\u6D38\u6D3A\u6D3F\u6D40\u6D42\u6D44\u6D49\u6D4C\u6D50\u6D55\u6D56\u6D57\u6D58\u6D5B\u6D5D\u6D5F\u6D61\u6D62\u6D64\u6D65\u6D67\u6D68\u6D6B\u6D6C\u6D6D\u6D70\u6D71\u6D72\u6D73\u6D75\u6D76\u6D79\u6D7A\u6D7B\u6D7D", 4, "\u6D83\u6D84\u6D86\u6D87\u6D8A\u6D8B\u6D8D\u6D8F\u6D90\u6D92\u6D96", 4, "\u6D9C\u6DA2\u6DA5\u6DAC\u6DAD\u6DB0\u6DB1\u6DB3\u6DB4\u6DB6\u6DB7\u6DB9", 5, "\u6DC1\u6DC2\u6DC3\u6DC8\u6DC9\u6DCA"],
+ ["9c40", "\u6DCD\u6DCE\u6DCF\u6DD0\u6DD2\u6DD3\u6DD4\u6DD5\u6DD7\u6DDA\u6DDB\u6DDC\u6DDF\u6DE2\u6DE3\u6DE5\u6DE7\u6DE8\u6DE9\u6DEA\u6DED\u6DEF\u6DF0\u6DF2\u6DF4\u6DF5\u6DF6\u6DF8\u6DFA\u6DFD", 7, "\u6E06\u6E07\u6E08\u6E09\u6E0B\u6E0F\u6E12\u6E13\u6E15\u6E18\u6E19\u6E1B\u6E1C\u6E1E\u6E1F\u6E22\u6E26\u6E27\u6E28\u6E2A\u6E2C\u6E2E\u6E30\u6E31\u6E33\u6E35"],
+ ["9c80", "\u6E36\u6E37\u6E39\u6E3B", 7, "\u6E45", 7, "\u6E4F\u6E50\u6E51\u6E52\u6E55\u6E57\u6E59\u6E5A\u6E5C\u6E5D\u6E5E\u6E60", 10, "\u6E6C\u6E6D\u6E6F", 14, "\u6E80\u6E81\u6E82\u6E84\u6E87\u6E88\u6E8A", 4, "\u6E91", 6, "\u6E99\u6E9A\u6E9B\u6E9D\u6E9E\u6EA0\u6EA1\u6EA3\u6EA4\u6EA6\u6EA8\u6EA9\u6EAB\u6EAC\u6EAD\u6EAE\u6EB0\u6EB3\u6EB5\u6EB8\u6EB9\u6EBC\u6EBE\u6EBF\u6EC0\u6EC3\u6EC4\u6EC5\u6EC6\u6EC8\u6EC9\u6ECA\u6ECC\u6ECD\u6ECE\u6ED0\u6ED2\u6ED6\u6ED8\u6ED9\u6EDB\u6EDC\u6EDD\u6EE3\u6EE7\u6EEA", 5],
+ ["9d40", "\u6EF0\u6EF1\u6EF2\u6EF3\u6EF5\u6EF6\u6EF7\u6EF8\u6EFA", 7, "\u6F03\u6F04\u6F05\u6F07\u6F08\u6F0A", 4, "\u6F10\u6F11\u6F12\u6F16", 9, "\u6F21\u6F22\u6F23\u6F25\u6F26\u6F27\u6F28\u6F2C\u6F2E\u6F30\u6F32\u6F34\u6F35\u6F37", 6, "\u6F3F\u6F40\u6F41\u6F42"],
+ ["9d80", "\u6F43\u6F44\u6F45\u6F48\u6F49\u6F4A\u6F4C\u6F4E", 9, "\u6F59\u6F5A\u6F5B\u6F5D\u6F5F\u6F60\u6F61\u6F63\u6F64\u6F65\u6F67", 5, "\u6F6F\u6F70\u6F71\u6F73\u6F75\u6F76\u6F77\u6F79\u6F7B\u6F7D", 6, "\u6F85\u6F86\u6F87\u6F8A\u6F8B\u6F8F", 12, "\u6F9D\u6F9E\u6F9F\u6FA0\u6FA2", 4, "\u6FA8", 10, "\u6FB4\u6FB5\u6FB7\u6FB8\u6FBA", 5, "\u6FC1\u6FC3", 5, "\u6FCA", 6, "\u6FD3", 10, "\u6FDF\u6FE2\u6FE3\u6FE4\u6FE5"],
+ ["9e40", "\u6FE6", 7, "\u6FF0", 32, "\u7012", 7, "\u701C", 6, "\u7024", 6],
+ ["9e80", "\u702B", 9, "\u7036\u7037\u7038\u703A", 17, "\u704D\u704E\u7050", 13, "\u705F", 11, "\u706E\u7071\u7072\u7073\u7074\u7077\u7079\u707A\u707B\u707D\u7081\u7082\u7083\u7084\u7086\u7087\u7088\u708B\u708C\u708D\u708F\u7090\u7091\u7093\u7097\u7098\u709A\u709B\u709E", 12, "\u70B0\u70B2\u70B4\u70B5\u70B6\u70BA\u70BE\u70BF\u70C4\u70C5\u70C6\u70C7\u70C9\u70CB", 12, "\u70DA"],
+ ["9f40", "\u70DC\u70DD\u70DE\u70E0\u70E1\u70E2\u70E3\u70E5\u70EA\u70EE\u70F0", 6, "\u70F8\u70FA\u70FB\u70FC\u70FE", 10, "\u710B", 4, "\u7111\u7112\u7114\u7117\u711B", 10, "\u7127", 7, "\u7132\u7133\u7134"],
+ ["9f80", "\u7135\u7137", 13, "\u7146\u7147\u7148\u7149\u714B\u714D\u714F", 12, "\u715D\u715F", 4, "\u7165\u7169", 4, "\u716F\u7170\u7171\u7174\u7175\u7176\u7177\u7179\u717B\u717C\u717E", 5, "\u7185", 4, "\u718B\u718C\u718D\u718E\u7190\u7191\u7192\u7193\u7195\u7196\u7197\u719A", 4, "\u71A1", 6, "\u71A9\u71AA\u71AB\u71AD", 5, "\u71B4\u71B6\u71B7\u71B8\u71BA", 8, "\u71C4", 9, "\u71CF", 4],
+ ["a040", "\u71D6", 9, "\u71E1\u71E2\u71E3\u71E4\u71E6\u71E8", 5, "\u71EF", 9, "\u71FA", 11, "\u7207", 19],
+ ["a080", "\u721B\u721C\u721E", 9, "\u7229\u722B\u722D\u722E\u722F\u7232\u7233\u7234\u723A\u723C\u723E\u7240", 6, "\u7249\u724A\u724B\u724E\u724F\u7250\u7251\u7253\u7254\u7255\u7257\u7258\u725A\u725C\u725E\u7260\u7263\u7264\u7265\u7268\u726A\u726B\u726C\u726D\u7270\u7271\u7273\u7274\u7276\u7277\u7278\u727B\u727C\u727D\u7282\u7283\u7285", 4, "\u728C\u728E\u7290\u7291\u7293", 11, "\u72A0", 11, "\u72AE\u72B1\u72B2\u72B3\u72B5\u72BA", 6, "\u72C5\u72C6\u72C7\u72C9\u72CA\u72CB\u72CC\u72CF\u72D1\u72D3\u72D4\u72D5\u72D6\u72D8\u72DA\u72DB"],
+ ["a1a1", "\u3000\u3001\u3002\xB7\u02C9\u02C7\xA8\u3003\u3005\u2014\uFF5E\u2016\u2026\u2018\u2019\u201C\u201D\u3014\u3015\u3008", 7, "\u3016\u3017\u3010\u3011\xB1\xD7\xF7\u2236\u2227\u2228\u2211\u220F\u222A\u2229\u2208\u2237\u221A\u22A5\u2225\u2220\u2312\u2299\u222B\u222E\u2261\u224C\u2248\u223D\u221D\u2260\u226E\u226F\u2264\u2265\u221E\u2235\u2234\u2642\u2640\xB0\u2032\u2033\u2103\uFF04\xA4\uFFE0\uFFE1\u2030\xA7\u2116\u2606\u2605\u25CB\u25CF\u25CE\u25C7\u25C6\u25A1\u25A0\u25B3\u25B2\u203B\u2192\u2190\u2191\u2193\u3013"],
+ ["a2a1", "\u2170", 9],
+ ["a2b1", "\u2488", 19, "\u2474", 19, "\u2460", 9],
+ ["a2e5", "\u3220", 9],
+ ["a2f1", "\u2160", 11],
+ ["a3a1", "\uFF01\uFF02\uFF03\uFFE5\uFF05", 88, "\uFFE3"],
+ ["a4a1", "\u3041", 82],
+ ["a5a1", "\u30A1", 85],
+ ["a6a1", "\u0391", 16, "\u03A3", 6],
+ ["a6c1", "\u03B1", 16, "\u03C3", 6],
+ ["a6e0", "\uFE35\uFE36\uFE39\uFE3A\uFE3F\uFE40\uFE3D\uFE3E\uFE41\uFE42\uFE43\uFE44"],
+ ["a6ee", "\uFE3B\uFE3C\uFE37\uFE38\uFE31"],
+ ["a6f4", "\uFE33\uFE34"],
+ ["a7a1", "\u0410", 5, "\u0401\u0416", 25],
+ ["a7d1", "\u0430", 5, "\u0451\u0436", 25],
+ ["a840", "\u02CA\u02CB\u02D9\u2013\u2015\u2025\u2035\u2105\u2109\u2196\u2197\u2198\u2199\u2215\u221F\u2223\u2252\u2266\u2267\u22BF\u2550", 35, "\u2581", 6],
+ ["a880", "\u2588", 7, "\u2593\u2594\u2595\u25BC\u25BD\u25E2\u25E3\u25E4\u25E5\u2609\u2295\u3012\u301D\u301E"],
+ ["a8a1", "\u0101\xE1\u01CE\xE0\u0113\xE9\u011B\xE8\u012B\xED\u01D0\xEC\u014D\xF3\u01D2\xF2\u016B\xFA\u01D4\xF9\u01D6\u01D8\u01DA\u01DC\xFC\xEA\u0251"],
+ ["a8bd", "\u0144\u0148"],
+ ["a8c0", "\u0261"],
+ ["a8c5", "\u3105", 36],
+ ["a940", "\u3021", 8, "\u32A3\u338E\u338F\u339C\u339D\u339E\u33A1\u33C4\u33CE\u33D1\u33D2\u33D5\uFE30\uFFE2\uFFE4"],
+ ["a959", "\u2121\u3231"],
+ ["a95c", "\u2010"],
+ ["a960", "\u30FC\u309B\u309C\u30FD\u30FE\u3006\u309D\u309E\uFE49", 9, "\uFE54\uFE55\uFE56\uFE57\uFE59", 8],
+ ["a980", "\uFE62", 4, "\uFE68\uFE69\uFE6A\uFE6B"],
+ ["a996", "\u3007"],
+ ["a9a4", "\u2500", 75],
+ ["aa40", "\u72DC\u72DD\u72DF\u72E2", 5, "\u72EA\u72EB\u72F5\u72F6\u72F9\u72FD\u72FE\u72FF\u7300\u7302\u7304", 5, "\u730B\u730C\u730D\u730F\u7310\u7311\u7312\u7314\u7318\u7319\u731A\u731F\u7320\u7323\u7324\u7326\u7327\u7328\u732D\u732F\u7330\u7332\u7333\u7335\u7336\u733A\u733B\u733C\u733D\u7340", 8],
+ ["aa80", "\u7349\u734A\u734B\u734C\u734E\u734F\u7351\u7353\u7354\u7355\u7356\u7358", 7, "\u7361", 10, "\u736E\u7370\u7371"],
+ ["ab40", "\u7372", 11, "\u737F", 4, "\u7385\u7386\u7388\u738A\u738C\u738D\u738F\u7390\u7392\u7393\u7394\u7395\u7397\u7398\u7399\u739A\u739C\u739D\u739E\u73A0\u73A1\u73A3", 5, "\u73AA\u73AC\u73AD\u73B1\u73B4\u73B5\u73B6\u73B8\u73B9\u73BC\u73BD\u73BE\u73BF\u73C1\u73C3", 4],
+ ["ab80", "\u73CB\u73CC\u73CE\u73D2", 6, "\u73DA\u73DB\u73DC\u73DD\u73DF\u73E1\u73E2\u73E3\u73E4\u73E6\u73E8\u73EA\u73EB\u73EC\u73EE\u73EF\u73F0\u73F1\u73F3", 4],
+ ["ac40", "\u73F8", 10, "\u7404\u7407\u7408\u740B\u740C\u740D\u740E\u7411", 8, "\u741C", 5, "\u7423\u7424\u7427\u7429\u742B\u742D\u742F\u7431\u7432\u7437", 4, "\u743D\u743E\u743F\u7440\u7442", 11],
+ ["ac80", "\u744E", 6, "\u7456\u7458\u745D\u7460", 12, "\u746E\u746F\u7471", 4, "\u7478\u7479\u747A"],
+ ["ad40", "\u747B\u747C\u747D\u747F\u7482\u7484\u7485\u7486\u7488\u7489\u748A\u748C\u748D\u748F\u7491", 10, "\u749D\u749F", 7, "\u74AA", 15, "\u74BB", 12],
+ ["ad80", "\u74C8", 9, "\u74D3", 8, "\u74DD\u74DF\u74E1\u74E5\u74E7", 6, "\u74F0\u74F1\u74F2"],
+ ["ae40", "\u74F3\u74F5\u74F8", 6, "\u7500\u7501\u7502\u7503\u7505", 7, "\u750E\u7510\u7512\u7514\u7515\u7516\u7517\u751B\u751D\u751E\u7520", 4, "\u7526\u7527\u752A\u752E\u7534\u7536\u7539\u753C\u753D\u753F\u7541\u7542\u7543\u7544\u7546\u7547\u7549\u754A\u754D\u7550\u7551\u7552\u7553\u7555\u7556\u7557\u7558"],
+ ["ae80", "\u755D", 7, "\u7567\u7568\u7569\u756B", 6, "\u7573\u7575\u7576\u7577\u757A", 4, "\u7580\u7581\u7582\u7584\u7585\u7587"],
+ ["af40", "\u7588\u7589\u758A\u758C\u758D\u758E\u7590\u7593\u7595\u7598\u759B\u759C\u759E\u75A2\u75A6", 4, "\u75AD\u75B6\u75B7\u75BA\u75BB\u75BF\u75C0\u75C1\u75C6\u75CB\u75CC\u75CE\u75CF\u75D0\u75D1\u75D3\u75D7\u75D9\u75DA\u75DC\u75DD\u75DF\u75E0\u75E1\u75E5\u75E9\u75EC\u75ED\u75EE\u75EF\u75F2\u75F3\u75F5\u75F6\u75F7\u75F8\u75FA\u75FB\u75FD\u75FE\u7602\u7604\u7606\u7607"],
+ ["af80", "\u7608\u7609\u760B\u760D\u760E\u760F\u7611\u7612\u7613\u7614\u7616\u761A\u761C\u761D\u761E\u7621\u7623\u7627\u7628\u762C\u762E\u762F\u7631\u7632\u7636\u7637\u7639\u763A\u763B\u763D\u7641\u7642\u7644"],
+ ["b040", "\u7645", 6, "\u764E", 5, "\u7655\u7657", 4, "\u765D\u765F\u7660\u7661\u7662\u7664", 6, "\u766C\u766D\u766E\u7670", 7, "\u7679\u767A\u767C\u767F\u7680\u7681\u7683\u7685\u7689\u768A\u768C\u768D\u768F\u7690\u7692\u7694\u7695\u7697\u7698\u769A\u769B"],
+ ["b080", "\u769C", 7, "\u76A5", 8, "\u76AF\u76B0\u76B3\u76B5", 9, "\u76C0\u76C1\u76C3\u554A\u963F\u57C3\u6328\u54CE\u5509\u54C0\u7691\u764C\u853C\u77EE\u827E\u788D\u7231\u9698\u978D\u6C28\u5B89\u4FFA\u6309\u6697\u5CB8\u80FA\u6848\u80AE\u6602\u76CE\u51F9\u6556\u71AC\u7FF1\u8884\u50B2\u5965\u61CA\u6FB3\u82AD\u634C\u6252\u53ED\u5427\u7B06\u516B\u75A4\u5DF4\u62D4\u8DCB\u9776\u628A\u8019\u575D\u9738\u7F62\u7238\u767D\u67CF\u767E\u6446\u4F70\u8D25\u62DC\u7A17\u6591\u73ED\u642C\u6273\u822C\u9881\u677F\u7248\u626E\u62CC\u4F34\u74E3\u534A\u529E\u7ECA\u90A6\u5E2E\u6886\u699C\u8180\u7ED1\u68D2\u78C5\u868C\u9551\u508D\u8C24\u82DE\u80DE\u5305\u8912\u5265"],
+ ["b140", "\u76C4\u76C7\u76C9\u76CB\u76CC\u76D3\u76D5\u76D9\u76DA\u76DC\u76DD\u76DE\u76E0", 4, "\u76E6", 7, "\u76F0\u76F3\u76F5\u76F6\u76F7\u76FA\u76FB\u76FD\u76FF\u7700\u7702\u7703\u7705\u7706\u770A\u770C\u770E", 10, "\u771B\u771C\u771D\u771E\u7721\u7723\u7724\u7725\u7727\u772A\u772B"],
+ ["b180", "\u772C\u772E\u7730", 4, "\u7739\u773B\u773D\u773E\u773F\u7742\u7744\u7745\u7746\u7748", 7, "\u7752", 7, "\u775C\u8584\u96F9\u4FDD\u5821\u9971\u5B9D\u62B1\u62A5\u66B4\u8C79\u9C8D\u7206\u676F\u7891\u60B2\u5351\u5317\u8F88\u80CC\u8D1D\u94A1\u500D\u72C8\u5907\u60EB\u7119\u88AB\u5954\u82EF\u672C\u7B28\u5D29\u7EF7\u752D\u6CF5\u8E66\u8FF8\u903C\u9F3B\u6BD4\u9119\u7B14\u5F7C\u78A7\u84D6\u853D\u6BD5\u6BD9\u6BD6\u5E01\u5E87\u75F9\u95ED\u655D\u5F0A\u5FC5\u8F9F\u58C1\u81C2\u907F\u965B\u97AD\u8FB9\u7F16\u8D2C\u6241\u4FBF\u53D8\u535E\u8FA8\u8FA9\u8FAB\u904D\u6807\u5F6A\u8198\u8868\u9CD6\u618B\u522B\u762A\u5F6C\u658C\u6FD2\u6EE8\u5BBE\u6448\u5175\u51B0\u67C4\u4E19\u79C9\u997C\u70B3"],
+ ["b240", "\u775D\u775E\u775F\u7760\u7764\u7767\u7769\u776A\u776D", 11, "\u777A\u777B\u777C\u7781\u7782\u7783\u7786", 5, "\u778F\u7790\u7793", 11, "\u77A1\u77A3\u77A4\u77A6\u77A8\u77AB\u77AD\u77AE\u77AF\u77B1\u77B2\u77B4\u77B6", 4],
+ ["b280", "\u77BC\u77BE\u77C0", 12, "\u77CE", 8, "\u77D8\u77D9\u77DA\u77DD", 4, "\u77E4\u75C5\u5E76\u73BB\u83E0\u64AD\u62E8\u94B5\u6CE2\u535A\u52C3\u640F\u94C2\u7B94\u4F2F\u5E1B\u8236\u8116\u818A\u6E24\u6CCA\u9A73\u6355\u535C\u54FA\u8865\u57E0\u4E0D\u5E03\u6B65\u7C3F\u90E8\u6016\u64E6\u731C\u88C1\u6750\u624D\u8D22\u776C\u8E29\u91C7\u5F69\u83DC\u8521\u9910\u53C2\u8695\u6B8B\u60ED\u60E8\u707F\u82CD\u8231\u4ED3\u6CA7\u85CF\u64CD\u7CD9\u69FD\u66F9\u8349\u5395\u7B56\u4FA7\u518C\u6D4B\u5C42\u8E6D\u63D2\u53C9\u832C\u8336\u67E5\u78B4\u643D\u5BDF\u5C94\u5DEE\u8BE7\u62C6\u67F4\u8C7A\u6400\u63BA\u8749\u998B\u8C17\u7F20\u94F2\u4EA7\u9610\u98A4\u660C\u7316"],
+ ["b340", "\u77E6\u77E8\u77EA\u77EF\u77F0\u77F1\u77F2\u77F4\u77F5\u77F7\u77F9\u77FA\u77FB\u77FC\u7803", 5, "\u780A\u780B\u780E\u780F\u7810\u7813\u7815\u7819\u781B\u781E\u7820\u7821\u7822\u7824\u7828\u782A\u782B\u782E\u782F\u7831\u7832\u7833\u7835\u7836\u783D\u783F\u7841\u7842\u7843\u7844\u7846\u7848\u7849\u784A\u784B\u784D\u784F\u7851\u7853\u7854\u7858\u7859\u785A"],
+ ["b380", "\u785B\u785C\u785E", 11, "\u786F", 7, "\u7878\u7879\u787A\u787B\u787D", 6, "\u573A\u5C1D\u5E38\u957F\u507F\u80A0\u5382\u655E\u7545\u5531\u5021\u8D85\u6284\u949E\u671D\u5632\u6F6E\u5DE2\u5435\u7092\u8F66\u626F\u64A4\u63A3\u5F7B\u6F88\u90F4\u81E3\u8FB0\u5C18\u6668\u5FF1\u6C89\u9648\u8D81\u886C\u6491\u79F0\u57CE\u6A59\u6210\u5448\u4E58\u7A0B\u60E9\u6F84\u8BDA\u627F\u901E\u9A8B\u79E4\u5403\u75F4\u6301\u5319\u6C60\u8FDF\u5F1B\u9A70\u803B\u9F7F\u4F88\u5C3A\u8D64\u7FC5\u65A5\u70BD\u5145\u51B2\u866B\u5D07\u5BA0\u62BD\u916C\u7574\u8E0C\u7A20\u6101\u7B79\u4EC7\u7EF8\u7785\u4E11\u81ED\u521D\u51FA\u6A71\u53A8\u8E87\u9504\u96CF\u6EC1\u9664\u695A"],
+ ["b440", "\u7884\u7885\u7886\u7888\u788A\u788B\u788F\u7890\u7892\u7894\u7895\u7896\u7899\u789D\u789E\u78A0\u78A2\u78A4\u78A6\u78A8", 7, "\u78B5\u78B6\u78B7\u78B8\u78BA\u78BB\u78BC\u78BD\u78BF\u78C0\u78C2\u78C3\u78C4\u78C6\u78C7\u78C8\u78CC\u78CD\u78CE\u78CF\u78D1\u78D2\u78D3\u78D6\u78D7\u78D8\u78DA", 9],
+ ["b480", "\u78E4\u78E5\u78E6\u78E7\u78E9\u78EA\u78EB\u78ED", 4, "\u78F3\u78F5\u78F6\u78F8\u78F9\u78FB", 5, "\u7902\u7903\u7904\u7906", 6, "\u7840\u50A8\u77D7\u6410\u89E6\u5904\u63E3\u5DDD\u7A7F\u693D\u4F20\u8239\u5598\u4E32\u75AE\u7A97\u5E62\u5E8A\u95EF\u521B\u5439\u708A\u6376\u9524\u5782\u6625\u693F\u9187\u5507\u6DF3\u7EAF\u8822\u6233\u7EF0\u75B5\u8328\u78C1\u96CC\u8F9E\u6148\u74F7\u8BCD\u6B64\u523A\u8D50\u6B21\u806A\u8471\u56F1\u5306\u4ECE\u4E1B\u51D1\u7C97\u918B\u7C07\u4FC3\u8E7F\u7BE1\u7A9C\u6467\u5D14\u50AC\u8106\u7601\u7CB9\u6DEC\u7FE0\u6751\u5B58\u5BF8\u78CB\u64AE\u6413\u63AA\u632B\u9519\u642D\u8FBE\u7B54\u7629\u6253\u5927\u5446\u6B79\u50A3\u6234\u5E26\u6B86\u4EE3\u8D37\u888B\u5F85\u902E"],
+ ["b540", "\u790D", 5, "\u7914", 9, "\u791F", 4, "\u7925", 14, "\u7935", 4, "\u793D\u793F\u7942\u7943\u7944\u7945\u7947\u794A", 8, "\u7954\u7955\u7958\u7959\u7961\u7963"],
+ ["b580", "\u7964\u7966\u7969\u796A\u796B\u796C\u796E\u7970", 6, "\u7979\u797B", 4, "\u7982\u7983\u7986\u7987\u7988\u7989\u798B\u798C\u798D\u798E\u7990\u7991\u7992\u6020\u803D\u62C5\u4E39\u5355\u90F8\u63B8\u80C6\u65E6\u6C2E\u4F46\u60EE\u6DE1\u8BDE\u5F39\u86CB\u5F53\u6321\u515A\u8361\u6863\u5200\u6363\u8E48\u5012\u5C9B\u7977\u5BFC\u5230\u7A3B\u60BC\u9053\u76D7\u5FB7\u5F97\u7684\u8E6C\u706F\u767B\u7B49\u77AA\u51F3\u9093\u5824\u4F4E\u6EF4\u8FEA\u654C\u7B1B\u72C4\u6DA4\u7FDF\u5AE1\u62B5\u5E95\u5730\u8482\u7B2C\u5E1D\u5F1F\u9012\u7F14\u98A0\u6382\u6EC7\u7898\u70B9\u5178\u975B\u57AB\u7535\u4F43\u7538\u5E97\u60E6\u5960\u6DC0\u6BBF\u7889\u53FC\u96D5\u51CB\u5201\u6389\u540A\u9493\u8C03\u8DCC\u7239\u789F\u8776\u8FED\u8C0D\u53E0"],
+ ["b640", "\u7993", 6, "\u799B", 11, "\u79A8", 10, "\u79B4", 4, "\u79BC\u79BF\u79C2\u79C4\u79C5\u79C7\u79C8\u79CA\u79CC\u79CE\u79CF\u79D0\u79D3\u79D4\u79D6\u79D7\u79D9", 5, "\u79E0\u79E1\u79E2\u79E5\u79E8\u79EA"],
+ ["b680", "\u79EC\u79EE\u79F1", 6, "\u79F9\u79FA\u79FC\u79FE\u79FF\u7A01\u7A04\u7A05\u7A07\u7A08\u7A09\u7A0A\u7A0C\u7A0F", 4, "\u7A15\u7A16\u7A18\u7A19\u7A1B\u7A1C\u4E01\u76EF\u53EE\u9489\u9876\u9F0E\u952D\u5B9A\u8BA2\u4E22\u4E1C\u51AC\u8463\u61C2\u52A8\u680B\u4F97\u606B\u51BB\u6D1E\u515C\u6296\u6597\u9661\u8C46\u9017\u75D8\u90FD\u7763\u6BD2\u728A\u72EC\u8BFB\u5835\u7779\u8D4C\u675C\u9540\u809A\u5EA6\u6E21\u5992\u7AEF\u77ED\u953B\u6BB5\u65AD\u7F0E\u5806\u5151\u961F\u5BF9\u58A9\u5428\u8E72\u6566\u987F\u56E4\u949D\u76FE\u9041\u6387\u54C6\u591A\u593A\u579B\u8EB2\u6735\u8DFA\u8235\u5241\u60F0\u5815\u86FE\u5CE8\u9E45\u4FC4\u989D\u8BB9\u5A25\u6076\u5384\u627C\u904F\u9102\u997F\u6069\u800C\u513F\u8033\u5C14\u9975\u6D31\u4E8C"],
+ ["b740", "\u7A1D\u7A1F\u7A21\u7A22\u7A24", 14, "\u7A34\u7A35\u7A36\u7A38\u7A3A\u7A3E\u7A40", 5, "\u7A47", 9, "\u7A52", 4, "\u7A58", 16],
+ ["b780", "\u7A69", 6, "\u7A71\u7A72\u7A73\u7A75\u7A7B\u7A7C\u7A7D\u7A7E\u7A82\u7A85\u7A87\u7A89\u7A8A\u7A8B\u7A8C\u7A8E\u7A8F\u7A90\u7A93\u7A94\u7A99\u7A9A\u7A9B\u7A9E\u7AA1\u7AA2\u8D30\u53D1\u7F5A\u7B4F\u4F10\u4E4F\u9600\u6CD5\u73D0\u85E9\u5E06\u756A\u7FFB\u6A0A\u77FE\u9492\u7E41\u51E1\u70E6\u53CD\u8FD4\u8303\u8D29\u72AF\u996D\u6CDB\u574A\u82B3\u65B9\u80AA\u623F\u9632\u59A8\u4EFF\u8BBF\u7EBA\u653E\u83F2\u975E\u5561\u98DE\u80A5\u532A\u8BFD\u5420\u80BA\u5E9F\u6CB8\u8D39\u82AC\u915A\u5429\u6C1B\u5206\u7EB7\u575F\u711A\u6C7E\u7C89\u594B\u4EFD\u5FFF\u6124\u7CAA\u4E30\u5C01\u67AB\u8702\u5CF0\u950B\u98CE\u75AF\u70FD\u9022\u51AF\u7F1D\u8BBD\u5949\u51E4\u4F5B\u5426\u592B\u6577\u80A4\u5B75\u6276\u62C2\u8F90\u5E45\u6C1F\u7B26\u4F0F\u4FD8\u670D"],
+ ["b840", "\u7AA3\u7AA4\u7AA7\u7AA9\u7AAA\u7AAB\u7AAE", 4, "\u7AB4", 10, "\u7AC0", 10, "\u7ACC", 9, "\u7AD7\u7AD8\u7ADA\u7ADB\u7ADC\u7ADD\u7AE1\u7AE2\u7AE4\u7AE7", 5, "\u7AEE\u7AF0\u7AF1\u7AF2\u7AF3"],
+ ["b880", "\u7AF4", 4, "\u7AFB\u7AFC\u7AFE\u7B00\u7B01\u7B02\u7B05\u7B07\u7B09\u7B0C\u7B0D\u7B0E\u7B10\u7B12\u7B13\u7B16\u7B17\u7B18\u7B1A\u7B1C\u7B1D\u7B1F\u7B21\u7B22\u7B23\u7B27\u7B29\u7B2D\u6D6E\u6DAA\u798F\u88B1\u5F17\u752B\u629A\u8F85\u4FEF\u91DC\u65A7\u812F\u8151\u5E9C\u8150\u8D74\u526F\u8986\u8D4B\u590D\u5085\u4ED8\u961C\u7236\u8179\u8D1F\u5BCC\u8BA3\u9644\u5987\u7F1A\u5490\u5676\u560E\u8BE5\u6539\u6982\u9499\u76D6\u6E89\u5E72\u7518\u6746\u67D1\u7AFF\u809D\u8D76\u611F\u79C6\u6562\u8D63\u5188\u521A\u94A2\u7F38\u809B\u7EB2\u5C97\u6E2F\u6760\u7BD9\u768B\u9AD8\u818F\u7F94\u7CD5\u641E\u9550\u7A3F\u544A\u54E5\u6B4C\u6401\u6208\u9E3D\u80F3\u7599\u5272\u9769\u845B\u683C\u86E4\u9601\u9694\u94EC\u4E2A\u5404\u7ED9\u6839\u8DDF\u8015\u66F4\u5E9A\u7FB9"],
+ ["b940", "\u7B2F\u7B30\u7B32\u7B34\u7B35\u7B36\u7B37\u7B39\u7B3B\u7B3D\u7B3F", 5, "\u7B46\u7B48\u7B4A\u7B4D\u7B4E\u7B53\u7B55\u7B57\u7B59\u7B5C\u7B5E\u7B5F\u7B61\u7B63", 10, "\u7B6F\u7B70\u7B73\u7B74\u7B76\u7B78\u7B7A\u7B7C\u7B7D\u7B7F\u7B81\u7B82\u7B83\u7B84\u7B86", 6, "\u7B8E\u7B8F"],
+ ["b980", "\u7B91\u7B92\u7B93\u7B96\u7B98\u7B99\u7B9A\u7B9B\u7B9E\u7B9F\u7BA0\u7BA3\u7BA4\u7BA5\u7BAE\u7BAF\u7BB0\u7BB2\u7BB3\u7BB5\u7BB6\u7BB7\u7BB9", 7, "\u7BC2\u7BC3\u7BC4\u57C2\u803F\u6897\u5DE5\u653B\u529F\u606D\u9F9A\u4F9B\u8EAC\u516C\u5BAB\u5F13\u5DE9\u6C5E\u62F1\u8D21\u5171\u94A9\u52FE\u6C9F\u82DF\u72D7\u57A2\u6784\u8D2D\u591F\u8F9C\u83C7\u5495\u7B8D\u4F30\u6CBD\u5B64\u59D1\u9F13\u53E4\u86CA\u9AA8\u8C37\u80A1\u6545\u987E\u56FA\u96C7\u522E\u74DC\u5250\u5BE1\u6302\u8902\u4E56\u62D0\u602A\u68FA\u5173\u5B98\u51A0\u89C2\u7BA1\u9986\u7F50\u60EF\u704C\u8D2F\u5149\u5E7F\u901B\u7470\u89C4\u572D\u7845\u5F52\u9F9F\u95FA\u8F68\u9B3C\u8BE1\u7678\u6842\u67DC\u8DEA\u8D35\u523D\u8F8A\u6EDA\u68CD\u9505\u90ED\u56FD\u679C\u88F9\u8FC7\u54C8"],
+ ["ba40", "\u7BC5\u7BC8\u7BC9\u7BCA\u7BCB\u7BCD\u7BCE\u7BCF\u7BD0\u7BD2\u7BD4", 4, "\u7BDB\u7BDC\u7BDE\u7BDF\u7BE0\u7BE2\u7BE3\u7BE4\u7BE7\u7BE8\u7BE9\u7BEB\u7BEC\u7BED\u7BEF\u7BF0\u7BF2", 4, "\u7BF8\u7BF9\u7BFA\u7BFB\u7BFD\u7BFF", 7, "\u7C08\u7C09\u7C0A\u7C0D\u7C0E\u7C10", 5, "\u7C17\u7C18\u7C19"],
+ ["ba80", "\u7C1A", 4, "\u7C20", 5, "\u7C28\u7C29\u7C2B", 12, "\u7C39", 5, "\u7C42\u9AB8\u5B69\u6D77\u6C26\u4EA5\u5BB3\u9A87\u9163\u61A8\u90AF\u97E9\u542B\u6DB5\u5BD2\u51FD\u558A\u7F55\u7FF0\u64BC\u634D\u65F1\u61BE\u608D\u710A\u6C57\u6C49\u592F\u676D\u822A\u58D5\u568E\u8C6A\u6BEB\u90DD\u597D\u8017\u53F7\u6D69\u5475\u559D\u8377\u83CF\u6838\u79BE\u548C\u4F55\u5408\u76D2\u8C89\u9602\u6CB3\u6DB8\u8D6B\u8910\u9E64\u8D3A\u563F\u9ED1\u75D5\u5F88\u72E0\u6068\u54FC\u4EA8\u6A2A\u8861\u6052\u8F70\u54C4\u70D8\u8679\u9E3F\u6D2A\u5B8F\u5F18\u7EA2\u5589\u4FAF\u7334\u543C\u539A\u5019\u540E\u547C\u4E4E\u5FFD\u745A\u58F6\u846B\u80E1\u8774\u72D0\u7CCA\u6E56"],
+ ["bb40", "\u7C43", 9, "\u7C4E", 36, "\u7C75", 5, "\u7C7E", 9],
+ ["bb80", "\u7C88\u7C8A", 6, "\u7C93\u7C94\u7C96\u7C99\u7C9A\u7C9B\u7CA0\u7CA1\u7CA3\u7CA6\u7CA7\u7CA8\u7CA9\u7CAB\u7CAC\u7CAD\u7CAF\u7CB0\u7CB4", 4, "\u7CBA\u7CBB\u5F27\u864E\u552C\u62A4\u4E92\u6CAA\u6237\u82B1\u54D7\u534E\u733E\u6ED1\u753B\u5212\u5316\u8BDD\u69D0\u5F8A\u6000\u6DEE\u574F\u6B22\u73AF\u6853\u8FD8\u7F13\u6362\u60A3\u5524\u75EA\u8C62\u7115\u6DA3\u5BA6\u5E7B\u8352\u614C\u9EC4\u78FA\u8757\u7C27\u7687\u51F0\u60F6\u714C\u6643\u5E4C\u604D\u8C0E\u7070\u6325\u8F89\u5FBD\u6062\u86D4\u56DE\u6BC1\u6094\u6167\u5349\u60E0\u6666\u8D3F\u79FD\u4F1A\u70E9\u6C47\u8BB3\u8BF2\u7ED8\u8364\u660F\u5A5A\u9B42\u6D51\u6DF7\u8C41\u6D3B\u4F19\u706B\u83B7\u6216\u60D1\u970D\u8D27\u7978\u51FB\u573E\u57FA\u673A\u7578\u7A3D\u79EF\u7B95"],
+ ["bc40", "\u7CBF\u7CC0\u7CC2\u7CC3\u7CC4\u7CC6\u7CC9\u7CCB\u7CCE", 6, "\u7CD8\u7CDA\u7CDB\u7CDD\u7CDE\u7CE1", 6, "\u7CE9", 5, "\u7CF0", 7, "\u7CF9\u7CFA\u7CFC", 13, "\u7D0B", 5],
+ ["bc80", "\u7D11", 14, "\u7D21\u7D23\u7D24\u7D25\u7D26\u7D28\u7D29\u7D2A\u7D2C\u7D2D\u7D2E\u7D30", 6, "\u808C\u9965\u8FF9\u6FC0\u8BA5\u9E21\u59EC\u7EE9\u7F09\u5409\u6781\u68D8\u8F91\u7C4D\u96C6\u53CA\u6025\u75BE\u6C72\u5373\u5AC9\u7EA7\u6324\u51E0\u810A\u5DF1\u84DF\u6280\u5180\u5B63\u4F0E\u796D\u5242\u60B8\u6D4E\u5BC4\u5BC2\u8BA1\u8BB0\u65E2\u5FCC\u9645\u5993\u7EE7\u7EAA\u5609\u67B7\u5939\u4F73\u5BB6\u52A0\u835A\u988A\u8D3E\u7532\u94BE\u5047\u7A3C\u4EF7\u67B6\u9A7E\u5AC1\u6B7C\u76D1\u575A\u5C16\u7B3A\u95F4\u714E\u517C\u80A9\u8270\u5978\u7F04\u8327\u68C0\u67EC\u78B1\u7877\u62E3\u6361\u7B80\u4FED\u526A\u51CF\u8350\u69DB\u9274\u8DF5\u8D31\u89C1\u952E\u7BAD\u4EF6"],
+ ["bd40", "\u7D37", 54, "\u7D6F", 7],
+ ["bd80", "\u7D78", 32, "\u5065\u8230\u5251\u996F\u6E10\u6E85\u6DA7\u5EFA\u50F5\u59DC\u5C06\u6D46\u6C5F\u7586\u848B\u6868\u5956\u8BB2\u5320\u9171\u964D\u8549\u6912\u7901\u7126\u80F6\u4EA4\u90CA\u6D47\u9A84\u5A07\u56BC\u6405\u94F0\u77EB\u4FA5\u811A\u72E1\u89D2\u997A\u7F34\u7EDE\u527F\u6559\u9175\u8F7F\u8F83\u53EB\u7A96\u63ED\u63A5\u7686\u79F8\u8857\u9636\u622A\u52AB\u8282\u6854\u6770\u6377\u776B\u7AED\u6D01\u7ED3\u89E3\u59D0\u6212\u85C9\u82A5\u754C\u501F\u4ECB\u75A5\u8BEB\u5C4A\u5DFE\u7B4B\u65A4\u91D1\u4ECA\u6D25\u895F\u7D27\u9526\u4EC5\u8C28\u8FDB\u9773\u664B\u7981\u8FD1\u70EC\u6D78"],
+ ["be40", "\u7D99", 12, "\u7DA7", 6, "\u7DAF", 42],
+ ["be80", "\u7DDA", 32, "\u5C3D\u52B2\u8346\u5162\u830E\u775B\u6676\u9CB8\u4EAC\u60CA\u7CBE\u7CB3\u7ECF\u4E95\u8B66\u666F\u9888\u9759\u5883\u656C\u955C\u5F84\u75C9\u9756\u7ADF\u7ADE\u51C0\u70AF\u7A98\u63EA\u7A76\u7EA0\u7396\u97ED\u4E45\u7078\u4E5D\u9152\u53A9\u6551\u65E7\u81FC\u8205\u548E\u5C31\u759A\u97A0\u62D8\u72D9\u75BD\u5C45\u9A79\u83CA\u5C40\u5480\u77E9\u4E3E\u6CAE\u805A\u62D2\u636E\u5DE8\u5177\u8DDD\u8E1E\u952F\u4FF1\u53E5\u60E7\u70AC\u5267\u6350\u9E43\u5A1F\u5026\u7737\u5377\u7EE2\u6485\u652B\u6289\u6398\u5014\u7235\u89C9\u51B3\u8BC0\u7EDD\u5747\u83CC\u94A7\u519B\u541B\u5CFB"],
+ ["bf40", "\u7DFB", 62],
+ ["bf80", "\u7E3A\u7E3C", 4, "\u7E42", 4, "\u7E48", 21, "\u4FCA\u7AE3\u6D5A\u90E1\u9A8F\u5580\u5496\u5361\u54AF\u5F00\u63E9\u6977\u51EF\u6168\u520A\u582A\u52D8\u574E\u780D\u770B\u5EB7\u6177\u7CE0\u625B\u6297\u4EA2\u7095\u8003\u62F7\u70E4\u9760\u5777\u82DB\u67EF\u68F5\u78D5\u9897\u79D1\u58F3\u54B3\u53EF\u6E34\u514B\u523B\u5BA2\u8BFE\u80AF\u5543\u57A6\u6073\u5751\u542D\u7A7A\u6050\u5B54\u63A7\u62A0\u53E3\u6263\u5BC7\u67AF\u54ED\u7A9F\u82E6\u9177\u5E93\u88E4\u5938\u57AE\u630E\u8DE8\u80EF\u5757\u7B77\u4FA9\u5FEB\u5BBD\u6B3E\u5321\u7B50\u72C2\u6846\u77FF\u7736\u65F7\u51B5\u4E8F\u76D4\u5CBF\u7AA5\u8475\u594E\u9B41\u5080"],
+ ["c040", "\u7E5E", 35, "\u7E83", 23, "\u7E9C\u7E9D\u7E9E"],
+ ["c080", "\u7EAE\u7EB4\u7EBB\u7EBC\u7ED6\u7EE4\u7EEC\u7EF9\u7F0A\u7F10\u7F1E\u7F37\u7F39\u7F3B", 6, "\u7F43\u7F46", 9, "\u7F52\u7F53\u9988\u6127\u6E83\u5764\u6606\u6346\u56F0\u62EC\u6269\u5ED3\u9614\u5783\u62C9\u5587\u8721\u814A\u8FA3\u5566\u83B1\u6765\u8D56\u84DD\u5A6A\u680F\u62E6\u7BEE\u9611\u5170\u6F9C\u8C30\u63FD\u89C8\u61D2\u7F06\u70C2\u6EE5\u7405\u6994\u72FC\u5ECA\u90CE\u6717\u6D6A\u635E\u52B3\u7262\u8001\u4F6C\u59E5\u916A\u70D9\u6D9D\u52D2\u4E50\u96F7\u956D\u857E\u78CA\u7D2F\u5121\u5792\u64C2\u808B\u7C7B\u6CEA\u68F1\u695E\u51B7\u5398\u68A8\u7281\u9ECE\u7BF1\u72F8\u79BB\u6F13\u7406\u674E\u91CC\u9CA4\u793C\u8389\u8354\u540F\u6817\u4E3D\u5389\u52B1\u783E\u5386\u5229\u5088\u4F8B\u4FD0"],
+ ["c140", "\u7F56\u7F59\u7F5B\u7F5C\u7F5D\u7F5E\u7F60\u7F63", 4, "\u7F6B\u7F6C\u7F6D\u7F6F\u7F70\u7F73\u7F75\u7F76\u7F77\u7F78\u7F7A\u7F7B\u7F7C\u7F7D\u7F7F\u7F80\u7F82", 7, "\u7F8B\u7F8D\u7F8F", 4, "\u7F95", 4, "\u7F9B\u7F9C\u7FA0\u7FA2\u7FA3\u7FA5\u7FA6\u7FA8", 6, "\u7FB1"],
+ ["c180", "\u7FB3", 4, "\u7FBA\u7FBB\u7FBE\u7FC0\u7FC2\u7FC3\u7FC4\u7FC6\u7FC7\u7FC8\u7FC9\u7FCB\u7FCD\u7FCF", 4, "\u7FD6\u7FD7\u7FD9", 5, "\u7FE2\u7FE3\u75E2\u7ACB\u7C92\u6CA5\u96B6\u529B\u7483\u54E9\u4FE9\u8054\u83B2\u8FDE\u9570\u5EC9\u601C\u6D9F\u5E18\u655B\u8138\u94FE\u604B\u70BC\u7EC3\u7CAE\u51C9\u6881\u7CB1\u826F\u4E24\u8F86\u91CF\u667E\u4EAE\u8C05\u64A9\u804A\u50DA\u7597\u71CE\u5BE5\u8FBD\u6F66\u4E86\u6482\u9563\u5ED6\u6599\u5217\u88C2\u70C8\u52A3\u730E\u7433\u6797\u78F7\u9716\u4E34\u90BB\u9CDE\u6DCB\u51DB\u8D41\u541D\u62CE\u73B2\u83F1\u96F6\u9F84\u94C3\u4F36\u7F9A\u51CC\u7075\u9675\u5CAD\u9886\u53E6\u4EE4\u6E9C\u7409\u69B4\u786B\u998F\u7559\u5218\u7624\u6D41\u67F3\u516D\u9F99\u804B\u5499\u7B3C\u7ABF"],
+ ["c240", "\u7FE4\u7FE7\u7FE8\u7FEA\u7FEB\u7FEC\u7FED\u7FEF\u7FF2\u7FF4", 6, "\u7FFD\u7FFE\u7FFF\u8002\u8007\u8008\u8009\u800A\u800E\u800F\u8011\u8013\u801A\u801B\u801D\u801E\u801F\u8021\u8023\u8024\u802B", 5, "\u8032\u8034\u8039\u803A\u803C\u803E\u8040\u8041\u8044\u8045\u8047\u8048\u8049\u804E\u804F\u8050\u8051\u8053\u8055\u8056\u8057"],
+ ["c280", "\u8059\u805B", 13, "\u806B", 5, "\u8072", 11, "\u9686\u5784\u62E2\u9647\u697C\u5A04\u6402\u7BD3\u6F0F\u964B\u82A6\u5362\u9885\u5E90\u7089\u63B3\u5364\u864F\u9C81\u9E93\u788C\u9732\u8DEF\u8D42\u9E7F\u6F5E\u7984\u5F55\u9646\u622E\u9A74\u5415\u94DD\u4FA3\u65C5\u5C65\u5C61\u7F15\u8651\u6C2F\u5F8B\u7387\u6EE4\u7EFF\u5CE6\u631B\u5B6A\u6EE6\u5375\u4E71\u63A0\u7565\u62A1\u8F6E\u4F26\u4ED1\u6CA6\u7EB6\u8BBA\u841D\u87BA\u7F57\u903B\u9523\u7BA9\u9AA1\u88F8\u843D\u6D1B\u9A86\u7EDC\u5988\u9EBB\u739B\u7801\u8682\u9A6C\u9A82\u561B\u5417\u57CB\u4E70\u9EA6\u5356\u8FC8\u8109\u7792\u9992\u86EE\u6EE1\u8513\u66FC\u6162\u6F2B"],
+ ["c340", "\u807E\u8081\u8082\u8085\u8088\u808A\u808D", 5, "\u8094\u8095\u8097\u8099\u809E\u80A3\u80A6\u80A7\u80A8\u80AC\u80B0\u80B3\u80B5\u80B6\u80B8\u80B9\u80BB\u80C5\u80C7", 4, "\u80CF", 6, "\u80D8\u80DF\u80E0\u80E2\u80E3\u80E6\u80EE\u80F5\u80F7\u80F9\u80FB\u80FE\u80FF\u8100\u8101\u8103\u8104\u8105\u8107\u8108\u810B"],
+ ["c380", "\u810C\u8115\u8117\u8119\u811B\u811C\u811D\u811F", 12, "\u812D\u812E\u8130\u8133\u8134\u8135\u8137\u8139", 4, "\u813F\u8C29\u8292\u832B\u76F2\u6C13\u5FD9\u83BD\u732B\u8305\u951A\u6BDB\u77DB\u94C6\u536F\u8302\u5192\u5E3D\u8C8C\u8D38\u4E48\u73AB\u679A\u6885\u9176\u9709\u7164\u6CA1\u7709\u5A92\u9541\u6BCF\u7F8E\u6627\u5BD0\u59B9\u5A9A\u95E8\u95F7\u4EEC\u840C\u8499\u6AAC\u76DF\u9530\u731B\u68A6\u5B5F\u772F\u919A\u9761\u7CDC\u8FF7\u8C1C\u5F25\u7C73\u79D8\u89C5\u6CCC\u871C\u5BC6\u5E42\u68C9\u7720\u7EF5\u5195\u514D\u52C9\u5A29\u7F05\u9762\u82D7\u63CF\u7784\u85D0\u79D2\u6E3A\u5E99\u5999\u8511\u706D\u6C11\u62BF\u76BF\u654F\u60AF\u95FD\u660E\u879F\u9E23\u94ED\u540D\u547D\u8C2C\u6478"],
+ ["c440", "\u8140", 5, "\u8147\u8149\u814D\u814E\u814F\u8152\u8156\u8157\u8158\u815B", 4, "\u8161\u8162\u8163\u8164\u8166\u8168\u816A\u816B\u816C\u816F\u8172\u8173\u8175\u8176\u8177\u8178\u8181\u8183", 4, "\u8189\u818B\u818C\u818D\u818E\u8190\u8192", 5, "\u8199\u819A\u819E", 4, "\u81A4\u81A5"],
+ ["c480", "\u81A7\u81A9\u81AB", 7, "\u81B4", 5, "\u81BC\u81BD\u81BE\u81BF\u81C4\u81C5\u81C7\u81C8\u81C9\u81CB\u81CD", 6, "\u6479\u8611\u6A21\u819C\u78E8\u6469\u9B54\u62B9\u672B\u83AB\u58A8\u9ED8\u6CAB\u6F20\u5BDE\u964C\u8C0B\u725F\u67D0\u62C7\u7261\u4EA9\u59C6\u6BCD\u5893\u66AE\u5E55\u52DF\u6155\u6728\u76EE\u7766\u7267\u7A46\u62FF\u54EA\u5450\u94A0\u90A3\u5A1C\u7EB3\u6C16\u4E43\u5976\u8010\u5948\u5357\u7537\u96BE\u56CA\u6320\u8111\u607C\u95F9\u6DD6\u5462\u9981\u5185\u5AE9\u80FD\u59AE\u9713\u502A\u6CE5\u5C3C\u62DF\u4F60\u533F\u817B\u9006\u6EBA\u852B\u62C8\u5E74\u78BE\u64B5\u637B\u5FF5\u5A18\u917F\u9E1F\u5C3F\u634F\u8042\u5B7D\u556E\u954A\u954D\u6D85\u60A8\u67E0\u72DE\u51DD\u5B81"],
+ ["c540", "\u81D4", 14, "\u81E4\u81E5\u81E6\u81E8\u81E9\u81EB\u81EE", 4, "\u81F5", 5, "\u81FD\u81FF\u8203\u8207", 4, "\u820E\u820F\u8211\u8213\u8215", 5, "\u821D\u8220\u8224\u8225\u8226\u8227\u8229\u822E\u8232\u823A\u823C\u823D\u823F"],
+ ["c580", "\u8240\u8241\u8242\u8243\u8245\u8246\u8248\u824A\u824C\u824D\u824E\u8250", 7, "\u8259\u825B\u825C\u825D\u825E\u8260", 7, "\u8269\u62E7\u6CDE\u725B\u626D\u94AE\u7EBD\u8113\u6D53\u519C\u5F04\u5974\u52AA\u6012\u5973\u6696\u8650\u759F\u632A\u61E6\u7CEF\u8BFA\u54E6\u6B27\u9E25\u6BB4\u85D5\u5455\u5076\u6CA4\u556A\u8DB4\u722C\u5E15\u6015\u7436\u62CD\u6392\u724C\u5F98\u6E43\u6D3E\u6500\u6F58\u76D8\u78D0\u76FC\u7554\u5224\u53DB\u4E53\u5E9E\u65C1\u802A\u80D6\u629B\u5486\u5228\u70AE\u888D\u8DD1\u6CE1\u5478\u80DA\u57F9\u88F4\u8D54\u966A\u914D\u4F69\u6C9B\u55B7\u76C6\u7830\u62A8\u70F9\u6F8E\u5F6D\u84EC\u68DA\u787C\u7BF7\u81A8\u670B\u9E4F\u6367\u78B0\u576F\u7812\u9739\u6279\u62AB\u5288\u7435\u6BD7"],
+ ["c640", "\u826A\u826B\u826C\u826D\u8271\u8275\u8276\u8277\u8278\u827B\u827C\u8280\u8281\u8283\u8285\u8286\u8287\u8289\u828C\u8290\u8293\u8294\u8295\u8296\u829A\u829B\u829E\u82A0\u82A2\u82A3\u82A7\u82B2\u82B5\u82B6\u82BA\u82BB\u82BC\u82BF\u82C0\u82C2\u82C3\u82C5\u82C6\u82C9\u82D0\u82D6\u82D9\u82DA\u82DD\u82E2\u82E7\u82E8\u82E9\u82EA\u82EC\u82ED\u82EE\u82F0\u82F2\u82F3\u82F5\u82F6\u82F8"],
+ ["c680", "\u82FA\u82FC", 4, "\u830A\u830B\u830D\u8310\u8312\u8313\u8316\u8318\u8319\u831D", 9, "\u8329\u832A\u832E\u8330\u8332\u8337\u833B\u833D\u5564\u813E\u75B2\u76AE\u5339\u75DE\u50FB\u5C41\u8B6C\u7BC7\u504F\u7247\u9A97\u98D8\u6F02\u74E2\u7968\u6487\u77A5\u62FC\u9891\u8D2B\u54C1\u8058\u4E52\u576A\u82F9\u840D\u5E73\u51ED\u74F6\u8BC4\u5C4F\u5761\u6CFC\u9887\u5A46\u7834\u9B44\u8FEB\u7C95\u5256\u6251\u94FA\u4EC6\u8386\u8461\u83E9\u84B2\u57D4\u6734\u5703\u666E\u6D66\u8C31\u66DD\u7011\u671F\u6B3A\u6816\u621A\u59BB\u4E03\u51C4\u6F06\u67D2\u6C8F\u5176\u68CB\u5947\u6B67\u7566\u5D0E\u8110\u9F50\u65D7\u7948\u7941\u9A91\u8D77\u5C82\u4E5E\u4F01\u542F\u5951\u780C\u5668\u6C14\u8FC4\u5F03\u6C7D\u6CE3\u8BAB\u6390"],
+ ["c740", "\u833E\u833F\u8341\u8342\u8344\u8345\u8348\u834A", 4, "\u8353\u8355", 4, "\u835D\u8362\u8370", 6, "\u8379\u837A\u837E", 6, "\u8387\u8388\u838A\u838B\u838C\u838D\u838F\u8390\u8391\u8394\u8395\u8396\u8397\u8399\u839A\u839D\u839F\u83A1", 6, "\u83AC\u83AD\u83AE"],
+ ["c780", "\u83AF\u83B5\u83BB\u83BE\u83BF\u83C2\u83C3\u83C4\u83C6\u83C8\u83C9\u83CB\u83CD\u83CE\u83D0\u83D1\u83D2\u83D3\u83D5\u83D7\u83D9\u83DA\u83DB\u83DE\u83E2\u83E3\u83E4\u83E6\u83E7\u83E8\u83EB\u83EC\u83ED\u6070\u6D3D\u7275\u6266\u948E\u94C5\u5343\u8FC1\u7B7E\u4EDF\u8C26\u4E7E\u9ED4\u94B1\u94B3\u524D\u6F5C\u9063\u6D45\u8C34\u5811\u5D4C\u6B20\u6B49\u67AA\u545B\u8154\u7F8C\u5899\u8537\u5F3A\u62A2\u6A47\u9539\u6572\u6084\u6865\u77A7\u4E54\u4FA8\u5DE7\u9798\u64AC\u7FD8\u5CED\u4FCF\u7A8D\u5207\u8304\u4E14\u602F\u7A83\u94A6\u4FB5\u4EB2\u79E6\u7434\u52E4\u82B9\u64D2\u79BD\u5BDD\u6C81\u9752\u8F7B\u6C22\u503E\u537F\u6E05\u64CE\u6674\u6C30\u60C5\u9877\u8BF7\u5E86\u743C\u7A77\u79CB\u4E18\u90B1\u7403\u6C42\u56DA\u914B\u6CC5\u8D8B\u533A\u86C6\u66F2\u8EAF\u5C48\u9A71\u6E20"],
+ ["c840", "\u83EE\u83EF\u83F3", 4, "\u83FA\u83FB\u83FC\u83FE\u83FF\u8400\u8402\u8405\u8407\u8408\u8409\u840A\u8410\u8412", 5, "\u8419\u841A\u841B\u841E", 5, "\u8429", 7, "\u8432", 5, "\u8439\u843A\u843B\u843E", 7, "\u8447\u8448\u8449"],
+ ["c880", "\u844A", 6, "\u8452", 4, "\u8458\u845D\u845E\u845F\u8460\u8462\u8464", 4, "\u846A\u846E\u846F\u8470\u8472\u8474\u8477\u8479\u847B\u847C\u53D6\u5A36\u9F8B\u8DA3\u53BB\u5708\u98A7\u6743\u919B\u6CC9\u5168\u75CA\u62F3\u72AC\u5238\u529D\u7F3A\u7094\u7638\u5374\u9E4A\u69B7\u786E\u96C0\u88D9\u7FA4\u7136\u71C3\u5189\u67D3\u74E4\u58E4\u6518\u56B7\u8BA9\u9976\u6270\u7ED5\u60F9\u70ED\u58EC\u4EC1\u4EBA\u5FCD\u97E7\u4EFB\u8BA4\u5203\u598A\u7EAB\u6254\u4ECD\u65E5\u620E\u8338\u84C9\u8363\u878D\u7194\u6EB6\u5BB9\u7ED2\u5197\u63C9\u67D4\u8089\u8339\u8815\u5112\u5B7A\u5982\u8FB1\u4E73\u6C5D\u5165\u8925\u8F6F\u962E\u854A\u745E\u9510\u95F0\u6DA6\u82E5\u5F31\u6492\u6D12\u8428\u816E\u9CC3\u585E\u8D5B\u4E09\u53C1"],
+ ["c940", "\u847D", 4, "\u8483\u8484\u8485\u8486\u848A\u848D\u848F", 7, "\u8498\u849A\u849B\u849D\u849E\u849F\u84A0\u84A2", 12, "\u84B0\u84B1\u84B3\u84B5\u84B6\u84B7\u84BB\u84BC\u84BE\u84C0\u84C2\u84C3\u84C5\u84C6\u84C7\u84C8\u84CB\u84CC\u84CE\u84CF\u84D2\u84D4\u84D5\u84D7"],
+ ["c980", "\u84D8", 4, "\u84DE\u84E1\u84E2\u84E4\u84E7", 4, "\u84ED\u84EE\u84EF\u84F1", 10, "\u84FD\u84FE\u8500\u8501\u8502\u4F1E\u6563\u6851\u55D3\u4E27\u6414\u9A9A\u626B\u5AC2\u745F\u8272\u6DA9\u68EE\u50E7\u838E\u7802\u6740\u5239\u6C99\u7EB1\u50BB\u5565\u715E\u7B5B\u6652\u73CA\u82EB\u6749\u5C71\u5220\u717D\u886B\u95EA\u9655\u64C5\u8D61\u81B3\u5584\u6C55\u6247\u7F2E\u5892\u4F24\u5546\u8D4F\u664C\u4E0A\u5C1A\u88F3\u68A2\u634E\u7A0D\u70E7\u828D\u52FA\u97F6\u5C11\u54E8\u90B5\u7ECD\u5962\u8D4A\u86C7\u820C\u820D\u8D66\u6444\u5C04\u6151\u6D89\u793E\u8BBE\u7837\u7533\u547B\u4F38\u8EAB\u6DF1\u5A20\u7EC5\u795E\u6C88\u5BA1\u5A76\u751A\u80BE\u614E\u6E17\u58F0\u751F\u7525\u7272\u5347\u7EF3"],
+ ["ca40", "\u8503", 8, "\u850D\u850E\u850F\u8510\u8512\u8514\u8515\u8516\u8518\u8519\u851B\u851C\u851D\u851E\u8520\u8522", 8, "\u852D", 9, "\u853E", 4, "\u8544\u8545\u8546\u8547\u854B", 10],
+ ["ca80", "\u8557\u8558\u855A\u855B\u855C\u855D\u855F", 4, "\u8565\u8566\u8567\u8569", 8, "\u8573\u8575\u8576\u8577\u8578\u857C\u857D\u857F\u8580\u8581\u7701\u76DB\u5269\u80DC\u5723\u5E08\u5931\u72EE\u65BD\u6E7F\u8BD7\u5C38\u8671\u5341\u77F3\u62FE\u65F6\u4EC0\u98DF\u8680\u5B9E\u8BC6\u53F2\u77E2\u4F7F\u5C4E\u9A76\u59CB\u5F0F\u793A\u58EB\u4E16\u67FF\u4E8B\u62ED\u8A93\u901D\u52BF\u662F\u55DC\u566C\u9002\u4ED5\u4F8D\u91CA\u9970\u6C0F\u5E02\u6043\u5BA4\u89C6\u8BD5\u6536\u624B\u9996\u5B88\u5BFF\u6388\u552E\u53D7\u7626\u517D\u852C\u67A2\u68B3\u6B8A\u6292\u8F93\u53D4\u8212\u6DD1\u758F\u4E66\u8D4E\u5B70\u719F\u85AF\u6691\u66D9\u7F72\u8700\u9ECD\u9F20\u5C5E\u672F\u8FF0\u6811\u675F\u620D\u7AD6\u5885\u5EB6\u6570\u6F31"],
+ ["cb40", "\u8582\u8583\u8586\u8588", 6, "\u8590", 10, "\u859D", 6, "\u85A5\u85A6\u85A7\u85A9\u85AB\u85AC\u85AD\u85B1", 5, "\u85B8\u85BA", 6, "\u85C2", 6, "\u85CA", 4, "\u85D1\u85D2"],
+ ["cb80", "\u85D4\u85D6", 5, "\u85DD", 6, "\u85E5\u85E6\u85E7\u85E8\u85EA", 14, "\u6055\u5237\u800D\u6454\u8870\u7529\u5E05\u6813\u62F4\u971C\u53CC\u723D\u8C01\u6C34\u7761\u7A0E\u542E\u77AC\u987A\u821C\u8BF4\u7855\u6714\u70C1\u65AF\u6495\u5636\u601D\u79C1\u53F8\u4E1D\u6B7B\u8086\u5BFA\u55E3\u56DB\u4F3A\u4F3C\u9972\u5DF3\u677E\u8038\u6002\u9882\u9001\u5B8B\u8BBC\u8BF5\u641C\u8258\u64DE\u55FD\u82CF\u9165\u4FD7\u7D20\u901F\u7C9F\u50F3\u5851\u6EAF\u5BBF\u8BC9\u8083\u9178\u849C\u7B97\u867D\u968B\u968F\u7EE5\u9AD3\u788E\u5C81\u7A57\u9042\u96A7\u795F\u5B59\u635F\u7B0B\u84D1\u68AD\u5506\u7F29\u7410\u7D22\u9501\u6240\u584C\u4ED6\u5B83\u5979\u5854"],
+ ["cc40", "\u85F9\u85FA\u85FC\u85FD\u85FE\u8600", 4, "\u8606", 10, "\u8612\u8613\u8614\u8615\u8617", 15, "\u8628\u862A", 13, "\u8639\u863A\u863B\u863D\u863E\u863F\u8640"],
+ ["cc80", "\u8641", 11, "\u8652\u8653\u8655", 4, "\u865B\u865C\u865D\u865F\u8660\u8661\u8663", 7, "\u736D\u631E\u8E4B\u8E0F\u80CE\u82D4\u62AC\u53F0\u6CF0\u915E\u592A\u6001\u6C70\u574D\u644A\u8D2A\u762B\u6EE9\u575B\u6A80\u75F0\u6F6D\u8C2D\u8C08\u5766\u6BEF\u8892\u78B3\u63A2\u53F9\u70AD\u6C64\u5858\u642A\u5802\u68E0\u819B\u5510\u7CD6\u5018\u8EBA\u6DCC\u8D9F\u70EB\u638F\u6D9B\u6ED4\u7EE6\u8404\u6843\u9003\u6DD8\u9676\u8BA8\u5957\u7279\u85E4\u817E\u75BC\u8A8A\u68AF\u5254\u8E22\u9511\u63D0\u9898\u8E44\u557C\u4F53\u66FF\u568F\u60D5\u6D95\u5243\u5C49\u5929\u6DFB\u586B\u7530\u751C\u606C\u8214\u8146\u6311\u6761\u8FE2\u773A\u8DF3\u8D34\u94C1\u5E16\u5385\u542C\u70C3"],
+ ["cd40", "\u866D\u866F\u8670\u8672", 6, "\u8683", 6, "\u868E", 4, "\u8694\u8696", 5, "\u869E", 4, "\u86A5\u86A6\u86AB\u86AD\u86AE\u86B2\u86B3\u86B7\u86B8\u86B9\u86BB", 4, "\u86C1\u86C2\u86C3\u86C5\u86C8\u86CC\u86CD\u86D2\u86D3\u86D5\u86D6\u86D7\u86DA\u86DC"],
+ ["cd80", "\u86DD\u86E0\u86E1\u86E2\u86E3\u86E5\u86E6\u86E7\u86E8\u86EA\u86EB\u86EC\u86EF\u86F5\u86F6\u86F7\u86FA\u86FB\u86FC\u86FD\u86FF\u8701\u8704\u8705\u8706\u870B\u870C\u870E\u870F\u8710\u8711\u8714\u8716\u6C40\u5EF7\u505C\u4EAD\u5EAD\u633A\u8247\u901A\u6850\u916E\u77B3\u540C\u94DC\u5F64\u7AE5\u6876\u6345\u7B52\u7EDF\u75DB\u5077\u6295\u5934\u900F\u51F8\u79C3\u7A81\u56FE\u5F92\u9014\u6D82\u5C60\u571F\u5410\u5154\u6E4D\u56E2\u63A8\u9893\u817F\u8715\u892A\u9000\u541E\u5C6F\u81C0\u62D6\u6258\u8131\u9E35\u9640\u9A6E\u9A7C\u692D\u59A5\u62D3\u553E\u6316\u54C7\u86D9\u6D3C\u5A03\u74E6\u889C\u6B6A\u5916\u8C4C\u5F2F\u6E7E\u73A9\u987D\u4E38\u70F7\u5B8C\u7897\u633D\u665A\u7696\u60CB\u5B9B\u5A49\u4E07\u8155\u6C6A\u738B\u4EA1\u6789\u7F51\u5F80\u65FA\u671B\u5FD8\u5984\u5A01"],
+ ["ce40", "\u8719\u871B\u871D\u871F\u8720\u8724\u8726\u8727\u8728\u872A\u872B\u872C\u872D\u872F\u8730\u8732\u8733\u8735\u8736\u8738\u8739\u873A\u873C\u873D\u8740", 6, "\u874A\u874B\u874D\u874F\u8750\u8751\u8752\u8754\u8755\u8756\u8758\u875A", 5, "\u8761\u8762\u8766", 7, "\u876F\u8771\u8772\u8773\u8775"],
+ ["ce80", "\u8777\u8778\u8779\u877A\u877F\u8780\u8781\u8784\u8786\u8787\u8789\u878A\u878C\u878E", 4, "\u8794\u8795\u8796\u8798", 6, "\u87A0", 4, "\u5DCD\u5FAE\u5371\u97E6\u8FDD\u6845\u56F4\u552F\u60DF\u4E3A\u6F4D\u7EF4\u82C7\u840E\u59D4\u4F1F\u4F2A\u5C3E\u7EAC\u672A\u851A\u5473\u754F\u80C3\u5582\u9B4F\u4F4D\u6E2D\u8C13\u5C09\u6170\u536B\u761F\u6E29\u868A\u6587\u95FB\u7EB9\u543B\u7A33\u7D0A\u95EE\u55E1\u7FC1\u74EE\u631D\u8717\u6DA1\u7A9D\u6211\u65A1\u5367\u63E1\u6C83\u5DEB\u545C\u94A8\u4E4C\u6C61\u8BEC\u5C4B\u65E0\u829C\u68A7\u543E\u5434\u6BCB\u6B66\u4E94\u6342\u5348\u821E\u4F0D\u4FAE\u575E\u620A\u96FE\u6664\u7269\u52FF\u52A1\u609F\u8BEF\u6614\u7199\u6790\u897F\u7852\u77FD\u6670\u563B\u5438\u9521\u727A"],
+ ["cf40", "\u87A5\u87A6\u87A7\u87A9\u87AA\u87AE\u87B0\u87B1\u87B2\u87B4\u87B6\u87B7\u87B8\u87B9\u87BB\u87BC\u87BE\u87BF\u87C1", 4, "\u87C7\u87C8\u87C9\u87CC", 4, "\u87D4", 6, "\u87DC\u87DD\u87DE\u87DF\u87E1\u87E2\u87E3\u87E4\u87E6\u87E7\u87E8\u87E9\u87EB\u87EC\u87ED\u87EF", 9],
+ ["cf80", "\u87FA\u87FB\u87FC\u87FD\u87FF\u8800\u8801\u8802\u8804", 5, "\u880B", 7, "\u8814\u8817\u8818\u8819\u881A\u881C", 4, "\u8823\u7A00\u606F\u5E0C\u6089\u819D\u5915\u60DC\u7184\u70EF\u6EAA\u6C50\u7280\u6A84\u88AD\u5E2D\u4E60\u5AB3\u559C\u94E3\u6D17\u7CFB\u9699\u620F\u7EC6\u778E\u867E\u5323\u971E\u8F96\u6687\u5CE1\u4FA0\u72ED\u4E0B\u53A6\u590F\u5413\u6380\u9528\u5148\u4ED9\u9C9C\u7EA4\u54B8\u8D24\u8854\u8237\u95F2\u6D8E\u5F26\u5ACC\u663E\u9669\u73B0\u732E\u53BF\u817A\u9985\u7FA1\u5BAA\u9677\u9650\u7EBF\u76F8\u53A2\u9576\u9999\u7BB1\u8944\u6E58\u4E61\u7FD4\u7965\u8BE6\u60F3\u54CD\u4EAB\u9879\u5DF7\u6A61\u50CF\u5411\u8C61\u8427\u785D\u9704\u524A\u54EE\u56A3\u9500\u6D88\u5BB5\u6DC6\u6653"],
+ ["d040", "\u8824", 13, "\u8833", 5, "\u883A\u883B\u883D\u883E\u883F\u8841\u8842\u8843\u8846", 5, "\u884E", 5, "\u8855\u8856\u8858\u885A", 6, "\u8866\u8867\u886A\u886D\u886F\u8871\u8873\u8874\u8875\u8876\u8878\u8879\u887A"],
+ ["d080", "\u887B\u887C\u8880\u8883\u8886\u8887\u8889\u888A\u888C\u888E\u888F\u8890\u8891\u8893\u8894\u8895\u8897", 4, "\u889D", 4, "\u88A3\u88A5", 5, "\u5C0F\u5B5D\u6821\u8096\u5578\u7B11\u6548\u6954\u4E9B\u6B47\u874E\u978B\u534F\u631F\u643A\u90AA\u659C\u80C1\u8C10\u5199\u68B0\u5378\u87F9\u61C8\u6CC4\u6CFB\u8C22\u5C51\u85AA\u82AF\u950C\u6B23\u8F9B\u65B0\u5FFB\u5FC3\u4FE1\u8845\u661F\u8165\u7329\u60FA\u5174\u5211\u578B\u5F62\u90A2\u884C\u9192\u5E78\u674F\u6027\u59D3\u5144\u51F6\u80F8\u5308\u6C79\u96C4\u718A\u4F11\u4FEE\u7F9E\u673D\u55C5\u9508\u79C0\u8896\u7EE3\u589F\u620C\u9700\u865A\u5618\u987B\u5F90\u8BB8\u84C4\u9157\u53D9\u65ED\u5E8F\u755C\u6064\u7D6E\u5A7F\u7EEA\u7EED\u8F69\u55A7\u5BA3\u60AC\u65CB\u7384"],
+ ["d140", "\u88AC\u88AE\u88AF\u88B0\u88B2", 4, "\u88B8\u88B9\u88BA\u88BB\u88BD\u88BE\u88BF\u88C0\u88C3\u88C4\u88C7\u88C8\u88CA\u88CB\u88CC\u88CD\u88CF\u88D0\u88D1\u88D3\u88D6\u88D7\u88DA", 4, "\u88E0\u88E1\u88E6\u88E7\u88E9", 6, "\u88F2\u88F5\u88F6\u88F7\u88FA\u88FB\u88FD\u88FF\u8900\u8901\u8903", 5],
+ ["d180", "\u8909\u890B", 4, "\u8911\u8914", 4, "\u891C", 4, "\u8922\u8923\u8924\u8926\u8927\u8928\u8929\u892C\u892D\u892E\u892F\u8931\u8932\u8933\u8935\u8937\u9009\u7663\u7729\u7EDA\u9774\u859B\u5B66\u7A74\u96EA\u8840\u52CB\u718F\u5FAA\u65EC\u8BE2\u5BFB\u9A6F\u5DE1\u6B89\u6C5B\u8BAD\u8BAF\u900A\u8FC5\u538B\u62BC\u9E26\u9E2D\u5440\u4E2B\u82BD\u7259\u869C\u5D16\u8859\u6DAF\u96C5\u54D1\u4E9A\u8BB6\u7109\u54BD\u9609\u70DF\u6DF9\u76D0\u4E25\u7814\u8712\u5CA9\u5EF6\u8A00\u989C\u960E\u708E\u6CBF\u5944\u63A9\u773C\u884D\u6F14\u8273\u5830\u71D5\u538C\u781A\u96C1\u5501\u5F66\u7130\u5BB4\u8C1A\u9A8C\u6B83\u592E\u9E2F\u79E7\u6768\u626C\u4F6F\u75A1\u7F8A\u6D0B\u9633\u6C27\u4EF0\u75D2\u517B\u6837\u6F3E\u9080\u8170\u5996\u7476"],
+ ["d240", "\u8938", 8, "\u8942\u8943\u8945", 24, "\u8960", 5, "\u8967", 19, "\u897C"],
+ ["d280", "\u897D\u897E\u8980\u8982\u8984\u8985\u8987", 26, "\u6447\u5C27\u9065\u7A91\u8C23\u59DA\u54AC\u8200\u836F\u8981\u8000\u6930\u564E\u8036\u7237\u91CE\u51B6\u4E5F\u9875\u6396\u4E1A\u53F6\u66F3\u814B\u591C\u6DB2\u4E00\u58F9\u533B\u63D6\u94F1\u4F9D\u4F0A\u8863\u9890\u5937\u9057\u79FB\u4EEA\u80F0\u7591\u6C82\u5B9C\u59E8\u5F5D\u6905\u8681\u501A\u5DF2\u4E59\u77E3\u4EE5\u827A\u6291\u6613\u9091\u5C79\u4EBF\u5F79\u81C6\u9038\u8084\u75AB\u4EA6\u88D4\u610F\u6BC5\u5FC6\u4E49\u76CA\u6EA2\u8BE3\u8BAE\u8C0A\u8BD1\u5F02\u7FFC\u7FCC\u7ECE\u8335\u836B\u56E0\u6BB7\u97F3\u9634\u59FB\u541F\u94F6\u6DEB\u5BC5\u996E\u5C39\u5F15\u9690"],
+ ["d340", "\u89A2", 30, "\u89C3\u89CD\u89D3\u89D4\u89D5\u89D7\u89D8\u89D9\u89DB\u89DD\u89DF\u89E0\u89E1\u89E2\u89E4\u89E7\u89E8\u89E9\u89EA\u89EC\u89ED\u89EE\u89F0\u89F1\u89F2\u89F4", 6],
+ ["d380", "\u89FB", 4, "\u8A01", 5, "\u8A08", 21, "\u5370\u82F1\u6A31\u5A74\u9E70\u5E94\u7F28\u83B9\u8424\u8425\u8367\u8747\u8FCE\u8D62\u76C8\u5F71\u9896\u786C\u6620\u54DF\u62E5\u4F63\u81C3\u75C8\u5EB8\u96CD\u8E0A\u86F9\u548F\u6CF3\u6D8C\u6C38\u607F\u52C7\u7528\u5E7D\u4F18\u60A0\u5FE7\u5C24\u7531\u90AE\u94C0\u72B9\u6CB9\u6E38\u9149\u6709\u53CB\u53F3\u4F51\u91C9\u8BF1\u53C8\u5E7C\u8FC2\u6DE4\u4E8E\u76C2\u6986\u865E\u611A\u8206\u4F59\u4FDE\u903E\u9C7C\u6109\u6E1D\u6E14\u9685\u4E88\u5A31\u96E8\u4E0E\u5C7F\u79B9\u5B87\u8BED\u7FBD\u7389\u57DF\u828B\u90C1\u5401\u9047\u55BB\u5CEA\u5FA1\u6108\u6B32\u72F1\u80B2\u8A89"],
+ ["d440", "\u8A1E", 31, "\u8A3F", 8, "\u8A49", 21],
+ ["d480", "\u8A5F", 25, "\u8A7A", 6, "\u6D74\u5BD3\u88D5\u9884\u8C6B\u9A6D\u9E33\u6E0A\u51A4\u5143\u57A3\u8881\u539F\u63F4\u8F95\u56ED\u5458\u5706\u733F\u6E90\u7F18\u8FDC\u82D1\u613F\u6028\u9662\u66F0\u7EA6\u8D8A\u8DC3\u94A5\u5CB3\u7CA4\u6708\u60A6\u9605\u8018\u4E91\u90E7\u5300\u9668\u5141\u8FD0\u8574\u915D\u6655\u97F5\u5B55\u531D\u7838\u6742\u683D\u54C9\u707E\u5BB0\u8F7D\u518D\u5728\u54B1\u6512\u6682\u8D5E\u8D43\u810F\u846C\u906D\u7CDF\u51FF\u85FB\u67A3\u65E9\u6FA1\u86A4\u8E81\u566A\u9020\u7682\u7076\u71E5\u8D23\u62E9\u5219\u6CFD\u8D3C\u600E\u589E\u618E\u66FE\u8D60\u624E\u55B3\u6E23\u672D\u8F67"],
+ ["d540", "\u8A81", 7, "\u8A8B", 7, "\u8A94", 46],
+ ["d580", "\u8AC3", 32, "\u94E1\u95F8\u7728\u6805\u69A8\u548B\u4E4D\u70B8\u8BC8\u6458\u658B\u5B85\u7A84\u503A\u5BE8\u77BB\u6BE1\u8A79\u7C98\u6CBE\u76CF\u65A9\u8F97\u5D2D\u5C55\u8638\u6808\u5360\u6218\u7AD9\u6E5B\u7EFD\u6A1F\u7AE0\u5F70\u6F33\u5F20\u638C\u6DA8\u6756\u4E08\u5E10\u8D26\u4ED7\u80C0\u7634\u969C\u62DB\u662D\u627E\u6CBC\u8D75\u7167\u7F69\u5146\u8087\u53EC\u906E\u6298\u54F2\u86F0\u8F99\u8005\u9517\u8517\u8FD9\u6D59\u73CD\u659F\u771F\u7504\u7827\u81FB\u8D1E\u9488\u4FA6\u6795\u75B9\u8BCA\u9707\u632F\u9547\u9635\u84B8\u6323\u7741\u5F81\u72F0\u4E89\u6014\u6574\u62EF\u6B63\u653F"],
+ ["d640", "\u8AE4", 34, "\u8B08", 27],
+ ["d680", "\u8B24\u8B25\u8B27", 30, "\u5E27\u75C7\u90D1\u8BC1\u829D\u679D\u652F\u5431\u8718\u77E5\u80A2\u8102\u6C41\u4E4B\u7EC7\u804C\u76F4\u690D\u6B96\u6267\u503C\u4F84\u5740\u6307\u6B62\u8DBE\u53EA\u65E8\u7EB8\u5FD7\u631A\u63B7\u81F3\u81F4\u7F6E\u5E1C\u5CD9\u5236\u667A\u79E9\u7A1A\u8D28\u7099\u75D4\u6EDE\u6CBB\u7A92\u4E2D\u76C5\u5FE0\u949F\u8877\u7EC8\u79CD\u80BF\u91CD\u4EF2\u4F17\u821F\u5468\u5DDE\u6D32\u8BCC\u7CA5\u8F74\u8098\u5E1A\u5492\u76B1\u5B99\u663C\u9AA4\u73E0\u682A\u86DB\u6731\u732A\u8BF8\u8BDB\u9010\u7AF9\u70DB\u716E\u62C4\u77A9\u5631\u4E3B\u8457\u67F1\u52A9\u86C0\u8D2E\u94F8\u7B51"],
+ ["d740", "\u8B46", 31, "\u8B67", 4, "\u8B6D", 25],
+ ["d780", "\u8B87", 24, "\u8BAC\u8BB1\u8BBB\u8BC7\u8BD0\u8BEA\u8C09\u8C1E\u4F4F\u6CE8\u795D\u9A7B\u6293\u722A\u62FD\u4E13\u7816\u8F6C\u64B0\u8D5A\u7BC6\u6869\u5E84\u88C5\u5986\u649E\u58EE\u72B6\u690E\u9525\u8FFD\u8D58\u5760\u7F00\u8C06\u51C6\u6349\u62D9\u5353\u684C\u7422\u8301\u914C\u5544\u7740\u707C\u6D4A\u5179\u54A8\u8D44\u59FF\u6ECB\u6DC4\u5B5C\u7D2B\u4ED4\u7C7D\u6ED3\u5B50\u81EA\u6E0D\u5B57\u9B03\u68D5\u8E2A\u5B97\u7EFC\u603B\u7EB5\u90B9\u8D70\u594F\u63CD\u79DF\u8DB3\u5352\u65CF\u7956\u8BC5\u963B\u7EC4\u94BB\u7E82\u5634\u9189\u6700\u7F6A\u5C0A\u9075\u6628\u5DE6\u4F50\u67DE\u505A\u4F5C\u5750\u5EA7"],
+ ["d840", "\u8C38", 8, "\u8C42\u8C43\u8C44\u8C45\u8C48\u8C4A\u8C4B\u8C4D", 7, "\u8C56\u8C57\u8C58\u8C59\u8C5B", 5, "\u8C63", 6, "\u8C6C", 6, "\u8C74\u8C75\u8C76\u8C77\u8C7B", 6, "\u8C83\u8C84\u8C86\u8C87"],
+ ["d880", "\u8C88\u8C8B\u8C8D", 6, "\u8C95\u8C96\u8C97\u8C99", 20, "\u4E8D\u4E0C\u5140\u4E10\u5EFF\u5345\u4E15\u4E98\u4E1E\u9B32\u5B6C\u5669\u4E28\u79BA\u4E3F\u5315\u4E47\u592D\u723B\u536E\u6C10\u56DF\u80E4\u9997\u6BD3\u777E\u9F17\u4E36\u4E9F\u9F10\u4E5C\u4E69\u4E93\u8288\u5B5B\u556C\u560F\u4EC4\u538D\u539D\u53A3\u53A5\u53AE\u9765\u8D5D\u531A\u53F5\u5326\u532E\u533E\u8D5C\u5366\u5363\u5202\u5208\u520E\u522D\u5233\u523F\u5240\u524C\u525E\u5261\u525C\u84AF\u527D\u5282\u5281\u5290\u5293\u5182\u7F54\u4EBB\u4EC3\u4EC9\u4EC2\u4EE8\u4EE1\u4EEB\u4EDE\u4F1B\u4EF3\u4F22\u4F64\u4EF5\u4F25\u4F27\u4F09\u4F2B\u4F5E\u4F67\u6538\u4F5A\u4F5D"],
+ ["d940", "\u8CAE", 62],
+ ["d980", "\u8CED", 32, "\u4F5F\u4F57\u4F32\u4F3D\u4F76\u4F74\u4F91\u4F89\u4F83\u4F8F\u4F7E\u4F7B\u4FAA\u4F7C\u4FAC\u4F94\u4FE6\u4FE8\u4FEA\u4FC5\u4FDA\u4FE3\u4FDC\u4FD1\u4FDF\u4FF8\u5029\u504C\u4FF3\u502C\u500F\u502E\u502D\u4FFE\u501C\u500C\u5025\u5028\u507E\u5043\u5055\u5048\u504E\u506C\u507B\u50A5\u50A7\u50A9\u50BA\u50D6\u5106\u50ED\u50EC\u50E6\u50EE\u5107\u510B\u4EDD\u6C3D\u4F58\u4F65\u4FCE\u9FA0\u6C46\u7C74\u516E\u5DFD\u9EC9\u9998\u5181\u5914\u52F9\u530D\u8A07\u5310\u51EB\u5919\u5155\u4EA0\u5156\u4EB3\u886E\u88A4\u4EB5\u8114\u88D2\u7980\u5B34\u8803\u7FB8\u51AB\u51B1\u51BD\u51BC"],
+ ["da40", "\u8D0E", 14, "\u8D20\u8D51\u8D52\u8D57\u8D5F\u8D65\u8D68\u8D69\u8D6A\u8D6C\u8D6E\u8D6F\u8D71\u8D72\u8D78", 8, "\u8D82\u8D83\u8D86\u8D87\u8D88\u8D89\u8D8C", 4, "\u8D92\u8D93\u8D95", 9, "\u8DA0\u8DA1"],
+ ["da80", "\u8DA2\u8DA4", 12, "\u8DB2\u8DB6\u8DB7\u8DB9\u8DBB\u8DBD\u8DC0\u8DC1\u8DC2\u8DC5\u8DC7\u8DC8\u8DC9\u8DCA\u8DCD\u8DD0\u8DD2\u8DD3\u8DD4\u51C7\u5196\u51A2\u51A5\u8BA0\u8BA6\u8BA7\u8BAA\u8BB4\u8BB5\u8BB7\u8BC2\u8BC3\u8BCB\u8BCF\u8BCE\u8BD2\u8BD3\u8BD4\u8BD6\u8BD8\u8BD9\u8BDC\u8BDF\u8BE0\u8BE4\u8BE8\u8BE9\u8BEE\u8BF0\u8BF3\u8BF6\u8BF9\u8BFC\u8BFF\u8C00\u8C02\u8C04\u8C07\u8C0C\u8C0F\u8C11\u8C12\u8C14\u8C15\u8C16\u8C19\u8C1B\u8C18\u8C1D\u8C1F\u8C20\u8C21\u8C25\u8C27\u8C2A\u8C2B\u8C2E\u8C2F\u8C32\u8C33\u8C35\u8C36\u5369\u537A\u961D\u9622\u9621\u9631\u962A\u963D\u963C\u9642\u9649\u9654\u965F\u9667\u966C\u9672\u9674\u9688\u968D\u9697\u96B0\u9097\u909B\u909D\u9099\u90AC\u90A1\u90B4\u90B3\u90B6\u90BA"],
+ ["db40", "\u8DD5\u8DD8\u8DD9\u8DDC\u8DE0\u8DE1\u8DE2\u8DE5\u8DE6\u8DE7\u8DE9\u8DED\u8DEE\u8DF0\u8DF1\u8DF2\u8DF4\u8DF6\u8DFC\u8DFE", 6, "\u8E06\u8E07\u8E08\u8E0B\u8E0D\u8E0E\u8E10\u8E11\u8E12\u8E13\u8E15", 7, "\u8E20\u8E21\u8E24", 4, "\u8E2B\u8E2D\u8E30\u8E32\u8E33\u8E34\u8E36\u8E37\u8E38\u8E3B\u8E3C\u8E3E"],
+ ["db80", "\u8E3F\u8E43\u8E45\u8E46\u8E4C", 4, "\u8E53", 5, "\u8E5A", 11, "\u8E67\u8E68\u8E6A\u8E6B\u8E6E\u8E71\u90B8\u90B0\u90CF\u90C5\u90BE\u90D0\u90C4\u90C7\u90D3\u90E6\u90E2\u90DC\u90D7\u90DB\u90EB\u90EF\u90FE\u9104\u9122\u911E\u9123\u9131\u912F\u9139\u9143\u9146\u520D\u5942\u52A2\u52AC\u52AD\u52BE\u54FF\u52D0\u52D6\u52F0\u53DF\u71EE\u77CD\u5EF4\u51F5\u51FC\u9B2F\u53B6\u5F01\u755A\u5DEF\u574C\u57A9\u57A1\u587E\u58BC\u58C5\u58D1\u5729\u572C\u572A\u5733\u5739\u572E\u572F\u575C\u573B\u5742\u5769\u5785\u576B\u5786\u577C\u577B\u5768\u576D\u5776\u5773\u57AD\u57A4\u578C\u57B2\u57CF\u57A7\u57B4\u5793\u57A0\u57D5\u57D8\u57DA\u57D9\u57D2\u57B8\u57F4\u57EF\u57F8\u57E4\u57DD"],
+ ["dc40", "\u8E73\u8E75\u8E77", 4, "\u8E7D\u8E7E\u8E80\u8E82\u8E83\u8E84\u8E86\u8E88", 6, "\u8E91\u8E92\u8E93\u8E95", 6, "\u8E9D\u8E9F", 11, "\u8EAD\u8EAE\u8EB0\u8EB1\u8EB3", 6, "\u8EBB", 7],
+ ["dc80", "\u8EC3", 10, "\u8ECF", 21, "\u580B\u580D\u57FD\u57ED\u5800\u581E\u5819\u5844\u5820\u5865\u586C\u5881\u5889\u589A\u5880\u99A8\u9F19\u61FF\u8279\u827D\u827F\u828F\u828A\u82A8\u8284\u828E\u8291\u8297\u8299\u82AB\u82B8\u82BE\u82B0\u82C8\u82CA\u82E3\u8298\u82B7\u82AE\u82CB\u82CC\u82C1\u82A9\u82B4\u82A1\u82AA\u829F\u82C4\u82CE\u82A4\u82E1\u8309\u82F7\u82E4\u830F\u8307\u82DC\u82F4\u82D2\u82D8\u830C\u82FB\u82D3\u8311\u831A\u8306\u8314\u8315\u82E0\u82D5\u831C\u8351\u835B\u835C\u8308\u8392\u833C\u8334\u8331\u839B\u835E\u832F\u834F\u8347\u8343\u835F\u8340\u8317\u8360\u832D\u833A\u8333\u8366\u8365"],
+ ["dd40", "\u8EE5", 62],
+ ["dd80", "\u8F24", 32, "\u8368\u831B\u8369\u836C\u836A\u836D\u836E\u83B0\u8378\u83B3\u83B4\u83A0\u83AA\u8393\u839C\u8385\u837C\u83B6\u83A9\u837D\u83B8\u837B\u8398\u839E\u83A8\u83BA\u83BC\u83C1\u8401\u83E5\u83D8\u5807\u8418\u840B\u83DD\u83FD\u83D6\u841C\u8438\u8411\u8406\u83D4\u83DF\u840F\u8403\u83F8\u83F9\u83EA\u83C5\u83C0\u8426\u83F0\u83E1\u845C\u8451\u845A\u8459\u8473\u8487\u8488\u847A\u8489\u8478\u843C\u8446\u8469\u8476\u848C\u848E\u8431\u846D\u84C1\u84CD\u84D0\u84E6\u84BD\u84D3\u84CA\u84BF\u84BA\u84E0\u84A1\u84B9\u84B4\u8497\u84E5\u84E3\u850C\u750D\u8538\u84F0\u8539\u851F\u853A"],
+ ["de40", "\u8F45", 32, "\u8F6A\u8F80\u8F8C\u8F92\u8F9D\u8FA0\u8FA1\u8FA2\u8FA4\u8FA5\u8FA6\u8FA7\u8FAA\u8FAC\u8FAD\u8FAE\u8FAF\u8FB2\u8FB3\u8FB4\u8FB5\u8FB7\u8FB8\u8FBA\u8FBB\u8FBC\u8FBF\u8FC0\u8FC3\u8FC6"],
+ ["de80", "\u8FC9", 4, "\u8FCF\u8FD2\u8FD6\u8FD7\u8FDA\u8FE0\u8FE1\u8FE3\u8FE7\u8FEC\u8FEF\u8FF1\u8FF2\u8FF4\u8FF5\u8FF6\u8FFA\u8FFB\u8FFC\u8FFE\u8FFF\u9007\u9008\u900C\u900E\u9013\u9015\u9018\u8556\u853B\u84FF\u84FC\u8559\u8548\u8568\u8564\u855E\u857A\u77A2\u8543\u8572\u857B\u85A4\u85A8\u8587\u858F\u8579\u85AE\u859C\u8585\u85B9\u85B7\u85B0\u85D3\u85C1\u85DC\u85FF\u8627\u8605\u8629\u8616\u863C\u5EFE\u5F08\u593C\u5941\u8037\u5955\u595A\u5958\u530F\u5C22\u5C25\u5C2C\u5C34\u624C\u626A\u629F\u62BB\u62CA\u62DA\u62D7\u62EE\u6322\u62F6\u6339\u634B\u6343\u63AD\u63F6\u6371\u637A\u638E\u63B4\u636D\u63AC\u638A\u6369\u63AE\u63BC\u63F2\u63F8\u63E0\u63FF\u63C4\u63DE\u63CE\u6452\u63C6\u63BE\u6445\u6441\u640B\u641B\u6420\u640C\u6426\u6421\u645E\u6484\u646D\u6496"],
+ ["df40", "\u9019\u901C\u9023\u9024\u9025\u9027", 5, "\u9030", 4, "\u9037\u9039\u903A\u903D\u903F\u9040\u9043\u9045\u9046\u9048", 4, "\u904E\u9054\u9055\u9056\u9059\u905A\u905C", 5, "\u9064\u9066\u9067\u9069\u906A\u906B\u906C\u906F", 4, "\u9076", 6, "\u907E\u9081"],
+ ["df80", "\u9084\u9085\u9086\u9087\u9089\u908A\u908C", 4, "\u9092\u9094\u9096\u9098\u909A\u909C\u909E\u909F\u90A0\u90A4\u90A5\u90A7\u90A8\u90A9\u90AB\u90AD\u90B2\u90B7\u90BC\u90BD\u90BF\u90C0\u647A\u64B7\u64B8\u6499\u64BA\u64C0\u64D0\u64D7\u64E4\u64E2\u6509\u6525\u652E\u5F0B\u5FD2\u7519\u5F11\u535F\u53F1\u53FD\u53E9\u53E8\u53FB\u5412\u5416\u5406\u544B\u5452\u5453\u5454\u5456\u5443\u5421\u5457\u5459\u5423\u5432\u5482\u5494\u5477\u5471\u5464\u549A\u549B\u5484\u5476\u5466\u549D\u54D0\u54AD\u54C2\u54B4\u54D2\u54A7\u54A6\u54D3\u54D4\u5472\u54A3\u54D5\u54BB\u54BF\u54CC\u54D9\u54DA\u54DC\u54A9\u54AA\u54A4\u54DD\u54CF\u54DE\u551B\u54E7\u5520\u54FD\u5514\u54F3\u5522\u5523\u550F\u5511\u5527\u552A\u5567\u558F\u55B5\u5549\u556D\u5541\u5555\u553F\u5550\u553C"],
+ ["e040", "\u90C2\u90C3\u90C6\u90C8\u90C9\u90CB\u90CC\u90CD\u90D2\u90D4\u90D5\u90D6\u90D8\u90D9\u90DA\u90DE\u90DF\u90E0\u90E3\u90E4\u90E5\u90E9\u90EA\u90EC\u90EE\u90F0\u90F1\u90F2\u90F3\u90F5\u90F6\u90F7\u90F9\u90FA\u90FB\u90FC\u90FF\u9100\u9101\u9103\u9105", 19, "\u911A\u911B\u911C"],
+ ["e080", "\u911D\u911F\u9120\u9121\u9124", 10, "\u9130\u9132", 6, "\u913A", 8, "\u9144\u5537\u5556\u5575\u5576\u5577\u5533\u5530\u555C\u558B\u55D2\u5583\u55B1\u55B9\u5588\u5581\u559F\u557E\u55D6\u5591\u557B\u55DF\u55BD\u55BE\u5594\u5599\u55EA\u55F7\u55C9\u561F\u55D1\u55EB\u55EC\u55D4\u55E6\u55DD\u55C4\u55EF\u55E5\u55F2\u55F3\u55CC\u55CD\u55E8\u55F5\u55E4\u8F94\u561E\u5608\u560C\u5601\u5624\u5623\u55FE\u5600\u5627\u562D\u5658\u5639\u5657\u562C\u564D\u5662\u5659\u565C\u564C\u5654\u5686\u5664\u5671\u566B\u567B\u567C\u5685\u5693\u56AF\u56D4\u56D7\u56DD\u56E1\u56F5\u56EB\u56F9\u56FF\u5704\u570A\u5709\u571C\u5E0F\u5E19\u5E14\u5E11\u5E31\u5E3B\u5E3C"],
+ ["e140", "\u9145\u9147\u9148\u9151\u9153\u9154\u9155\u9156\u9158\u9159\u915B\u915C\u915F\u9160\u9166\u9167\u9168\u916B\u916D\u9173\u917A\u917B\u917C\u9180", 4, "\u9186\u9188\u918A\u918E\u918F\u9193", 6, "\u919C", 5, "\u91A4", 5, "\u91AB\u91AC\u91B0\u91B1\u91B2\u91B3\u91B6\u91B7\u91B8\u91B9\u91BB"],
+ ["e180", "\u91BC", 10, "\u91C8\u91CB\u91D0\u91D2", 9, "\u91DD", 8, "\u5E37\u5E44\u5E54\u5E5B\u5E5E\u5E61\u5C8C\u5C7A\u5C8D\u5C90\u5C96\u5C88\u5C98\u5C99\u5C91\u5C9A\u5C9C\u5CB5\u5CA2\u5CBD\u5CAC\u5CAB\u5CB1\u5CA3\u5CC1\u5CB7\u5CC4\u5CD2\u5CE4\u5CCB\u5CE5\u5D02\u5D03\u5D27\u5D26\u5D2E\u5D24\u5D1E\u5D06\u5D1B\u5D58\u5D3E\u5D34\u5D3D\u5D6C\u5D5B\u5D6F\u5D5D\u5D6B\u5D4B\u5D4A\u5D69\u5D74\u5D82\u5D99\u5D9D\u8C73\u5DB7\u5DC5\u5F73\u5F77\u5F82\u5F87\u5F89\u5F8C\u5F95\u5F99\u5F9C\u5FA8\u5FAD\u5FB5\u5FBC\u8862\u5F61\u72AD\u72B0\u72B4\u72B7\u72B8\u72C3\u72C1\u72CE\u72CD\u72D2\u72E8\u72EF\u72E9\u72F2\u72F4\u72F7\u7301\u72F3\u7303\u72FA"],
+ ["e240", "\u91E6", 62],
+ ["e280", "\u9225", 32, "\u72FB\u7317\u7313\u7321\u730A\u731E\u731D\u7315\u7322\u7339\u7325\u732C\u7338\u7331\u7350\u734D\u7357\u7360\u736C\u736F\u737E\u821B\u5925\u98E7\u5924\u5902\u9963\u9967", 5, "\u9974\u9977\u997D\u9980\u9984\u9987\u998A\u998D\u9990\u9991\u9993\u9994\u9995\u5E80\u5E91\u5E8B\u5E96\u5EA5\u5EA0\u5EB9\u5EB5\u5EBE\u5EB3\u8D53\u5ED2\u5ED1\u5EDB\u5EE8\u5EEA\u81BA\u5FC4\u5FC9\u5FD6\u5FCF\u6003\u5FEE\u6004\u5FE1\u5FE4\u5FFE\u6005\u6006\u5FEA\u5FED\u5FF8\u6019\u6035\u6026\u601B\u600F\u600D\u6029\u602B\u600A\u603F\u6021\u6078\u6079\u607B\u607A\u6042"],
+ ["e340", "\u9246", 45, "\u9275", 16],
+ ["e380", "\u9286", 7, "\u928F", 24, "\u606A\u607D\u6096\u609A\u60AD\u609D\u6083\u6092\u608C\u609B\u60EC\u60BB\u60B1\u60DD\u60D8\u60C6\u60DA\u60B4\u6120\u6126\u6115\u6123\u60F4\u6100\u610E\u612B\u614A\u6175\u61AC\u6194\u61A7\u61B7\u61D4\u61F5\u5FDD\u96B3\u95E9\u95EB\u95F1\u95F3\u95F5\u95F6\u95FC\u95FE\u9603\u9604\u9606\u9608\u960A\u960B\u960C\u960D\u960F\u9612\u9615\u9616\u9617\u9619\u961A\u4E2C\u723F\u6215\u6C35\u6C54\u6C5C\u6C4A\u6CA3\u6C85\u6C90\u6C94\u6C8C\u6C68\u6C69\u6C74\u6C76\u6C86\u6CA9\u6CD0\u6CD4\u6CAD\u6CF7\u6CF8\u6CF1\u6CD7\u6CB2\u6CE0\u6CD6\u6CFA\u6CEB\u6CEE\u6CB1\u6CD3\u6CEF\u6CFE"],
+ ["e440", "\u92A8", 5, "\u92AF", 24, "\u92C9", 31],
+ ["e480", "\u92E9", 32, "\u6D39\u6D27\u6D0C\u6D43\u6D48\u6D07\u6D04\u6D19\u6D0E\u6D2B\u6D4D\u6D2E\u6D35\u6D1A\u6D4F\u6D52\u6D54\u6D33\u6D91\u6D6F\u6D9E\u6DA0\u6D5E\u6D93\u6D94\u6D5C\u6D60\u6D7C\u6D63\u6E1A\u6DC7\u6DC5\u6DDE\u6E0E\u6DBF\u6DE0\u6E11\u6DE6\u6DDD\u6DD9\u6E16\u6DAB\u6E0C\u6DAE\u6E2B\u6E6E\u6E4E\u6E6B\u6EB2\u6E5F\u6E86\u6E53\u6E54\u6E32\u6E25\u6E44\u6EDF\u6EB1\u6E98\u6EE0\u6F2D\u6EE2\u6EA5\u6EA7\u6EBD\u6EBB\u6EB7\u6ED7\u6EB4\u6ECF\u6E8F\u6EC2\u6E9F\u6F62\u6F46\u6F47\u6F24\u6F15\u6EF9\u6F2F\u6F36\u6F4B\u6F74\u6F2A\u6F09\u6F29\u6F89\u6F8D\u6F8C\u6F78\u6F72\u6F7C\u6F7A\u6FD1"],
+ ["e540", "\u930A", 51, "\u933F", 10],
+ ["e580", "\u934A", 31, "\u936B\u6FC9\u6FA7\u6FB9\u6FB6\u6FC2\u6FE1\u6FEE\u6FDE\u6FE0\u6FEF\u701A\u7023\u701B\u7039\u7035\u704F\u705E\u5B80\u5B84\u5B95\u5B93\u5BA5\u5BB8\u752F\u9A9E\u6434\u5BE4\u5BEE\u8930\u5BF0\u8E47\u8B07\u8FB6\u8FD3\u8FD5\u8FE5\u8FEE\u8FE4\u8FE9\u8FE6\u8FF3\u8FE8\u9005\u9004\u900B\u9026\u9011\u900D\u9016\u9021\u9035\u9036\u902D\u902F\u9044\u9051\u9052\u9050\u9068\u9058\u9062\u905B\u66B9\u9074\u907D\u9082\u9088\u9083\u908B\u5F50\u5F57\u5F56\u5F58\u5C3B\u54AB\u5C50\u5C59\u5B71\u5C63\u5C66\u7FBC\u5F2A\u5F29\u5F2D\u8274\u5F3C\u9B3B\u5C6E\u5981\u5983\u598D\u59A9\u59AA\u59A3"],
+ ["e640", "\u936C", 34, "\u9390", 27],
+ ["e680", "\u93AC", 29, "\u93CB\u93CC\u93CD\u5997\u59CA\u59AB\u599E\u59A4\u59D2\u59B2\u59AF\u59D7\u59BE\u5A05\u5A06\u59DD\u5A08\u59E3\u59D8\u59F9\u5A0C\u5A09\u5A32\u5A34\u5A11\u5A23\u5A13\u5A40\u5A67\u5A4A\u5A55\u5A3C\u5A62\u5A75\u80EC\u5AAA\u5A9B\u5A77\u5A7A\u5ABE\u5AEB\u5AB2\u5AD2\u5AD4\u5AB8\u5AE0\u5AE3\u5AF1\u5AD6\u5AE6\u5AD8\u5ADC\u5B09\u5B17\u5B16\u5B32\u5B37\u5B40\u5C15\u5C1C\u5B5A\u5B65\u5B73\u5B51\u5B53\u5B62\u9A75\u9A77\u9A78\u9A7A\u9A7F\u9A7D\u9A80\u9A81\u9A85\u9A88\u9A8A\u9A90\u9A92\u9A93\u9A96\u9A98\u9A9B\u9A9C\u9A9D\u9A9F\u9AA0\u9AA2\u9AA3\u9AA5\u9AA7\u7E9F\u7EA1\u7EA3\u7EA5\u7EA8\u7EA9"],
+ ["e740", "\u93CE", 7, "\u93D7", 54],
+ ["e780", "\u940E", 32, "\u7EAD\u7EB0\u7EBE\u7EC0\u7EC1\u7EC2\u7EC9\u7ECB\u7ECC\u7ED0\u7ED4\u7ED7\u7EDB\u7EE0\u7EE1\u7EE8\u7EEB\u7EEE\u7EEF\u7EF1\u7EF2\u7F0D\u7EF6\u7EFA\u7EFB\u7EFE\u7F01\u7F02\u7F03\u7F07\u7F08\u7F0B\u7F0C\u7F0F\u7F11\u7F12\u7F17\u7F19\u7F1C\u7F1B\u7F1F\u7F21", 6, "\u7F2A\u7F2B\u7F2C\u7F2D\u7F2F", 4, "\u7F35\u5E7A\u757F\u5DDB\u753E\u9095\u738E\u7391\u73AE\u73A2\u739F\u73CF\u73C2\u73D1\u73B7\u73B3\u73C0\u73C9\u73C8\u73E5\u73D9\u987C\u740A\u73E9\u73E7\u73DE\u73BA\u73F2\u740F\u742A\u745B\u7426\u7425\u7428\u7430\u742E\u742C"],
+ ["e840", "\u942F", 14, "\u943F", 43, "\u946C\u946D\u946E\u946F"],
+ ["e880", "\u9470", 20, "\u9491\u9496\u9498\u94C7\u94CF\u94D3\u94D4\u94DA\u94E6\u94FB\u951C\u9520\u741B\u741A\u7441\u745C\u7457\u7455\u7459\u7477\u746D\u747E\u749C\u748E\u7480\u7481\u7487\u748B\u749E\u74A8\u74A9\u7490\u74A7\u74D2\u74BA\u97EA\u97EB\u97EC\u674C\u6753\u675E\u6748\u6769\u67A5\u6787\u676A\u6773\u6798\u67A7\u6775\u67A8\u679E\u67AD\u678B\u6777\u677C\u67F0\u6809\u67D8\u680A\u67E9\u67B0\u680C\u67D9\u67B5\u67DA\u67B3\u67DD\u6800\u67C3\u67B8\u67E2\u680E\u67C1\u67FD\u6832\u6833\u6860\u6861\u684E\u6862\u6844\u6864\u6883\u681D\u6855\u6866\u6841\u6867\u6840\u683E\u684A\u6849\u6829\u68B5\u688F\u6874\u6877\u6893\u686B\u68C2\u696E\u68FC\u691F\u6920\u68F9"],
+ ["e940", "\u9527\u9533\u953D\u9543\u9548\u954B\u9555\u955A\u9560\u956E\u9574\u9575\u9577", 7, "\u9580", 42],
+ ["e980", "\u95AB", 32, "\u6924\u68F0\u690B\u6901\u6957\u68E3\u6910\u6971\u6939\u6960\u6942\u695D\u6984\u696B\u6980\u6998\u6978\u6934\u69CC\u6987\u6988\u69CE\u6989\u6966\u6963\u6979\u699B\u69A7\u69BB\u69AB\u69AD\u69D4\u69B1\u69C1\u69CA\u69DF\u6995\u69E0\u698D\u69FF\u6A2F\u69ED\u6A17\u6A18\u6A65\u69F2\u6A44\u6A3E\u6AA0\u6A50\u6A5B\u6A35\u6A8E\u6A79\u6A3D\u6A28\u6A58\u6A7C\u6A91\u6A90\u6AA9\u6A97\u6AAB\u7337\u7352\u6B81\u6B82\u6B87\u6B84\u6B92\u6B93\u6B8D\u6B9A\u6B9B\u6BA1\u6BAA\u8F6B\u8F6D\u8F71\u8F72\u8F73\u8F75\u8F76\u8F78\u8F77\u8F79\u8F7A\u8F7C\u8F7E\u8F81\u8F82\u8F84\u8F87\u8F8B"],
+ ["ea40", "\u95CC", 27, "\u95EC\u95FF\u9607\u9613\u9618\u961B\u961E\u9620\u9623", 6, "\u962B\u962C\u962D\u962F\u9630\u9637\u9638\u9639\u963A\u963E\u9641\u9643\u964A\u964E\u964F\u9651\u9652\u9653\u9656\u9657"],
+ ["ea80", "\u9658\u9659\u965A\u965C\u965D\u965E\u9660\u9663\u9665\u9666\u966B\u966D", 4, "\u9673\u9678", 12, "\u9687\u9689\u968A\u8F8D\u8F8E\u8F8F\u8F98\u8F9A\u8ECE\u620B\u6217\u621B\u621F\u6222\u6221\u6225\u6224\u622C\u81E7\u74EF\u74F4\u74FF\u750F\u7511\u7513\u6534\u65EE\u65EF\u65F0\u660A\u6619\u6772\u6603\u6615\u6600\u7085\u66F7\u661D\u6634\u6631\u6636\u6635\u8006\u665F\u6654\u6641\u664F\u6656\u6661\u6657\u6677\u6684\u668C\u66A7\u669D\u66BE\u66DB\u66DC\u66E6\u66E9\u8D32\u8D33\u8D36\u8D3B\u8D3D\u8D40\u8D45\u8D46\u8D48\u8D49\u8D47\u8D4D\u8D55\u8D59\u89C7\u89CA\u89CB\u89CC\u89CE\u89CF\u89D0\u89D1\u726E\u729F\u725D\u7266\u726F\u727E\u727F\u7284\u728B\u728D\u728F\u7292\u6308\u6332\u63B0"],
+ ["eb40", "\u968C\u968E\u9691\u9692\u9693\u9695\u9696\u969A\u969B\u969D", 9, "\u96A8", 7, "\u96B1\u96B2\u96B4\u96B5\u96B7\u96B8\u96BA\u96BB\u96BF\u96C2\u96C3\u96C8\u96CA\u96CB\u96D0\u96D1\u96D3\u96D4\u96D6", 9, "\u96E1", 6, "\u96EB"],
+ ["eb80", "\u96EC\u96ED\u96EE\u96F0\u96F1\u96F2\u96F4\u96F5\u96F8\u96FA\u96FB\u96FC\u96FD\u96FF\u9702\u9703\u9705\u970A\u970B\u970C\u9710\u9711\u9712\u9714\u9715\u9717", 4, "\u971D\u971F\u9720\u643F\u64D8\u8004\u6BEA\u6BF3\u6BFD\u6BF5\u6BF9\u6C05\u6C07\u6C06\u6C0D\u6C15\u6C18\u6C19\u6C1A\u6C21\u6C29\u6C24\u6C2A\u6C32\u6535\u6555\u656B\u724D\u7252\u7256\u7230\u8662\u5216\u809F\u809C\u8093\u80BC\u670A\u80BD\u80B1\u80AB\u80AD\u80B4\u80B7\u80E7\u80E8\u80E9\u80EA\u80DB\u80C2\u80C4\u80D9\u80CD\u80D7\u6710\u80DD\u80EB\u80F1\u80F4\u80ED\u810D\u810E\u80F2\u80FC\u6715\u8112\u8C5A\u8136\u811E\u812C\u8118\u8132\u8148\u814C\u8153\u8174\u8159\u815A\u8171\u8160\u8169\u817C\u817D\u816D\u8167\u584D\u5AB5\u8188\u8182\u8191\u6ED5\u81A3\u81AA\u81CC\u6726\u81CA\u81BB"],
+ ["ec40", "\u9721", 8, "\u972B\u972C\u972E\u972F\u9731\u9733", 4, "\u973A\u973B\u973C\u973D\u973F", 18, "\u9754\u9755\u9757\u9758\u975A\u975C\u975D\u975F\u9763\u9764\u9766\u9767\u9768\u976A", 7],
+ ["ec80", "\u9772\u9775\u9777", 4, "\u977D", 7, "\u9786", 4, "\u978C\u978E\u978F\u9790\u9793\u9795\u9796\u9797\u9799", 4, "\u81C1\u81A6\u6B24\u6B37\u6B39\u6B43\u6B46\u6B59\u98D1\u98D2\u98D3\u98D5\u98D9\u98DA\u6BB3\u5F40\u6BC2\u89F3\u6590\u9F51\u6593\u65BC\u65C6\u65C4\u65C3\u65CC\u65CE\u65D2\u65D6\u7080\u709C\u7096\u709D\u70BB\u70C0\u70B7\u70AB\u70B1\u70E8\u70CA\u7110\u7113\u7116\u712F\u7131\u7173\u715C\u7168\u7145\u7172\u714A\u7178\u717A\u7198\u71B3\u71B5\u71A8\u71A0\u71E0\u71D4\u71E7\u71F9\u721D\u7228\u706C\u7118\u7166\u71B9\u623E\u623D\u6243\u6248\u6249\u793B\u7940\u7946\u7949\u795B\u795C\u7953\u795A\u7962\u7957\u7960\u796F\u7967\u797A\u7985\u798A\u799A\u79A7\u79B3\u5FD1\u5FD0"],
+ ["ed40", "\u979E\u979F\u97A1\u97A2\u97A4", 6, "\u97AC\u97AE\u97B0\u97B1\u97B3\u97B5", 46],
+ ["ed80", "\u97E4\u97E5\u97E8\u97EE", 4, "\u97F4\u97F7", 23, "\u603C\u605D\u605A\u6067\u6041\u6059\u6063\u60AB\u6106\u610D\u615D\u61A9\u619D\u61CB\u61D1\u6206\u8080\u807F\u6C93\u6CF6\u6DFC\u77F6\u77F8\u7800\u7809\u7817\u7818\u7811\u65AB\u782D\u781C\u781D\u7839\u783A\u783B\u781F\u783C\u7825\u782C\u7823\u7829\u784E\u786D\u7856\u7857\u7826\u7850\u7847\u784C\u786A\u789B\u7893\u789A\u7887\u789C\u78A1\u78A3\u78B2\u78B9\u78A5\u78D4\u78D9\u78C9\u78EC\u78F2\u7905\u78F4\u7913\u7924\u791E\u7934\u9F9B\u9EF9\u9EFB\u9EFC\u76F1\u7704\u770D\u76F9\u7707\u7708\u771A\u7722\u7719\u772D\u7726\u7735\u7738\u7750\u7751\u7747\u7743\u775A\u7768"],
+ ["ee40", "\u980F", 62],
+ ["ee80", "\u984E", 32, "\u7762\u7765\u777F\u778D\u777D\u7780\u778C\u7791\u779F\u77A0\u77B0\u77B5\u77BD\u753A\u7540\u754E\u754B\u7548\u755B\u7572\u7579\u7583\u7F58\u7F61\u7F5F\u8A48\u7F68\u7F74\u7F71\u7F79\u7F81\u7F7E\u76CD\u76E5\u8832\u9485\u9486\u9487\u948B\u948A\u948C\u948D\u948F\u9490\u9494\u9497\u9495\u949A\u949B\u949C\u94A3\u94A4\u94AB\u94AA\u94AD\u94AC\u94AF\u94B0\u94B2\u94B4\u94B6", 4, "\u94BC\u94BD\u94BF\u94C4\u94C8", 6, "\u94D0\u94D1\u94D2\u94D5\u94D6\u94D7\u94D9\u94D8\u94DB\u94DE\u94DF\u94E0\u94E2\u94E4\u94E5\u94E7\u94E8\u94EA"],
+ ["ef40", "\u986F", 5, "\u988B\u988E\u9892\u9895\u9899\u98A3\u98A8", 37, "\u98CF\u98D0\u98D4\u98D6\u98D7\u98DB\u98DC\u98DD\u98E0", 4],
+ ["ef80", "\u98E5\u98E6\u98E9", 30, "\u94E9\u94EB\u94EE\u94EF\u94F3\u94F4\u94F5\u94F7\u94F9\u94FC\u94FD\u94FF\u9503\u9502\u9506\u9507\u9509\u950A\u950D\u950E\u950F\u9512", 4, "\u9518\u951B\u951D\u951E\u951F\u9522\u952A\u952B\u9529\u952C\u9531\u9532\u9534\u9536\u9537\u9538\u953C\u953E\u953F\u9542\u9535\u9544\u9545\u9546\u9549\u954C\u954E\u954F\u9552\u9553\u9554\u9556\u9557\u9558\u9559\u955B\u955E\u955F\u955D\u9561\u9562\u9564", 8, "\u956F\u9571\u9572\u9573\u953A\u77E7\u77EC\u96C9\u79D5\u79ED\u79E3\u79EB\u7A06\u5D47\u7A03\u7A02\u7A1E\u7A14"],
+ ["f040", "\u9908", 4, "\u990E\u990F\u9911", 28, "\u992F", 26],
+ ["f080", "\u994A", 9, "\u9956", 12, "\u9964\u9966\u9973\u9978\u9979\u997B\u997E\u9982\u9983\u9989\u7A39\u7A37\u7A51\u9ECF\u99A5\u7A70\u7688\u768E\u7693\u7699\u76A4\u74DE\u74E0\u752C\u9E20\u9E22\u9E28", 4, "\u9E32\u9E31\u9E36\u9E38\u9E37\u9E39\u9E3A\u9E3E\u9E41\u9E42\u9E44\u9E46\u9E47\u9E48\u9E49\u9E4B\u9E4C\u9E4E\u9E51\u9E55\u9E57\u9E5A\u9E5B\u9E5C\u9E5E\u9E63\u9E66", 6, "\u9E71\u9E6D\u9E73\u7592\u7594\u7596\u75A0\u759D\u75AC\u75A3\u75B3\u75B4\u75B8\u75C4\u75B1\u75B0\u75C3\u75C2\u75D6\u75CD\u75E3\u75E8\u75E6\u75E4\u75EB\u75E7\u7603\u75F1\u75FC\u75FF\u7610\u7600\u7605\u760C\u7617\u760A\u7625\u7618\u7615\u7619"],
+ ["f140", "\u998C\u998E\u999A", 10, "\u99A6\u99A7\u99A9", 47],
+ ["f180", "\u99D9", 32, "\u761B\u763C\u7622\u7620\u7640\u762D\u7630\u763F\u7635\u7643\u763E\u7633\u764D\u765E\u7654\u765C\u7656\u766B\u766F\u7FCA\u7AE6\u7A78\u7A79\u7A80\u7A86\u7A88\u7A95\u7AA6\u7AA0\u7AAC\u7AA8\u7AAD\u7AB3\u8864\u8869\u8872\u887D\u887F\u8882\u88A2\u88C6\u88B7\u88BC\u88C9\u88E2\u88CE\u88E3\u88E5\u88F1\u891A\u88FC\u88E8\u88FE\u88F0\u8921\u8919\u8913\u891B\u890A\u8934\u892B\u8936\u8941\u8966\u897B\u758B\u80E5\u76B2\u76B4\u77DC\u8012\u8014\u8016\u801C\u8020\u8022\u8025\u8026\u8027\u8029\u8028\u8031\u800B\u8035\u8043\u8046\u804D\u8052\u8069\u8071\u8983\u9878\u9880\u9883"],
+ ["f240", "\u99FA", 62],
+ ["f280", "\u9A39", 32, "\u9889\u988C\u988D\u988F\u9894\u989A\u989B\u989E\u989F\u98A1\u98A2\u98A5\u98A6\u864D\u8654\u866C\u866E\u867F\u867A\u867C\u867B\u86A8\u868D\u868B\u86AC\u869D\u86A7\u86A3\u86AA\u8693\u86A9\u86B6\u86C4\u86B5\u86CE\u86B0\u86BA\u86B1\u86AF\u86C9\u86CF\u86B4\u86E9\u86F1\u86F2\u86ED\u86F3\u86D0\u8713\u86DE\u86F4\u86DF\u86D8\u86D1\u8703\u8707\u86F8\u8708\u870A\u870D\u8709\u8723\u873B\u871E\u8725\u872E\u871A\u873E\u8748\u8734\u8731\u8729\u8737\u873F\u8782\u8722\u877D\u877E\u877B\u8760\u8770\u874C\u876E\u878B\u8753\u8763\u877C\u8764\u8759\u8765\u8793\u87AF\u87A8\u87D2"],
+ ["f340", "\u9A5A", 17, "\u9A72\u9A83\u9A89\u9A8D\u9A8E\u9A94\u9A95\u9A99\u9AA6\u9AA9", 6, "\u9AB2\u9AB3\u9AB4\u9AB5\u9AB9\u9ABB\u9ABD\u9ABE\u9ABF\u9AC3\u9AC4\u9AC6", 4, "\u9ACD\u9ACE\u9ACF\u9AD0\u9AD2\u9AD4\u9AD5\u9AD6\u9AD7\u9AD9\u9ADA\u9ADB\u9ADC"],
+ ["f380", "\u9ADD\u9ADE\u9AE0\u9AE2\u9AE3\u9AE4\u9AE5\u9AE7\u9AE8\u9AE9\u9AEA\u9AEC\u9AEE\u9AF0", 8, "\u9AFA\u9AFC", 6, "\u9B04\u9B05\u9B06\u87C6\u8788\u8785\u87AD\u8797\u8783\u87AB\u87E5\u87AC\u87B5\u87B3\u87CB\u87D3\u87BD\u87D1\u87C0\u87CA\u87DB\u87EA\u87E0\u87EE\u8816\u8813\u87FE\u880A\u881B\u8821\u8839\u883C\u7F36\u7F42\u7F44\u7F45\u8210\u7AFA\u7AFD\u7B08\u7B03\u7B04\u7B15\u7B0A\u7B2B\u7B0F\u7B47\u7B38\u7B2A\u7B19\u7B2E\u7B31\u7B20\u7B25\u7B24\u7B33\u7B3E\u7B1E\u7B58\u7B5A\u7B45\u7B75\u7B4C\u7B5D\u7B60\u7B6E\u7B7B\u7B62\u7B72\u7B71\u7B90\u7BA6\u7BA7\u7BB8\u7BAC\u7B9D\u7BA8\u7B85\u7BAA\u7B9C\u7BA2\u7BAB\u7BB4\u7BD1\u7BC1\u7BCC\u7BDD\u7BDA\u7BE5\u7BE6\u7BEA\u7C0C\u7BFE\u7BFC\u7C0F\u7C16\u7C0B"],
+ ["f440", "\u9B07\u9B09", 5, "\u9B10\u9B11\u9B12\u9B14", 10, "\u9B20\u9B21\u9B22\u9B24", 10, "\u9B30\u9B31\u9B33", 7, "\u9B3D\u9B3E\u9B3F\u9B40\u9B46\u9B4A\u9B4B\u9B4C\u9B4E\u9B50\u9B52\u9B53\u9B55", 5],
+ ["f480", "\u9B5B", 32, "\u7C1F\u7C2A\u7C26\u7C38\u7C41\u7C40\u81FE\u8201\u8202\u8204\u81EC\u8844\u8221\u8222\u8223\u822D\u822F\u8228\u822B\u8238\u823B\u8233\u8234\u823E\u8244\u8249\u824B\u824F\u825A\u825F\u8268\u887E\u8885\u8888\u88D8\u88DF\u895E\u7F9D\u7F9F\u7FA7\u7FAF\u7FB0\u7FB2\u7C7C\u6549\u7C91\u7C9D\u7C9C\u7C9E\u7CA2\u7CB2\u7CBC\u7CBD\u7CC1\u7CC7\u7CCC\u7CCD\u7CC8\u7CC5\u7CD7\u7CE8\u826E\u66A8\u7FBF\u7FCE\u7FD5\u7FE5\u7FE1\u7FE6\u7FE9\u7FEE\u7FF3\u7CF8\u7D77\u7DA6\u7DAE\u7E47\u7E9B\u9EB8\u9EB4\u8D73\u8D84\u8D94\u8D91\u8DB1\u8D67\u8D6D\u8C47\u8C49\u914A\u9150\u914E\u914F\u9164"],
+ ["f540", "\u9B7C", 62],
+ ["f580", "\u9BBB", 32, "\u9162\u9161\u9170\u9169\u916F\u917D\u917E\u9172\u9174\u9179\u918C\u9185\u9190\u918D\u9191\u91A2\u91A3\u91AA\u91AD\u91AE\u91AF\u91B5\u91B4\u91BA\u8C55\u9E7E\u8DB8\u8DEB\u8E05\u8E59\u8E69\u8DB5\u8DBF\u8DBC\u8DBA\u8DC4\u8DD6\u8DD7\u8DDA\u8DDE\u8DCE\u8DCF\u8DDB\u8DC6\u8DEC\u8DF7\u8DF8\u8DE3\u8DF9\u8DFB\u8DE4\u8E09\u8DFD\u8E14\u8E1D\u8E1F\u8E2C\u8E2E\u8E23\u8E2F\u8E3A\u8E40\u8E39\u8E35\u8E3D\u8E31\u8E49\u8E41\u8E42\u8E51\u8E52\u8E4A\u8E70\u8E76\u8E7C\u8E6F\u8E74\u8E85\u8E8F\u8E94\u8E90\u8E9C\u8E9E\u8C78\u8C82\u8C8A\u8C85\u8C98\u8C94\u659B\u89D6\u89DE\u89DA\u89DC"],
+ ["f640", "\u9BDC", 62],
+ ["f680", "\u9C1B", 32, "\u89E5\u89EB\u89EF\u8A3E\u8B26\u9753\u96E9\u96F3\u96EF\u9706\u9701\u9708\u970F\u970E\u972A\u972D\u9730\u973E\u9F80\u9F83\u9F85", 5, "\u9F8C\u9EFE\u9F0B\u9F0D\u96B9\u96BC\u96BD\u96CE\u96D2\u77BF\u96E0\u928E\u92AE\u92C8\u933E\u936A\u93CA\u938F\u943E\u946B\u9C7F\u9C82\u9C85\u9C86\u9C87\u9C88\u7A23\u9C8B\u9C8E\u9C90\u9C91\u9C92\u9C94\u9C95\u9C9A\u9C9B\u9C9E", 5, "\u9CA5", 4, "\u9CAB\u9CAD\u9CAE\u9CB0", 7, "\u9CBA\u9CBB\u9CBC\u9CBD\u9CC4\u9CC5\u9CC6\u9CC7\u9CCA\u9CCB"],
+ ["f740", "\u9C3C", 62],
+ ["f780", "\u9C7B\u9C7D\u9C7E\u9C80\u9C83\u9C84\u9C89\u9C8A\u9C8C\u9C8F\u9C93\u9C96\u9C97\u9C98\u9C99\u9C9D\u9CAA\u9CAC\u9CAF\u9CB9\u9CBE", 4, "\u9CC8\u9CC9\u9CD1\u9CD2\u9CDA\u9CDB\u9CE0\u9CE1\u9CCC", 4, "\u9CD3\u9CD4\u9CD5\u9CD7\u9CD8\u9CD9\u9CDC\u9CDD\u9CDF\u9CE2\u977C\u9785\u9791\u9792\u9794\u97AF\u97AB\u97A3\u97B2\u97B4\u9AB1\u9AB0\u9AB7\u9E58\u9AB6\u9ABA\u9ABC\u9AC1\u9AC0\u9AC5\u9AC2\u9ACB\u9ACC\u9AD1\u9B45\u9B43\u9B47\u9B49\u9B48\u9B4D\u9B51\u98E8\u990D\u992E\u9955\u9954\u9ADF\u9AE1\u9AE6\u9AEF\u9AEB\u9AFB\u9AED\u9AF9\u9B08\u9B0F\u9B13\u9B1F\u9B23\u9EBD\u9EBE\u7E3B\u9E82\u9E87\u9E88\u9E8B\u9E92\u93D6\u9E9D\u9E9F\u9EDB\u9EDC\u9EDD\u9EE0\u9EDF\u9EE2\u9EE9\u9EE7\u9EE5\u9EEA\u9EEF\u9F22\u9F2C\u9F2F\u9F39\u9F37\u9F3D\u9F3E\u9F44"],
+ ["f840", "\u9CE3", 62],
+ ["f880", "\u9D22", 32],
+ ["f940", "\u9D43", 62],
+ ["f980", "\u9D82", 32],
+ ["fa40", "\u9DA3", 62],
+ ["fa80", "\u9DE2", 32],
+ ["fb40", "\u9E03", 27, "\u9E24\u9E27\u9E2E\u9E30\u9E34\u9E3B\u9E3C\u9E40\u9E4D\u9E50\u9E52\u9E53\u9E54\u9E56\u9E59\u9E5D\u9E5F\u9E60\u9E61\u9E62\u9E65\u9E6E\u9E6F\u9E72\u9E74", 9, "\u9E80"],
+ ["fb80", "\u9E81\u9E83\u9E84\u9E85\u9E86\u9E89\u9E8A\u9E8C", 5, "\u9E94", 8, "\u9E9E\u9EA0", 5, "\u9EA7\u9EA8\u9EA9\u9EAA"],
+ ["fc40", "\u9EAB", 8, "\u9EB5\u9EB6\u9EB7\u9EB9\u9EBA\u9EBC\u9EBF", 4, "\u9EC5\u9EC6\u9EC7\u9EC8\u9ECA\u9ECB\u9ECC\u9ED0\u9ED2\u9ED3\u9ED5\u9ED6\u9ED7\u9ED9\u9EDA\u9EDE\u9EE1\u9EE3\u9EE4\u9EE6\u9EE8\u9EEB\u9EEC\u9EED\u9EEE\u9EF0", 8, "\u9EFA\u9EFD\u9EFF", 6],
+ ["fc80", "\u9F06", 4, "\u9F0C\u9F0F\u9F11\u9F12\u9F14\u9F15\u9F16\u9F18\u9F1A", 5, "\u9F21\u9F23", 8, "\u9F2D\u9F2E\u9F30\u9F31"],
+ ["fd40", "\u9F32", 4, "\u9F38\u9F3A\u9F3C\u9F3F", 4, "\u9F45", 10, "\u9F52", 38],
+ ["fd80", "\u9F79", 5, "\u9F81\u9F82\u9F8D", 11, "\u9F9C\u9F9D\u9F9E\u9FA1", 4, "\uF92C\uF979\uF995\uF9E7\uF9F1"],
+ ["fe40", "\uFA0C\uFA0D\uFA0E\uFA0F\uFA11\uFA13\uFA14\uFA18\uFA1F\uFA20\uFA21\uFA23\uFA24\uFA27\uFA28\uFA29"]
+ ];
+ }
+});
+
+// ../../node_modules/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/encodings/tables/gbk-added.json
+var require_gbk_added = __commonJS({
+ "../../node_modules/.pnpm/iconv-lite@0.4.24/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", "\uE7C7"],
+ ["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]
+ ];
+ }
+});
+
+// ../../node_modules/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/encodings/tables/gb18030-ranges.json
+var require_gb18030_ranges = __commonJS({
+ "../../node_modules/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/encodings/tables/gb18030-ranges.json"(exports2, module2) {
+ module2.exports = { uChars: [128, 165, 169, 178, 184, 216, 226, 235, 238, 244, 248, 251, 253, 258, 276, 284, 300, 325, 329, 334, 364, 463, 465, 467, 469, 471, 473, 475, 477, 506, 594, 610, 712, 716, 730, 930, 938, 962, 970, 1026, 1104, 1106, 8209, 8215, 8218, 8222, 8231, 8241, 8244, 8246, 8252, 8365, 8452, 8454, 8458, 8471, 8482, 8556, 8570, 8596, 8602, 8713, 8720, 8722, 8726, 8731, 8737, 8740, 8742, 8748, 8751, 8760, 8766, 8777, 8781, 8787, 8802, 8808, 8816, 8854, 8858, 8870, 8896, 8979, 9322, 9372, 9548, 9588, 9616, 9622, 9634, 9652, 9662, 9672, 9676, 9680, 9702, 9735, 9738, 9793, 9795, 11906, 11909, 11913, 11917, 11928, 11944, 11947, 11951, 11956, 11960, 11964, 11979, 12284, 12292, 12312, 12319, 12330, 12351, 12436, 12447, 12535, 12543, 12586, 12842, 12850, 12964, 13200, 13215, 13218, 13253, 13263, 13267, 13270, 13384, 13428, 13727, 13839, 13851, 14617, 14703, 14801, 14816, 14964, 15183, 15471, 15585, 16471, 16736, 17208, 17325, 17330, 17374, 17623, 17997, 18018, 18212, 18218, 18301, 18318, 18760, 18811, 18814, 18820, 18823, 18844, 18848, 18872, 19576, 19620, 19738, 19887, 40870, 59244, 59336, 59367, 59413, 59417, 59423, 59431, 59437, 59443, 59452, 59460, 59478, 59493, 63789, 63866, 63894, 63976, 63986, 64016, 64018, 64021, 64025, 64034, 64037, 64042, 65074, 65093, 65107, 65112, 65127, 65132, 65375, 65510, 65536], gbChars: [0, 36, 38, 45, 50, 81, 89, 95, 96, 100, 103, 104, 105, 109, 126, 133, 148, 172, 175, 179, 208, 306, 307, 308, 309, 310, 311, 312, 313, 341, 428, 443, 544, 545, 558, 741, 742, 749, 750, 805, 819, 820, 7922, 7924, 7925, 7927, 7934, 7943, 7944, 7945, 7950, 8062, 8148, 8149, 8152, 8164, 8174, 8236, 8240, 8262, 8264, 8374, 8380, 8381, 8384, 8388, 8390, 8392, 8393, 8394, 8396, 8401, 8406, 8416, 8419, 8424, 8437, 8439, 8445, 8482, 8485, 8496, 8521, 8603, 8936, 8946, 9046, 9050, 9063, 9066, 9076, 9092, 9100, 9108, 9111, 9113, 9131, 9162, 9164, 9218, 9219, 11329, 11331, 11334, 11336, 11346, 11361, 11363, 11366, 11370, 11372, 11375, 11389, 11682, 11686, 11687, 11692, 11694, 11714, 11716, 11723, 11725, 11730, 11736, 11982, 11989, 12102, 12336, 12348, 12350, 12384, 12393, 12395, 12397, 12510, 12553, 12851, 12962, 12973, 13738, 13823, 13919, 13933, 14080, 14298, 14585, 14698, 15583, 15847, 16318, 16434, 16438, 16481, 16729, 17102, 17122, 17315, 17320, 17402, 17418, 17859, 17909, 17911, 17915, 17916, 17936, 17939, 17961, 18664, 18703, 18814, 18962, 19043, 33469, 33470, 33471, 33484, 33485, 33490, 33497, 33501, 33505, 33513, 33520, 33536, 33550, 37845, 37921, 37948, 38029, 38038, 38064, 38065, 38066, 38069, 38075, 38076, 38078, 39108, 39109, 39113, 39114, 39115, 39116, 39265, 39394, 189e3] };
+ }
+});
+
+// ../../node_modules/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/encodings/tables/cp949.json
+var require_cp949 = __commonJS({
+ "../../node_modules/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/encodings/tables/cp949.json"(exports2, module2) {
+ module2.exports = [
+ ["0", "\0", 127],
+ ["8141", "\uAC02\uAC03\uAC05\uAC06\uAC0B", 4, "\uAC18\uAC1E\uAC1F\uAC21\uAC22\uAC23\uAC25", 6, "\uAC2E\uAC32\uAC33\uAC34"],
+ ["8161", "\uAC35\uAC36\uAC37\uAC3A\uAC3B\uAC3D\uAC3E\uAC3F\uAC41", 9, "\uAC4C\uAC4E", 5, "\uAC55"],
+ ["8181", "\uAC56\uAC57\uAC59\uAC5A\uAC5B\uAC5D", 18, "\uAC72\uAC73\uAC75\uAC76\uAC79\uAC7B", 4, "\uAC82\uAC87\uAC88\uAC8D\uAC8E\uAC8F\uAC91\uAC92\uAC93\uAC95", 6, "\uAC9E\uACA2", 5, "\uACAB\uACAD\uACAE\uACB1", 6, "\uACBA\uACBE\uACBF\uACC0\uACC2\uACC3\uACC5\uACC6\uACC7\uACC9\uACCA\uACCB\uACCD", 7, "\uACD6\uACD8", 7, "\uACE2\uACE3\uACE5\uACE6\uACE9\uACEB\uACED\uACEE\uACF2\uACF4\uACF7", 4, "\uACFE\uACFF\uAD01\uAD02\uAD03\uAD05\uAD07", 4, "\uAD0E\uAD10\uAD12\uAD13"],
+ ["8241", "\uAD14\uAD15\uAD16\uAD17\uAD19\uAD1A\uAD1B\uAD1D\uAD1E\uAD1F\uAD21", 7, "\uAD2A\uAD2B\uAD2E", 5],
+ ["8261", "\uAD36\uAD37\uAD39\uAD3A\uAD3B\uAD3D", 6, "\uAD46\uAD48\uAD4A", 5, "\uAD51\uAD52\uAD53\uAD55\uAD56\uAD57"],
+ ["8281", "\uAD59", 7, "\uAD62\uAD64", 7, "\uAD6E\uAD6F\uAD71\uAD72\uAD77\uAD78\uAD79\uAD7A\uAD7E\uAD80\uAD83", 4, "\uAD8A\uAD8B\uAD8D\uAD8E\uAD8F\uAD91", 10, "\uAD9E", 5, "\uADA5", 17, "\uADB8", 7, "\uADC2\uADC3\uADC5\uADC6\uADC7\uADC9", 6, "\uADD2\uADD4", 7, "\uADDD\uADDE\uADDF\uADE1\uADE2\uADE3\uADE5", 18],
+ ["8341", "\uADFA\uADFB\uADFD\uADFE\uAE02", 5, "\uAE0A\uAE0C\uAE0E", 5, "\uAE15", 7],
+ ["8361", "\uAE1D", 18, "\uAE32\uAE33\uAE35\uAE36\uAE39\uAE3B\uAE3C"],
+ ["8381", "\uAE3D\uAE3E\uAE3F\uAE42\uAE44\uAE47\uAE48\uAE49\uAE4B\uAE4F\uAE51\uAE52\uAE53\uAE55\uAE57", 4, "\uAE5E\uAE62\uAE63\uAE64\uAE66\uAE67\uAE6A\uAE6B\uAE6D\uAE6E\uAE6F\uAE71", 6, "\uAE7A\uAE7E", 5, "\uAE86", 5, "\uAE8D", 46, "\uAEBF\uAEC1\uAEC2\uAEC3\uAEC5", 6, "\uAECE\uAED2", 5, "\uAEDA\uAEDB\uAEDD", 8],
+ ["8441", "\uAEE6\uAEE7\uAEE9\uAEEA\uAEEC\uAEEE", 5, "\uAEF5\uAEF6\uAEF7\uAEF9\uAEFA\uAEFB\uAEFD", 8],
+ ["8461", "\uAF06\uAF09\uAF0A\uAF0B\uAF0C\uAF0E\uAF0F\uAF11", 18],
+ ["8481", "\uAF24", 7, "\uAF2E\uAF2F\uAF31\uAF33\uAF35", 6, "\uAF3E\uAF40\uAF44\uAF45\uAF46\uAF47\uAF4A", 5, "\uAF51", 10, "\uAF5E", 5, "\uAF66", 18, "\uAF7A", 5, "\uAF81\uAF82\uAF83\uAF85\uAF86\uAF87\uAF89", 6, "\uAF92\uAF93\uAF94\uAF96", 5, "\uAF9D", 26, "\uAFBA\uAFBB\uAFBD\uAFBE"],
+ ["8541", "\uAFBF\uAFC1", 5, "\uAFCA\uAFCC\uAFCF", 4, "\uAFD5", 6, "\uAFDD", 4],
+ ["8561", "\uAFE2", 5, "\uAFEA", 5, "\uAFF2\uAFF3\uAFF5\uAFF6\uAFF7\uAFF9", 6, "\uB002\uB003"],
+ ["8581", "\uB005", 6, "\uB00D\uB00E\uB00F\uB011\uB012\uB013\uB015", 6, "\uB01E", 9, "\uB029", 26, "\uB046\uB047\uB049\uB04B\uB04D\uB04F\uB050\uB051\uB052\uB056\uB058\uB05A\uB05B\uB05C\uB05E", 29, "\uB07E\uB07F\uB081\uB082\uB083\uB085", 6, "\uB08E\uB090\uB092", 5, "\uB09B\uB09D\uB09E\uB0A3\uB0A4"],
+ ["8641", "\uB0A5\uB0A6\uB0A7\uB0AA\uB0B0\uB0B2\uB0B6\uB0B7\uB0B9\uB0BA\uB0BB\uB0BD", 6, "\uB0C6\uB0CA", 5, "\uB0D2"],
+ ["8661", "\uB0D3\uB0D5\uB0D6\uB0D7\uB0D9", 6, "\uB0E1\uB0E2\uB0E3\uB0E4\uB0E6", 10],
+ ["8681", "\uB0F1", 22, "\uB10A\uB10D\uB10E\uB10F\uB111\uB114\uB115\uB116\uB117\uB11A\uB11E", 4, "\uB126\uB127\uB129\uB12A\uB12B\uB12D", 6, "\uB136\uB13A", 5, "\uB142\uB143\uB145\uB146\uB147\uB149", 6, "\uB152\uB153\uB156\uB157\uB159\uB15A\uB15B\uB15D\uB15E\uB15F\uB161", 22, "\uB17A\uB17B\uB17D\uB17E\uB17F\uB181\uB183", 4, "\uB18A\uB18C\uB18E\uB18F\uB190\uB191\uB195\uB196\uB197\uB199\uB19A\uB19B\uB19D"],
+ ["8741", "\uB19E", 9, "\uB1A9", 15],
+ ["8761", "\uB1B9", 18, "\uB1CD\uB1CE\uB1CF\uB1D1\uB1D2\uB1D3\uB1D5"],
+ ["8781", "\uB1D6", 5, "\uB1DE\uB1E0", 7, "\uB1EA\uB1EB\uB1ED\uB1EE\uB1EF\uB1F1", 7, "\uB1FA\uB1FC\uB1FE", 5, "\uB206\uB207\uB209\uB20A\uB20D", 6, "\uB216\uB218\uB21A", 5, "\uB221", 18, "\uB235", 6, "\uB23D", 26, "\uB259\uB25A\uB25B\uB25D\uB25E\uB25F\uB261", 6, "\uB26A", 4],
+ ["8841", "\uB26F", 4, "\uB276", 5, "\uB27D", 6, "\uB286\uB287\uB288\uB28A", 4],
+ ["8861", "\uB28F\uB292\uB293\uB295\uB296\uB297\uB29B", 4, "\uB2A2\uB2A4\uB2A7\uB2A8\uB2A9\uB2AB\uB2AD\uB2AE\uB2AF\uB2B1\uB2B2\uB2B3\uB2B5\uB2B6\uB2B7"],
+ ["8881", "\uB2B8", 15, "\uB2CA\uB2CB\uB2CD\uB2CE\uB2CF\uB2D1\uB2D3", 4, "\uB2DA\uB2DC\uB2DE\uB2DF\uB2E0\uB2E1\uB2E3\uB2E7\uB2E9\uB2EA\uB2F0\uB2F1\uB2F2\uB2F6\uB2FC\uB2FD\uB2FE\uB302\uB303\uB305\uB306\uB307\uB309", 6, "\uB312\uB316", 5, "\uB31D", 54, "\uB357\uB359\uB35A\uB35D\uB360\uB361\uB362\uB363"],
+ ["8941", "\uB366\uB368\uB36A\uB36C\uB36D\uB36F\uB372\uB373\uB375\uB376\uB377\uB379", 6, "\uB382\uB386", 5, "\uB38D"],
+ ["8961", "\uB38E\uB38F\uB391\uB392\uB393\uB395", 10, "\uB3A2", 5, "\uB3A9\uB3AA\uB3AB\uB3AD"],
+ ["8981", "\uB3AE", 21, "\uB3C6\uB3C7\uB3C9\uB3CA\uB3CD\uB3CF\uB3D1\uB3D2\uB3D3\uB3D6\uB3D8\uB3DA\uB3DC\uB3DE\uB3DF\uB3E1\uB3E2\uB3E3\uB3E5\uB3E6\uB3E7\uB3E9", 18, "\uB3FD", 18, "\uB411", 6, "\uB419\uB41A\uB41B\uB41D\uB41E\uB41F\uB421", 6, "\uB42A\uB42C", 7, "\uB435", 15],
+ ["8a41", "\uB445", 10, "\uB452\uB453\uB455\uB456\uB457\uB459", 6, "\uB462\uB464\uB466"],
+ ["8a61", "\uB467", 4, "\uB46D", 18, "\uB481\uB482"],
+ ["8a81", "\uB483", 4, "\uB489", 19, "\uB49E", 5, "\uB4A5\uB4A6\uB4A7\uB4A9\uB4AA\uB4AB\uB4AD", 7, "\uB4B6\uB4B8\uB4BA", 5, "\uB4C1\uB4C2\uB4C3\uB4C5\uB4C6\uB4C7\uB4C9", 6, "\uB4D1\uB4D2\uB4D3\uB4D4\uB4D6", 5, "\uB4DE\uB4DF\uB4E1\uB4E2\uB4E5\uB4E7", 4, "\uB4EE\uB4F0\uB4F2", 5, "\uB4F9", 26, "\uB516\uB517\uB519\uB51A\uB51D"],
+ ["8b41", "\uB51E", 5, "\uB526\uB52B", 4, "\uB532\uB533\uB535\uB536\uB537\uB539", 6, "\uB542\uB546"],
+ ["8b61", "\uB547\uB548\uB549\uB54A\uB54E\uB54F\uB551\uB552\uB553\uB555", 6, "\uB55E\uB562", 8],
+ ["8b81", "\uB56B", 52, "\uB5A2\uB5A3\uB5A5\uB5A6\uB5A7\uB5A9\uB5AC\uB5AD\uB5AE\uB5AF\uB5B2\uB5B6", 4, "\uB5BE\uB5BF\uB5C1\uB5C2\uB5C3\uB5C5", 6, "\uB5CE\uB5D2", 5, "\uB5D9", 18, "\uB5ED", 18],
+ ["8c41", "\uB600", 15, "\uB612\uB613\uB615\uB616\uB617\uB619", 4],
+ ["8c61", "\uB61E", 6, "\uB626", 5, "\uB62D", 6, "\uB635", 5],
+ ["8c81", "\uB63B", 12, "\uB649", 26, "\uB665\uB666\uB667\uB669", 50, "\uB69E\uB69F\uB6A1\uB6A2\uB6A3\uB6A5", 5, "\uB6AD\uB6AE\uB6AF\uB6B0\uB6B2", 16],
+ ["8d41", "\uB6C3", 16, "\uB6D5", 8],
+ ["8d61", "\uB6DE", 17, "\uB6F1\uB6F2\uB6F3\uB6F5\uB6F6\uB6F7\uB6F9\uB6FA"],
+ ["8d81", "\uB6FB", 4, "\uB702\uB703\uB704\uB706", 33, "\uB72A\uB72B\uB72D\uB72E\uB731", 6, "\uB73A\uB73C", 7, "\uB745\uB746\uB747\uB749\uB74A\uB74B\uB74D", 6, "\uB756", 9, "\uB761\uB762\uB763\uB765\uB766\uB767\uB769", 6, "\uB772\uB774\uB776", 5, "\uB77E\uB77F\uB781\uB782\uB783\uB785", 6, "\uB78E\uB793\uB794\uB795\uB79A\uB79B\uB79D\uB79E"],
+ ["8e41", "\uB79F\uB7A1", 6, "\uB7AA\uB7AE", 5, "\uB7B6\uB7B7\uB7B9", 8],
+ ["8e61", "\uB7C2", 4, "\uB7C8\uB7CA", 19],
+ ["8e81", "\uB7DE", 13, "\uB7EE\uB7EF\uB7F1\uB7F2\uB7F3\uB7F5", 6, "\uB7FE\uB802", 4, "\uB80A\uB80B\uB80D\uB80E\uB80F\uB811", 6, "\uB81A\uB81C\uB81E", 5, "\uB826\uB827\uB829\uB82A\uB82B\uB82D", 6, "\uB836\uB83A", 5, "\uB841\uB842\uB843\uB845", 11, "\uB852\uB854", 7, "\uB85E\uB85F\uB861\uB862\uB863\uB865", 6, "\uB86E\uB870\uB872", 5, "\uB879\uB87A\uB87B\uB87D", 7],
+ ["8f41", "\uB885", 7, "\uB88E", 17],
+ ["8f61", "\uB8A0", 7, "\uB8A9", 6, "\uB8B1\uB8B2\uB8B3\uB8B5\uB8B6\uB8B7\uB8B9", 4],
+ ["8f81", "\uB8BE\uB8BF\uB8C2\uB8C4\uB8C6", 5, "\uB8CD\uB8CE\uB8CF\uB8D1\uB8D2\uB8D3\uB8D5", 7, "\uB8DE\uB8E0\uB8E2", 5, "\uB8EA\uB8EB\uB8ED\uB8EE\uB8EF\uB8F1", 6, "\uB8FA\uB8FC\uB8FE", 5, "\uB905", 18, "\uB919", 6, "\uB921", 26, "\uB93E\uB93F\uB941\uB942\uB943\uB945", 6, "\uB94D\uB94E\uB950\uB952", 5],
+ ["9041", "\uB95A\uB95B\uB95D\uB95E\uB95F\uB961", 6, "\uB96A\uB96C\uB96E", 5, "\uB976\uB977\uB979\uB97A\uB97B\uB97D"],
+ ["9061", "\uB97E", 5, "\uB986\uB988\uB98B\uB98C\uB98F", 15],
+ ["9081", "\uB99F", 12, "\uB9AE\uB9AF\uB9B1\uB9B2\uB9B3\uB9B5", 6, "\uB9BE\uB9C0\uB9C2", 5, "\uB9CA\uB9CB\uB9CD\uB9D3", 4, "\uB9DA\uB9DC\uB9DF\uB9E0\uB9E2\uB9E6\uB9E7\uB9E9\uB9EA\uB9EB\uB9ED", 6, "\uB9F6\uB9FB", 4, "\uBA02", 5, "\uBA09", 11, "\uBA16", 33, "\uBA3A\uBA3B\uBA3D\uBA3E\uBA3F\uBA41\uBA43\uBA44\uBA45\uBA46"],
+ ["9141", "\uBA47\uBA4A\uBA4C\uBA4F\uBA50\uBA51\uBA52\uBA56\uBA57\uBA59\uBA5A\uBA5B\uBA5D", 6, "\uBA66\uBA6A", 5],
+ ["9161", "\uBA72\uBA73\uBA75\uBA76\uBA77\uBA79", 9, "\uBA86\uBA88\uBA89\uBA8A\uBA8B\uBA8D", 5],
+ ["9181", "\uBA93", 20, "\uBAAA\uBAAD\uBAAE\uBAAF\uBAB1\uBAB3", 4, "\uBABA\uBABC\uBABE", 5, "\uBAC5\uBAC6\uBAC7\uBAC9", 14, "\uBADA", 33, "\uBAFD\uBAFE\uBAFF\uBB01\uBB02\uBB03\uBB05", 7, "\uBB0E\uBB10\uBB12", 5, "\uBB19\uBB1A\uBB1B\uBB1D\uBB1E\uBB1F\uBB21", 6],
+ ["9241", "\uBB28\uBB2A\uBB2C", 7, "\uBB37\uBB39\uBB3A\uBB3F", 4, "\uBB46\uBB48\uBB4A\uBB4B\uBB4C\uBB4E\uBB51\uBB52"],
+ ["9261", "\uBB53\uBB55\uBB56\uBB57\uBB59", 7, "\uBB62\uBB64", 7, "\uBB6D", 4],
+ ["9281", "\uBB72", 21, "\uBB89\uBB8A\uBB8B\uBB8D\uBB8E\uBB8F\uBB91", 18, "\uBBA5\uBBA6\uBBA7\uBBA9\uBBAA\uBBAB\uBBAD", 6, "\uBBB5\uBBB6\uBBB8", 7, "\uBBC1\uBBC2\uBBC3\uBBC5\uBBC6\uBBC7\uBBC9", 6, "\uBBD1\uBBD2\uBBD4", 35, "\uBBFA\uBBFB\uBBFD\uBBFE\uBC01"],
+ ["9341", "\uBC03", 4, "\uBC0A\uBC0E\uBC10\uBC12\uBC13\uBC19\uBC1A\uBC20\uBC21\uBC22\uBC23\uBC26\uBC28\uBC2A\uBC2B\uBC2C\uBC2E\uBC2F\uBC32\uBC33\uBC35"],
+ ["9361", "\uBC36\uBC37\uBC39", 6, "\uBC42\uBC46\uBC47\uBC48\uBC4A\uBC4B\uBC4E\uBC4F\uBC51", 8],
+ ["9381", "\uBC5A\uBC5B\uBC5C\uBC5E", 37, "\uBC86\uBC87\uBC89\uBC8A\uBC8D\uBC8F", 4, "\uBC96\uBC98\uBC9B", 4, "\uBCA2\uBCA3\uBCA5\uBCA6\uBCA9", 6, "\uBCB2\uBCB6", 5, "\uBCBE\uBCBF\uBCC1\uBCC2\uBCC3\uBCC5", 7, "\uBCCE\uBCD2\uBCD3\uBCD4\uBCD6\uBCD7\uBCD9\uBCDA\uBCDB\uBCDD", 22, "\uBCF7\uBCF9\uBCFA\uBCFB\uBCFD"],
+ ["9441", "\uBCFE", 5, "\uBD06\uBD08\uBD0A", 5, "\uBD11\uBD12\uBD13\uBD15", 8],
+ ["9461", "\uBD1E", 5, "\uBD25", 6, "\uBD2D", 12],
+ ["9481", "\uBD3A", 5, "\uBD41", 6, "\uBD4A\uBD4B\uBD4D\uBD4E\uBD4F\uBD51", 6, "\uBD5A", 9, "\uBD65\uBD66\uBD67\uBD69", 22, "\uBD82\uBD83\uBD85\uBD86\uBD8B", 4, "\uBD92\uBD94\uBD96\uBD97\uBD98\uBD9B\uBD9D", 6, "\uBDA5", 10, "\uBDB1", 6, "\uBDB9", 24],
+ ["9541", "\uBDD2\uBDD3\uBDD6\uBDD7\uBDD9\uBDDA\uBDDB\uBDDD", 11, "\uBDEA", 5, "\uBDF1"],
+ ["9561", "\uBDF2\uBDF3\uBDF5\uBDF6\uBDF7\uBDF9", 6, "\uBE01\uBE02\uBE04\uBE06", 5, "\uBE0E\uBE0F\uBE11\uBE12\uBE13"],
+ ["9581", "\uBE15", 6, "\uBE1E\uBE20", 35, "\uBE46\uBE47\uBE49\uBE4A\uBE4B\uBE4D\uBE4F", 4, "\uBE56\uBE58\uBE5C\uBE5D\uBE5E\uBE5F\uBE62\uBE63\uBE65\uBE66\uBE67\uBE69\uBE6B", 4, "\uBE72\uBE76", 4, "\uBE7E\uBE7F\uBE81\uBE82\uBE83\uBE85", 6, "\uBE8E\uBE92", 5, "\uBE9A", 13, "\uBEA9", 14],
+ ["9641", "\uBEB8", 23, "\uBED2\uBED3"],
+ ["9661", "\uBED5\uBED6\uBED9", 6, "\uBEE1\uBEE2\uBEE6", 5, "\uBEED", 8],
+ ["9681", "\uBEF6", 10, "\uBF02", 5, "\uBF0A", 13, "\uBF1A\uBF1E", 33, "\uBF42\uBF43\uBF45\uBF46\uBF47\uBF49", 6, "\uBF52\uBF53\uBF54\uBF56", 44],
+ ["9741", "\uBF83", 16, "\uBF95", 8],
+ ["9761", "\uBF9E", 17, "\uBFB1", 7],
+ ["9781", "\uBFB9", 11, "\uBFC6", 5, "\uBFCE\uBFCF\uBFD1\uBFD2\uBFD3\uBFD5", 6, "\uBFDD\uBFDE\uBFE0\uBFE2", 89, "\uC03D\uC03E\uC03F"],
+ ["9841", "\uC040", 16, "\uC052", 5, "\uC059\uC05A\uC05B"],
+ ["9861", "\uC05D\uC05E\uC05F\uC061", 6, "\uC06A", 15],
+ ["9881", "\uC07A", 21, "\uC092\uC093\uC095\uC096\uC097\uC099", 6, "\uC0A2\uC0A4\uC0A6", 5, "\uC0AE\uC0B1\uC0B2\uC0B7", 4, "\uC0BE\uC0C2\uC0C3\uC0C4\uC0C6\uC0C7\uC0CA\uC0CB\uC0CD\uC0CE\uC0CF\uC0D1", 6, "\uC0DA\uC0DE", 5, "\uC0E6\uC0E7\uC0E9\uC0EA\uC0EB\uC0ED", 6, "\uC0F6\uC0F8\uC0FA", 5, "\uC101\uC102\uC103\uC105\uC106\uC107\uC109", 6, "\uC111\uC112\uC113\uC114\uC116", 5, "\uC121\uC122\uC125\uC128\uC129\uC12A\uC12B\uC12E"],
+ ["9941", "\uC132\uC133\uC134\uC135\uC137\uC13A\uC13B\uC13D\uC13E\uC13F\uC141", 6, "\uC14A\uC14E", 5, "\uC156\uC157"],
+ ["9961", "\uC159\uC15A\uC15B\uC15D", 6, "\uC166\uC16A", 5, "\uC171\uC172\uC173\uC175\uC176\uC177\uC179\uC17A\uC17B"],
+ ["9981", "\uC17C", 8, "\uC186", 5, "\uC18F\uC191\uC192\uC193\uC195\uC197", 4, "\uC19E\uC1A0\uC1A2\uC1A3\uC1A4\uC1A6\uC1A7\uC1AA\uC1AB\uC1AD\uC1AE\uC1AF\uC1B1", 11, "\uC1BE", 5, "\uC1C5\uC1C6\uC1C7\uC1C9\uC1CA\uC1CB\uC1CD", 6, "\uC1D5\uC1D6\uC1D9", 6, "\uC1E1\uC1E2\uC1E3\uC1E5\uC1E6\uC1E7\uC1E9", 6, "\uC1F2\uC1F4", 7, "\uC1FE\uC1FF\uC201\uC202\uC203\uC205", 6, "\uC20E\uC210\uC212", 5, "\uC21A\uC21B\uC21D\uC21E\uC221\uC222\uC223"],
+ ["9a41", "\uC224\uC225\uC226\uC227\uC22A\uC22C\uC22E\uC230\uC233\uC235", 16],
+ ["9a61", "\uC246\uC247\uC249", 6, "\uC252\uC253\uC255\uC256\uC257\uC259", 6, "\uC261\uC262\uC263\uC264\uC266"],
+ ["9a81", "\uC267", 4, "\uC26E\uC26F\uC271\uC272\uC273\uC275", 6, "\uC27E\uC280\uC282", 5, "\uC28A", 5, "\uC291", 6, "\uC299\uC29A\uC29C\uC29E", 5, "\uC2A6\uC2A7\uC2A9\uC2AA\uC2AB\uC2AE", 5, "\uC2B6\uC2B8\uC2BA", 33, "\uC2DE\uC2DF\uC2E1\uC2E2\uC2E5", 5, "\uC2EE\uC2F0\uC2F2\uC2F3\uC2F4\uC2F5\uC2F7\uC2FA\uC2FD\uC2FE\uC2FF\uC301", 6, "\uC30A\uC30B\uC30E\uC30F"],
+ ["9b41", "\uC310\uC311\uC312\uC316\uC317\uC319\uC31A\uC31B\uC31D", 6, "\uC326\uC327\uC32A", 8],
+ ["9b61", "\uC333", 17, "\uC346", 7],
+ ["9b81", "\uC34E", 25, "\uC36A\uC36B\uC36D\uC36E\uC36F\uC371\uC373", 4, "\uC37A\uC37B\uC37E", 5, "\uC385\uC386\uC387\uC389\uC38A\uC38B\uC38D", 50, "\uC3C1", 22, "\uC3DA"],
+ ["9c41", "\uC3DB\uC3DD\uC3DE\uC3E1\uC3E3", 4, "\uC3EA\uC3EB\uC3EC\uC3EE", 5, "\uC3F6\uC3F7\uC3F9", 5],
+ ["9c61", "\uC3FF", 8, "\uC409", 6, "\uC411", 9],
+ ["9c81", "\uC41B", 8, "\uC425", 6, "\uC42D\uC42E\uC42F\uC431\uC432\uC433\uC435", 6, "\uC43E", 9, "\uC449", 26, "\uC466\uC467\uC469\uC46A\uC46B\uC46D", 6, "\uC476\uC477\uC478\uC47A", 5, "\uC481", 18, "\uC495", 6, "\uC49D", 12],
+ ["9d41", "\uC4AA", 13, "\uC4B9\uC4BA\uC4BB\uC4BD", 8],
+ ["9d61", "\uC4C6", 25],
+ ["9d81", "\uC4E0", 8, "\uC4EA", 5, "\uC4F2\uC4F3\uC4F5\uC4F6\uC4F7\uC4F9\uC4FB\uC4FC\uC4FD\uC4FE\uC502", 9, "\uC50D\uC50E\uC50F\uC511\uC512\uC513\uC515", 6, "\uC51D", 10, "\uC52A\uC52B\uC52D\uC52E\uC52F\uC531", 6, "\uC53A\uC53C\uC53E", 5, "\uC546\uC547\uC54B\uC54F\uC550\uC551\uC552\uC556\uC55A\uC55B\uC55C\uC55F\uC562\uC563\uC565\uC566\uC567\uC569", 6, "\uC572\uC576", 5, "\uC57E\uC57F\uC581\uC582\uC583\uC585\uC586\uC588\uC589\uC58A\uC58B\uC58E\uC590\uC592\uC593\uC594"],
+ ["9e41", "\uC596\uC599\uC59A\uC59B\uC59D\uC59E\uC59F\uC5A1", 7, "\uC5AA", 9, "\uC5B6"],
+ ["9e61", "\uC5B7\uC5BA\uC5BF", 4, "\uC5CB\uC5CD\uC5CF\uC5D2\uC5D3\uC5D5\uC5D6\uC5D7\uC5D9", 6, "\uC5E2\uC5E4\uC5E6\uC5E7"],
+ ["9e81", "\uC5E8\uC5E9\uC5EA\uC5EB\uC5EF\uC5F1\uC5F2\uC5F3\uC5F5\uC5F8\uC5F9\uC5FA\uC5FB\uC602\uC603\uC604\uC609\uC60A\uC60B\uC60D\uC60E\uC60F\uC611", 6, "\uC61A\uC61D", 6, "\uC626\uC627\uC629\uC62A\uC62B\uC62F\uC631\uC632\uC636\uC638\uC63A\uC63C\uC63D\uC63E\uC63F\uC642\uC643\uC645\uC646\uC647\uC649", 6, "\uC652\uC656", 5, "\uC65E\uC65F\uC661", 10, "\uC66D\uC66E\uC670\uC672", 5, "\uC67A\uC67B\uC67D\uC67E\uC67F\uC681", 6, "\uC68A\uC68C\uC68E", 5, "\uC696\uC697\uC699\uC69A\uC69B\uC69D", 6, "\uC6A6"],
+ ["9f41", "\uC6A8\uC6AA", 5, "\uC6B2\uC6B3\uC6B5\uC6B6\uC6B7\uC6BB", 4, "\uC6C2\uC6C4\uC6C6", 5, "\uC6CE"],
+ ["9f61", "\uC6CF\uC6D1\uC6D2\uC6D3\uC6D5", 6, "\uC6DE\uC6DF\uC6E2", 5, "\uC6EA\uC6EB\uC6ED\uC6EE\uC6EF\uC6F1\uC6F2"],
+ ["9f81", "\uC6F3", 4, "\uC6FA\uC6FB\uC6FC\uC6FE", 5, "\uC706\uC707\uC709\uC70A\uC70B\uC70D", 6, "\uC716\uC718\uC71A", 5, "\uC722\uC723\uC725\uC726\uC727\uC729", 6, "\uC732\uC734\uC736\uC738\uC739\uC73A\uC73B\uC73E\uC73F\uC741\uC742\uC743\uC745", 4, "\uC74B\uC74E\uC750\uC759\uC75A\uC75B\uC75D\uC75E\uC75F\uC761", 6, "\uC769\uC76A\uC76C", 7, "\uC776\uC777\uC779\uC77A\uC77B\uC77F\uC780\uC781\uC782\uC786\uC78B\uC78C\uC78D\uC78F\uC792\uC793\uC795\uC799\uC79B", 4, "\uC7A2\uC7A7", 4, "\uC7AE\uC7AF\uC7B1\uC7B2\uC7B3\uC7B5\uC7B6\uC7B7"],
+ ["a041", "\uC7B8\uC7B9\uC7BA\uC7BB\uC7BE\uC7C2", 5, "\uC7CA\uC7CB\uC7CD\uC7CF\uC7D1", 6, "\uC7D9\uC7DA\uC7DB\uC7DC"],
+ ["a061", "\uC7DE", 5, "\uC7E5\uC7E6\uC7E7\uC7E9\uC7EA\uC7EB\uC7ED", 13],
+ ["a081", "\uC7FB", 4, "\uC802\uC803\uC805\uC806\uC807\uC809\uC80B", 4, "\uC812\uC814\uC817", 4, "\uC81E\uC81F\uC821\uC822\uC823\uC825", 6, "\uC82E\uC830\uC832", 5, "\uC839\uC83A\uC83B\uC83D\uC83E\uC83F\uC841", 6, "\uC84A\uC84B\uC84E", 5, "\uC855", 26, "\uC872\uC873\uC875\uC876\uC877\uC879\uC87B", 4, "\uC882\uC884\uC888\uC889\uC88A\uC88E", 5, "\uC895", 7, "\uC89E\uC8A0\uC8A2\uC8A3\uC8A4"],
+ ["a141", "\uC8A5\uC8A6\uC8A7\uC8A9", 18, "\uC8BE\uC8BF\uC8C0\uC8C1"],
+ ["a161", "\uC8C2\uC8C3\uC8C5\uC8C6\uC8C7\uC8C9\uC8CA\uC8CB\uC8CD", 6, "\uC8D6\uC8D8\uC8DA", 5, "\uC8E2\uC8E3\uC8E5"],
+ ["a181", "\uC8E6", 14, "\uC8F6", 5, "\uC8FE\uC8FF\uC901\uC902\uC903\uC907", 4, "\uC90E\u3000\u3001\u3002\xB7\u2025\u2026\xA8\u3003\xAD\u2015\u2225\uFF3C\u223C\u2018\u2019\u201C\u201D\u3014\u3015\u3008", 9, "\xB1\xD7\xF7\u2260\u2264\u2265\u221E\u2234\xB0\u2032\u2033\u2103\u212B\uFFE0\uFFE1\uFFE5\u2642\u2640\u2220\u22A5\u2312\u2202\u2207\u2261\u2252\xA7\u203B\u2606\u2605\u25CB\u25CF\u25CE\u25C7\u25C6\u25A1\u25A0\u25B3\u25B2\u25BD\u25BC\u2192\u2190\u2191\u2193\u2194\u3013\u226A\u226B\u221A\u223D\u221D\u2235\u222B\u222C\u2208\u220B\u2286\u2287\u2282\u2283\u222A\u2229\u2227\u2228\uFFE2"],
+ ["a241", "\uC910\uC912", 5, "\uC919", 18],
+ ["a261", "\uC92D", 6, "\uC935", 18],
+ ["a281", "\uC948", 7, "\uC952\uC953\uC955\uC956\uC957\uC959", 6, "\uC962\uC964", 7, "\uC96D\uC96E\uC96F\u21D2\u21D4\u2200\u2203\xB4\uFF5E\u02C7\u02D8\u02DD\u02DA\u02D9\xB8\u02DB\xA1\xBF\u02D0\u222E\u2211\u220F\xA4\u2109\u2030\u25C1\u25C0\u25B7\u25B6\u2664\u2660\u2661\u2665\u2667\u2663\u2299\u25C8\u25A3\u25D0\u25D1\u2592\u25A4\u25A5\u25A8\u25A7\u25A6\u25A9\u2668\u260F\u260E\u261C\u261E\xB6\u2020\u2021\u2195\u2197\u2199\u2196\u2198\u266D\u2669\u266A\u266C\u327F\u321C\u2116\u33C7\u2122\u33C2\u33D8\u2121\u20AC\xAE"],
+ ["a341", "\uC971\uC972\uC973\uC975", 6, "\uC97D", 10, "\uC98A\uC98B\uC98D\uC98E\uC98F"],
+ ["a361", "\uC991", 6, "\uC99A\uC99C\uC99E", 16],
+ ["a381", "\uC9AF", 16, "\uC9C2\uC9C3\uC9C5\uC9C6\uC9C9\uC9CB", 4, "\uC9D2\uC9D4\uC9D7\uC9D8\uC9DB\uFF01", 58, "\uFFE6\uFF3D", 32, "\uFFE3"],
+ ["a441", "\uC9DE\uC9DF\uC9E1\uC9E3\uC9E5\uC9E6\uC9E8\uC9E9\uC9EA\uC9EB\uC9EE\uC9F2", 5, "\uC9FA\uC9FB\uC9FD\uC9FE\uC9FF\uCA01\uCA02\uCA03\uCA04"],
+ ["a461", "\uCA05\uCA06\uCA07\uCA0A\uCA0E", 5, "\uCA15\uCA16\uCA17\uCA19", 12],
+ ["a481", "\uCA26\uCA27\uCA28\uCA2A", 28, "\u3131", 93],
+ ["a541", "\uCA47", 4, "\uCA4E\uCA4F\uCA51\uCA52\uCA53\uCA55", 6, "\uCA5E\uCA62", 5, "\uCA69\uCA6A"],
+ ["a561", "\uCA6B", 17, "\uCA7E", 5, "\uCA85\uCA86"],
+ ["a581", "\uCA87", 16, "\uCA99", 14, "\u2170", 9],
+ ["a5b0", "\u2160", 9],
+ ["a5c1", "\u0391", 16, "\u03A3", 6],
+ ["a5e1", "\u03B1", 16, "\u03C3", 6],
+ ["a641", "\uCAA8", 19, "\uCABE\uCABF\uCAC1\uCAC2\uCAC3\uCAC5"],
+ ["a661", "\uCAC6", 5, "\uCACE\uCAD0\uCAD2\uCAD4\uCAD5\uCAD6\uCAD7\uCADA", 5, "\uCAE1", 6],
+ ["a681", "\uCAE8\uCAE9\uCAEA\uCAEB\uCAED", 6, "\uCAF5", 18, "\uCB09\uCB0A\u2500\u2502\u250C\u2510\u2518\u2514\u251C\u252C\u2524\u2534\u253C\u2501\u2503\u250F\u2513\u251B\u2517\u2523\u2533\u252B\u253B\u254B\u2520\u252F\u2528\u2537\u253F\u251D\u2530\u2525\u2538\u2542\u2512\u2511\u251A\u2519\u2516\u2515\u250E\u250D\u251E\u251F\u2521\u2522\u2526\u2527\u2529\u252A\u252D\u252E\u2531\u2532\u2535\u2536\u2539\u253A\u253D\u253E\u2540\u2541\u2543", 7],
+ ["a741", "\uCB0B", 4, "\uCB11\uCB12\uCB13\uCB15\uCB16\uCB17\uCB19", 6, "\uCB22", 7],
+ ["a761", "\uCB2A", 22, "\uCB42\uCB43\uCB44"],
+ ["a781", "\uCB45\uCB46\uCB47\uCB4A\uCB4B\uCB4D\uCB4E\uCB4F\uCB51", 6, "\uCB5A\uCB5B\uCB5C\uCB5E", 5, "\uCB65", 7, "\u3395\u3396\u3397\u2113\u3398\u33C4\u33A3\u33A4\u33A5\u33A6\u3399", 9, "\u33CA\u338D\u338E\u338F\u33CF\u3388\u3389\u33C8\u33A7\u33A8\u33B0", 9, "\u3380", 4, "\u33BA", 5, "\u3390", 4, "\u2126\u33C0\u33C1\u338A\u338B\u338C\u33D6\u33C5\u33AD\u33AE\u33AF\u33DB\u33A9\u33AA\u33AB\u33AC\u33DD\u33D0\u33D3\u33C3\u33C9\u33DC\u33C6"],
+ ["a841", "\uCB6D", 10, "\uCB7A", 14],
+ ["a861", "\uCB89", 18, "\uCB9D", 6],
+ ["a881", "\uCBA4", 19, "\uCBB9", 11, "\xC6\xD0\xAA\u0126"],
+ ["a8a6", "\u0132"],
+ ["a8a8", "\u013F\u0141\xD8\u0152\xBA\xDE\u0166\u014A"],
+ ["a8b1", "\u3260", 27, "\u24D0", 25, "\u2460", 14, "\xBD\u2153\u2154\xBC\xBE\u215B\u215C\u215D\u215E"],
+ ["a941", "\uCBC5", 14, "\uCBD5", 10],
+ ["a961", "\uCBE0\uCBE1\uCBE2\uCBE3\uCBE5\uCBE6\uCBE8\uCBEA", 18],
+ ["a981", "\uCBFD", 14, "\uCC0E\uCC0F\uCC11\uCC12\uCC13\uCC15", 6, "\uCC1E\uCC1F\uCC20\uCC23\uCC24\xE6\u0111\xF0\u0127\u0131\u0133\u0138\u0140\u0142\xF8\u0153\xDF\xFE\u0167\u014B\u0149\u3200", 27, "\u249C", 25, "\u2474", 14, "\xB9\xB2\xB3\u2074\u207F\u2081\u2082\u2083\u2084"],
+ ["aa41", "\uCC25\uCC26\uCC2A\uCC2B\uCC2D\uCC2F\uCC31", 6, "\uCC3A\uCC3F", 4, "\uCC46\uCC47\uCC49\uCC4A\uCC4B\uCC4D\uCC4E"],
+ ["aa61", "\uCC4F", 4, "\uCC56\uCC5A", 5, "\uCC61\uCC62\uCC63\uCC65\uCC67\uCC69", 6, "\uCC71\uCC72"],
+ ["aa81", "\uCC73\uCC74\uCC76", 29, "\u3041", 82],
+ ["ab41", "\uCC94\uCC95\uCC96\uCC97\uCC9A\uCC9B\uCC9D\uCC9E\uCC9F\uCCA1", 6, "\uCCAA\uCCAE", 5, "\uCCB6\uCCB7\uCCB9"],
+ ["ab61", "\uCCBA\uCCBB\uCCBD", 6, "\uCCC6\uCCC8\uCCCA", 5, "\uCCD1\uCCD2\uCCD3\uCCD5", 5],
+ ["ab81", "\uCCDB", 8, "\uCCE5", 6, "\uCCED\uCCEE\uCCEF\uCCF1", 12, "\u30A1", 85],
+ ["ac41", "\uCCFE\uCCFF\uCD00\uCD02", 5, "\uCD0A\uCD0B\uCD0D\uCD0E\uCD0F\uCD11", 6, "\uCD1A\uCD1C\uCD1E\uCD1F\uCD20"],
+ ["ac61", "\uCD21\uCD22\uCD23\uCD25\uCD26\uCD27\uCD29\uCD2A\uCD2B\uCD2D", 11, "\uCD3A", 4],
+ ["ac81", "\uCD3F", 28, "\uCD5D\uCD5E\uCD5F\u0410", 5, "\u0401\u0416", 25],
+ ["acd1", "\u0430", 5, "\u0451\u0436", 25],
+ ["ad41", "\uCD61\uCD62\uCD63\uCD65", 6, "\uCD6E\uCD70\uCD72", 5, "\uCD79", 7],
+ ["ad61", "\uCD81", 6, "\uCD89", 10, "\uCD96\uCD97\uCD99\uCD9A\uCD9B\uCD9D\uCD9E\uCD9F"],
+ ["ad81", "\uCDA0\uCDA1\uCDA2\uCDA3\uCDA6\uCDA8\uCDAA", 5, "\uCDB1", 18, "\uCDC5"],
+ ["ae41", "\uCDC6", 5, "\uCDCD\uCDCE\uCDCF\uCDD1", 16],
+ ["ae61", "\uCDE2", 5, "\uCDE9\uCDEA\uCDEB\uCDED\uCDEE\uCDEF\uCDF1", 6, "\uCDFA\uCDFC\uCDFE", 4],
+ ["ae81", "\uCE03\uCE05\uCE06\uCE07\uCE09\uCE0A\uCE0B\uCE0D", 6, "\uCE15\uCE16\uCE17\uCE18\uCE1A", 5, "\uCE22\uCE23\uCE25\uCE26\uCE27\uCE29\uCE2A\uCE2B"],
+ ["af41", "\uCE2C\uCE2D\uCE2E\uCE2F\uCE32\uCE34\uCE36", 19],
+ ["af61", "\uCE4A", 13, "\uCE5A\uCE5B\uCE5D\uCE5E\uCE62", 5, "\uCE6A\uCE6C"],
+ ["af81", "\uCE6E", 5, "\uCE76\uCE77\uCE79\uCE7A\uCE7B\uCE7D", 6, "\uCE86\uCE88\uCE8A", 5, "\uCE92\uCE93\uCE95\uCE96\uCE97\uCE99"],
+ ["b041", "\uCE9A", 5, "\uCEA2\uCEA6", 5, "\uCEAE", 12],
+ ["b061", "\uCEBB", 5, "\uCEC2", 19],
+ ["b081", "\uCED6", 13, "\uCEE6\uCEE7\uCEE9\uCEEA\uCEED", 6, "\uCEF6\uCEFA", 5, "\uAC00\uAC01\uAC04\uAC07\uAC08\uAC09\uAC0A\uAC10", 7, "\uAC19", 4, "\uAC20\uAC24\uAC2C\uAC2D\uAC2F\uAC30\uAC31\uAC38\uAC39\uAC3C\uAC40\uAC4B\uAC4D\uAC54\uAC58\uAC5C\uAC70\uAC71\uAC74\uAC77\uAC78\uAC7A\uAC80\uAC81\uAC83\uAC84\uAC85\uAC86\uAC89\uAC8A\uAC8B\uAC8C\uAC90\uAC94\uAC9C\uAC9D\uAC9F\uACA0\uACA1\uACA8\uACA9\uACAA\uACAC\uACAF\uACB0\uACB8\uACB9\uACBB\uACBC\uACBD\uACC1\uACC4\uACC8\uACCC\uACD5\uACD7\uACE0\uACE1\uACE4\uACE7\uACE8\uACEA\uACEC\uACEF\uACF0\uACF1\uACF3\uACF5\uACF6\uACFC\uACFD\uAD00\uAD04\uAD06"],
+ ["b141", "\uCF02\uCF03\uCF05\uCF06\uCF07\uCF09", 6, "\uCF12\uCF14\uCF16", 5, "\uCF1D\uCF1E\uCF1F\uCF21\uCF22\uCF23"],
+ ["b161", "\uCF25", 6, "\uCF2E\uCF32", 5, "\uCF39", 11],
+ ["b181", "\uCF45", 14, "\uCF56\uCF57\uCF59\uCF5A\uCF5B\uCF5D", 6, "\uCF66\uCF68\uCF6A\uCF6B\uCF6C\uAD0C\uAD0D\uAD0F\uAD11\uAD18\uAD1C\uAD20\uAD29\uAD2C\uAD2D\uAD34\uAD35\uAD38\uAD3C\uAD44\uAD45\uAD47\uAD49\uAD50\uAD54\uAD58\uAD61\uAD63\uAD6C\uAD6D\uAD70\uAD73\uAD74\uAD75\uAD76\uAD7B\uAD7C\uAD7D\uAD7F\uAD81\uAD82\uAD88\uAD89\uAD8C\uAD90\uAD9C\uAD9D\uADA4\uADB7\uADC0\uADC1\uADC4\uADC8\uADD0\uADD1\uADD3\uADDC\uADE0\uADE4\uADF8\uADF9\uADFC\uADFF\uAE00\uAE01\uAE08\uAE09\uAE0B\uAE0D\uAE14\uAE30\uAE31\uAE34\uAE37\uAE38\uAE3A\uAE40\uAE41\uAE43\uAE45\uAE46\uAE4A\uAE4C\uAE4D\uAE4E\uAE50\uAE54\uAE56\uAE5C\uAE5D\uAE5F\uAE60\uAE61\uAE65\uAE68\uAE69\uAE6C\uAE70\uAE78"],
+ ["b241", "\uCF6D\uCF6E\uCF6F\uCF72\uCF73\uCF75\uCF76\uCF77\uCF79", 6, "\uCF81\uCF82\uCF83\uCF84\uCF86", 5, "\uCF8D"],
+ ["b261", "\uCF8E", 18, "\uCFA2", 5, "\uCFA9"],
+ ["b281", "\uCFAA", 5, "\uCFB1", 18, "\uCFC5", 6, "\uAE79\uAE7B\uAE7C\uAE7D\uAE84\uAE85\uAE8C\uAEBC\uAEBD\uAEBE\uAEC0\uAEC4\uAECC\uAECD\uAECF\uAED0\uAED1\uAED8\uAED9\uAEDC\uAEE8\uAEEB\uAEED\uAEF4\uAEF8\uAEFC\uAF07\uAF08\uAF0D\uAF10\uAF2C\uAF2D\uAF30\uAF32\uAF34\uAF3C\uAF3D\uAF3F\uAF41\uAF42\uAF43\uAF48\uAF49\uAF50\uAF5C\uAF5D\uAF64\uAF65\uAF79\uAF80\uAF84\uAF88\uAF90\uAF91\uAF95\uAF9C\uAFB8\uAFB9\uAFBC\uAFC0\uAFC7\uAFC8\uAFC9\uAFCB\uAFCD\uAFCE\uAFD4\uAFDC\uAFE8\uAFE9\uAFF0\uAFF1\uAFF4\uAFF8\uB000\uB001\uB004\uB00C\uB010\uB014\uB01C\uB01D\uB028\uB044\uB045\uB048\uB04A\uB04C\uB04E\uB053\uB054\uB055\uB057\uB059"],
+ ["b341", "\uCFCC", 19, "\uCFE2\uCFE3\uCFE5\uCFE6\uCFE7\uCFE9"],
+ ["b361", "\uCFEA", 5, "\uCFF2\uCFF4\uCFF6", 5, "\uCFFD\uCFFE\uCFFF\uD001\uD002\uD003\uD005", 5],
+ ["b381", "\uD00B", 5, "\uD012", 5, "\uD019", 19, "\uB05D\uB07C\uB07D\uB080\uB084\uB08C\uB08D\uB08F\uB091\uB098\uB099\uB09A\uB09C\uB09F\uB0A0\uB0A1\uB0A2\uB0A8\uB0A9\uB0AB", 4, "\uB0B1\uB0B3\uB0B4\uB0B5\uB0B8\uB0BC\uB0C4\uB0C5\uB0C7\uB0C8\uB0C9\uB0D0\uB0D1\uB0D4\uB0D8\uB0E0\uB0E5\uB108\uB109\uB10B\uB10C\uB110\uB112\uB113\uB118\uB119\uB11B\uB11C\uB11D\uB123\uB124\uB125\uB128\uB12C\uB134\uB135\uB137\uB138\uB139\uB140\uB141\uB144\uB148\uB150\uB151\uB154\uB155\uB158\uB15C\uB160\uB178\uB179\uB17C\uB180\uB182\uB188\uB189\uB18B\uB18D\uB192\uB193\uB194\uB198\uB19C\uB1A8\uB1CC\uB1D0\uB1D4\uB1DC\uB1DD"],
+ ["b441", "\uD02E", 5, "\uD036\uD037\uD039\uD03A\uD03B\uD03D", 6, "\uD046\uD048\uD04A", 5],
+ ["b461", "\uD051\uD052\uD053\uD055\uD056\uD057\uD059", 6, "\uD061", 10, "\uD06E\uD06F"],
+ ["b481", "\uD071\uD072\uD073\uD075", 6, "\uD07E\uD07F\uD080\uD082", 18, "\uB1DF\uB1E8\uB1E9\uB1EC\uB1F0\uB1F9\uB1FB\uB1FD\uB204\uB205\uB208\uB20B\uB20C\uB214\uB215\uB217\uB219\uB220\uB234\uB23C\uB258\uB25C\uB260\uB268\uB269\uB274\uB275\uB27C\uB284\uB285\uB289\uB290\uB291\uB294\uB298\uB299\uB29A\uB2A0\uB2A1\uB2A3\uB2A5\uB2A6\uB2AA\uB2AC\uB2B0\uB2B4\uB2C8\uB2C9\uB2CC\uB2D0\uB2D2\uB2D8\uB2D9\uB2DB\uB2DD\uB2E2\uB2E4\uB2E5\uB2E6\uB2E8\uB2EB", 4, "\uB2F3\uB2F4\uB2F5\uB2F7", 4, "\uB2FF\uB300\uB301\uB304\uB308\uB310\uB311\uB313\uB314\uB315\uB31C\uB354\uB355\uB356\uB358\uB35B\uB35C\uB35E\uB35F\uB364\uB365"],
+ ["b541", "\uD095", 14, "\uD0A6\uD0A7\uD0A9\uD0AA\uD0AB\uD0AD", 5],
+ ["b561", "\uD0B3\uD0B6\uD0B8\uD0BA", 5, "\uD0C2\uD0C3\uD0C5\uD0C6\uD0C7\uD0CA", 5, "\uD0D2\uD0D6", 4],
+ ["b581", "\uD0DB\uD0DE\uD0DF\uD0E1\uD0E2\uD0E3\uD0E5", 6, "\uD0EE\uD0F2", 5, "\uD0F9", 11, "\uB367\uB369\uB36B\uB36E\uB370\uB371\uB374\uB378\uB380\uB381\uB383\uB384\uB385\uB38C\uB390\uB394\uB3A0\uB3A1\uB3A8\uB3AC\uB3C4\uB3C5\uB3C8\uB3CB\uB3CC\uB3CE\uB3D0\uB3D4\uB3D5\uB3D7\uB3D9\uB3DB\uB3DD\uB3E0\uB3E4\uB3E8\uB3FC\uB410\uB418\uB41C\uB420\uB428\uB429\uB42B\uB434\uB450\uB451\uB454\uB458\uB460\uB461\uB463\uB465\uB46C\uB480\uB488\uB49D\uB4A4\uB4A8\uB4AC\uB4B5\uB4B7\uB4B9\uB4C0\uB4C4\uB4C8\uB4D0\uB4D5\uB4DC\uB4DD\uB4E0\uB4E3\uB4E4\uB4E6\uB4EC\uB4ED\uB4EF\uB4F1\uB4F8\uB514\uB515\uB518\uB51B\uB51C\uB524\uB525\uB527\uB528\uB529\uB52A\uB530\uB531\uB534\uB538"],
+ ["b641", "\uD105", 7, "\uD10E", 17],
+ ["b661", "\uD120", 15, "\uD132\uD133\uD135\uD136\uD137\uD139\uD13B\uD13C\uD13D\uD13E"],
+ ["b681", "\uD13F\uD142\uD146", 5, "\uD14E\uD14F\uD151\uD152\uD153\uD155", 6, "\uD15E\uD160\uD162", 5, "\uD169\uD16A\uD16B\uD16D\uB540\uB541\uB543\uB544\uB545\uB54B\uB54C\uB54D\uB550\uB554\uB55C\uB55D\uB55F\uB560\uB561\uB5A0\uB5A1\uB5A4\uB5A8\uB5AA\uB5AB\uB5B0\uB5B1\uB5B3\uB5B4\uB5B5\uB5BB\uB5BC\uB5BD\uB5C0\uB5C4\uB5CC\uB5CD\uB5CF\uB5D0\uB5D1\uB5D8\uB5EC\uB610\uB611\uB614\uB618\uB625\uB62C\uB634\uB648\uB664\uB668\uB69C\uB69D\uB6A0\uB6A4\uB6AB\uB6AC\uB6B1\uB6D4\uB6F0\uB6F4\uB6F8\uB700\uB701\uB705\uB728\uB729\uB72C\uB72F\uB730\uB738\uB739\uB73B\uB744\uB748\uB74C\uB754\uB755\uB760\uB764\uB768\uB770\uB771\uB773\uB775\uB77C\uB77D\uB780\uB784\uB78C\uB78D\uB78F\uB790\uB791\uB792\uB796\uB797"],
+ ["b741", "\uD16E", 13, "\uD17D", 6, "\uD185\uD186\uD187\uD189\uD18A"],
+ ["b761", "\uD18B", 20, "\uD1A2\uD1A3\uD1A5\uD1A6\uD1A7"],
+ ["b781", "\uD1A9", 6, "\uD1B2\uD1B4\uD1B6\uD1B7\uD1B8\uD1B9\uD1BB\uD1BD\uD1BE\uD1BF\uD1C1", 14, "\uB798\uB799\uB79C\uB7A0\uB7A8\uB7A9\uB7AB\uB7AC\uB7AD\uB7B4\uB7B5\uB7B8\uB7C7\uB7C9\uB7EC\uB7ED\uB7F0\uB7F4\uB7FC\uB7FD\uB7FF\uB800\uB801\uB807\uB808\uB809\uB80C\uB810\uB818\uB819\uB81B\uB81D\uB824\uB825\uB828\uB82C\uB834\uB835\uB837\uB838\uB839\uB840\uB844\uB851\uB853\uB85C\uB85D\uB860\uB864\uB86C\uB86D\uB86F\uB871\uB878\uB87C\uB88D\uB8A8\uB8B0\uB8B4\uB8B8\uB8C0\uB8C1\uB8C3\uB8C5\uB8CC\uB8D0\uB8D4\uB8DD\uB8DF\uB8E1\uB8E8\uB8E9\uB8EC\uB8F0\uB8F8\uB8F9\uB8FB\uB8FD\uB904\uB918\uB920\uB93C\uB93D\uB940\uB944\uB94C\uB94F\uB951\uB958\uB959\uB95C\uB960\uB968\uB969"],
+ ["b841", "\uD1D0", 7, "\uD1D9", 17],
+ ["b861", "\uD1EB", 8, "\uD1F5\uD1F6\uD1F7\uD1F9", 13],
+ ["b881", "\uD208\uD20A", 5, "\uD211", 24, "\uB96B\uB96D\uB974\uB975\uB978\uB97C\uB984\uB985\uB987\uB989\uB98A\uB98D\uB98E\uB9AC\uB9AD\uB9B0\uB9B4\uB9BC\uB9BD\uB9BF\uB9C1\uB9C8\uB9C9\uB9CC\uB9CE", 4, "\uB9D8\uB9D9\uB9DB\uB9DD\uB9DE\uB9E1\uB9E3\uB9E4\uB9E5\uB9E8\uB9EC\uB9F4\uB9F5\uB9F7\uB9F8\uB9F9\uB9FA\uBA00\uBA01\uBA08\uBA15\uBA38\uBA39\uBA3C\uBA40\uBA42\uBA48\uBA49\uBA4B\uBA4D\uBA4E\uBA53\uBA54\uBA55\uBA58\uBA5C\uBA64\uBA65\uBA67\uBA68\uBA69\uBA70\uBA71\uBA74\uBA78\uBA83\uBA84\uBA85\uBA87\uBA8C\uBAA8\uBAA9\uBAAB\uBAAC\uBAB0\uBAB2\uBAB8\uBAB9\uBABB\uBABD\uBAC4\uBAC8\uBAD8\uBAD9\uBAFC"],
+ ["b941", "\uD22A\uD22B\uD22E\uD22F\uD231\uD232\uD233\uD235", 6, "\uD23E\uD240\uD242", 5, "\uD249\uD24A\uD24B\uD24C"],
+ ["b961", "\uD24D", 14, "\uD25D", 6, "\uD265\uD266\uD267\uD268"],
+ ["b981", "\uD269", 22, "\uD282\uD283\uD285\uD286\uD287\uD289\uD28A\uD28B\uD28C\uBB00\uBB04\uBB0D\uBB0F\uBB11\uBB18\uBB1C\uBB20\uBB29\uBB2B\uBB34\uBB35\uBB36\uBB38\uBB3B\uBB3C\uBB3D\uBB3E\uBB44\uBB45\uBB47\uBB49\uBB4D\uBB4F\uBB50\uBB54\uBB58\uBB61\uBB63\uBB6C\uBB88\uBB8C\uBB90\uBBA4\uBBA8\uBBAC\uBBB4\uBBB7\uBBC0\uBBC4\uBBC8\uBBD0\uBBD3\uBBF8\uBBF9\uBBFC\uBBFF\uBC00\uBC02\uBC08\uBC09\uBC0B\uBC0C\uBC0D\uBC0F\uBC11\uBC14", 4, "\uBC1B", 4, "\uBC24\uBC25\uBC27\uBC29\uBC2D\uBC30\uBC31\uBC34\uBC38\uBC40\uBC41\uBC43\uBC44\uBC45\uBC49\uBC4C\uBC4D\uBC50\uBC5D\uBC84\uBC85\uBC88\uBC8B\uBC8C\uBC8E\uBC94\uBC95\uBC97"],
+ ["ba41", "\uD28D\uD28E\uD28F\uD292\uD293\uD294\uD296", 5, "\uD29D\uD29E\uD29F\uD2A1\uD2A2\uD2A3\uD2A5", 6, "\uD2AD"],
+ ["ba61", "\uD2AE\uD2AF\uD2B0\uD2B2", 5, "\uD2BA\uD2BB\uD2BD\uD2BE\uD2C1\uD2C3", 4, "\uD2CA\uD2CC", 5],
+ ["ba81", "\uD2D2\uD2D3\uD2D5\uD2D6\uD2D7\uD2D9\uD2DA\uD2DB\uD2DD", 6, "\uD2E6", 9, "\uD2F2\uD2F3\uD2F5\uD2F6\uD2F7\uD2F9\uD2FA\uBC99\uBC9A\uBCA0\uBCA1\uBCA4\uBCA7\uBCA8\uBCB0\uBCB1\uBCB3\uBCB4\uBCB5\uBCBC\uBCBD\uBCC0\uBCC4\uBCCD\uBCCF\uBCD0\uBCD1\uBCD5\uBCD8\uBCDC\uBCF4\uBCF5\uBCF6\uBCF8\uBCFC\uBD04\uBD05\uBD07\uBD09\uBD10\uBD14\uBD24\uBD2C\uBD40\uBD48\uBD49\uBD4C\uBD50\uBD58\uBD59\uBD64\uBD68\uBD80\uBD81\uBD84\uBD87\uBD88\uBD89\uBD8A\uBD90\uBD91\uBD93\uBD95\uBD99\uBD9A\uBD9C\uBDA4\uBDB0\uBDB8\uBDD4\uBDD5\uBDD8\uBDDC\uBDE9\uBDF0\uBDF4\uBDF8\uBE00\uBE03\uBE05\uBE0C\uBE0D\uBE10\uBE14\uBE1C\uBE1D\uBE1F\uBE44\uBE45\uBE48\uBE4C\uBE4E\uBE54\uBE55\uBE57\uBE59\uBE5A\uBE5B\uBE60\uBE61\uBE64"],
+ ["bb41", "\uD2FB", 4, "\uD302\uD304\uD306", 5, "\uD30F\uD311\uD312\uD313\uD315\uD317", 4, "\uD31E\uD322\uD323"],
+ ["bb61", "\uD324\uD326\uD327\uD32A\uD32B\uD32D\uD32E\uD32F\uD331", 6, "\uD33A\uD33E", 5, "\uD346\uD347\uD348\uD349"],
+ ["bb81", "\uD34A", 31, "\uBE68\uBE6A\uBE70\uBE71\uBE73\uBE74\uBE75\uBE7B\uBE7C\uBE7D\uBE80\uBE84\uBE8C\uBE8D\uBE8F\uBE90\uBE91\uBE98\uBE99\uBEA8\uBED0\uBED1\uBED4\uBED7\uBED8\uBEE0\uBEE3\uBEE4\uBEE5\uBEEC\uBF01\uBF08\uBF09\uBF18\uBF19\uBF1B\uBF1C\uBF1D\uBF40\uBF41\uBF44\uBF48\uBF50\uBF51\uBF55\uBF94\uBFB0\uBFC5\uBFCC\uBFCD\uBFD0\uBFD4\uBFDC\uBFDF\uBFE1\uC03C\uC051\uC058\uC05C\uC060\uC068\uC069\uC090\uC091\uC094\uC098\uC0A0\uC0A1\uC0A3\uC0A5\uC0AC\uC0AD\uC0AF\uC0B0\uC0B3\uC0B4\uC0B5\uC0B6\uC0BC\uC0BD\uC0BF\uC0C0\uC0C1\uC0C5\uC0C8\uC0C9\uC0CC\uC0D0\uC0D8\uC0D9\uC0DB\uC0DC\uC0DD\uC0E4"],
+ ["bc41", "\uD36A", 17, "\uD37E\uD37F\uD381\uD382\uD383\uD385\uD386\uD387"],
+ ["bc61", "\uD388\uD389\uD38A\uD38B\uD38E\uD392", 5, "\uD39A\uD39B\uD39D\uD39E\uD39F\uD3A1", 6, "\uD3AA\uD3AC\uD3AE"],
+ ["bc81", "\uD3AF", 4, "\uD3B5\uD3B6\uD3B7\uD3B9\uD3BA\uD3BB\uD3BD", 6, "\uD3C6\uD3C7\uD3CA", 5, "\uD3D1", 5, "\uC0E5\uC0E8\uC0EC\uC0F4\uC0F5\uC0F7\uC0F9\uC100\uC104\uC108\uC110\uC115\uC11C", 4, "\uC123\uC124\uC126\uC127\uC12C\uC12D\uC12F\uC130\uC131\uC136\uC138\uC139\uC13C\uC140\uC148\uC149\uC14B\uC14C\uC14D\uC154\uC155\uC158\uC15C\uC164\uC165\uC167\uC168\uC169\uC170\uC174\uC178\uC185\uC18C\uC18D\uC18E\uC190\uC194\uC196\uC19C\uC19D\uC19F\uC1A1\uC1A5\uC1A8\uC1A9\uC1AC\uC1B0\uC1BD\uC1C4\uC1C8\uC1CC\uC1D4\uC1D7\uC1D8\uC1E0\uC1E4\uC1E8\uC1F0\uC1F1\uC1F3\uC1FC\uC1FD\uC200\uC204\uC20C\uC20D\uC20F\uC211\uC218\uC219\uC21C\uC21F\uC220\uC228\uC229\uC22B\uC22D"],
+ ["bd41", "\uD3D7\uD3D9", 7, "\uD3E2\uD3E4", 7, "\uD3EE\uD3EF\uD3F1\uD3F2\uD3F3\uD3F5\uD3F6\uD3F7"],
+ ["bd61", "\uD3F8\uD3F9\uD3FA\uD3FB\uD3FE\uD400\uD402", 5, "\uD409", 13],
+ ["bd81", "\uD417", 5, "\uD41E", 25, "\uC22F\uC231\uC232\uC234\uC248\uC250\uC251\uC254\uC258\uC260\uC265\uC26C\uC26D\uC270\uC274\uC27C\uC27D\uC27F\uC281\uC288\uC289\uC290\uC298\uC29B\uC29D\uC2A4\uC2A5\uC2A8\uC2AC\uC2AD\uC2B4\uC2B5\uC2B7\uC2B9\uC2DC\uC2DD\uC2E0\uC2E3\uC2E4\uC2EB\uC2EC\uC2ED\uC2EF\uC2F1\uC2F6\uC2F8\uC2F9\uC2FB\uC2FC\uC300\uC308\uC309\uC30C\uC30D\uC313\uC314\uC315\uC318\uC31C\uC324\uC325\uC328\uC329\uC345\uC368\uC369\uC36C\uC370\uC372\uC378\uC379\uC37C\uC37D\uC384\uC388\uC38C\uC3C0\uC3D8\uC3D9\uC3DC\uC3DF\uC3E0\uC3E2\uC3E8\uC3E9\uC3ED\uC3F4\uC3F5\uC3F8\uC408\uC410\uC424\uC42C\uC430"],
+ ["be41", "\uD438", 7, "\uD441\uD442\uD443\uD445", 14],
+ ["be61", "\uD454", 7, "\uD45D\uD45E\uD45F\uD461\uD462\uD463\uD465", 7, "\uD46E\uD470\uD471\uD472"],
+ ["be81", "\uD473", 4, "\uD47A\uD47B\uD47D\uD47E\uD481\uD483", 4, "\uD48A\uD48C\uD48E", 5, "\uD495", 8, "\uC434\uC43C\uC43D\uC448\uC464\uC465\uC468\uC46C\uC474\uC475\uC479\uC480\uC494\uC49C\uC4B8\uC4BC\uC4E9\uC4F0\uC4F1\uC4F4\uC4F8\uC4FA\uC4FF\uC500\uC501\uC50C\uC510\uC514\uC51C\uC528\uC529\uC52C\uC530\uC538\uC539\uC53B\uC53D\uC544\uC545\uC548\uC549\uC54A\uC54C\uC54D\uC54E\uC553\uC554\uC555\uC557\uC558\uC559\uC55D\uC55E\uC560\uC561\uC564\uC568\uC570\uC571\uC573\uC574\uC575\uC57C\uC57D\uC580\uC584\uC587\uC58C\uC58D\uC58F\uC591\uC595\uC597\uC598\uC59C\uC5A0\uC5A9\uC5B4\uC5B5\uC5B8\uC5B9\uC5BB\uC5BC\uC5BD\uC5BE\uC5C4", 6, "\uC5CC\uC5CE"],
+ ["bf41", "\uD49E", 10, "\uD4AA", 14],
+ ["bf61", "\uD4B9", 18, "\uD4CD\uD4CE\uD4CF\uD4D1\uD4D2\uD4D3\uD4D5"],
+ ["bf81", "\uD4D6", 5, "\uD4DD\uD4DE\uD4E0", 7, "\uD4E9\uD4EA\uD4EB\uD4ED\uD4EE\uD4EF\uD4F1", 6, "\uD4F9\uD4FA\uD4FC\uC5D0\uC5D1\uC5D4\uC5D8\uC5E0\uC5E1\uC5E3\uC5E5\uC5EC\uC5ED\uC5EE\uC5F0\uC5F4\uC5F6\uC5F7\uC5FC", 5, "\uC605\uC606\uC607\uC608\uC60C\uC610\uC618\uC619\uC61B\uC61C\uC624\uC625\uC628\uC62C\uC62D\uC62E\uC630\uC633\uC634\uC635\uC637\uC639\uC63B\uC640\uC641\uC644\uC648\uC650\uC651\uC653\uC654\uC655\uC65C\uC65D\uC660\uC66C\uC66F\uC671\uC678\uC679\uC67C\uC680\uC688\uC689\uC68B\uC68D\uC694\uC695\uC698\uC69C\uC6A4\uC6A5\uC6A7\uC6A9\uC6B0\uC6B1\uC6B4\uC6B8\uC6B9\uC6BA\uC6C0\uC6C1\uC6C3\uC6C5\uC6CC\uC6CD\uC6D0\uC6D4\uC6DC\uC6DD\uC6E0\uC6E1\uC6E8"],
+ ["c041", "\uD4FE", 5, "\uD505\uD506\uD507\uD509\uD50A\uD50B\uD50D", 6, "\uD516\uD518", 5],
+ ["c061", "\uD51E", 25],
+ ["c081", "\uD538\uD539\uD53A\uD53B\uD53E\uD53F\uD541\uD542\uD543\uD545", 6, "\uD54E\uD550\uD552", 5, "\uD55A\uD55B\uD55D\uD55E\uD55F\uD561\uD562\uD563\uC6E9\uC6EC\uC6F0\uC6F8\uC6F9\uC6FD\uC704\uC705\uC708\uC70C\uC714\uC715\uC717\uC719\uC720\uC721\uC724\uC728\uC730\uC731\uC733\uC735\uC737\uC73C\uC73D\uC740\uC744\uC74A\uC74C\uC74D\uC74F\uC751", 7, "\uC75C\uC760\uC768\uC76B\uC774\uC775\uC778\uC77C\uC77D\uC77E\uC783\uC784\uC785\uC787\uC788\uC789\uC78A\uC78E\uC790\uC791\uC794\uC796\uC797\uC798\uC79A\uC7A0\uC7A1\uC7A3\uC7A4\uC7A5\uC7A6\uC7AC\uC7AD\uC7B0\uC7B4\uC7BC\uC7BD\uC7BF\uC7C0\uC7C1\uC7C8\uC7C9\uC7CC\uC7CE\uC7D0\uC7D8\uC7DD\uC7E4\uC7E8\uC7EC\uC800\uC801\uC804\uC808\uC80A"],
+ ["c141", "\uD564\uD566\uD567\uD56A\uD56C\uD56E", 5, "\uD576\uD577\uD579\uD57A\uD57B\uD57D", 6, "\uD586\uD58A\uD58B"],
+ ["c161", "\uD58C\uD58D\uD58E\uD58F\uD591", 19, "\uD5A6\uD5A7"],
+ ["c181", "\uD5A8", 31, "\uC810\uC811\uC813\uC815\uC816\uC81C\uC81D\uC820\uC824\uC82C\uC82D\uC82F\uC831\uC838\uC83C\uC840\uC848\uC849\uC84C\uC84D\uC854\uC870\uC871\uC874\uC878\uC87A\uC880\uC881\uC883\uC885\uC886\uC887\uC88B\uC88C\uC88D\uC894\uC89D\uC89F\uC8A1\uC8A8\uC8BC\uC8BD\uC8C4\uC8C8\uC8CC\uC8D4\uC8D5\uC8D7\uC8D9\uC8E0\uC8E1\uC8E4\uC8F5\uC8FC\uC8FD\uC900\uC904\uC905\uC906\uC90C\uC90D\uC90F\uC911\uC918\uC92C\uC934\uC950\uC951\uC954\uC958\uC960\uC961\uC963\uC96C\uC970\uC974\uC97C\uC988\uC989\uC98C\uC990\uC998\uC999\uC99B\uC99D\uC9C0\uC9C1\uC9C4\uC9C7\uC9C8\uC9CA\uC9D0\uC9D1\uC9D3"],
+ ["c241", "\uD5CA\uD5CB\uD5CD\uD5CE\uD5CF\uD5D1\uD5D3", 4, "\uD5DA\uD5DC\uD5DE", 5, "\uD5E6\uD5E7\uD5E9\uD5EA\uD5EB\uD5ED\uD5EE"],
+ ["c261", "\uD5EF", 4, "\uD5F6\uD5F8\uD5FA", 5, "\uD602\uD603\uD605\uD606\uD607\uD609", 6, "\uD612"],
+ ["c281", "\uD616", 5, "\uD61D\uD61E\uD61F\uD621\uD622\uD623\uD625", 7, "\uD62E", 9, "\uD63A\uD63B\uC9D5\uC9D6\uC9D9\uC9DA\uC9DC\uC9DD\uC9E0\uC9E2\uC9E4\uC9E7\uC9EC\uC9ED\uC9EF\uC9F0\uC9F1\uC9F8\uC9F9\uC9FC\uCA00\uCA08\uCA09\uCA0B\uCA0C\uCA0D\uCA14\uCA18\uCA29\uCA4C\uCA4D\uCA50\uCA54\uCA5C\uCA5D\uCA5F\uCA60\uCA61\uCA68\uCA7D\uCA84\uCA98\uCABC\uCABD\uCAC0\uCAC4\uCACC\uCACD\uCACF\uCAD1\uCAD3\uCAD8\uCAD9\uCAE0\uCAEC\uCAF4\uCB08\uCB10\uCB14\uCB18\uCB20\uCB21\uCB41\uCB48\uCB49\uCB4C\uCB50\uCB58\uCB59\uCB5D\uCB64\uCB78\uCB79\uCB9C\uCBB8\uCBD4\uCBE4\uCBE7\uCBE9\uCC0C\uCC0D\uCC10\uCC14\uCC1C\uCC1D\uCC21\uCC22\uCC27\uCC28\uCC29\uCC2C\uCC2E\uCC30\uCC38\uCC39\uCC3B"],
+ ["c341", "\uD63D\uD63E\uD63F\uD641\uD642\uD643\uD644\uD646\uD647\uD64A\uD64C\uD64E\uD64F\uD650\uD652\uD653\uD656\uD657\uD659\uD65A\uD65B\uD65D", 4],
+ ["c361", "\uD662", 4, "\uD668\uD66A", 5, "\uD672\uD673\uD675", 11],
+ ["c381", "\uD681\uD682\uD684\uD686", 5, "\uD68E\uD68F\uD691\uD692\uD693\uD695", 7, "\uD69E\uD6A0\uD6A2", 5, "\uD6A9\uD6AA\uCC3C\uCC3D\uCC3E\uCC44\uCC45\uCC48\uCC4C\uCC54\uCC55\uCC57\uCC58\uCC59\uCC60\uCC64\uCC66\uCC68\uCC70\uCC75\uCC98\uCC99\uCC9C\uCCA0\uCCA8\uCCA9\uCCAB\uCCAC\uCCAD\uCCB4\uCCB5\uCCB8\uCCBC\uCCC4\uCCC5\uCCC7\uCCC9\uCCD0\uCCD4\uCCE4\uCCEC\uCCF0\uCD01\uCD08\uCD09\uCD0C\uCD10\uCD18\uCD19\uCD1B\uCD1D\uCD24\uCD28\uCD2C\uCD39\uCD5C\uCD60\uCD64\uCD6C\uCD6D\uCD6F\uCD71\uCD78\uCD88\uCD94\uCD95\uCD98\uCD9C\uCDA4\uCDA5\uCDA7\uCDA9\uCDB0\uCDC4\uCDCC\uCDD0\uCDE8\uCDEC\uCDF0\uCDF8\uCDF9\uCDFB\uCDFD\uCE04\uCE08\uCE0C\uCE14\uCE19\uCE20\uCE21\uCE24\uCE28\uCE30\uCE31\uCE33\uCE35"],
+ ["c441", "\uD6AB\uD6AD\uD6AE\uD6AF\uD6B1", 7, "\uD6BA\uD6BC", 7, "\uD6C6\uD6C7\uD6C9\uD6CA\uD6CB"],
+ ["c461", "\uD6CD\uD6CE\uD6CF\uD6D0\uD6D2\uD6D3\uD6D5\uD6D6\uD6D8\uD6DA", 5, "\uD6E1\uD6E2\uD6E3\uD6E5\uD6E6\uD6E7\uD6E9", 4],
+ ["c481", "\uD6EE\uD6EF\uD6F1\uD6F2\uD6F3\uD6F4\uD6F6", 5, "\uD6FE\uD6FF\uD701\uD702\uD703\uD705", 11, "\uD712\uD713\uD714\uCE58\uCE59\uCE5C\uCE5F\uCE60\uCE61\uCE68\uCE69\uCE6B\uCE6D\uCE74\uCE75\uCE78\uCE7C\uCE84\uCE85\uCE87\uCE89\uCE90\uCE91\uCE94\uCE98\uCEA0\uCEA1\uCEA3\uCEA4\uCEA5\uCEAC\uCEAD\uCEC1\uCEE4\uCEE5\uCEE8\uCEEB\uCEEC\uCEF4\uCEF5\uCEF7\uCEF8\uCEF9\uCF00\uCF01\uCF04\uCF08\uCF10\uCF11\uCF13\uCF15\uCF1C\uCF20\uCF24\uCF2C\uCF2D\uCF2F\uCF30\uCF31\uCF38\uCF54\uCF55\uCF58\uCF5C\uCF64\uCF65\uCF67\uCF69\uCF70\uCF71\uCF74\uCF78\uCF80\uCF85\uCF8C\uCFA1\uCFA8\uCFB0\uCFC4\uCFE0\uCFE1\uCFE4\uCFE8\uCFF0\uCFF1\uCFF3\uCFF5\uCFFC\uD000\uD004\uD011\uD018\uD02D\uD034\uD035\uD038\uD03C"],
+ ["c541", "\uD715\uD716\uD717\uD71A\uD71B\uD71D\uD71E\uD71F\uD721", 6, "\uD72A\uD72C\uD72E", 5, "\uD736\uD737\uD739"],
+ ["c561", "\uD73A\uD73B\uD73D", 6, "\uD745\uD746\uD748\uD74A", 5, "\uD752\uD753\uD755\uD75A", 4],
+ ["c581", "\uD75F\uD762\uD764\uD766\uD767\uD768\uD76A\uD76B\uD76D\uD76E\uD76F\uD771\uD772\uD773\uD775", 6, "\uD77E\uD77F\uD780\uD782", 5, "\uD78A\uD78B\uD044\uD045\uD047\uD049\uD050\uD054\uD058\uD060\uD06C\uD06D\uD070\uD074\uD07C\uD07D\uD081\uD0A4\uD0A5\uD0A8\uD0AC\uD0B4\uD0B5\uD0B7\uD0B9\uD0C0\uD0C1\uD0C4\uD0C8\uD0C9\uD0D0\uD0D1\uD0D3\uD0D4\uD0D5\uD0DC\uD0DD\uD0E0\uD0E4\uD0EC\uD0ED\uD0EF\uD0F0\uD0F1\uD0F8\uD10D\uD130\uD131\uD134\uD138\uD13A\uD140\uD141\uD143\uD144\uD145\uD14C\uD14D\uD150\uD154\uD15C\uD15D\uD15F\uD161\uD168\uD16C\uD17C\uD184\uD188\uD1A0\uD1A1\uD1A4\uD1A8\uD1B0\uD1B1\uD1B3\uD1B5\uD1BA\uD1BC\uD1C0\uD1D8\uD1F4\uD1F8\uD207\uD209\uD210\uD22C\uD22D\uD230\uD234\uD23C\uD23D\uD23F\uD241\uD248\uD25C"],
+ ["c641", "\uD78D\uD78E\uD78F\uD791", 6, "\uD79A\uD79C\uD79E", 5],
+ ["c6a1", "\uD264\uD280\uD281\uD284\uD288\uD290\uD291\uD295\uD29C\uD2A0\uD2A4\uD2AC\uD2B1\uD2B8\uD2B9\uD2BC\uD2BF\uD2C0\uD2C2\uD2C8\uD2C9\uD2CB\uD2D4\uD2D8\uD2DC\uD2E4\uD2E5\uD2F0\uD2F1\uD2F4\uD2F8\uD300\uD301\uD303\uD305\uD30C\uD30D\uD30E\uD310\uD314\uD316\uD31C\uD31D\uD31F\uD320\uD321\uD325\uD328\uD329\uD32C\uD330\uD338\uD339\uD33B\uD33C\uD33D\uD344\uD345\uD37C\uD37D\uD380\uD384\uD38C\uD38D\uD38F\uD390\uD391\uD398\uD399\uD39C\uD3A0\uD3A8\uD3A9\uD3AB\uD3AD\uD3B4\uD3B8\uD3BC\uD3C4\uD3C5\uD3C8\uD3C9\uD3D0\uD3D8\uD3E1\uD3E3\uD3EC\uD3ED\uD3F0\uD3F4\uD3FC\uD3FD\uD3FF\uD401"],
+ ["c7a1", "\uD408\uD41D\uD440\uD444\uD45C\uD460\uD464\uD46D\uD46F\uD478\uD479\uD47C\uD47F\uD480\uD482\uD488\uD489\uD48B\uD48D\uD494\uD4A9\uD4CC\uD4D0\uD4D4\uD4DC\uD4DF\uD4E8\uD4EC\uD4F0\uD4F8\uD4FB\uD4FD\uD504\uD508\uD50C\uD514\uD515\uD517\uD53C\uD53D\uD540\uD544\uD54C\uD54D\uD54F\uD551\uD558\uD559\uD55C\uD560\uD565\uD568\uD569\uD56B\uD56D\uD574\uD575\uD578\uD57C\uD584\uD585\uD587\uD588\uD589\uD590\uD5A5\uD5C8\uD5C9\uD5CC\uD5D0\uD5D2\uD5D8\uD5D9\uD5DB\uD5DD\uD5E4\uD5E5\uD5E8\uD5EC\uD5F4\uD5F5\uD5F7\uD5F9\uD600\uD601\uD604\uD608\uD610\uD611\uD613\uD614\uD615\uD61C\uD620"],
+ ["c8a1", "\uD624\uD62D\uD638\uD639\uD63C\uD640\uD645\uD648\uD649\uD64B\uD64D\uD651\uD654\uD655\uD658\uD65C\uD667\uD669\uD670\uD671\uD674\uD683\uD685\uD68C\uD68D\uD690\uD694\uD69D\uD69F\uD6A1\uD6A8\uD6AC\uD6B0\uD6B9\uD6BB\uD6C4\uD6C5\uD6C8\uD6CC\uD6D1\uD6D4\uD6D7\uD6D9\uD6E0\uD6E4\uD6E8\uD6F0\uD6F5\uD6FC\uD6FD\uD700\uD704\uD711\uD718\uD719\uD71C\uD720\uD728\uD729\uD72B\uD72D\uD734\uD735\uD738\uD73C\uD744\uD747\uD749\uD750\uD751\uD754\uD756\uD757\uD758\uD759\uD760\uD761\uD763\uD765\uD769\uD76C\uD770\uD774\uD77C\uD77D\uD781\uD788\uD789\uD78C\uD790\uD798\uD799\uD79B\uD79D"],
+ ["caa1", "\u4F3D\u4F73\u5047\u50F9\u52A0\u53EF\u5475\u54E5\u5609\u5AC1\u5BB6\u6687\u67B6\u67B7\u67EF\u6B4C\u73C2\u75C2\u7A3C\u82DB\u8304\u8857\u8888\u8A36\u8CC8\u8DCF\u8EFB\u8FE6\u99D5\u523B\u5374\u5404\u606A\u6164\u6BBC\u73CF\u811A\u89BA\u89D2\u95A3\u4F83\u520A\u58BE\u5978\u59E6\u5E72\u5E79\u61C7\u63C0\u6746\u67EC\u687F\u6F97\u764E\u770B\u78F5\u7A08\u7AFF\u7C21\u809D\u826E\u8271\u8AEB\u9593\u4E6B\u559D\u66F7\u6E34\u78A3\u7AED\u845B\u8910\u874E\u97A8\u52D8\u574E\u582A\u5D4C\u611F\u61BE\u6221\u6562\u67D1\u6A44\u6E1B\u7518\u75B3\u76E3\u77B0\u7D3A\u90AF\u9451\u9452\u9F95"],
+ ["cba1", "\u5323\u5CAC\u7532\u80DB\u9240\u9598\u525B\u5808\u59DC\u5CA1\u5D17\u5EB7\u5F3A\u5F4A\u6177\u6C5F\u757A\u7586\u7CE0\u7D73\u7DB1\u7F8C\u8154\u8221\u8591\u8941\u8B1B\u92FC\u964D\u9C47\u4ECB\u4EF7\u500B\u51F1\u584F\u6137\u613E\u6168\u6539\u69EA\u6F11\u75A5\u7686\u76D6\u7B87\u82A5\u84CB\uF900\u93A7\u958B\u5580\u5BA2\u5751\uF901\u7CB3\u7FB9\u91B5\u5028\u53BB\u5C45\u5DE8\u62D2\u636E\u64DA\u64E7\u6E20\u70AC\u795B\u8DDD\u8E1E\uF902\u907D\u9245\u92F8\u4E7E\u4EF6\u5065\u5DFE\u5EFA\u6106\u6957\u8171\u8654\u8E47\u9375\u9A2B\u4E5E\u5091\u6770\u6840\u5109\u528D\u5292\u6AA2"],
+ ["cca1", "\u77BC\u9210\u9ED4\u52AB\u602F\u8FF2\u5048\u61A9\u63ED\u64CA\u683C\u6A84\u6FC0\u8188\u89A1\u9694\u5805\u727D\u72AC\u7504\u7D79\u7E6D\u80A9\u898B\u8B74\u9063\u9D51\u6289\u6C7A\u6F54\u7D50\u7F3A\u8A23\u517C\u614A\u7B9D\u8B19\u9257\u938C\u4EAC\u4FD3\u501E\u50BE\u5106\u52C1\u52CD\u537F\u5770\u5883\u5E9A\u5F91\u6176\u61AC\u64CE\u656C\u666F\u66BB\u66F4\u6897\u6D87\u7085\u70F1\u749F\u74A5\u74CA\u75D9\u786C\u78EC\u7ADF\u7AF6\u7D45\u7D93\u8015\u803F\u811B\u8396\u8B66\u8F15\u9015\u93E1\u9803\u9838\u9A5A\u9BE8\u4FC2\u5553\u583A\u5951\u5B63\u5C46\u60B8\u6212\u6842\u68B0"],
+ ["cda1", "\u68E8\u6EAA\u754C\u7678\u78CE\u7A3D\u7CFB\u7E6B\u7E7C\u8A08\u8AA1\u8C3F\u968E\u9DC4\u53E4\u53E9\u544A\u5471\u56FA\u59D1\u5B64\u5C3B\u5EAB\u62F7\u6537\u6545\u6572\u66A0\u67AF\u69C1\u6CBD\u75FC\u7690\u777E\u7A3F\u7F94\u8003\u80A1\u818F\u82E6\u82FD\u83F0\u85C1\u8831\u88B4\u8AA5\uF903\u8F9C\u932E\u96C7\u9867\u9AD8\u9F13\u54ED\u659B\u66F2\u688F\u7A40\u8C37\u9D60\u56F0\u5764\u5D11\u6606\u68B1\u68CD\u6EFE\u7428\u889E\u9BE4\u6C68\uF904\u9AA8\u4F9B\u516C\u5171\u529F\u5B54\u5DE5\u6050\u606D\u62F1\u63A7\u653B\u73D9\u7A7A\u86A3\u8CA2\u978F\u4E32\u5BE1\u6208\u679C\u74DC"],
+ ["cea1", "\u79D1\u83D3\u8A87\u8AB2\u8DE8\u904E\u934B\u9846\u5ED3\u69E8\u85FF\u90ED\uF905\u51A0\u5B98\u5BEC\u6163\u68FA\u6B3E\u704C\u742F\u74D8\u7BA1\u7F50\u83C5\u89C0\u8CAB\u95DC\u9928\u522E\u605D\u62EC\u9002\u4F8A\u5149\u5321\u58D9\u5EE3\u66E0\u6D38\u709A\u72C2\u73D6\u7B50\u80F1\u945B\u5366\u639B\u7F6B\u4E56\u5080\u584A\u58DE\u602A\u6127\u62D0\u69D0\u9B41\u5B8F\u7D18\u80B1\u8F5F\u4EA4\u50D1\u54AC\u55AC\u5B0C\u5DA0\u5DE7\u652A\u654E\u6821\u6A4B\u72E1\u768E\u77EF\u7D5E\u7FF9\u81A0\u854E\u86DF\u8F03\u8F4E\u90CA\u9903\u9A55\u9BAB\u4E18\u4E45\u4E5D\u4EC7\u4FF1\u5177\u52FE"],
+ ["cfa1", "\u5340\u53E3\u53E5\u548E\u5614\u5775\u57A2\u5BC7\u5D87\u5ED0\u61FC\u62D8\u6551\u67B8\u67E9\u69CB\u6B50\u6BC6\u6BEC\u6C42\u6E9D\u7078\u72D7\u7396\u7403\u77BF\u77E9\u7A76\u7D7F\u8009\u81FC\u8205\u820A\u82DF\u8862\u8B33\u8CFC\u8EC0\u9011\u90B1\u9264\u92B6\u99D2\u9A45\u9CE9\u9DD7\u9F9C\u570B\u5C40\u83CA\u97A0\u97AB\u9EB4\u541B\u7A98\u7FA4\u88D9\u8ECD\u90E1\u5800\u5C48\u6398\u7A9F\u5BAE\u5F13\u7A79\u7AAE\u828E\u8EAC\u5026\u5238\u52F8\u5377\u5708\u62F3\u6372\u6B0A\u6DC3\u7737\u53A5\u7357\u8568\u8E76\u95D5\u673A\u6AC3\u6F70\u8A6D\u8ECC\u994B\uF906\u6677\u6B78\u8CB4"],
+ ["d0a1", "\u9B3C\uF907\u53EB\u572D\u594E\u63C6\u69FB\u73EA\u7845\u7ABA\u7AC5\u7CFE\u8475\u898F\u8D73\u9035\u95A8\u52FB\u5747\u7547\u7B60\u83CC\u921E\uF908\u6A58\u514B\u524B\u5287\u621F\u68D8\u6975\u9699\u50C5\u52A4\u52E4\u61C3\u65A4\u6839\u69FF\u747E\u7B4B\u82B9\u83EB\u89B2\u8B39\u8FD1\u9949\uF909\u4ECA\u5997\u64D2\u6611\u6A8E\u7434\u7981\u79BD\u82A9\u887E\u887F\u895F\uF90A\u9326\u4F0B\u53CA\u6025\u6271\u6C72\u7D1A\u7D66\u4E98\u5162\u77DC\u80AF\u4F01\u4F0E\u5176\u5180\u55DC\u5668\u573B\u57FA\u57FC\u5914\u5947\u5993\u5BC4\u5C90\u5D0E\u5DF1\u5E7E\u5FCC\u6280\u65D7\u65E3"],
+ ["d1a1", "\u671E\u671F\u675E\u68CB\u68C4\u6A5F\u6B3A\u6C23\u6C7D\u6C82\u6DC7\u7398\u7426\u742A\u7482\u74A3\u7578\u757F\u7881\u78EF\u7941\u7947\u7948\u797A\u7B95\u7D00\u7DBA\u7F88\u8006\u802D\u808C\u8A18\u8B4F\u8C48\u8D77\u9321\u9324\u98E2\u9951\u9A0E\u9A0F\u9A65\u9E92\u7DCA\u4F76\u5409\u62EE\u6854\u91D1\u55AB\u513A\uF90B\uF90C\u5A1C\u61E6\uF90D\u62CF\u62FF\uF90E", 5, "\u90A3\uF914", 4, "\u8AFE\uF919\uF91A\uF91B\uF91C\u6696\uF91D\u7156\uF91E\uF91F\u96E3\uF920\u634F\u637A\u5357\uF921\u678F\u6960\u6E73\uF922\u7537\uF923\uF924\uF925"],
+ ["d2a1", "\u7D0D\uF926\uF927\u8872\u56CA\u5A18\uF928", 4, "\u4E43\uF92D\u5167\u5948\u67F0\u8010\uF92E\u5973\u5E74\u649A\u79CA\u5FF5\u606C\u62C8\u637B\u5BE7\u5BD7\u52AA\uF92F\u5974\u5F29\u6012\uF930\uF931\uF932\u7459\uF933", 5, "\u99D1\uF939", 10, "\u6FC3\uF944\uF945\u81BF\u8FB2\u60F1\uF946\uF947\u8166\uF948\uF949\u5C3F\uF94A", 7, "\u5AE9\u8A25\u677B\u7D10\uF952", 5, "\u80FD\uF958\uF959\u5C3C\u6CE5\u533F\u6EBA\u591A\u8336"],
+ ["d3a1", "\u4E39\u4EB6\u4F46\u55AE\u5718\u58C7\u5F56\u65B7\u65E6\u6A80\u6BB5\u6E4D\u77ED\u7AEF\u7C1E\u7DDE\u86CB\u8892\u9132\u935B\u64BB\u6FBE\u737A\u75B8\u9054\u5556\u574D\u61BA\u64D4\u66C7\u6DE1\u6E5B\u6F6D\u6FB9\u75F0\u8043\u81BD\u8541\u8983\u8AC7\u8B5A\u931F\u6C93\u7553\u7B54\u8E0F\u905D\u5510\u5802\u5858\u5E62\u6207\u649E\u68E0\u7576\u7CD6\u87B3\u9EE8\u4EE3\u5788\u576E\u5927\u5C0D\u5CB1\u5E36\u5F85\u6234\u64E1\u73B3\u81FA\u888B\u8CB8\u968A\u9EDB\u5B85\u5FB7\u60B3\u5012\u5200\u5230\u5716\u5835\u5857\u5C0E\u5C60\u5CF6\u5D8B\u5EA6\u5F92\u60BC\u6311\u6389\u6417\u6843"],
+ ["d4a1", "\u68F9\u6AC2\u6DD8\u6E21\u6ED4\u6FE4\u71FE\u76DC\u7779\u79B1\u7A3B\u8404\u89A9\u8CED\u8DF3\u8E48\u9003\u9014\u9053\u90FD\u934D\u9676\u97DC\u6BD2\u7006\u7258\u72A2\u7368\u7763\u79BF\u7BE4\u7E9B\u8B80\u58A9\u60C7\u6566\u65FD\u66BE\u6C8C\u711E\u71C9\u8C5A\u9813\u4E6D\u7A81\u4EDD\u51AC\u51CD\u52D5\u540C\u61A7\u6771\u6850\u68DF\u6D1E\u6F7C\u75BC\u77B3\u7AE5\u80F4\u8463\u9285\u515C\u6597\u675C\u6793\u75D8\u7AC7\u8373\uF95A\u8C46\u9017\u982D\u5C6F\u81C0\u829A\u9041\u906F\u920D\u5F97\u5D9D\u6A59\u71C8\u767B\u7B49\u85E4\u8B04\u9127\u9A30\u5587\u61F6\uF95B\u7669\u7F85"],
+ ["d5a1", "\u863F\u87BA\u88F8\u908F\uF95C\u6D1B\u70D9\u73DE\u7D61\u843D\uF95D\u916A\u99F1\uF95E\u4E82\u5375\u6B04\u6B12\u703E\u721B\u862D\u9E1E\u524C\u8FA3\u5D50\u64E5\u652C\u6B16\u6FEB\u7C43\u7E9C\u85CD\u8964\u89BD\u62C9\u81D8\u881F\u5ECA\u6717\u6D6A\u72FC\u7405\u746F\u8782\u90DE\u4F86\u5D0D\u5FA0\u840A\u51B7\u63A0\u7565\u4EAE\u5006\u5169\u51C9\u6881\u6A11\u7CAE\u7CB1\u7CE7\u826F\u8AD2\u8F1B\u91CF\u4FB6\u5137\u52F5\u5442\u5EEC\u616E\u623E\u65C5\u6ADA\u6FFE\u792A\u85DC\u8823\u95AD\u9A62\u9A6A\u9E97\u9ECE\u529B\u66C6\u6B77\u701D\u792B\u8F62\u9742\u6190\u6200\u6523\u6F23"],
+ ["d6a1", "\u7149\u7489\u7DF4\u806F\u84EE\u8F26\u9023\u934A\u51BD\u5217\u52A3\u6D0C\u70C8\u88C2\u5EC9\u6582\u6BAE\u6FC2\u7C3E\u7375\u4EE4\u4F36\u56F9\uF95F\u5CBA\u5DBA\u601C\u73B2\u7B2D\u7F9A\u7FCE\u8046\u901E\u9234\u96F6\u9748\u9818\u9F61\u4F8B\u6FA7\u79AE\u91B4\u96B7\u52DE\uF960\u6488\u64C4\u6AD3\u6F5E\u7018\u7210\u76E7\u8001\u8606\u865C\u8DEF\u8F05\u9732\u9B6F\u9DFA\u9E75\u788C\u797F\u7DA0\u83C9\u9304\u9E7F\u9E93\u8AD6\u58DF\u5F04\u6727\u7027\u74CF\u7C60\u807E\u5121\u7028\u7262\u78CA\u8CC2\u8CDA\u8CF4\u96F7\u4E86\u50DA\u5BEE\u5ED6\u6599\u71CE\u7642\u77AD\u804A\u84FC"],
+ ["d7a1", "\u907C\u9B27\u9F8D\u58D8\u5A41\u5C62\u6A13\u6DDA\u6F0F\u763B\u7D2F\u7E37\u851E\u8938\u93E4\u964B\u5289\u65D2\u67F3\u69B4\u6D41\u6E9C\u700F\u7409\u7460\u7559\u7624\u786B\u8B2C\u985E\u516D\u622E\u9678\u4F96\u502B\u5D19\u6DEA\u7DB8\u8F2A\u5F8B\u6144\u6817\uF961\u9686\u52D2\u808B\u51DC\u51CC\u695E\u7A1C\u7DBE\u83F1\u9675\u4FDA\u5229\u5398\u540F\u550E\u5C65\u60A7\u674E\u68A8\u6D6C\u7281\u72F8\u7406\u7483\uF962\u75E2\u7C6C\u7F79\u7FB8\u8389\u88CF\u88E1\u91CC\u91D0\u96E2\u9BC9\u541D\u6F7E\u71D0\u7498\u85FA\u8EAA\u96A3\u9C57\u9E9F\u6797\u6DCB\u7433\u81E8\u9716\u782C"],
+ ["d8a1", "\u7ACB\u7B20\u7C92\u6469\u746A\u75F2\u78BC\u78E8\u99AC\u9B54\u9EBB\u5BDE\u5E55\u6F20\u819C\u83AB\u9088\u4E07\u534D\u5A29\u5DD2\u5F4E\u6162\u633D\u6669\u66FC\u6EFF\u6F2B\u7063\u779E\u842C\u8513\u883B\u8F13\u9945\u9C3B\u551C\u62B9\u672B\u6CAB\u8309\u896A\u977A\u4EA1\u5984\u5FD8\u5FD9\u671B\u7DB2\u7F54\u8292\u832B\u83BD\u8F1E\u9099\u57CB\u59B9\u5A92\u5BD0\u6627\u679A\u6885\u6BCF\u7164\u7F75\u8CB7\u8CE3\u9081\u9B45\u8108\u8C8A\u964C\u9A40\u9EA5\u5B5F\u6C13\u731B\u76F2\u76DF\u840C\u51AA\u8993\u514D\u5195\u52C9\u68C9\u6C94\u7704\u7720\u7DBF\u7DEC\u9762\u9EB5\u6EC5"],
+ ["d9a1", "\u8511\u51A5\u540D\u547D\u660E\u669D\u6927\u6E9F\u76BF\u7791\u8317\u84C2\u879F\u9169\u9298\u9CF4\u8882\u4FAE\u5192\u52DF\u59C6\u5E3D\u6155\u6478\u6479\u66AE\u67D0\u6A21\u6BCD\u6BDB\u725F\u7261\u7441\u7738\u77DB\u8017\u82BC\u8305\u8B00\u8B28\u8C8C\u6728\u6C90\u7267\u76EE\u7766\u7A46\u9DA9\u6B7F\u6C92\u5922\u6726\u8499\u536F\u5893\u5999\u5EDF\u63CF\u6634\u6773\u6E3A\u732B\u7AD7\u82D7\u9328\u52D9\u5DEB\u61AE\u61CB\u620A\u62C7\u64AB\u65E0\u6959\u6B66\u6BCB\u7121\u73F7\u755D\u7E46\u821E\u8302\u856A\u8AA3\u8CBF\u9727\u9D61\u58A8\u9ED8\u5011\u520E\u543B\u554F\u6587"],
+ ["daa1", "\u6C76\u7D0A\u7D0B\u805E\u868A\u9580\u96EF\u52FF\u6C95\u7269\u5473\u5A9A\u5C3E\u5D4B\u5F4C\u5FAE\u672A\u68B6\u6963\u6E3C\u6E44\u7709\u7C73\u7F8E\u8587\u8B0E\u8FF7\u9761\u9EF4\u5CB7\u60B6\u610D\u61AB\u654F\u65FB\u65FC\u6C11\u6CEF\u739F\u73C9\u7DE1\u9594\u5BC6\u871C\u8B10\u525D\u535A\u62CD\u640F\u64B2\u6734\u6A38\u6CCA\u73C0\u749E\u7B94\u7C95\u7E1B\u818A\u8236\u8584\u8FEB\u96F9\u99C1\u4F34\u534A\u53CD\u53DB\u62CC\u642C\u6500\u6591\u69C3\u6CEE\u6F58\u73ED\u7554\u7622\u76E4\u76FC\u78D0\u78FB\u792C\u7D46\u822C\u87E0\u8FD4\u9812\u98EF\u52C3\u62D4\u64A5\u6E24\u6F51"],
+ ["dba1", "\u767C\u8DCB\u91B1\u9262\u9AEE\u9B43\u5023\u508D\u574A\u59A8\u5C28\u5E47\u5F77\u623F\u653E\u65B9\u65C1\u6609\u678B\u699C\u6EC2\u78C5\u7D21\u80AA\u8180\u822B\u82B3\u84A1\u868C\u8A2A\u8B17\u90A6\u9632\u9F90\u500D\u4FF3\uF963\u57F9\u5F98\u62DC\u6392\u676F\u6E43\u7119\u76C3\u80CC\u80DA\u88F4\u88F5\u8919\u8CE0\u8F29\u914D\u966A\u4F2F\u4F70\u5E1B\u67CF\u6822\u767D\u767E\u9B44\u5E61\u6A0A\u7169\u71D4\u756A\uF964\u7E41\u8543\u85E9\u98DC\u4F10\u7B4F\u7F70\u95A5\u51E1\u5E06\u68B5\u6C3E\u6C4E\u6CDB\u72AF\u7BC4\u8303\u6CD5\u743A\u50FB\u5288\u58C1\u64D8\u6A97\u74A7\u7656"],
+ ["dca1", "\u78A7\u8617\u95E2\u9739\uF965\u535E\u5F01\u8B8A\u8FA8\u8FAF\u908A\u5225\u77A5\u9C49\u9F08\u4E19\u5002\u5175\u5C5B\u5E77\u661E\u663A\u67C4\u68C5\u70B3\u7501\u75C5\u79C9\u7ADD\u8F27\u9920\u9A08\u4FDD\u5821\u5831\u5BF6\u666E\u6B65\u6D11\u6E7A\u6F7D\u73E4\u752B\u83E9\u88DC\u8913\u8B5C\u8F14\u4F0F\u50D5\u5310\u535C\u5B93\u5FA9\u670D\u798F\u8179\u832F\u8514\u8907\u8986\u8F39\u8F3B\u99A5\u9C12\u672C\u4E76\u4FF8\u5949\u5C01\u5CEF\u5CF0\u6367\u68D2\u70FD\u71A2\u742B\u7E2B\u84EC\u8702\u9022\u92D2\u9CF3\u4E0D\u4ED8\u4FEF\u5085\u5256\u526F\u5426\u5490\u57E0\u592B\u5A66"],
+ ["dda1", "\u5B5A\u5B75\u5BCC\u5E9C\uF966\u6276\u6577\u65A7\u6D6E\u6EA5\u7236\u7B26\u7C3F\u7F36\u8150\u8151\u819A\u8240\u8299\u83A9\u8A03\u8CA0\u8CE6\u8CFB\u8D74\u8DBA\u90E8\u91DC\u961C\u9644\u99D9\u9CE7\u5317\u5206\u5429\u5674\u58B3\u5954\u596E\u5FFF\u61A4\u626E\u6610\u6C7E\u711A\u76C6\u7C89\u7CDE\u7D1B\u82AC\u8CC1\u96F0\uF967\u4F5B\u5F17\u5F7F\u62C2\u5D29\u670B\u68DA\u787C\u7E43\u9D6C\u4E15\u5099\u5315\u532A\u5351\u5983\u5A62\u5E87\u60B2\u618A\u6249\u6279\u6590\u6787\u69A7\u6BD4\u6BD6\u6BD7\u6BD8\u6CB8\uF968\u7435\u75FA\u7812\u7891\u79D5\u79D8\u7C83\u7DCB\u7FE1\u80A5"],
+ ["dea1", "\u813E\u81C2\u83F2\u871A\u88E8\u8AB9\u8B6C\u8CBB\u9119\u975E\u98DB\u9F3B\u56AC\u5B2A\u5F6C\u658C\u6AB3\u6BAF\u6D5C\u6FF1\u7015\u725D\u73AD\u8CA7\u8CD3\u983B\u6191\u6C37\u8058\u9A01\u4E4D\u4E8B\u4E9B\u4ED5\u4F3A\u4F3C\u4F7F\u4FDF\u50FF\u53F2\u53F8\u5506\u55E3\u56DB\u58EB\u5962\u5A11\u5BEB\u5BFA\u5C04\u5DF3\u5E2B\u5F99\u601D\u6368\u659C\u65AF\u67F6\u67FB\u68AD\u6B7B\u6C99\u6CD7\u6E23\u7009\u7345\u7802\u793E\u7940\u7960\u79C1\u7BE9\u7D17\u7D72\u8086\u820D\u838E\u84D1\u86C7\u88DF\u8A50\u8A5E\u8B1D\u8CDC\u8D66\u8FAD\u90AA\u98FC\u99DF\u9E9D\u524A\uF969\u6714\uF96A"],
+ ["dfa1", "\u5098\u522A\u5C71\u6563\u6C55\u73CA\u7523\u759D\u7B97\u849C\u9178\u9730\u4E77\u6492\u6BBA\u715E\u85A9\u4E09\uF96B\u6749\u68EE\u6E17\u829F\u8518\u886B\u63F7\u6F81\u9212\u98AF\u4E0A\u50B7\u50CF\u511F\u5546\u55AA\u5617\u5B40\u5C19\u5CE0\u5E38\u5E8A\u5EA0\u5EC2\u60F3\u6851\u6A61\u6E58\u723D\u7240\u72C0\u76F8\u7965\u7BB1\u7FD4\u88F3\u89F4\u8A73\u8C61\u8CDE\u971C\u585E\u74BD\u8CFD\u55C7\uF96C\u7A61\u7D22\u8272\u7272\u751F\u7525\uF96D\u7B19\u5885\u58FB\u5DBC\u5E8F\u5EB6\u5F90\u6055\u6292\u637F\u654D\u6691\u66D9\u66F8\u6816\u68F2\u7280\u745E\u7B6E\u7D6E\u7DD6\u7F72"],
+ ["e0a1", "\u80E5\u8212\u85AF\u897F\u8A93\u901D\u92E4\u9ECD\u9F20\u5915\u596D\u5E2D\u60DC\u6614\u6673\u6790\u6C50\u6DC5\u6F5F\u77F3\u78A9\u84C6\u91CB\u932B\u4ED9\u50CA\u5148\u5584\u5B0B\u5BA3\u6247\u657E\u65CB\u6E32\u717D\u7401\u7444\u7487\u74BF\u766C\u79AA\u7DDA\u7E55\u7FA8\u817A\u81B3\u8239\u861A\u87EC\u8A75\u8DE3\u9078\u9291\u9425\u994D\u9BAE\u5368\u5C51\u6954\u6CC4\u6D29\u6E2B\u820C\u859B\u893B\u8A2D\u8AAA\u96EA\u9F67\u5261\u66B9\u6BB2\u7E96\u87FE\u8D0D\u9583\u965D\u651D\u6D89\u71EE\uF96E\u57CE\u59D3\u5BAC\u6027\u60FA\u6210\u661F\u665F\u7329\u73F9\u76DB\u7701\u7B6C"],
+ ["e1a1", "\u8056\u8072\u8165\u8AA0\u9192\u4E16\u52E2\u6B72\u6D17\u7A05\u7B39\u7D30\uF96F\u8CB0\u53EC\u562F\u5851\u5BB5\u5C0F\u5C11\u5DE2\u6240\u6383\u6414\u662D\u68B3\u6CBC\u6D88\u6EAF\u701F\u70A4\u71D2\u7526\u758F\u758E\u7619\u7B11\u7BE0\u7C2B\u7D20\u7D39\u852C\u856D\u8607\u8A34\u900D\u9061\u90B5\u92B7\u97F6\u9A37\u4FD7\u5C6C\u675F\u6D91\u7C9F\u7E8C\u8B16\u8D16\u901F\u5B6B\u5DFD\u640D\u84C0\u905C\u98E1\u7387\u5B8B\u609A\u677E\u6DDE\u8A1F\u8AA6\u9001\u980C\u5237\uF970\u7051\u788E\u9396\u8870\u91D7\u4FEE\u53D7\u55FD\u56DA\u5782\u58FD\u5AC2\u5B88\u5CAB\u5CC0\u5E25\u6101"],
+ ["e2a1", "\u620D\u624B\u6388\u641C\u6536\u6578\u6A39\u6B8A\u6C34\u6D19\u6F31\u71E7\u72E9\u7378\u7407\u74B2\u7626\u7761\u79C0\u7A57\u7AEA\u7CB9\u7D8F\u7DAC\u7E61\u7F9E\u8129\u8331\u8490\u84DA\u85EA\u8896\u8AB0\u8B90\u8F38\u9042\u9083\u916C\u9296\u92B9\u968B\u96A7\u96A8\u96D6\u9700\u9808\u9996\u9AD3\u9B1A\u53D4\u587E\u5919\u5B70\u5BBF\u6DD1\u6F5A\u719F\u7421\u74B9\u8085\u83FD\u5DE1\u5F87\u5FAA\u6042\u65EC\u6812\u696F\u6A53\u6B89\u6D35\u6DF3\u73E3\u76FE\u77AC\u7B4D\u7D14\u8123\u821C\u8340\u84F4\u8563\u8A62\u8AC4\u9187\u931E\u9806\u99B4\u620C\u8853\u8FF0\u9265\u5D07\u5D27"],
+ ["e3a1", "\u5D69\u745F\u819D\u8768\u6FD5\u62FE\u7FD2\u8936\u8972\u4E1E\u4E58\u50E7\u52DD\u5347\u627F\u6607\u7E69\u8805\u965E\u4F8D\u5319\u5636\u59CB\u5AA4\u5C38\u5C4E\u5C4D\u5E02\u5F11\u6043\u65BD\u662F\u6642\u67BE\u67F4\u731C\u77E2\u793A\u7FC5\u8494\u84CD\u8996\u8A66\u8A69\u8AE1\u8C55\u8C7A\u57F4\u5BD4\u5F0F\u606F\u62ED\u690D\u6B96\u6E5C\u7184\u7BD2\u8755\u8B58\u8EFE\u98DF\u98FE\u4F38\u4F81\u4FE1\u547B\u5A20\u5BB8\u613C\u65B0\u6668\u71FC\u7533\u795E\u7D33\u814E\u81E3\u8398\u85AA\u85CE\u8703\u8A0A\u8EAB\u8F9B\uF971\u8FC5\u5931\u5BA4\u5BE6\u6089\u5BE9\u5C0B\u5FC3\u6C81"],
+ ["e4a1", "\uF972\u6DF1\u700B\u751A\u82AF\u8AF6\u4EC0\u5341\uF973\u96D9\u6C0F\u4E9E\u4FC4\u5152\u555E\u5A25\u5CE8\u6211\u7259\u82BD\u83AA\u86FE\u8859\u8A1D\u963F\u96C5\u9913\u9D09\u9D5D\u580A\u5CB3\u5DBD\u5E44\u60E1\u6115\u63E1\u6A02\u6E25\u9102\u9354\u984E\u9C10\u9F77\u5B89\u5CB8\u6309\u664F\u6848\u773C\u96C1\u978D\u9854\u9B9F\u65A1\u8B01\u8ECB\u95BC\u5535\u5CA9\u5DD6\u5EB5\u6697\u764C\u83F4\u95C7\u58D3\u62BC\u72CE\u9D28\u4EF0\u592E\u600F\u663B\u6B83\u79E7\u9D26\u5393\u54C0\u57C3\u5D16\u611B\u66D6\u6DAF\u788D\u827E\u9698\u9744\u5384\u627C\u6396\u6DB2\u7E0A\u814B\u984D"],
+ ["e5a1", "\u6AFB\u7F4C\u9DAF\u9E1A\u4E5F\u503B\u51B6\u591C\u60F9\u63F6\u6930\u723A\u8036\uF974\u91CE\u5F31\uF975\uF976\u7D04\u82E5\u846F\u84BB\u85E5\u8E8D\uF977\u4F6F\uF978\uF979\u58E4\u5B43\u6059\u63DA\u6518\u656D\u6698\uF97A\u694A\u6A23\u6D0B\u7001\u716C\u75D2\u760D\u79B3\u7A70\uF97B\u7F8A\uF97C\u8944\uF97D\u8B93\u91C0\u967D\uF97E\u990A\u5704\u5FA1\u65BC\u6F01\u7600\u79A6\u8A9E\u99AD\u9B5A\u9F6C\u5104\u61B6\u6291\u6A8D\u81C6\u5043\u5830\u5F66\u7109\u8A00\u8AFA\u5B7C\u8616\u4FFA\u513C\u56B4\u5944\u63A9\u6DF9\u5DAA\u696D\u5186\u4E88\u4F59\uF97F\uF980\uF981\u5982\uF982"],
+ ["e6a1", "\uF983\u6B5F\u6C5D\uF984\u74B5\u7916\uF985\u8207\u8245\u8339\u8F3F\u8F5D\uF986\u9918\uF987\uF988\uF989\u4EA6\uF98A\u57DF\u5F79\u6613\uF98B\uF98C\u75AB\u7E79\u8B6F\uF98D\u9006\u9A5B\u56A5\u5827\u59F8\u5A1F\u5BB4\uF98E\u5EF6\uF98F\uF990\u6350\u633B\uF991\u693D\u6C87\u6CBF\u6D8E\u6D93\u6DF5\u6F14\uF992\u70DF\u7136\u7159\uF993\u71C3\u71D5\uF994\u784F\u786F\uF995\u7B75\u7DE3\uF996\u7E2F\uF997\u884D\u8EDF\uF998\uF999\uF99A\u925B\uF99B\u9CF6\uF99C\uF99D\uF99E\u6085\u6D85\uF99F\u71B1\uF9A0\uF9A1\u95B1\u53AD\uF9A2\uF9A3\uF9A4\u67D3\uF9A5\u708E\u7130\u7430\u8276\u82D2"],
+ ["e7a1", "\uF9A6\u95BB\u9AE5\u9E7D\u66C4\uF9A7\u71C1\u8449\uF9A8\uF9A9\u584B\uF9AA\uF9AB\u5DB8\u5F71\uF9AC\u6620\u668E\u6979\u69AE\u6C38\u6CF3\u6E36\u6F41\u6FDA\u701B\u702F\u7150\u71DF\u7370\uF9AD\u745B\uF9AE\u74D4\u76C8\u7A4E\u7E93\uF9AF\uF9B0\u82F1\u8A60\u8FCE\uF9B1\u9348\uF9B2\u9719\uF9B3\uF9B4\u4E42\u502A\uF9B5\u5208\u53E1\u66F3\u6C6D\u6FCA\u730A\u777F\u7A62\u82AE\u85DD\u8602\uF9B6\u88D4\u8A63\u8B7D\u8C6B\uF9B7\u92B3\uF9B8\u9713\u9810\u4E94\u4F0D\u4FC9\u50B2\u5348\u543E\u5433\u55DA\u5862\u58BA\u5967\u5A1B\u5BE4\u609F\uF9B9\u61CA\u6556\u65FF\u6664\u68A7\u6C5A\u6FB3"],
+ ["e8a1", "\u70CF\u71AC\u7352\u7B7D\u8708\u8AA4\u9C32\u9F07\u5C4B\u6C83\u7344\u7389\u923A\u6EAB\u7465\u761F\u7A69\u7E15\u860A\u5140\u58C5\u64C1\u74EE\u7515\u7670\u7FC1\u9095\u96CD\u9954\u6E26\u74E6\u7AA9\u7AAA\u81E5\u86D9\u8778\u8A1B\u5A49\u5B8C\u5B9B\u68A1\u6900\u6D63\u73A9\u7413\u742C\u7897\u7DE9\u7FEB\u8118\u8155\u839E\u8C4C\u962E\u9811\u66F0\u5F80\u65FA\u6789\u6C6A\u738B\u502D\u5A03\u6B6A\u77EE\u5916\u5D6C\u5DCD\u7325\u754F\uF9BA\uF9BB\u50E5\u51F9\u582F\u592D\u5996\u59DA\u5BE5\uF9BC\uF9BD\u5DA2\u62D7\u6416\u6493\u64FE\uF9BE\u66DC\uF9BF\u6A48\uF9C0\u71FF\u7464\uF9C1"],
+ ["e9a1", "\u7A88\u7AAF\u7E47\u7E5E\u8000\u8170\uF9C2\u87EF\u8981\u8B20\u9059\uF9C3\u9080\u9952\u617E\u6B32\u6D74\u7E1F\u8925\u8FB1\u4FD1\u50AD\u5197\u52C7\u57C7\u5889\u5BB9\u5EB8\u6142\u6995\u6D8C\u6E67\u6EB6\u7194\u7462\u7528\u752C\u8073\u8338\u84C9\u8E0A\u9394\u93DE\uF9C4\u4E8E\u4F51\u5076\u512A\u53C8\u53CB\u53F3\u5B87\u5BD3\u5C24\u611A\u6182\u65F4\u725B\u7397\u7440\u76C2\u7950\u7991\u79B9\u7D06\u7FBD\u828B\u85D5\u865E\u8FC2\u9047\u90F5\u91EA\u9685\u96E8\u96E9\u52D6\u5F67\u65ED\u6631\u682F\u715C\u7A36\u90C1\u980A\u4E91\uF9C5\u6A52\u6B9E\u6F90\u7189\u8018\u82B8\u8553"],
+ ["eaa1", "\u904B\u9695\u96F2\u97FB\u851A\u9B31\u4E90\u718A\u96C4\u5143\u539F\u54E1\u5713\u5712\u57A3\u5A9B\u5AC4\u5BC3\u6028\u613F\u63F4\u6C85\u6D39\u6E72\u6E90\u7230\u733F\u7457\u82D1\u8881\u8F45\u9060\uF9C6\u9662\u9858\u9D1B\u6708\u8D8A\u925E\u4F4D\u5049\u50DE\u5371\u570D\u59D4\u5A01\u5C09\u6170\u6690\u6E2D\u7232\u744B\u7DEF\u80C3\u840E\u8466\u853F\u875F\u885B\u8918\u8B02\u9055\u97CB\u9B4F\u4E73\u4F91\u5112\u516A\uF9C7\u552F\u55A9\u5B7A\u5BA5\u5E7C\u5E7D\u5EBE\u60A0\u60DF\u6108\u6109\u63C4\u6538\u6709\uF9C8\u67D4\u67DA\uF9C9\u6961\u6962\u6CB9\u6D27\uF9CA\u6E38\uF9CB"],
+ ["eba1", "\u6FE1\u7336\u7337\uF9CC\u745C\u7531\uF9CD\u7652\uF9CE\uF9CF\u7DAD\u81FE\u8438\u88D5\u8A98\u8ADB\u8AED\u8E30\u8E42\u904A\u903E\u907A\u9149\u91C9\u936E\uF9D0\uF9D1\u5809\uF9D2\u6BD3\u8089\u80B2\uF9D3\uF9D4\u5141\u596B\u5C39\uF9D5\uF9D6\u6F64\u73A7\u80E4\u8D07\uF9D7\u9217\u958F\uF9D8\uF9D9\uF9DA\uF9DB\u807F\u620E\u701C\u7D68\u878D\uF9DC\u57A0\u6069\u6147\u6BB7\u8ABE\u9280\u96B1\u4E59\u541F\u6DEB\u852D\u9670\u97F3\u98EE\u63D6\u6CE3\u9091\u51DD\u61C9\u81BA\u9DF9\u4F9D\u501A\u5100\u5B9C\u610F\u61FF\u64EC\u6905\u6BC5\u7591\u77E3\u7FA9\u8264\u858F\u87FB\u8863\u8ABC"],
+ ["eca1", "\u8B70\u91AB\u4E8C\u4EE5\u4F0A\uF9DD\uF9DE\u5937\u59E8\uF9DF\u5DF2\u5F1B\u5F5B\u6021\uF9E0\uF9E1\uF9E2\uF9E3\u723E\u73E5\uF9E4\u7570\u75CD\uF9E5\u79FB\uF9E6\u800C\u8033\u8084\u82E1\u8351\uF9E7\uF9E8\u8CBD\u8CB3\u9087\uF9E9\uF9EA\u98F4\u990C\uF9EB\uF9EC\u7037\u76CA\u7FCA\u7FCC\u7FFC\u8B1A\u4EBA\u4EC1\u5203\u5370\uF9ED\u54BD\u56E0\u59FB\u5BC5\u5F15\u5FCD\u6E6E\uF9EE\uF9EF\u7D6A\u8335\uF9F0\u8693\u8A8D\uF9F1\u976D\u9777\uF9F2\uF9F3\u4E00\u4F5A\u4F7E\u58F9\u65E5\u6EA2\u9038\u93B0\u99B9\u4EFB\u58EC\u598A\u59D9\u6041\uF9F4\uF9F5\u7A14\uF9F6\u834F\u8CC3\u5165\u5344"],
+ ["eda1", "\uF9F7\uF9F8\uF9F9\u4ECD\u5269\u5B55\u82BF\u4ED4\u523A\u54A8\u59C9\u59FF\u5B50\u5B57\u5B5C\u6063\u6148\u6ECB\u7099\u716E\u7386\u74F7\u75B5\u78C1\u7D2B\u8005\u81EA\u8328\u8517\u85C9\u8AEE\u8CC7\u96CC\u4F5C\u52FA\u56BC\u65AB\u6628\u707C\u70B8\u7235\u7DBD\u828D\u914C\u96C0\u9D72\u5B71\u68E7\u6B98\u6F7A\u76DE\u5C91\u66AB\u6F5B\u7BB4\u7C2A\u8836\u96DC\u4E08\u4ED7\u5320\u5834\u58BB\u58EF\u596C\u5C07\u5E33\u5E84\u5F35\u638C\u66B2\u6756\u6A1F\u6AA3\u6B0C\u6F3F\u7246\uF9FA\u7350\u748B\u7AE0\u7CA7\u8178\u81DF\u81E7\u838A\u846C\u8523\u8594\u85CF\u88DD\u8D13\u91AC\u9577"],
+ ["eea1", "\u969C\u518D\u54C9\u5728\u5BB0\u624D\u6750\u683D\u6893\u6E3D\u6ED3\u707D\u7E21\u88C1\u8CA1\u8F09\u9F4B\u9F4E\u722D\u7B8F\u8ACD\u931A\u4F47\u4F4E\u5132\u5480\u59D0\u5E95\u62B5\u6775\u696E\u6A17\u6CAE\u6E1A\u72D9\u732A\u75BD\u7BB8\u7D35\u82E7\u83F9\u8457\u85F7\u8A5B\u8CAF\u8E87\u9019\u90B8\u96CE\u9F5F\u52E3\u540A\u5AE1\u5BC2\u6458\u6575\u6EF4\u72C4\uF9FB\u7684\u7A4D\u7B1B\u7C4D\u7E3E\u7FDF\u837B\u8B2B\u8CCA\u8D64\u8DE1\u8E5F\u8FEA\u8FF9\u9069\u93D1\u4F43\u4F7A\u50B3\u5168\u5178\u524D\u526A\u5861\u587C\u5960\u5C08\u5C55\u5EDB\u609B\u6230\u6813\u6BBF\u6C08\u6FB1"],
+ ["efa1", "\u714E\u7420\u7530\u7538\u7551\u7672\u7B4C\u7B8B\u7BAD\u7BC6\u7E8F\u8A6E\u8F3E\u8F49\u923F\u9293\u9322\u942B\u96FB\u985A\u986B\u991E\u5207\u622A\u6298\u6D59\u7664\u7ACA\u7BC0\u7D76\u5360\u5CBE\u5E97\u6F38\u70B9\u7C98\u9711\u9B8E\u9EDE\u63A5\u647A\u8776\u4E01\u4E95\u4EAD\u505C\u5075\u5448\u59C3\u5B9A\u5E40\u5EAD\u5EF7\u5F81\u60C5\u633A\u653F\u6574\u65CC\u6676\u6678\u67FE\u6968\u6A89\u6B63\u6C40\u6DC0\u6DE8\u6E1F\u6E5E\u701E\u70A1\u738E\u73FD\u753A\u775B\u7887\u798E\u7A0B\u7A7D\u7CBE\u7D8E\u8247\u8A02\u8AEA\u8C9E\u912D\u914A\u91D8\u9266\u92CC\u9320\u9706\u9756"],
+ ["f0a1", "\u975C\u9802\u9F0E\u5236\u5291\u557C\u5824\u5E1D\u5F1F\u608C\u63D0\u68AF\u6FDF\u796D\u7B2C\u81CD\u85BA\u88FD\u8AF8\u8E44\u918D\u9664\u969B\u973D\u984C\u9F4A\u4FCE\u5146\u51CB\u52A9\u5632\u5F14\u5F6B\u63AA\u64CD\u65E9\u6641\u66FA\u66F9\u671D\u689D\u68D7\u69FD\u6F15\u6F6E\u7167\u71E5\u722A\u74AA\u773A\u7956\u795A\u79DF\u7A20\u7A95\u7C97\u7CDF\u7D44\u7E70\u8087\u85FB\u86A4\u8A54\u8ABF\u8D99\u8E81\u9020\u906D\u91E3\u963B\u96D5\u9CE5\u65CF\u7C07\u8DB3\u93C3\u5B58\u5C0A\u5352\u62D9\u731D\u5027\u5B97\u5F9E\u60B0\u616B\u68D5\u6DD9\u742E\u7A2E\u7D42\u7D9C\u7E31\u816B"],
+ ["f1a1", "\u8E2A\u8E35\u937E\u9418\u4F50\u5750\u5DE6\u5EA7\u632B\u7F6A\u4E3B\u4F4F\u4F8F\u505A\u59DD\u80C4\u546A\u5468\u55FE\u594F\u5B99\u5DDE\u5EDA\u665D\u6731\u67F1\u682A\u6CE8\u6D32\u6E4A\u6F8D\u70B7\u73E0\u7587\u7C4C\u7D02\u7D2C\u7DA2\u821F\u86DB\u8A3B\u8A85\u8D70\u8E8A\u8F33\u9031\u914E\u9152\u9444\u99D0\u7AF9\u7CA5\u4FCA\u5101\u51C6\u57C8\u5BEF\u5CFB\u6659\u6A3D\u6D5A\u6E96\u6FEC\u710C\u756F\u7AE3\u8822\u9021\u9075\u96CB\u99FF\u8301\u4E2D\u4EF2\u8846\u91CD\u537D\u6ADB\u696B\u6C41\u847A\u589E\u618E\u66FE\u62EF\u70DD\u7511\u75C7\u7E52\u84B8\u8B49\u8D08\u4E4B\u53EA"],
+ ["f2a1", "\u54AB\u5730\u5740\u5FD7\u6301\u6307\u646F\u652F\u65E8\u667A\u679D\u67B3\u6B62\u6C60\u6C9A\u6F2C\u77E5\u7825\u7949\u7957\u7D19\u80A2\u8102\u81F3\u829D\u82B7\u8718\u8A8C\uF9FC\u8D04\u8DBE\u9072\u76F4\u7A19\u7A37\u7E54\u8077\u5507\u55D4\u5875\u632F\u6422\u6649\u664B\u686D\u699B\u6B84\u6D25\u6EB1\u73CD\u7468\u74A1\u755B\u75B9\u76E1\u771E\u778B\u79E6\u7E09\u7E1D\u81FB\u852F\u8897\u8A3A\u8CD1\u8EEB\u8FB0\u9032\u93AD\u9663\u9673\u9707\u4F84\u53F1\u59EA\u5AC9\u5E19\u684E\u74C6\u75BE\u79E9\u7A92\u81A3\u86ED\u8CEA\u8DCC\u8FED\u659F\u6715\uF9FD\u57F7\u6F57\u7DDD\u8F2F"],
+ ["f3a1", "\u93F6\u96C6\u5FB5\u61F2\u6F84\u4E14\u4F98\u501F\u53C9\u55DF\u5D6F\u5DEE\u6B21\u6B64\u78CB\u7B9A\uF9FE\u8E49\u8ECA\u906E\u6349\u643E\u7740\u7A84\u932F\u947F\u9F6A\u64B0\u6FAF\u71E6\u74A8\u74DA\u7AC4\u7C12\u7E82\u7CB2\u7E98\u8B9A\u8D0A\u947D\u9910\u994C\u5239\u5BDF\u64E6\u672D\u7D2E\u50ED\u53C3\u5879\u6158\u6159\u61FA\u65AC\u7AD9\u8B92\u8B96\u5009\u5021\u5275\u5531\u5A3C\u5EE0\u5F70\u6134\u655E\u660C\u6636\u66A2\u69CD\u6EC4\u6F32\u7316\u7621\u7A93\u8139\u8259\u83D6\u84BC\u50B5\u57F0\u5BC0\u5BE8\u5F69\u63A1\u7826\u7DB5\u83DC\u8521\u91C7\u91F5\u518A\u67F5\u7B56"],
+ ["f4a1", "\u8CAC\u51C4\u59BB\u60BD\u8655\u501C\uF9FF\u5254\u5C3A\u617D\u621A\u62D3\u64F2\u65A5\u6ECC\u7620\u810A\u8E60\u965F\u96BB\u4EDF\u5343\u5598\u5929\u5DDD\u64C5\u6CC9\u6DFA\u7394\u7A7F\u821B\u85A6\u8CE4\u8E10\u9077\u91E7\u95E1\u9621\u97C6\u51F8\u54F2\u5586\u5FB9\u64A4\u6F88\u7DB4\u8F1F\u8F4D\u9435\u50C9\u5C16\u6CBE\u6DFB\u751B\u77BB\u7C3D\u7C64\u8A79\u8AC2\u581E\u59BE\u5E16\u6377\u7252\u758A\u776B\u8ADC\u8CBC\u8F12\u5EF3\u6674\u6DF8\u807D\u83C1\u8ACB\u9751\u9BD6\uFA00\u5243\u66FF\u6D95\u6EEF\u7DE0\u8AE6\u902E\u905E\u9AD4\u521D\u527F\u54E8\u6194\u6284\u62DB\u68A2"],
+ ["f5a1", "\u6912\u695A\u6A35\u7092\u7126\u785D\u7901\u790E\u79D2\u7A0D\u8096\u8278\u82D5\u8349\u8549\u8C82\u8D85\u9162\u918B\u91AE\u4FC3\u56D1\u71ED\u77D7\u8700\u89F8\u5BF8\u5FD6\u6751\u90A8\u53E2\u585A\u5BF5\u60A4\u6181\u6460\u7E3D\u8070\u8525\u9283\u64AE\u50AC\u5D14\u6700\u589C\u62BD\u63A8\u690E\u6978\u6A1E\u6E6B\u76BA\u79CB\u82BB\u8429\u8ACF\u8DA8\u8FFD\u9112\u914B\u919C\u9310\u9318\u939A\u96DB\u9A36\u9C0D\u4E11\u755C\u795D\u7AFA\u7B51\u7BC9\u7E2E\u84C4\u8E59\u8E74\u8EF8\u9010\u6625\u693F\u7443\u51FA\u672E\u9EDC\u5145\u5FE0\u6C96\u87F2\u885D\u8877\u60B4\u81B5\u8403"],
+ ["f6a1", "\u8D05\u53D6\u5439\u5634\u5A36\u5C31\u708A\u7FE0\u805A\u8106\u81ED\u8DA3\u9189\u9A5F\u9DF2\u5074\u4EC4\u53A0\u60FB\u6E2C\u5C64\u4F88\u5024\u55E4\u5CD9\u5E5F\u6065\u6894\u6CBB\u6DC4\u71BE\u75D4\u75F4\u7661\u7A1A\u7A49\u7DC7\u7DFB\u7F6E\u81F4\u86A9\u8F1C\u96C9\u99B3\u9F52\u5247\u52C5\u98ED\u89AA\u4E03\u67D2\u6F06\u4FB5\u5BE2\u6795\u6C88\u6D78\u741B\u7827\u91DD\u937C\u87C4\u79E4\u7A31\u5FEB\u4ED6\u54A4\u553E\u58AE\u59A5\u60F0\u6253\u62D6\u6736\u6955\u8235\u9640\u99B1\u99DD\u502C\u5353\u5544\u577C\uFA01\u6258\uFA02\u64E2\u666B\u67DD\u6FC1\u6FEF\u7422\u7438\u8A17"],
+ ["f7a1", "\u9438\u5451\u5606\u5766\u5F48\u619A\u6B4E\u7058\u70AD\u7DBB\u8A95\u596A\u812B\u63A2\u7708\u803D\u8CAA\u5854\u642D\u69BB\u5B95\u5E11\u6E6F\uFA03\u8569\u514C\u53F0\u592A\u6020\u614B\u6B86\u6C70\u6CF0\u7B1E\u80CE\u82D4\u8DC6\u90B0\u98B1\uFA04\u64C7\u6FA4\u6491\u6504\u514E\u5410\u571F\u8A0E\u615F\u6876\uFA05\u75DB\u7B52\u7D71\u901A\u5806\u69CC\u817F\u892A\u9000\u9839\u5078\u5957\u59AC\u6295\u900F\u9B2A\u615D\u7279\u95D6\u5761\u5A46\u5DF4\u628A\u64AD\u64FA\u6777\u6CE2\u6D3E\u722C\u7436\u7834\u7F77\u82AD\u8DDB\u9817\u5224\u5742\u677F\u7248\u74E3\u8CA9\u8FA6\u9211"],
+ ["f8a1", "\u962A\u516B\u53ED\u634C\u4F69\u5504\u6096\u6557\u6C9B\u6D7F\u724C\u72FD\u7A17\u8987\u8C9D\u5F6D\u6F8E\u70F9\u81A8\u610E\u4FBF\u504F\u6241\u7247\u7BC7\u7DE8\u7FE9\u904D\u97AD\u9A19\u8CB6\u576A\u5E73\u67B0\u840D\u8A55\u5420\u5B16\u5E63\u5EE2\u5F0A\u6583\u80BA\u853D\u9589\u965B\u4F48\u5305\u530D\u530F\u5486\u54FA\u5703\u5E03\u6016\u629B\u62B1\u6355\uFA06\u6CE1\u6D66\u75B1\u7832\u80DE\u812F\u82DE\u8461\u84B2\u888D\u8912\u900B\u92EA\u98FD\u9B91\u5E45\u66B4\u66DD\u7011\u7206\uFA07\u4FF5\u527D\u5F6A\u6153\u6753\u6A19\u6F02\u74E2\u7968\u8868\u8C79\u98C7\u98C4\u9A43"],
+ ["f9a1", "\u54C1\u7A1F\u6953\u8AF7\u8C4A\u98A8\u99AE\u5F7C\u62AB\u75B2\u76AE\u88AB\u907F\u9642\u5339\u5F3C\u5FC5\u6CCC\u73CC\u7562\u758B\u7B46\u82FE\u999D\u4E4F\u903C\u4E0B\u4F55\u53A6\u590F\u5EC8\u6630\u6CB3\u7455\u8377\u8766\u8CC0\u9050\u971E\u9C15\u58D1\u5B78\u8650\u8B14\u9DB4\u5BD2\u6068\u608D\u65F1\u6C57\u6F22\u6FA3\u701A\u7F55\u7FF0\u9591\u9592\u9650\u97D3\u5272\u8F44\u51FD\u542B\u54B8\u5563\u558A\u6ABB\u6DB5\u7DD8\u8266\u929C\u9677\u9E79\u5408\u54C8\u76D2\u86E4\u95A4\u95D4\u965C\u4EA2\u4F09\u59EE\u5AE6\u5DF7\u6052\u6297\u676D\u6841\u6C86\u6E2F\u7F38\u809B\u822A"],
+ ["faa1", "\uFA08\uFA09\u9805\u4EA5\u5055\u54B3\u5793\u595A\u5B69\u5BB3\u61C8\u6977\u6D77\u7023\u87F9\u89E3\u8A72\u8AE7\u9082\u99ED\u9AB8\u52BE\u6838\u5016\u5E78\u674F\u8347\u884C\u4EAB\u5411\u56AE\u73E6\u9115\u97FF\u9909\u9957\u9999\u5653\u589F\u865B\u8A31\u61B2\u6AF6\u737B\u8ED2\u6B47\u96AA\u9A57\u5955\u7200\u8D6B\u9769\u4FD4\u5CF4\u5F26\u61F8\u665B\u6CEB\u70AB\u7384\u73B9\u73FE\u7729\u774D\u7D43\u7D62\u7E23\u8237\u8852\uFA0A\u8CE2\u9249\u986F\u5B51\u7A74\u8840\u9801\u5ACC\u4FE0\u5354\u593E\u5CFD\u633E\u6D79\u72F9\u8105\u8107\u83A2\u92CF\u9830\u4EA8\u5144\u5211\u578B"],
+ ["fba1", "\u5F62\u6CC2\u6ECE\u7005\u7050\u70AF\u7192\u73E9\u7469\u834A\u87A2\u8861\u9008\u90A2\u93A3\u99A8\u516E\u5F57\u60E0\u6167\u66B3\u8559\u8E4A\u91AF\u978B\u4E4E\u4E92\u547C\u58D5\u58FA\u597D\u5CB5\u5F27\u6236\u6248\u660A\u6667\u6BEB\u6D69\u6DCF\u6E56\u6EF8\u6F94\u6FE0\u6FE9\u705D\u72D0\u7425\u745A\u74E0\u7693\u795C\u7CCA\u7E1E\u80E1\u82A6\u846B\u84BF\u864E\u865F\u8774\u8B77\u8C6A\u93AC\u9800\u9865\u60D1\u6216\u9177\u5A5A\u660F\u6DF7\u6E3E\u743F\u9B42\u5FFD\u60DA\u7B0F\u54C4\u5F18\u6C5E\u6CD3\u6D2A\u70D8\u7D05\u8679\u8A0C\u9D3B\u5316\u548C\u5B05\u6A3A\u706B\u7575"],
+ ["fca1", "\u798D\u79BE\u82B1\u83EF\u8A71\u8B41\u8CA8\u9774\uFA0B\u64F4\u652B\u78BA\u78BB\u7A6B\u4E38\u559A\u5950\u5BA6\u5E7B\u60A3\u63DB\u6B61\u6665\u6853\u6E19\u7165\u74B0\u7D08\u9084\u9A69\u9C25\u6D3B\u6ED1\u733E\u8C41\u95CA\u51F0\u5E4C\u5FA8\u604D\u60F6\u6130\u614C\u6643\u6644\u69A5\u6CC1\u6E5F\u6EC9\u6F62\u714C\u749C\u7687\u7BC1\u7C27\u8352\u8757\u9051\u968D\u9EC3\u532F\u56DE\u5EFB\u5F8A\u6062\u6094\u61F7\u6666\u6703\u6A9C\u6DEE\u6FAE\u7070\u736A\u7E6A\u81BE\u8334\u86D4\u8AA8\u8CC4\u5283\u7372\u5B96\u6A6B\u9404\u54EE\u5686\u5B5D\u6548\u6585\u66C9\u689F\u6D8D\u6DC6"],
+ ["fda1", "\u723B\u80B4\u9175\u9A4D\u4FAF\u5019\u539A\u540E\u543C\u5589\u55C5\u5E3F\u5F8C\u673D\u7166\u73DD\u9005\u52DB\u52F3\u5864\u58CE\u7104\u718F\u71FB\u85B0\u8A13\u6688\u85A8\u55A7\u6684\u714A\u8431\u5349\u5599\u6BC1\u5F59\u5FBD\u63EE\u6689\u7147\u8AF1\u8F1D\u9EBE\u4F11\u643A\u70CB\u7566\u8667\u6064\u8B4E\u9DF8\u5147\u51F6\u5308\u6D36\u80F8\u9ED1\u6615\u6B23\u7098\u75D5\u5403\u5C79\u7D07\u8A16\u6B20\u6B3D\u6B46\u5438\u6070\u6D3D\u7FD5\u8208\u50D6\u51DE\u559C\u566B\u56CD\u59EC\u5B09\u5E0C\u6199\u6198\u6231\u665E\u66E6\u7199\u71B9\u71BA\u72A7\u79A7\u7A00\u7FB2\u8A70"]
+ ];
+ }
+});
+
+// ../../node_modules/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/encodings/tables/cp950.json
+var require_cp950 = __commonJS({
+ "../../node_modules/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/encodings/tables/cp950.json"(exports2, module2) {
+ module2.exports = [
+ ["0", "\0", 127],
+ ["a140", "\u3000\uFF0C\u3001\u3002\uFF0E\u2027\uFF1B\uFF1A\uFF1F\uFF01\uFE30\u2026\u2025\uFE50\uFE51\uFE52\xB7\uFE54\uFE55\uFE56\uFE57\uFF5C\u2013\uFE31\u2014\uFE33\u2574\uFE34\uFE4F\uFF08\uFF09\uFE35\uFE36\uFF5B\uFF5D\uFE37\uFE38\u3014\u3015\uFE39\uFE3A\u3010\u3011\uFE3B\uFE3C\u300A\u300B\uFE3D\uFE3E\u3008\u3009\uFE3F\uFE40\u300C\u300D\uFE41\uFE42\u300E\u300F\uFE43\uFE44\uFE59\uFE5A"],
+ ["a1a1", "\uFE5B\uFE5C\uFE5D\uFE5E\u2018\u2019\u201C\u201D\u301D\u301E\u2035\u2032\uFF03\uFF06\uFF0A\u203B\xA7\u3003\u25CB\u25CF\u25B3\u25B2\u25CE\u2606\u2605\u25C7\u25C6\u25A1\u25A0\u25BD\u25BC\u32A3\u2105\xAF\uFFE3\uFF3F\u02CD\uFE49\uFE4A\uFE4D\uFE4E\uFE4B\uFE4C\uFE5F\uFE60\uFE61\uFF0B\uFF0D\xD7\xF7\xB1\u221A\uFF1C\uFF1E\uFF1D\u2266\u2267\u2260\u221E\u2252\u2261\uFE62", 4, "\uFF5E\u2229\u222A\u22A5\u2220\u221F\u22BF\u33D2\u33D1\u222B\u222E\u2235\u2234\u2640\u2642\u2295\u2299\u2191\u2193\u2190\u2192\u2196\u2197\u2199\u2198\u2225\u2223\uFF0F"],
+ ["a240", "\uFF3C\u2215\uFE68\uFF04\uFFE5\u3012\uFFE0\uFFE1\uFF05\uFF20\u2103\u2109\uFE69\uFE6A\uFE6B\u33D5\u339C\u339D\u339E\u33CE\u33A1\u338E\u338F\u33C4\xB0\u5159\u515B\u515E\u515D\u5161\u5163\u55E7\u74E9\u7CCE\u2581", 7, "\u258F\u258E\u258D\u258C\u258B\u258A\u2589\u253C\u2534\u252C\u2524\u251C\u2594\u2500\u2502\u2595\u250C\u2510\u2514\u2518\u256D"],
+ ["a2a1", "\u256E\u2570\u256F\u2550\u255E\u256A\u2561\u25E2\u25E3\u25E5\u25E4\u2571\u2572\u2573\uFF10", 9, "\u2160", 9, "\u3021", 8, "\u5341\u5344\u5345\uFF21", 25, "\uFF41", 21],
+ ["a340", "\uFF57\uFF58\uFF59\uFF5A\u0391", 16, "\u03A3", 6, "\u03B1", 16, "\u03C3", 6, "\u3105", 10],
+ ["a3a1", "\u3110", 25, "\u02D9\u02C9\u02CA\u02C7\u02CB"],
+ ["a3e1", "\u20AC"],
+ ["a440", "\u4E00\u4E59\u4E01\u4E03\u4E43\u4E5D\u4E86\u4E8C\u4EBA\u513F\u5165\u516B\u51E0\u5200\u5201\u529B\u5315\u5341\u535C\u53C8\u4E09\u4E0B\u4E08\u4E0A\u4E2B\u4E38\u51E1\u4E45\u4E48\u4E5F\u4E5E\u4E8E\u4EA1\u5140\u5203\u52FA\u5343\u53C9\u53E3\u571F\u58EB\u5915\u5927\u5973\u5B50\u5B51\u5B53\u5BF8\u5C0F\u5C22\u5C38\u5C71\u5DDD\u5DE5\u5DF1\u5DF2\u5DF3\u5DFE\u5E72\u5EFE\u5F0B\u5F13\u624D"],
+ ["a4a1", "\u4E11\u4E10\u4E0D\u4E2D\u4E30\u4E39\u4E4B\u5C39\u4E88\u4E91\u4E95\u4E92\u4E94\u4EA2\u4EC1\u4EC0\u4EC3\u4EC6\u4EC7\u4ECD\u4ECA\u4ECB\u4EC4\u5143\u5141\u5167\u516D\u516E\u516C\u5197\u51F6\u5206\u5207\u5208\u52FB\u52FE\u52FF\u5316\u5339\u5348\u5347\u5345\u535E\u5384\u53CB\u53CA\u53CD\u58EC\u5929\u592B\u592A\u592D\u5B54\u5C11\u5C24\u5C3A\u5C6F\u5DF4\u5E7B\u5EFF\u5F14\u5F15\u5FC3\u6208\u6236\u624B\u624E\u652F\u6587\u6597\u65A4\u65B9\u65E5\u66F0\u6708\u6728\u6B20\u6B62\u6B79\u6BCB\u6BD4\u6BDB\u6C0F\u6C34\u706B\u722A\u7236\u723B\u7247\u7259\u725B\u72AC\u738B\u4E19"],
+ ["a540", "\u4E16\u4E15\u4E14\u4E18\u4E3B\u4E4D\u4E4F\u4E4E\u4EE5\u4ED8\u4ED4\u4ED5\u4ED6\u4ED7\u4EE3\u4EE4\u4ED9\u4EDE\u5145\u5144\u5189\u518A\u51AC\u51F9\u51FA\u51F8\u520A\u52A0\u529F\u5305\u5306\u5317\u531D\u4EDF\u534A\u5349\u5361\u5360\u536F\u536E\u53BB\u53EF\u53E4\u53F3\u53EC\u53EE\u53E9\u53E8\u53FC\u53F8\u53F5\u53EB\u53E6\u53EA\u53F2\u53F1\u53F0\u53E5\u53ED\u53FB\u56DB\u56DA\u5916"],
+ ["a5a1", "\u592E\u5931\u5974\u5976\u5B55\u5B83\u5C3C\u5DE8\u5DE7\u5DE6\u5E02\u5E03\u5E73\u5E7C\u5F01\u5F18\u5F17\u5FC5\u620A\u6253\u6254\u6252\u6251\u65A5\u65E6\u672E\u672C\u672A\u672B\u672D\u6B63\u6BCD\u6C11\u6C10\u6C38\u6C41\u6C40\u6C3E\u72AF\u7384\u7389\u74DC\u74E6\u7518\u751F\u7528\u7529\u7530\u7531\u7532\u7533\u758B\u767D\u76AE\u76BF\u76EE\u77DB\u77E2\u77F3\u793A\u79BE\u7A74\u7ACB\u4E1E\u4E1F\u4E52\u4E53\u4E69\u4E99\u4EA4\u4EA6\u4EA5\u4EFF\u4F09\u4F19\u4F0A\u4F15\u4F0D\u4F10\u4F11\u4F0F\u4EF2\u4EF6\u4EFB\u4EF0\u4EF3\u4EFD\u4F01\u4F0B\u5149\u5147\u5146\u5148\u5168"],
+ ["a640", "\u5171\u518D\u51B0\u5217\u5211\u5212\u520E\u5216\u52A3\u5308\u5321\u5320\u5370\u5371\u5409\u540F\u540C\u540A\u5410\u5401\u540B\u5404\u5411\u540D\u5408\u5403\u540E\u5406\u5412\u56E0\u56DE\u56DD\u5733\u5730\u5728\u572D\u572C\u572F\u5729\u5919\u591A\u5937\u5938\u5984\u5978\u5983\u597D\u5979\u5982\u5981\u5B57\u5B58\u5B87\u5B88\u5B85\u5B89\u5BFA\u5C16\u5C79\u5DDE\u5E06\u5E76\u5E74"],
+ ["a6a1", "\u5F0F\u5F1B\u5FD9\u5FD6\u620E\u620C\u620D\u6210\u6263\u625B\u6258\u6536\u65E9\u65E8\u65EC\u65ED\u66F2\u66F3\u6709\u673D\u6734\u6731\u6735\u6B21\u6B64\u6B7B\u6C16\u6C5D\u6C57\u6C59\u6C5F\u6C60\u6C50\u6C55\u6C61\u6C5B\u6C4D\u6C4E\u7070\u725F\u725D\u767E\u7AF9\u7C73\u7CF8\u7F36\u7F8A\u7FBD\u8001\u8003\u800C\u8012\u8033\u807F\u8089\u808B\u808C\u81E3\u81EA\u81F3\u81FC\u820C\u821B\u821F\u826E\u8272\u827E\u866B\u8840\u884C\u8863\u897F\u9621\u4E32\u4EA8\u4F4D\u4F4F\u4F47\u4F57\u4F5E\u4F34\u4F5B\u4F55\u4F30\u4F50\u4F51\u4F3D\u4F3A\u4F38\u4F43\u4F54\u4F3C\u4F46\u4F63"],
+ ["a740", "\u4F5C\u4F60\u4F2F\u4F4E\u4F36\u4F59\u4F5D\u4F48\u4F5A\u514C\u514B\u514D\u5175\u51B6\u51B7\u5225\u5224\u5229\u522A\u5228\u52AB\u52A9\u52AA\u52AC\u5323\u5373\u5375\u541D\u542D\u541E\u543E\u5426\u544E\u5427\u5446\u5443\u5433\u5448\u5442\u541B\u5429\u544A\u5439\u543B\u5438\u542E\u5435\u5436\u5420\u543C\u5440\u5431\u542B\u541F\u542C\u56EA\u56F0\u56E4\u56EB\u574A\u5751\u5740\u574D"],
+ ["a7a1", "\u5747\u574E\u573E\u5750\u574F\u573B\u58EF\u593E\u599D\u5992\u59A8\u599E\u59A3\u5999\u5996\u598D\u59A4\u5993\u598A\u59A5\u5B5D\u5B5C\u5B5A\u5B5B\u5B8C\u5B8B\u5B8F\u5C2C\u5C40\u5C41\u5C3F\u5C3E\u5C90\u5C91\u5C94\u5C8C\u5DEB\u5E0C\u5E8F\u5E87\u5E8A\u5EF7\u5F04\u5F1F\u5F64\u5F62\u5F77\u5F79\u5FD8\u5FCC\u5FD7\u5FCD\u5FF1\u5FEB\u5FF8\u5FEA\u6212\u6211\u6284\u6297\u6296\u6280\u6276\u6289\u626D\u628A\u627C\u627E\u6279\u6273\u6292\u626F\u6298\u626E\u6295\u6293\u6291\u6286\u6539\u653B\u6538\u65F1\u66F4\u675F\u674E\u674F\u6750\u6751\u675C\u6756\u675E\u6749\u6746\u6760"],
+ ["a840", "\u6753\u6757\u6B65\u6BCF\u6C42\u6C5E\u6C99\u6C81\u6C88\u6C89\u6C85\u6C9B\u6C6A\u6C7A\u6C90\u6C70\u6C8C\u6C68\u6C96\u6C92\u6C7D\u6C83\u6C72\u6C7E\u6C74\u6C86\u6C76\u6C8D\u6C94\u6C98\u6C82\u7076\u707C\u707D\u7078\u7262\u7261\u7260\u72C4\u72C2\u7396\u752C\u752B\u7537\u7538\u7682\u76EF\u77E3\u79C1\u79C0\u79BF\u7A76\u7CFB\u7F55\u8096\u8093\u809D\u8098\u809B\u809A\u80B2\u826F\u8292"],
+ ["a8a1", "\u828B\u828D\u898B\u89D2\u8A00\u8C37\u8C46\u8C55\u8C9D\u8D64\u8D70\u8DB3\u8EAB\u8ECA\u8F9B\u8FB0\u8FC2\u8FC6\u8FC5\u8FC4\u5DE1\u9091\u90A2\u90AA\u90A6\u90A3\u9149\u91C6\u91CC\u9632\u962E\u9631\u962A\u962C\u4E26\u4E56\u4E73\u4E8B\u4E9B\u4E9E\u4EAB\u4EAC\u4F6F\u4F9D\u4F8D\u4F73\u4F7F\u4F6C\u4F9B\u4F8B\u4F86\u4F83\u4F70\u4F75\u4F88\u4F69\u4F7B\u4F96\u4F7E\u4F8F\u4F91\u4F7A\u5154\u5152\u5155\u5169\u5177\u5176\u5178\u51BD\u51FD\u523B\u5238\u5237\u523A\u5230\u522E\u5236\u5241\u52BE\u52BB\u5352\u5354\u5353\u5351\u5366\u5377\u5378\u5379\u53D6\u53D4\u53D7\u5473\u5475"],
+ ["a940", "\u5496\u5478\u5495\u5480\u547B\u5477\u5484\u5492\u5486\u547C\u5490\u5471\u5476\u548C\u549A\u5462\u5468\u548B\u547D\u548E\u56FA\u5783\u5777\u576A\u5769\u5761\u5766\u5764\u577C\u591C\u5949\u5947\u5948\u5944\u5954\u59BE\u59BB\u59D4\u59B9\u59AE\u59D1\u59C6\u59D0\u59CD\u59CB\u59D3\u59CA\u59AF\u59B3\u59D2\u59C5\u5B5F\u5B64\u5B63\u5B97\u5B9A\u5B98\u5B9C\u5B99\u5B9B\u5C1A\u5C48\u5C45"],
+ ["a9a1", "\u5C46\u5CB7\u5CA1\u5CB8\u5CA9\u5CAB\u5CB1\u5CB3\u5E18\u5E1A\u5E16\u5E15\u5E1B\u5E11\u5E78\u5E9A\u5E97\u5E9C\u5E95\u5E96\u5EF6\u5F26\u5F27\u5F29\u5F80\u5F81\u5F7F\u5F7C\u5FDD\u5FE0\u5FFD\u5FF5\u5FFF\u600F\u6014\u602F\u6035\u6016\u602A\u6015\u6021\u6027\u6029\u602B\u601B\u6216\u6215\u623F\u623E\u6240\u627F\u62C9\u62CC\u62C4\u62BF\u62C2\u62B9\u62D2\u62DB\u62AB\u62D3\u62D4\u62CB\u62C8\u62A8\u62BD\u62BC\u62D0\u62D9\u62C7\u62CD\u62B5\u62DA\u62B1\u62D8\u62D6\u62D7\u62C6\u62AC\u62CE\u653E\u65A7\u65BC\u65FA\u6614\u6613\u660C\u6606\u6602\u660E\u6600\u660F\u6615\u660A"],
+ ["aa40", "\u6607\u670D\u670B\u676D\u678B\u6795\u6771\u679C\u6773\u6777\u6787\u679D\u6797\u676F\u6770\u677F\u6789\u677E\u6790\u6775\u679A\u6793\u677C\u676A\u6772\u6B23\u6B66\u6B67\u6B7F\u6C13\u6C1B\u6CE3\u6CE8\u6CF3\u6CB1\u6CCC\u6CE5\u6CB3\u6CBD\u6CBE\u6CBC\u6CE2\u6CAB\u6CD5\u6CD3\u6CB8\u6CC4\u6CB9\u6CC1\u6CAE\u6CD7\u6CC5\u6CF1\u6CBF\u6CBB\u6CE1\u6CDB\u6CCA\u6CAC\u6CEF\u6CDC\u6CD6\u6CE0"],
+ ["aaa1", "\u7095\u708E\u7092\u708A\u7099\u722C\u722D\u7238\u7248\u7267\u7269\u72C0\u72CE\u72D9\u72D7\u72D0\u73A9\u73A8\u739F\u73AB\u73A5\u753D\u759D\u7599\u759A\u7684\u76C2\u76F2\u76F4\u77E5\u77FD\u793E\u7940\u7941\u79C9\u79C8\u7A7A\u7A79\u7AFA\u7CFE\u7F54\u7F8C\u7F8B\u8005\u80BA\u80A5\u80A2\u80B1\u80A1\u80AB\u80A9\u80B4\u80AA\u80AF\u81E5\u81FE\u820D\u82B3\u829D\u8299\u82AD\u82BD\u829F\u82B9\u82B1\u82AC\u82A5\u82AF\u82B8\u82A3\u82B0\u82BE\u82B7\u864E\u8671\u521D\u8868\u8ECB\u8FCE\u8FD4\u8FD1\u90B5\u90B8\u90B1\u90B6\u91C7\u91D1\u9577\u9580\u961C\u9640\u963F\u963B\u9644"],
+ ["ab40", "\u9642\u96B9\u96E8\u9752\u975E\u4E9F\u4EAD\u4EAE\u4FE1\u4FB5\u4FAF\u4FBF\u4FE0\u4FD1\u4FCF\u4FDD\u4FC3\u4FB6\u4FD8\u4FDF\u4FCA\u4FD7\u4FAE\u4FD0\u4FC4\u4FC2\u4FDA\u4FCE\u4FDE\u4FB7\u5157\u5192\u5191\u51A0\u524E\u5243\u524A\u524D\u524C\u524B\u5247\u52C7\u52C9\u52C3\u52C1\u530D\u5357\u537B\u539A\u53DB\u54AC\u54C0\u54A8\u54CE\u54C9\u54B8\u54A6\u54B3\u54C7\u54C2\u54BD\u54AA\u54C1"],
+ ["aba1", "\u54C4\u54C8\u54AF\u54AB\u54B1\u54BB\u54A9\u54A7\u54BF\u56FF\u5782\u578B\u57A0\u57A3\u57A2\u57CE\u57AE\u5793\u5955\u5951\u594F\u594E\u5950\u59DC\u59D8\u59FF\u59E3\u59E8\u5A03\u59E5\u59EA\u59DA\u59E6\u5A01\u59FB\u5B69\u5BA3\u5BA6\u5BA4\u5BA2\u5BA5\u5C01\u5C4E\u5C4F\u5C4D\u5C4B\u5CD9\u5CD2\u5DF7\u5E1D\u5E25\u5E1F\u5E7D\u5EA0\u5EA6\u5EFA\u5F08\u5F2D\u5F65\u5F88\u5F85\u5F8A\u5F8B\u5F87\u5F8C\u5F89\u6012\u601D\u6020\u6025\u600E\u6028\u604D\u6070\u6068\u6062\u6046\u6043\u606C\u606B\u606A\u6064\u6241\u62DC\u6316\u6309\u62FC\u62ED\u6301\u62EE\u62FD\u6307\u62F1\u62F7"],
+ ["ac40", "\u62EF\u62EC\u62FE\u62F4\u6311\u6302\u653F\u6545\u65AB\u65BD\u65E2\u6625\u662D\u6620\u6627\u662F\u661F\u6628\u6631\u6624\u66F7\u67FF\u67D3\u67F1\u67D4\u67D0\u67EC\u67B6\u67AF\u67F5\u67E9\u67EF\u67C4\u67D1\u67B4\u67DA\u67E5\u67B8\u67CF\u67DE\u67F3\u67B0\u67D9\u67E2\u67DD\u67D2\u6B6A\u6B83\u6B86\u6BB5\u6BD2\u6BD7\u6C1F\u6CC9\u6D0B\u6D32\u6D2A\u6D41\u6D25\u6D0C\u6D31\u6D1E\u6D17"],
+ ["aca1", "\u6D3B\u6D3D\u6D3E\u6D36\u6D1B\u6CF5\u6D39\u6D27\u6D38\u6D29\u6D2E\u6D35\u6D0E\u6D2B\u70AB\u70BA\u70B3\u70AC\u70AF\u70AD\u70B8\u70AE\u70A4\u7230\u7272\u726F\u7274\u72E9\u72E0\u72E1\u73B7\u73CA\u73BB\u73B2\u73CD\u73C0\u73B3\u751A\u752D\u754F\u754C\u754E\u754B\u75AB\u75A4\u75A5\u75A2\u75A3\u7678\u7686\u7687\u7688\u76C8\u76C6\u76C3\u76C5\u7701\u76F9\u76F8\u7709\u770B\u76FE\u76FC\u7707\u77DC\u7802\u7814\u780C\u780D\u7946\u7949\u7948\u7947\u79B9\u79BA\u79D1\u79D2\u79CB\u7A7F\u7A81\u7AFF\u7AFD\u7C7D\u7D02\u7D05\u7D00\u7D09\u7D07\u7D04\u7D06\u7F38\u7F8E\u7FBF\u8004"],
+ ["ad40", "\u8010\u800D\u8011\u8036\u80D6\u80E5\u80DA\u80C3\u80C4\u80CC\u80E1\u80DB\u80CE\u80DE\u80E4\u80DD\u81F4\u8222\u82E7\u8303\u8305\u82E3\u82DB\u82E6\u8304\u82E5\u8302\u8309\u82D2\u82D7\u82F1\u8301\u82DC\u82D4\u82D1\u82DE\u82D3\u82DF\u82EF\u8306\u8650\u8679\u867B\u867A\u884D\u886B\u8981\u89D4\u8A08\u8A02\u8A03\u8C9E\u8CA0\u8D74\u8D73\u8DB4\u8ECD\u8ECC\u8FF0\u8FE6\u8FE2\u8FEA\u8FE5"],
+ ["ada1", "\u8FED\u8FEB\u8FE4\u8FE8\u90CA\u90CE\u90C1\u90C3\u914B\u914A\u91CD\u9582\u9650\u964B\u964C\u964D\u9762\u9769\u97CB\u97ED\u97F3\u9801\u98A8\u98DB\u98DF\u9996\u9999\u4E58\u4EB3\u500C\u500D\u5023\u4FEF\u5026\u5025\u4FF8\u5029\u5016\u5006\u503C\u501F\u501A\u5012\u5011\u4FFA\u5000\u5014\u5028\u4FF1\u5021\u500B\u5019\u5018\u4FF3\u4FEE\u502D\u502A\u4FFE\u502B\u5009\u517C\u51A4\u51A5\u51A2\u51CD\u51CC\u51C6\u51CB\u5256\u525C\u5254\u525B\u525D\u532A\u537F\u539F\u539D\u53DF\u54E8\u5510\u5501\u5537\u54FC\u54E5\u54F2\u5506\u54FA\u5514\u54E9\u54ED\u54E1\u5509\u54EE\u54EA"],
+ ["ae40", "\u54E6\u5527\u5507\u54FD\u550F\u5703\u5704\u57C2\u57D4\u57CB\u57C3\u5809\u590F\u5957\u5958\u595A\u5A11\u5A18\u5A1C\u5A1F\u5A1B\u5A13\u59EC\u5A20\u5A23\u5A29\u5A25\u5A0C\u5A09\u5B6B\u5C58\u5BB0\u5BB3\u5BB6\u5BB4\u5BAE\u5BB5\u5BB9\u5BB8\u5C04\u5C51\u5C55\u5C50\u5CED\u5CFD\u5CFB\u5CEA\u5CE8\u5CF0\u5CF6\u5D01\u5CF4\u5DEE\u5E2D\u5E2B\u5EAB\u5EAD\u5EA7\u5F31\u5F92\u5F91\u5F90\u6059"],
+ ["aea1", "\u6063\u6065\u6050\u6055\u606D\u6069\u606F\u6084\u609F\u609A\u608D\u6094\u608C\u6085\u6096\u6247\u62F3\u6308\u62FF\u634E\u633E\u632F\u6355\u6342\u6346\u634F\u6349\u633A\u6350\u633D\u632A\u632B\u6328\u634D\u634C\u6548\u6549\u6599\u65C1\u65C5\u6642\u6649\u664F\u6643\u6652\u664C\u6645\u6641\u66F8\u6714\u6715\u6717\u6821\u6838\u6848\u6846\u6853\u6839\u6842\u6854\u6829\u68B3\u6817\u684C\u6851\u683D\u67F4\u6850\u6840\u683C\u6843\u682A\u6845\u6813\u6818\u6841\u6B8A\u6B89\u6BB7\u6C23\u6C27\u6C28\u6C26\u6C24\u6CF0\u6D6A\u6D95\u6D88\u6D87\u6D66\u6D78\u6D77\u6D59\u6D93"],
+ ["af40", "\u6D6C\u6D89\u6D6E\u6D5A\u6D74\u6D69\u6D8C\u6D8A\u6D79\u6D85\u6D65\u6D94\u70CA\u70D8\u70E4\u70D9\u70C8\u70CF\u7239\u7279\u72FC\u72F9\u72FD\u72F8\u72F7\u7386\u73ED\u7409\u73EE\u73E0\u73EA\u73DE\u7554\u755D\u755C\u755A\u7559\u75BE\u75C5\u75C7\u75B2\u75B3\u75BD\u75BC\u75B9\u75C2\u75B8\u768B\u76B0\u76CA\u76CD\u76CE\u7729\u771F\u7720\u7728\u77E9\u7830\u7827\u7838\u781D\u7834\u7837"],
+ ["afa1", "\u7825\u782D\u7820\u781F\u7832\u7955\u7950\u7960\u795F\u7956\u795E\u795D\u7957\u795A\u79E4\u79E3\u79E7\u79DF\u79E6\u79E9\u79D8\u7A84\u7A88\u7AD9\u7B06\u7B11\u7C89\u7D21\u7D17\u7D0B\u7D0A\u7D20\u7D22\u7D14\u7D10\u7D15\u7D1A\u7D1C\u7D0D\u7D19\u7D1B\u7F3A\u7F5F\u7F94\u7FC5\u7FC1\u8006\u8018\u8015\u8019\u8017\u803D\u803F\u80F1\u8102\u80F0\u8105\u80ED\u80F4\u8106\u80F8\u80F3\u8108\u80FD\u810A\u80FC\u80EF\u81ED\u81EC\u8200\u8210\u822A\u822B\u8228\u822C\u82BB\u832B\u8352\u8354\u834A\u8338\u8350\u8349\u8335\u8334\u834F\u8332\u8339\u8336\u8317\u8340\u8331\u8328\u8343"],
+ ["b040", "\u8654\u868A\u86AA\u8693\u86A4\u86A9\u868C\u86A3\u869C\u8870\u8877\u8881\u8882\u887D\u8879\u8A18\u8A10\u8A0E\u8A0C\u8A15\u8A0A\u8A17\u8A13\u8A16\u8A0F\u8A11\u8C48\u8C7A\u8C79\u8CA1\u8CA2\u8D77\u8EAC\u8ED2\u8ED4\u8ECF\u8FB1\u9001\u9006\u8FF7\u9000\u8FFA\u8FF4\u9003\u8FFD\u9005\u8FF8\u9095\u90E1\u90DD\u90E2\u9152\u914D\u914C\u91D8\u91DD\u91D7\u91DC\u91D9\u9583\u9662\u9663\u9661"],
+ ["b0a1", "\u965B\u965D\u9664\u9658\u965E\u96BB\u98E2\u99AC\u9AA8\u9AD8\u9B25\u9B32\u9B3C\u4E7E\u507A\u507D\u505C\u5047\u5043\u504C\u505A\u5049\u5065\u5076\u504E\u5055\u5075\u5074\u5077\u504F\u500F\u506F\u506D\u515C\u5195\u51F0\u526A\u526F\u52D2\u52D9\u52D8\u52D5\u5310\u530F\u5319\u533F\u5340\u533E\u53C3\u66FC\u5546\u556A\u5566\u5544\u555E\u5561\u5543\u554A\u5531\u5556\u554F\u5555\u552F\u5564\u5538\u552E\u555C\u552C\u5563\u5533\u5541\u5557\u5708\u570B\u5709\u57DF\u5805\u580A\u5806\u57E0\u57E4\u57FA\u5802\u5835\u57F7\u57F9\u5920\u5962\u5A36\u5A41\u5A49\u5A66\u5A6A\u5A40"],
+ ["b140", "\u5A3C\u5A62\u5A5A\u5A46\u5A4A\u5B70\u5BC7\u5BC5\u5BC4\u5BC2\u5BBF\u5BC6\u5C09\u5C08\u5C07\u5C60\u5C5C\u5C5D\u5D07\u5D06\u5D0E\u5D1B\u5D16\u5D22\u5D11\u5D29\u5D14\u5D19\u5D24\u5D27\u5D17\u5DE2\u5E38\u5E36\u5E33\u5E37\u5EB7\u5EB8\u5EB6\u5EB5\u5EBE\u5F35\u5F37\u5F57\u5F6C\u5F69\u5F6B\u5F97\u5F99\u5F9E\u5F98\u5FA1\u5FA0\u5F9C\u607F\u60A3\u6089\u60A0\u60A8\u60CB\u60B4\u60E6\u60BD"],
+ ["b1a1", "\u60C5\u60BB\u60B5\u60DC\u60BC\u60D8\u60D5\u60C6\u60DF\u60B8\u60DA\u60C7\u621A\u621B\u6248\u63A0\u63A7\u6372\u6396\u63A2\u63A5\u6377\u6367\u6398\u63AA\u6371\u63A9\u6389\u6383\u639B\u636B\u63A8\u6384\u6388\u6399\u63A1\u63AC\u6392\u638F\u6380\u637B\u6369\u6368\u637A\u655D\u6556\u6551\u6559\u6557\u555F\u654F\u6558\u6555\u6554\u659C\u659B\u65AC\u65CF\u65CB\u65CC\u65CE\u665D\u665A\u6664\u6668\u6666\u665E\u66F9\u52D7\u671B\u6881\u68AF\u68A2\u6893\u68B5\u687F\u6876\u68B1\u68A7\u6897\u68B0\u6883\u68C4\u68AD\u6886\u6885\u6894\u689D\u68A8\u689F\u68A1\u6882\u6B32\u6BBA"],
+ ["b240", "\u6BEB\u6BEC\u6C2B\u6D8E\u6DBC\u6DF3\u6DD9\u6DB2\u6DE1\u6DCC\u6DE4\u6DFB\u6DFA\u6E05\u6DC7\u6DCB\u6DAF\u6DD1\u6DAE\u6DDE\u6DF9\u6DB8\u6DF7\u6DF5\u6DC5\u6DD2\u6E1A\u6DB5\u6DDA\u6DEB\u6DD8\u6DEA\u6DF1\u6DEE\u6DE8\u6DC6\u6DC4\u6DAA\u6DEC\u6DBF\u6DE6\u70F9\u7109\u710A\u70FD\u70EF\u723D\u727D\u7281\u731C\u731B\u7316\u7313\u7319\u7387\u7405\u740A\u7403\u7406\u73FE\u740D\u74E0\u74F6"],
+ ["b2a1", "\u74F7\u751C\u7522\u7565\u7566\u7562\u7570\u758F\u75D4\u75D5\u75B5\u75CA\u75CD\u768E\u76D4\u76D2\u76DB\u7737\u773E\u773C\u7736\u7738\u773A\u786B\u7843\u784E\u7965\u7968\u796D\u79FB\u7A92\u7A95\u7B20\u7B28\u7B1B\u7B2C\u7B26\u7B19\u7B1E\u7B2E\u7C92\u7C97\u7C95\u7D46\u7D43\u7D71\u7D2E\u7D39\u7D3C\u7D40\u7D30\u7D33\u7D44\u7D2F\u7D42\u7D32\u7D31\u7F3D\u7F9E\u7F9A\u7FCC\u7FCE\u7FD2\u801C\u804A\u8046\u812F\u8116\u8123\u812B\u8129\u8130\u8124\u8202\u8235\u8237\u8236\u8239\u838E\u839E\u8398\u8378\u83A2\u8396\u83BD\u83AB\u8392\u838A\u8393\u8389\u83A0\u8377\u837B\u837C"],
+ ["b340", "\u8386\u83A7\u8655\u5F6A\u86C7\u86C0\u86B6\u86C4\u86B5\u86C6\u86CB\u86B1\u86AF\u86C9\u8853\u889E\u8888\u88AB\u8892\u8896\u888D\u888B\u8993\u898F\u8A2A\u8A1D\u8A23\u8A25\u8A31\u8A2D\u8A1F\u8A1B\u8A22\u8C49\u8C5A\u8CA9\u8CAC\u8CAB\u8CA8\u8CAA\u8CA7\u8D67\u8D66\u8DBE\u8DBA\u8EDB\u8EDF\u9019\u900D\u901A\u9017\u9023\u901F\u901D\u9010\u9015\u901E\u9020\u900F\u9022\u9016\u901B\u9014"],
+ ["b3a1", "\u90E8\u90ED\u90FD\u9157\u91CE\u91F5\u91E6\u91E3\u91E7\u91ED\u91E9\u9589\u966A\u9675\u9673\u9678\u9670\u9674\u9676\u9677\u966C\u96C0\u96EA\u96E9\u7AE0\u7ADF\u9802\u9803\u9B5A\u9CE5\u9E75\u9E7F\u9EA5\u9EBB\u50A2\u508D\u5085\u5099\u5091\u5080\u5096\u5098\u509A\u6700\u51F1\u5272\u5274\u5275\u5269\u52DE\u52DD\u52DB\u535A\u53A5\u557B\u5580\u55A7\u557C\u558A\u559D\u5598\u5582\u559C\u55AA\u5594\u5587\u558B\u5583\u55B3\u55AE\u559F\u553E\u55B2\u559A\u55BB\u55AC\u55B1\u557E\u5589\u55AB\u5599\u570D\u582F\u582A\u5834\u5824\u5830\u5831\u5821\u581D\u5820\u58F9\u58FA\u5960"],
+ ["b440", "\u5A77\u5A9A\u5A7F\u5A92\u5A9B\u5AA7\u5B73\u5B71\u5BD2\u5BCC\u5BD3\u5BD0\u5C0A\u5C0B\u5C31\u5D4C\u5D50\u5D34\u5D47\u5DFD\u5E45\u5E3D\u5E40\u5E43\u5E7E\u5ECA\u5EC1\u5EC2\u5EC4\u5F3C\u5F6D\u5FA9\u5FAA\u5FA8\u60D1\u60E1\u60B2\u60B6\u60E0\u611C\u6123\u60FA\u6115\u60F0\u60FB\u60F4\u6168\u60F1\u610E\u60F6\u6109\u6100\u6112\u621F\u6249\u63A3\u638C\u63CF\u63C0\u63E9\u63C9\u63C6\u63CD"],
+ ["b4a1", "\u63D2\u63E3\u63D0\u63E1\u63D6\u63ED\u63EE\u6376\u63F4\u63EA\u63DB\u6452\u63DA\u63F9\u655E\u6566\u6562\u6563\u6591\u6590\u65AF\u666E\u6670\u6674\u6676\u666F\u6691\u667A\u667E\u6677\u66FE\u66FF\u671F\u671D\u68FA\u68D5\u68E0\u68D8\u68D7\u6905\u68DF\u68F5\u68EE\u68E7\u68F9\u68D2\u68F2\u68E3\u68CB\u68CD\u690D\u6912\u690E\u68C9\u68DA\u696E\u68FB\u6B3E\u6B3A\u6B3D\u6B98\u6B96\u6BBC\u6BEF\u6C2E\u6C2F\u6C2C\u6E2F\u6E38\u6E54\u6E21\u6E32\u6E67\u6E4A\u6E20\u6E25\u6E23\u6E1B\u6E5B\u6E58\u6E24\u6E56\u6E6E\u6E2D\u6E26\u6E6F\u6E34\u6E4D\u6E3A\u6E2C\u6E43\u6E1D\u6E3E\u6ECB"],
+ ["b540", "\u6E89\u6E19\u6E4E\u6E63\u6E44\u6E72\u6E69\u6E5F\u7119\u711A\u7126\u7130\u7121\u7136\u716E\u711C\u724C\u7284\u7280\u7336\u7325\u7334\u7329\u743A\u742A\u7433\u7422\u7425\u7435\u7436\u7434\u742F\u741B\u7426\u7428\u7525\u7526\u756B\u756A\u75E2\u75DB\u75E3\u75D9\u75D8\u75DE\u75E0\u767B\u767C\u7696\u7693\u76B4\u76DC\u774F\u77ED\u785D\u786C\u786F\u7A0D\u7A08\u7A0B\u7A05\u7A00\u7A98"],
+ ["b5a1", "\u7A97\u7A96\u7AE5\u7AE3\u7B49\u7B56\u7B46\u7B50\u7B52\u7B54\u7B4D\u7B4B\u7B4F\u7B51\u7C9F\u7CA5\u7D5E\u7D50\u7D68\u7D55\u7D2B\u7D6E\u7D72\u7D61\u7D66\u7D62\u7D70\u7D73\u5584\u7FD4\u7FD5\u800B\u8052\u8085\u8155\u8154\u814B\u8151\u814E\u8139\u8146\u813E\u814C\u8153\u8174\u8212\u821C\u83E9\u8403\u83F8\u840D\u83E0\u83C5\u840B\u83C1\u83EF\u83F1\u83F4\u8457\u840A\u83F0\u840C\u83CC\u83FD\u83F2\u83CA\u8438\u840E\u8404\u83DC\u8407\u83D4\u83DF\u865B\u86DF\u86D9\u86ED\u86D4\u86DB\u86E4\u86D0\u86DE\u8857\u88C1\u88C2\u88B1\u8983\u8996\u8A3B\u8A60\u8A55\u8A5E\u8A3C\u8A41"],
+ ["b640", "\u8A54\u8A5B\u8A50\u8A46\u8A34\u8A3A\u8A36\u8A56\u8C61\u8C82\u8CAF\u8CBC\u8CB3\u8CBD\u8CC1\u8CBB\u8CC0\u8CB4\u8CB7\u8CB6\u8CBF\u8CB8\u8D8A\u8D85\u8D81\u8DCE\u8DDD\u8DCB\u8DDA\u8DD1\u8DCC\u8DDB\u8DC6\u8EFB\u8EF8\u8EFC\u8F9C\u902E\u9035\u9031\u9038\u9032\u9036\u9102\u90F5\u9109\u90FE\u9163\u9165\u91CF\u9214\u9215\u9223\u9209\u921E\u920D\u9210\u9207\u9211\u9594\u958F\u958B\u9591"],
+ ["b6a1", "\u9593\u9592\u958E\u968A\u968E\u968B\u967D\u9685\u9686\u968D\u9672\u9684\u96C1\u96C5\u96C4\u96C6\u96C7\u96EF\u96F2\u97CC\u9805\u9806\u9808\u98E7\u98EA\u98EF\u98E9\u98F2\u98ED\u99AE\u99AD\u9EC3\u9ECD\u9ED1\u4E82\u50AD\u50B5\u50B2\u50B3\u50C5\u50BE\u50AC\u50B7\u50BB\u50AF\u50C7\u527F\u5277\u527D\u52DF\u52E6\u52E4\u52E2\u52E3\u532F\u55DF\u55E8\u55D3\u55E6\u55CE\u55DC\u55C7\u55D1\u55E3\u55E4\u55EF\u55DA\u55E1\u55C5\u55C6\u55E5\u55C9\u5712\u5713\u585E\u5851\u5858\u5857\u585A\u5854\u586B\u584C\u586D\u584A\u5862\u5852\u584B\u5967\u5AC1\u5AC9\u5ACC\u5ABE\u5ABD\u5ABC"],
+ ["b740", "\u5AB3\u5AC2\u5AB2\u5D69\u5D6F\u5E4C\u5E79\u5EC9\u5EC8\u5F12\u5F59\u5FAC\u5FAE\u611A\u610F\u6148\u611F\u60F3\u611B\u60F9\u6101\u6108\u614E\u614C\u6144\u614D\u613E\u6134\u6127\u610D\u6106\u6137\u6221\u6222\u6413\u643E\u641E\u642A\u642D\u643D\u642C\u640F\u641C\u6414\u640D\u6436\u6416\u6417\u6406\u656C\u659F\u65B0\u6697\u6689\u6687\u6688\u6696\u6684\u6698\u668D\u6703\u6994\u696D"],
+ ["b7a1", "\u695A\u6977\u6960\u6954\u6975\u6930\u6982\u694A\u6968\u696B\u695E\u6953\u6979\u6986\u695D\u6963\u695B\u6B47\u6B72\u6BC0\u6BBF\u6BD3\u6BFD\u6EA2\u6EAF\u6ED3\u6EB6\u6EC2\u6E90\u6E9D\u6EC7\u6EC5\u6EA5\u6E98\u6EBC\u6EBA\u6EAB\u6ED1\u6E96\u6E9C\u6EC4\u6ED4\u6EAA\u6EA7\u6EB4\u714E\u7159\u7169\u7164\u7149\u7167\u715C\u716C\u7166\u714C\u7165\u715E\u7146\u7168\u7156\u723A\u7252\u7337\u7345\u733F\u733E\u746F\u745A\u7455\u745F\u745E\u7441\u743F\u7459\u745B\u745C\u7576\u7578\u7600\u75F0\u7601\u75F2\u75F1\u75FA\u75FF\u75F4\u75F3\u76DE\u76DF\u775B\u776B\u7766\u775E\u7763"],
+ ["b840", "\u7779\u776A\u776C\u775C\u7765\u7768\u7762\u77EE\u788E\u78B0\u7897\u7898\u788C\u7889\u787C\u7891\u7893\u787F\u797A\u797F\u7981\u842C\u79BD\u7A1C\u7A1A\u7A20\u7A14\u7A1F\u7A1E\u7A9F\u7AA0\u7B77\u7BC0\u7B60\u7B6E\u7B67\u7CB1\u7CB3\u7CB5\u7D93\u7D79\u7D91\u7D81\u7D8F\u7D5B\u7F6E\u7F69\u7F6A\u7F72\u7FA9\u7FA8\u7FA4\u8056\u8058\u8086\u8084\u8171\u8170\u8178\u8165\u816E\u8173\u816B"],
+ ["b8a1", "\u8179\u817A\u8166\u8205\u8247\u8482\u8477\u843D\u8431\u8475\u8466\u846B\u8449\u846C\u845B\u843C\u8435\u8461\u8463\u8469\u846D\u8446\u865E\u865C\u865F\u86F9\u8713\u8708\u8707\u8700\u86FE\u86FB\u8702\u8703\u8706\u870A\u8859\u88DF\u88D4\u88D9\u88DC\u88D8\u88DD\u88E1\u88CA\u88D5\u88D2\u899C\u89E3\u8A6B\u8A72\u8A73\u8A66\u8A69\u8A70\u8A87\u8A7C\u8A63\u8AA0\u8A71\u8A85\u8A6D\u8A62\u8A6E\u8A6C\u8A79\u8A7B\u8A3E\u8A68\u8C62\u8C8A\u8C89\u8CCA\u8CC7\u8CC8\u8CC4\u8CB2\u8CC3\u8CC2\u8CC5\u8DE1\u8DDF\u8DE8\u8DEF\u8DF3\u8DFA\u8DEA\u8DE4\u8DE6\u8EB2\u8F03\u8F09\u8EFE\u8F0A"],
+ ["b940", "\u8F9F\u8FB2\u904B\u904A\u9053\u9042\u9054\u903C\u9055\u9050\u9047\u904F\u904E\u904D\u9051\u903E\u9041\u9112\u9117\u916C\u916A\u9169\u91C9\u9237\u9257\u9238\u923D\u9240\u923E\u925B\u924B\u9264\u9251\u9234\u9249\u924D\u9245\u9239\u923F\u925A\u9598\u9698\u9694\u9695\u96CD\u96CB\u96C9\u96CA\u96F7\u96FB\u96F9\u96F6\u9756\u9774\u9776\u9810\u9811\u9813\u980A\u9812\u980C\u98FC\u98F4"],
+ ["b9a1", "\u98FD\u98FE\u99B3\u99B1\u99B4\u9AE1\u9CE9\u9E82\u9F0E\u9F13\u9F20\u50E7\u50EE\u50E5\u50D6\u50ED\u50DA\u50D5\u50CF\u50D1\u50F1\u50CE\u50E9\u5162\u51F3\u5283\u5282\u5331\u53AD\u55FE\u5600\u561B\u5617\u55FD\u5614\u5606\u5609\u560D\u560E\u55F7\u5616\u561F\u5608\u5610\u55F6\u5718\u5716\u5875\u587E\u5883\u5893\u588A\u5879\u5885\u587D\u58FD\u5925\u5922\u5924\u596A\u5969\u5AE1\u5AE6\u5AE9\u5AD7\u5AD6\u5AD8\u5AE3\u5B75\u5BDE\u5BE7\u5BE1\u5BE5\u5BE6\u5BE8\u5BE2\u5BE4\u5BDF\u5C0D\u5C62\u5D84\u5D87\u5E5B\u5E63\u5E55\u5E57\u5E54\u5ED3\u5ED6\u5F0A\u5F46\u5F70\u5FB9\u6147"],
+ ["ba40", "\u613F\u614B\u6177\u6162\u6163\u615F\u615A\u6158\u6175\u622A\u6487\u6458\u6454\u64A4\u6478\u645F\u647A\u6451\u6467\u6434\u646D\u647B\u6572\u65A1\u65D7\u65D6\u66A2\u66A8\u669D\u699C\u69A8\u6995\u69C1\u69AE\u69D3\u69CB\u699B\u69B7\u69BB\u69AB\u69B4\u69D0\u69CD\u69AD\u69CC\u69A6\u69C3\u69A3\u6B49\u6B4C\u6C33\u6F33\u6F14\u6EFE\u6F13\u6EF4\u6F29\u6F3E\u6F20\u6F2C\u6F0F\u6F02\u6F22"],
+ ["baa1", "\u6EFF\u6EEF\u6F06\u6F31\u6F38\u6F32\u6F23\u6F15\u6F2B\u6F2F\u6F88\u6F2A\u6EEC\u6F01\u6EF2\u6ECC\u6EF7\u7194\u7199\u717D\u718A\u7184\u7192\u723E\u7292\u7296\u7344\u7350\u7464\u7463\u746A\u7470\u746D\u7504\u7591\u7627\u760D\u760B\u7609\u7613\u76E1\u76E3\u7784\u777D\u777F\u7761\u78C1\u789F\u78A7\u78B3\u78A9\u78A3\u798E\u798F\u798D\u7A2E\u7A31\u7AAA\u7AA9\u7AED\u7AEF\u7BA1\u7B95\u7B8B\u7B75\u7B97\u7B9D\u7B94\u7B8F\u7BB8\u7B87\u7B84\u7CB9\u7CBD\u7CBE\u7DBB\u7DB0\u7D9C\u7DBD\u7DBE\u7DA0\u7DCA\u7DB4\u7DB2\u7DB1\u7DBA\u7DA2\u7DBF\u7DB5\u7DB8\u7DAD\u7DD2\u7DC7\u7DAC"],
+ ["bb40", "\u7F70\u7FE0\u7FE1\u7FDF\u805E\u805A\u8087\u8150\u8180\u818F\u8188\u818A\u817F\u8182\u81E7\u81FA\u8207\u8214\u821E\u824B\u84C9\u84BF\u84C6\u84C4\u8499\u849E\u84B2\u849C\u84CB\u84B8\u84C0\u84D3\u8490\u84BC\u84D1\u84CA\u873F\u871C\u873B\u8722\u8725\u8734\u8718\u8755\u8737\u8729\u88F3\u8902\u88F4\u88F9\u88F8\u88FD\u88E8\u891A\u88EF\u8AA6\u8A8C\u8A9E\u8AA3\u8A8D\u8AA1\u8A93\u8AA4"],
+ ["bba1", "\u8AAA\u8AA5\u8AA8\u8A98\u8A91\u8A9A\u8AA7\u8C6A\u8C8D\u8C8C\u8CD3\u8CD1\u8CD2\u8D6B\u8D99\u8D95\u8DFC\u8F14\u8F12\u8F15\u8F13\u8FA3\u9060\u9058\u905C\u9063\u9059\u905E\u9062\u905D\u905B\u9119\u9118\u911E\u9175\u9178\u9177\u9174\u9278\u9280\u9285\u9298\u9296\u927B\u9293\u929C\u92A8\u927C\u9291\u95A1\u95A8\u95A9\u95A3\u95A5\u95A4\u9699\u969C\u969B\u96CC\u96D2\u9700\u977C\u9785\u97F6\u9817\u9818\u98AF\u98B1\u9903\u9905\u990C\u9909\u99C1\u9AAF\u9AB0\u9AE6\u9B41\u9B42\u9CF4\u9CF6\u9CF3\u9EBC\u9F3B\u9F4A\u5104\u5100\u50FB\u50F5\u50F9\u5102\u5108\u5109\u5105\u51DC"],
+ ["bc40", "\u5287\u5288\u5289\u528D\u528A\u52F0\u53B2\u562E\u563B\u5639\u5632\u563F\u5634\u5629\u5653\u564E\u5657\u5674\u5636\u562F\u5630\u5880\u589F\u589E\u58B3\u589C\u58AE\u58A9\u58A6\u596D\u5B09\u5AFB\u5B0B\u5AF5\u5B0C\u5B08\u5BEE\u5BEC\u5BE9\u5BEB\u5C64\u5C65\u5D9D\u5D94\u5E62\u5E5F\u5E61\u5EE2\u5EDA\u5EDF\u5EDD\u5EE3\u5EE0\u5F48\u5F71\u5FB7\u5FB5\u6176\u6167\u616E\u615D\u6155\u6182"],
+ ["bca1", "\u617C\u6170\u616B\u617E\u61A7\u6190\u61AB\u618E\u61AC\u619A\u61A4\u6194\u61AE\u622E\u6469\u646F\u6479\u649E\u64B2\u6488\u6490\u64B0\u64A5\u6493\u6495\u64A9\u6492\u64AE\u64AD\u64AB\u649A\u64AC\u6499\u64A2\u64B3\u6575\u6577\u6578\u66AE\u66AB\u66B4\u66B1\u6A23\u6A1F\u69E8\u6A01\u6A1E\u6A19\u69FD\u6A21\u6A13\u6A0A\u69F3\u6A02\u6A05\u69ED\u6A11\u6B50\u6B4E\u6BA4\u6BC5\u6BC6\u6F3F\u6F7C\u6F84\u6F51\u6F66\u6F54\u6F86\u6F6D\u6F5B\u6F78\u6F6E\u6F8E\u6F7A\u6F70\u6F64\u6F97\u6F58\u6ED5\u6F6F\u6F60\u6F5F\u719F\u71AC\u71B1\u71A8\u7256\u729B\u734E\u7357\u7469\u748B\u7483"],
+ ["bd40", "\u747E\u7480\u757F\u7620\u7629\u761F\u7624\u7626\u7621\u7622\u769A\u76BA\u76E4\u778E\u7787\u778C\u7791\u778B\u78CB\u78C5\u78BA\u78CA\u78BE\u78D5\u78BC\u78D0\u7A3F\u7A3C\u7A40\u7A3D\u7A37\u7A3B\u7AAF\u7AAE\u7BAD\u7BB1\u7BC4\u7BB4\u7BC6\u7BC7\u7BC1\u7BA0\u7BCC\u7CCA\u7DE0\u7DF4\u7DEF\u7DFB\u7DD8\u7DEC\u7DDD\u7DE8\u7DE3\u7DDA\u7DDE\u7DE9\u7D9E\u7DD9\u7DF2\u7DF9\u7F75\u7F77\u7FAF"],
+ ["bda1", "\u7FE9\u8026\u819B\u819C\u819D\u81A0\u819A\u8198\u8517\u853D\u851A\u84EE\u852C\u852D\u8513\u8511\u8523\u8521\u8514\u84EC\u8525\u84FF\u8506\u8782\u8774\u8776\u8760\u8766\u8778\u8768\u8759\u8757\u874C\u8753\u885B\u885D\u8910\u8907\u8912\u8913\u8915\u890A\u8ABC\u8AD2\u8AC7\u8AC4\u8A95\u8ACB\u8AF8\u8AB2\u8AC9\u8AC2\u8ABF\u8AB0\u8AD6\u8ACD\u8AB6\u8AB9\u8ADB\u8C4C\u8C4E\u8C6C\u8CE0\u8CDE\u8CE6\u8CE4\u8CEC\u8CED\u8CE2\u8CE3\u8CDC\u8CEA\u8CE1\u8D6D\u8D9F\u8DA3\u8E2B\u8E10\u8E1D\u8E22\u8E0F\u8E29\u8E1F\u8E21\u8E1E\u8EBA\u8F1D\u8F1B\u8F1F\u8F29\u8F26\u8F2A\u8F1C\u8F1E"],
+ ["be40", "\u8F25\u9069\u906E\u9068\u906D\u9077\u9130\u912D\u9127\u9131\u9187\u9189\u918B\u9183\u92C5\u92BB\u92B7\u92EA\u92AC\u92E4\u92C1\u92B3\u92BC\u92D2\u92C7\u92F0\u92B2\u95AD\u95B1\u9704\u9706\u9707\u9709\u9760\u978D\u978B\u978F\u9821\u982B\u981C\u98B3\u990A\u9913\u9912\u9918\u99DD\u99D0\u99DF\u99DB\u99D1\u99D5\u99D2\u99D9\u9AB7\u9AEE\u9AEF\u9B27\u9B45\u9B44\u9B77\u9B6F\u9D06\u9D09"],
+ ["bea1", "\u9D03\u9EA9\u9EBE\u9ECE\u58A8\u9F52\u5112\u5118\u5114\u5110\u5115\u5180\u51AA\u51DD\u5291\u5293\u52F3\u5659\u566B\u5679\u5669\u5664\u5678\u566A\u5668\u5665\u5671\u566F\u566C\u5662\u5676\u58C1\u58BE\u58C7\u58C5\u596E\u5B1D\u5B34\u5B78\u5BF0\u5C0E\u5F4A\u61B2\u6191\u61A9\u618A\u61CD\u61B6\u61BE\u61CA\u61C8\u6230\u64C5\u64C1\u64CB\u64BB\u64BC\u64DA\u64C4\u64C7\u64C2\u64CD\u64BF\u64D2\u64D4\u64BE\u6574\u66C6\u66C9\u66B9\u66C4\u66C7\u66B8\u6A3D\u6A38\u6A3A\u6A59\u6A6B\u6A58\u6A39\u6A44\u6A62\u6A61\u6A4B\u6A47\u6A35\u6A5F\u6A48\u6B59\u6B77\u6C05\u6FC2\u6FB1\u6FA1"],
+ ["bf40", "\u6FC3\u6FA4\u6FC1\u6FA7\u6FB3\u6FC0\u6FB9\u6FB6\u6FA6\u6FA0\u6FB4\u71BE\u71C9\u71D0\u71D2\u71C8\u71D5\u71B9\u71CE\u71D9\u71DC\u71C3\u71C4\u7368\u749C\u74A3\u7498\u749F\u749E\u74E2\u750C\u750D\u7634\u7638\u763A\u76E7\u76E5\u77A0\u779E\u779F\u77A5\u78E8\u78DA\u78EC\u78E7\u79A6\u7A4D\u7A4E\u7A46\u7A4C\u7A4B\u7ABA\u7BD9\u7C11\u7BC9\u7BE4\u7BDB\u7BE1\u7BE9\u7BE6\u7CD5\u7CD6\u7E0A"],
+ ["bfa1", "\u7E11\u7E08\u7E1B\u7E23\u7E1E\u7E1D\u7E09\u7E10\u7F79\u7FB2\u7FF0\u7FF1\u7FEE\u8028\u81B3\u81A9\u81A8\u81FB\u8208\u8258\u8259\u854A\u8559\u8548\u8568\u8569\u8543\u8549\u856D\u856A\u855E\u8783\u879F\u879E\u87A2\u878D\u8861\u892A\u8932\u8925\u892B\u8921\u89AA\u89A6\u8AE6\u8AFA\u8AEB\u8AF1\u8B00\u8ADC\u8AE7\u8AEE\u8AFE\u8B01\u8B02\u8AF7\u8AED\u8AF3\u8AF6\u8AFC\u8C6B\u8C6D\u8C93\u8CF4\u8E44\u8E31\u8E34\u8E42\u8E39\u8E35\u8F3B\u8F2F\u8F38\u8F33\u8FA8\u8FA6\u9075\u9074\u9078\u9072\u907C\u907A\u9134\u9192\u9320\u9336\u92F8\u9333\u932F\u9322\u92FC\u932B\u9304\u931A"],
+ ["c040", "\u9310\u9326\u9321\u9315\u932E\u9319\u95BB\u96A7\u96A8\u96AA\u96D5\u970E\u9711\u9716\u970D\u9713\u970F\u975B\u975C\u9766\u9798\u9830\u9838\u983B\u9837\u982D\u9839\u9824\u9910\u9928\u991E\u991B\u9921\u991A\u99ED\u99E2\u99F1\u9AB8\u9ABC\u9AFB\u9AED\u9B28\u9B91\u9D15\u9D23\u9D26\u9D28\u9D12\u9D1B\u9ED8\u9ED4\u9F8D\u9F9C\u512A\u511F\u5121\u5132\u52F5\u568E\u5680\u5690\u5685\u5687"],
+ ["c0a1", "\u568F\u58D5\u58D3\u58D1\u58CE\u5B30\u5B2A\u5B24\u5B7A\u5C37\u5C68\u5DBC\u5DBA\u5DBD\u5DB8\u5E6B\u5F4C\u5FBD\u61C9\u61C2\u61C7\u61E6\u61CB\u6232\u6234\u64CE\u64CA\u64D8\u64E0\u64F0\u64E6\u64EC\u64F1\u64E2\u64ED\u6582\u6583\u66D9\u66D6\u6A80\u6A94\u6A84\u6AA2\u6A9C\u6ADB\u6AA3\u6A7E\u6A97\u6A90\u6AA0\u6B5C\u6BAE\u6BDA\u6C08\u6FD8\u6FF1\u6FDF\u6FE0\u6FDB\u6FE4\u6FEB\u6FEF\u6F80\u6FEC\u6FE1\u6FE9\u6FD5\u6FEE\u6FF0\u71E7\u71DF\u71EE\u71E6\u71E5\u71ED\u71EC\u71F4\u71E0\u7235\u7246\u7370\u7372\u74A9\u74B0\u74A6\u74A8\u7646\u7642\u764C\u76EA\u77B3\u77AA\u77B0\u77AC"],
+ ["c140", "\u77A7\u77AD\u77EF\u78F7\u78FA\u78F4\u78EF\u7901\u79A7\u79AA\u7A57\u7ABF\u7C07\u7C0D\u7BFE\u7BF7\u7C0C\u7BE0\u7CE0\u7CDC\u7CDE\u7CE2\u7CDF\u7CD9\u7CDD\u7E2E\u7E3E\u7E46\u7E37\u7E32\u7E43\u7E2B\u7E3D\u7E31\u7E45\u7E41\u7E34\u7E39\u7E48\u7E35\u7E3F\u7E2F\u7F44\u7FF3\u7FFC\u8071\u8072\u8070\u806F\u8073\u81C6\u81C3\u81BA\u81C2\u81C0\u81BF\u81BD\u81C9\u81BE\u81E8\u8209\u8271\u85AA"],
+ ["c1a1", "\u8584\u857E\u859C\u8591\u8594\u85AF\u859B\u8587\u85A8\u858A\u8667\u87C0\u87D1\u87B3\u87D2\u87C6\u87AB\u87BB\u87BA\u87C8\u87CB\u893B\u8936\u8944\u8938\u893D\u89AC\u8B0E\u8B17\u8B19\u8B1B\u8B0A\u8B20\u8B1D\u8B04\u8B10\u8C41\u8C3F\u8C73\u8CFA\u8CFD\u8CFC\u8CF8\u8CFB\u8DA8\u8E49\u8E4B\u8E48\u8E4A\u8F44\u8F3E\u8F42\u8F45\u8F3F\u907F\u907D\u9084\u9081\u9082\u9080\u9139\u91A3\u919E\u919C\u934D\u9382\u9328\u9375\u934A\u9365\u934B\u9318\u937E\u936C\u935B\u9370\u935A\u9354\u95CA\u95CB\u95CC\u95C8\u95C6\u96B1\u96B8\u96D6\u971C\u971E\u97A0\u97D3\u9846\u98B6\u9935\u9A01"],
+ ["c240", "\u99FF\u9BAE\u9BAB\u9BAA\u9BAD\u9D3B\u9D3F\u9E8B\u9ECF\u9EDE\u9EDC\u9EDD\u9EDB\u9F3E\u9F4B\u53E2\u5695\u56AE\u58D9\u58D8\u5B38\u5F5D\u61E3\u6233\u64F4\u64F2\u64FE\u6506\u64FA\u64FB\u64F7\u65B7\u66DC\u6726\u6AB3\u6AAC\u6AC3\u6ABB\u6AB8\u6AC2\u6AAE\u6AAF\u6B5F\u6B78\u6BAF\u7009\u700B\u6FFE\u7006\u6FFA\u7011\u700F\u71FB\u71FC\u71FE\u71F8\u7377\u7375\u74A7\u74BF\u7515\u7656\u7658"],
+ ["c2a1", "\u7652\u77BD\u77BF\u77BB\u77BC\u790E\u79AE\u7A61\u7A62\u7A60\u7AC4\u7AC5\u7C2B\u7C27\u7C2A\u7C1E\u7C23\u7C21\u7CE7\u7E54\u7E55\u7E5E\u7E5A\u7E61\u7E52\u7E59\u7F48\u7FF9\u7FFB\u8077\u8076\u81CD\u81CF\u820A\u85CF\u85A9\u85CD\u85D0\u85C9\u85B0\u85BA\u85B9\u85A6\u87EF\u87EC\u87F2\u87E0\u8986\u89B2\u89F4\u8B28\u8B39\u8B2C\u8B2B\u8C50\u8D05\u8E59\u8E63\u8E66\u8E64\u8E5F\u8E55\u8EC0\u8F49\u8F4D\u9087\u9083\u9088\u91AB\u91AC\u91D0\u9394\u938A\u9396\u93A2\u93B3\u93AE\u93AC\u93B0\u9398\u939A\u9397\u95D4\u95D6\u95D0\u95D5\u96E2\u96DC\u96D9\u96DB\u96DE\u9724\u97A3\u97A6"],
+ ["c340", "\u97AD\u97F9\u984D\u984F\u984C\u984E\u9853\u98BA\u993E\u993F\u993D\u992E\u99A5\u9A0E\u9AC1\u9B03\u9B06\u9B4F\u9B4E\u9B4D\u9BCA\u9BC9\u9BFD\u9BC8\u9BC0\u9D51\u9D5D\u9D60\u9EE0\u9F15\u9F2C\u5133\u56A5\u58DE\u58DF\u58E2\u5BF5\u9F90\u5EEC\u61F2\u61F7\u61F6\u61F5\u6500\u650F\u66E0\u66DD\u6AE5\u6ADD\u6ADA\u6AD3\u701B\u701F\u7028\u701A\u701D\u7015\u7018\u7206\u720D\u7258\u72A2\u7378"],
+ ["c3a1", "\u737A\u74BD\u74CA\u74E3\u7587\u7586\u765F\u7661\u77C7\u7919\u79B1\u7A6B\u7A69\u7C3E\u7C3F\u7C38\u7C3D\u7C37\u7C40\u7E6B\u7E6D\u7E79\u7E69\u7E6A\u7F85\u7E73\u7FB6\u7FB9\u7FB8\u81D8\u85E9\u85DD\u85EA\u85D5\u85E4\u85E5\u85F7\u87FB\u8805\u880D\u87F9\u87FE\u8960\u895F\u8956\u895E\u8B41\u8B5C\u8B58\u8B49\u8B5A\u8B4E\u8B4F\u8B46\u8B59\u8D08\u8D0A\u8E7C\u8E72\u8E87\u8E76\u8E6C\u8E7A\u8E74\u8F54\u8F4E\u8FAD\u908A\u908B\u91B1\u91AE\u93E1\u93D1\u93DF\u93C3\u93C8\u93DC\u93DD\u93D6\u93E2\u93CD\u93D8\u93E4\u93D7\u93E8\u95DC\u96B4\u96E3\u972A\u9727\u9761\u97DC\u97FB\u985E"],
+ ["c440", "\u9858\u985B\u98BC\u9945\u9949\u9A16\u9A19\u9B0D\u9BE8\u9BE7\u9BD6\u9BDB\u9D89\u9D61\u9D72\u9D6A\u9D6C\u9E92\u9E97\u9E93\u9EB4\u52F8\u56A8\u56B7\u56B6\u56B4\u56BC\u58E4\u5B40\u5B43\u5B7D\u5BF6\u5DC9\u61F8\u61FA\u6518\u6514\u6519\u66E6\u6727\u6AEC\u703E\u7030\u7032\u7210\u737B\u74CF\u7662\u7665\u7926\u792A\u792C\u792B\u7AC7\u7AF6\u7C4C\u7C43\u7C4D\u7CEF\u7CF0\u8FAE\u7E7D\u7E7C"],
+ ["c4a1", "\u7E82\u7F4C\u8000\u81DA\u8266\u85FB\u85F9\u8611\u85FA\u8606\u860B\u8607\u860A\u8814\u8815\u8964\u89BA\u89F8\u8B70\u8B6C\u8B66\u8B6F\u8B5F\u8B6B\u8D0F\u8D0D\u8E89\u8E81\u8E85\u8E82\u91B4\u91CB\u9418\u9403\u93FD\u95E1\u9730\u98C4\u9952\u9951\u99A8\u9A2B\u9A30\u9A37\u9A35\u9C13\u9C0D\u9E79\u9EB5\u9EE8\u9F2F\u9F5F\u9F63\u9F61\u5137\u5138\u56C1\u56C0\u56C2\u5914\u5C6C\u5DCD\u61FC\u61FE\u651D\u651C\u6595\u66E9\u6AFB\u6B04\u6AFA\u6BB2\u704C\u721B\u72A7\u74D6\u74D4\u7669\u77D3\u7C50\u7E8F\u7E8C\u7FBC\u8617\u862D\u861A\u8823\u8822\u8821\u881F\u896A\u896C\u89BD\u8B74"],
+ ["c540", "\u8B77\u8B7D\u8D13\u8E8A\u8E8D\u8E8B\u8F5F\u8FAF\u91BA\u942E\u9433\u9435\u943A\u9438\u9432\u942B\u95E2\u9738\u9739\u9732\u97FF\u9867\u9865\u9957\u9A45\u9A43\u9A40\u9A3E\u9ACF\u9B54\u9B51\u9C2D\u9C25\u9DAF\u9DB4\u9DC2\u9DB8\u9E9D\u9EEF\u9F19\u9F5C\u9F66\u9F67\u513C\u513B\u56C8\u56CA\u56C9\u5B7F\u5DD4\u5DD2\u5F4E\u61FF\u6524\u6B0A\u6B61\u7051\u7058\u7380\u74E4\u758A\u766E\u766C"],
+ ["c5a1", "\u79B3\u7C60\u7C5F\u807E\u807D\u81DF\u8972\u896F\u89FC\u8B80\u8D16\u8D17\u8E91\u8E93\u8F61\u9148\u9444\u9451\u9452\u973D\u973E\u97C3\u97C1\u986B\u9955\u9A55\u9A4D\u9AD2\u9B1A\u9C49\u9C31\u9C3E\u9C3B\u9DD3\u9DD7\u9F34\u9F6C\u9F6A\u9F94\u56CC\u5DD6\u6200\u6523\u652B\u652A\u66EC\u6B10\u74DA\u7ACA\u7C64\u7C63\u7C65\u7E93\u7E96\u7E94\u81E2\u8638\u863F\u8831\u8B8A\u9090\u908F\u9463\u9460\u9464\u9768\u986F\u995C\u9A5A\u9A5B\u9A57\u9AD3\u9AD4\u9AD1\u9C54\u9C57\u9C56\u9DE5\u9E9F\u9EF4\u56D1\u58E9\u652C\u705E\u7671\u7672\u77D7\u7F50\u7F88\u8836\u8839\u8862\u8B93\u8B92"],
+ ["c640", "\u8B96\u8277\u8D1B\u91C0\u946A\u9742\u9748\u9744\u97C6\u9870\u9A5F\u9B22\u9B58\u9C5F\u9DF9\u9DFA\u9E7C\u9E7D\u9F07\u9F77\u9F72\u5EF3\u6B16\u7063\u7C6C\u7C6E\u883B\u89C0\u8EA1\u91C1\u9472\u9470\u9871\u995E\u9AD6\u9B23\u9ECC\u7064\u77DA\u8B9A\u9477\u97C9\u9A62\u9A65\u7E9C\u8B9C\u8EAA\u91C5\u947D\u947E\u947C\u9C77\u9C78\u9EF7\u8C54\u947F\u9E1A\u7228\u9A6A\u9B31\u9E1B\u9E1E\u7C72"],
+ ["c940", "\u4E42\u4E5C\u51F5\u531A\u5382\u4E07\u4E0C\u4E47\u4E8D\u56D7\uFA0C\u5C6E\u5F73\u4E0F\u5187\u4E0E\u4E2E\u4E93\u4EC2\u4EC9\u4EC8\u5198\u52FC\u536C\u53B9\u5720\u5903\u592C\u5C10\u5DFF\u65E1\u6BB3\u6BCC\u6C14\u723F\u4E31\u4E3C\u4EE8\u4EDC\u4EE9\u4EE1\u4EDD\u4EDA\u520C\u531C\u534C\u5722\u5723\u5917\u592F\u5B81\u5B84\u5C12\u5C3B\u5C74\u5C73\u5E04\u5E80\u5E82\u5FC9\u6209\u6250\u6C15"],
+ ["c9a1", "\u6C36\u6C43\u6C3F\u6C3B\u72AE\u72B0\u738A\u79B8\u808A\u961E\u4F0E\u4F18\u4F2C\u4EF5\u4F14\u4EF1\u4F00\u4EF7\u4F08\u4F1D\u4F02\u4F05\u4F22\u4F13\u4F04\u4EF4\u4F12\u51B1\u5213\u5209\u5210\u52A6\u5322\u531F\u534D\u538A\u5407\u56E1\u56DF\u572E\u572A\u5734\u593C\u5980\u597C\u5985\u597B\u597E\u5977\u597F\u5B56\u5C15\u5C25\u5C7C\u5C7A\u5C7B\u5C7E\u5DDF\u5E75\u5E84\u5F02\u5F1A\u5F74\u5FD5\u5FD4\u5FCF\u625C\u625E\u6264\u6261\u6266\u6262\u6259\u6260\u625A\u6265\u65EF\u65EE\u673E\u6739\u6738\u673B\u673A\u673F\u673C\u6733\u6C18\u6C46\u6C52\u6C5C\u6C4F\u6C4A\u6C54\u6C4B"],
+ ["ca40", "\u6C4C\u7071\u725E\u72B4\u72B5\u738E\u752A\u767F\u7A75\u7F51\u8278\u827C\u8280\u827D\u827F\u864D\u897E\u9099\u9097\u9098\u909B\u9094\u9622\u9624\u9620\u9623\u4F56\u4F3B\u4F62\u4F49\u4F53\u4F64\u4F3E\u4F67\u4F52\u4F5F\u4F41\u4F58\u4F2D\u4F33\u4F3F\u4F61\u518F\u51B9\u521C\u521E\u5221\u52AD\u52AE\u5309\u5363\u5372\u538E\u538F\u5430\u5437\u542A\u5454\u5445\u5419\u541C\u5425\u5418"],
+ ["caa1", "\u543D\u544F\u5441\u5428\u5424\u5447\u56EE\u56E7\u56E5\u5741\u5745\u574C\u5749\u574B\u5752\u5906\u5940\u59A6\u5998\u59A0\u5997\u598E\u59A2\u5990\u598F\u59A7\u59A1\u5B8E\u5B92\u5C28\u5C2A\u5C8D\u5C8F\u5C88\u5C8B\u5C89\u5C92\u5C8A\u5C86\u5C93\u5C95\u5DE0\u5E0A\u5E0E\u5E8B\u5E89\u5E8C\u5E88\u5E8D\u5F05\u5F1D\u5F78\u5F76\u5FD2\u5FD1\u5FD0\u5FED\u5FE8\u5FEE\u5FF3\u5FE1\u5FE4\u5FE3\u5FFA\u5FEF\u5FF7\u5FFB\u6000\u5FF4\u623A\u6283\u628C\u628E\u628F\u6294\u6287\u6271\u627B\u627A\u6270\u6281\u6288\u6277\u627D\u6272\u6274\u6537\u65F0\u65F4\u65F3\u65F2\u65F5\u6745\u6747"],
+ ["cb40", "\u6759\u6755\u674C\u6748\u675D\u674D\u675A\u674B\u6BD0\u6C19\u6C1A\u6C78\u6C67\u6C6B\u6C84\u6C8B\u6C8F\u6C71\u6C6F\u6C69\u6C9A\u6C6D\u6C87\u6C95\u6C9C\u6C66\u6C73\u6C65\u6C7B\u6C8E\u7074\u707A\u7263\u72BF\u72BD\u72C3\u72C6\u72C1\u72BA\u72C5\u7395\u7397\u7393\u7394\u7392\u753A\u7539\u7594\u7595\u7681\u793D\u8034\u8095\u8099\u8090\u8092\u809C\u8290\u828F\u8285\u828E\u8291\u8293"],
+ ["cba1", "\u828A\u8283\u8284\u8C78\u8FC9\u8FBF\u909F\u90A1\u90A5\u909E\u90A7\u90A0\u9630\u9628\u962F\u962D\u4E33\u4F98\u4F7C\u4F85\u4F7D\u4F80\u4F87\u4F76\u4F74\u4F89\u4F84\u4F77\u4F4C\u4F97\u4F6A\u4F9A\u4F79\u4F81\u4F78\u4F90\u4F9C\u4F94\u4F9E\u4F92\u4F82\u4F95\u4F6B\u4F6E\u519E\u51BC\u51BE\u5235\u5232\u5233\u5246\u5231\u52BC\u530A\u530B\u533C\u5392\u5394\u5487\u547F\u5481\u5491\u5482\u5488\u546B\u547A\u547E\u5465\u546C\u5474\u5466\u548D\u546F\u5461\u5460\u5498\u5463\u5467\u5464\u56F7\u56F9\u576F\u5772\u576D\u576B\u5771\u5770\u5776\u5780\u5775\u577B\u5773\u5774\u5762"],
+ ["cc40", "\u5768\u577D\u590C\u5945\u59B5\u59BA\u59CF\u59CE\u59B2\u59CC\u59C1\u59B6\u59BC\u59C3\u59D6\u59B1\u59BD\u59C0\u59C8\u59B4\u59C7\u5B62\u5B65\u5B93\u5B95\u5C44\u5C47\u5CAE\u5CA4\u5CA0\u5CB5\u5CAF\u5CA8\u5CAC\u5C9F\u5CA3\u5CAD\u5CA2\u5CAA\u5CA7\u5C9D\u5CA5\u5CB6\u5CB0\u5CA6\u5E17\u5E14\u5E19\u5F28\u5F22\u5F23\u5F24\u5F54\u5F82\u5F7E\u5F7D\u5FDE\u5FE5\u602D\u6026\u6019\u6032\u600B"],
+ ["cca1", "\u6034\u600A\u6017\u6033\u601A\u601E\u602C\u6022\u600D\u6010\u602E\u6013\u6011\u600C\u6009\u601C\u6214\u623D\u62AD\u62B4\u62D1\u62BE\u62AA\u62B6\u62CA\u62AE\u62B3\u62AF\u62BB\u62A9\u62B0\u62B8\u653D\u65A8\u65BB\u6609\u65FC\u6604\u6612\u6608\u65FB\u6603\u660B\u660D\u6605\u65FD\u6611\u6610\u66F6\u670A\u6785\u676C\u678E\u6792\u6776\u677B\u6798\u6786\u6784\u6774\u678D\u678C\u677A\u679F\u6791\u6799\u6783\u677D\u6781\u6778\u6779\u6794\u6B25\u6B80\u6B7E\u6BDE\u6C1D\u6C93\u6CEC\u6CEB\u6CEE\u6CD9\u6CB6\u6CD4\u6CAD\u6CE7\u6CB7\u6CD0\u6CC2\u6CBA\u6CC3\u6CC6\u6CED\u6CF2"],
+ ["cd40", "\u6CD2\u6CDD\u6CB4\u6C8A\u6C9D\u6C80\u6CDE\u6CC0\u6D30\u6CCD\u6CC7\u6CB0\u6CF9\u6CCF\u6CE9\u6CD1\u7094\u7098\u7085\u7093\u7086\u7084\u7091\u7096\u7082\u709A\u7083\u726A\u72D6\u72CB\u72D8\u72C9\u72DC\u72D2\u72D4\u72DA\u72CC\u72D1\u73A4\u73A1\u73AD\u73A6\u73A2\u73A0\u73AC\u739D\u74DD\u74E8\u753F\u7540\u753E\u758C\u7598\u76AF\u76F3\u76F1\u76F0\u76F5\u77F8\u77FC\u77F9\u77FB\u77FA"],
+ ["cda1", "\u77F7\u7942\u793F\u79C5\u7A78\u7A7B\u7AFB\u7C75\u7CFD\u8035\u808F\u80AE\u80A3\u80B8\u80B5\u80AD\u8220\u82A0\u82C0\u82AB\u829A\u8298\u829B\u82B5\u82A7\u82AE\u82BC\u829E\u82BA\u82B4\u82A8\u82A1\u82A9\u82C2\u82A4\u82C3\u82B6\u82A2\u8670\u866F\u866D\u866E\u8C56\u8FD2\u8FCB\u8FD3\u8FCD\u8FD6\u8FD5\u8FD7\u90B2\u90B4\u90AF\u90B3\u90B0\u9639\u963D\u963C\u963A\u9643\u4FCD\u4FC5\u4FD3\u4FB2\u4FC9\u4FCB\u4FC1\u4FD4\u4FDC\u4FD9\u4FBB\u4FB3\u4FDB\u4FC7\u4FD6\u4FBA\u4FC0\u4FB9\u4FEC\u5244\u5249\u52C0\u52C2\u533D\u537C\u5397\u5396\u5399\u5398\u54BA\u54A1\u54AD\u54A5\u54CF"],
+ ["ce40", "\u54C3\u830D\u54B7\u54AE\u54D6\u54B6\u54C5\u54C6\u54A0\u5470\u54BC\u54A2\u54BE\u5472\u54DE\u54B0\u57B5\u579E\u579F\u57A4\u578C\u5797\u579D\u579B\u5794\u5798\u578F\u5799\u57A5\u579A\u5795\u58F4\u590D\u5953\u59E1\u59DE\u59EE\u5A00\u59F1\u59DD\u59FA\u59FD\u59FC\u59F6\u59E4\u59F2\u59F7\u59DB\u59E9\u59F3\u59F5\u59E0\u59FE\u59F4\u59ED\u5BA8\u5C4C\u5CD0\u5CD8\u5CCC\u5CD7\u5CCB\u5CDB"],
+ ["cea1", "\u5CDE\u5CDA\u5CC9\u5CC7\u5CCA\u5CD6\u5CD3\u5CD4\u5CCF\u5CC8\u5CC6\u5CCE\u5CDF\u5CF8\u5DF9\u5E21\u5E22\u5E23\u5E20\u5E24\u5EB0\u5EA4\u5EA2\u5E9B\u5EA3\u5EA5\u5F07\u5F2E\u5F56\u5F86\u6037\u6039\u6054\u6072\u605E\u6045\u6053\u6047\u6049\u605B\u604C\u6040\u6042\u605F\u6024\u6044\u6058\u6066\u606E\u6242\u6243\u62CF\u630D\u630B\u62F5\u630E\u6303\u62EB\u62F9\u630F\u630C\u62F8\u62F6\u6300\u6313\u6314\u62FA\u6315\u62FB\u62F0\u6541\u6543\u65AA\u65BF\u6636\u6621\u6632\u6635\u661C\u6626\u6622\u6633\u662B\u663A\u661D\u6634\u6639\u662E\u670F\u6710\u67C1\u67F2\u67C8\u67BA"],
+ ["cf40", "\u67DC\u67BB\u67F8\u67D8\u67C0\u67B7\u67C5\u67EB\u67E4\u67DF\u67B5\u67CD\u67B3\u67F7\u67F6\u67EE\u67E3\u67C2\u67B9\u67CE\u67E7\u67F0\u67B2\u67FC\u67C6\u67ED\u67CC\u67AE\u67E6\u67DB\u67FA\u67C9\u67CA\u67C3\u67EA\u67CB\u6B28\u6B82\u6B84\u6BB6\u6BD6\u6BD8\u6BE0\u6C20\u6C21\u6D28\u6D34\u6D2D\u6D1F\u6D3C\u6D3F\u6D12\u6D0A\u6CDA\u6D33\u6D04\u6D19\u6D3A\u6D1A\u6D11\u6D00\u6D1D\u6D42"],
+ ["cfa1", "\u6D01\u6D18\u6D37\u6D03\u6D0F\u6D40\u6D07\u6D20\u6D2C\u6D08\u6D22\u6D09\u6D10\u70B7\u709F\u70BE\u70B1\u70B0\u70A1\u70B4\u70B5\u70A9\u7241\u7249\u724A\u726C\u7270\u7273\u726E\u72CA\u72E4\u72E8\u72EB\u72DF\u72EA\u72E6\u72E3\u7385\u73CC\u73C2\u73C8\u73C5\u73B9\u73B6\u73B5\u73B4\u73EB\u73BF\u73C7\u73BE\u73C3\u73C6\u73B8\u73CB\u74EC\u74EE\u752E\u7547\u7548\u75A7\u75AA\u7679\u76C4\u7708\u7703\u7704\u7705\u770A\u76F7\u76FB\u76FA\u77E7\u77E8\u7806\u7811\u7812\u7805\u7810\u780F\u780E\u7809\u7803\u7813\u794A\u794C\u794B\u7945\u7944\u79D5\u79CD\u79CF\u79D6\u79CE\u7A80"],
+ ["d040", "\u7A7E\u7AD1\u7B00\u7B01\u7C7A\u7C78\u7C79\u7C7F\u7C80\u7C81\u7D03\u7D08\u7D01\u7F58\u7F91\u7F8D\u7FBE\u8007\u800E\u800F\u8014\u8037\u80D8\u80C7\u80E0\u80D1\u80C8\u80C2\u80D0\u80C5\u80E3\u80D9\u80DC\u80CA\u80D5\u80C9\u80CF\u80D7\u80E6\u80CD\u81FF\u8221\u8294\u82D9\u82FE\u82F9\u8307\u82E8\u8300\u82D5\u833A\u82EB\u82D6\u82F4\u82EC\u82E1\u82F2\u82F5\u830C\u82FB\u82F6\u82F0\u82EA"],
+ ["d0a1", "\u82E4\u82E0\u82FA\u82F3\u82ED\u8677\u8674\u867C\u8673\u8841\u884E\u8867\u886A\u8869\u89D3\u8A04\u8A07\u8D72\u8FE3\u8FE1\u8FEE\u8FE0\u90F1\u90BD\u90BF\u90D5\u90C5\u90BE\u90C7\u90CB\u90C8\u91D4\u91D3\u9654\u964F\u9651\u9653\u964A\u964E\u501E\u5005\u5007\u5013\u5022\u5030\u501B\u4FF5\u4FF4\u5033\u5037\u502C\u4FF6\u4FF7\u5017\u501C\u5020\u5027\u5035\u502F\u5031\u500E\u515A\u5194\u5193\u51CA\u51C4\u51C5\u51C8\u51CE\u5261\u525A\u5252\u525E\u525F\u5255\u5262\u52CD\u530E\u539E\u5526\u54E2\u5517\u5512\u54E7\u54F3\u54E4\u551A\u54FF\u5504\u5508\u54EB\u5511\u5505\u54F1"],
+ ["d140", "\u550A\u54FB\u54F7\u54F8\u54E0\u550E\u5503\u550B\u5701\u5702\u57CC\u5832\u57D5\u57D2\u57BA\u57C6\u57BD\u57BC\u57B8\u57B6\u57BF\u57C7\u57D0\u57B9\u57C1\u590E\u594A\u5A19\u5A16\u5A2D\u5A2E\u5A15\u5A0F\u5A17\u5A0A\u5A1E\u5A33\u5B6C\u5BA7\u5BAD\u5BAC\u5C03\u5C56\u5C54\u5CEC\u5CFF\u5CEE\u5CF1\u5CF7\u5D00\u5CF9\u5E29\u5E28\u5EA8\u5EAE\u5EAA\u5EAC\u5F33\u5F30\u5F67\u605D\u605A\u6067"],
+ ["d1a1", "\u6041\u60A2\u6088\u6080\u6092\u6081\u609D\u6083\u6095\u609B\u6097\u6087\u609C\u608E\u6219\u6246\u62F2\u6310\u6356\u632C\u6344\u6345\u6336\u6343\u63E4\u6339\u634B\u634A\u633C\u6329\u6341\u6334\u6358\u6354\u6359\u632D\u6347\u6333\u635A\u6351\u6338\u6357\u6340\u6348\u654A\u6546\u65C6\u65C3\u65C4\u65C2\u664A\u665F\u6647\u6651\u6712\u6713\u681F\u681A\u6849\u6832\u6833\u683B\u684B\u684F\u6816\u6831\u681C\u6835\u682B\u682D\u682F\u684E\u6844\u6834\u681D\u6812\u6814\u6826\u6828\u682E\u684D\u683A\u6825\u6820\u6B2C\u6B2F\u6B2D\u6B31\u6B34\u6B6D\u8082\u6B88\u6BE6\u6BE4"],
+ ["d240", "\u6BE8\u6BE3\u6BE2\u6BE7\u6C25\u6D7A\u6D63\u6D64\u6D76\u6D0D\u6D61\u6D92\u6D58\u6D62\u6D6D\u6D6F\u6D91\u6D8D\u6DEF\u6D7F\u6D86\u6D5E\u6D67\u6D60\u6D97\u6D70\u6D7C\u6D5F\u6D82\u6D98\u6D2F\u6D68\u6D8B\u6D7E\u6D80\u6D84\u6D16\u6D83\u6D7B\u6D7D\u6D75\u6D90\u70DC\u70D3\u70D1\u70DD\u70CB\u7F39\u70E2\u70D7\u70D2\u70DE\u70E0\u70D4\u70CD\u70C5\u70C6\u70C7\u70DA\u70CE\u70E1\u7242\u7278"],
+ ["d2a1", "\u7277\u7276\u7300\u72FA\u72F4\u72FE\u72F6\u72F3\u72FB\u7301\u73D3\u73D9\u73E5\u73D6\u73BC\u73E7\u73E3\u73E9\u73DC\u73D2\u73DB\u73D4\u73DD\u73DA\u73D7\u73D8\u73E8\u74DE\u74DF\u74F4\u74F5\u7521\u755B\u755F\u75B0\u75C1\u75BB\u75C4\u75C0\u75BF\u75B6\u75BA\u768A\u76C9\u771D\u771B\u7710\u7713\u7712\u7723\u7711\u7715\u7719\u771A\u7722\u7727\u7823\u782C\u7822\u7835\u782F\u7828\u782E\u782B\u7821\u7829\u7833\u782A\u7831\u7954\u795B\u794F\u795C\u7953\u7952\u7951\u79EB\u79EC\u79E0\u79EE\u79ED\u79EA\u79DC\u79DE\u79DD\u7A86\u7A89\u7A85\u7A8B\u7A8C\u7A8A\u7A87\u7AD8\u7B10"],
+ ["d340", "\u7B04\u7B13\u7B05\u7B0F\u7B08\u7B0A\u7B0E\u7B09\u7B12\u7C84\u7C91\u7C8A\u7C8C\u7C88\u7C8D\u7C85\u7D1E\u7D1D\u7D11\u7D0E\u7D18\u7D16\u7D13\u7D1F\u7D12\u7D0F\u7D0C\u7F5C\u7F61\u7F5E\u7F60\u7F5D\u7F5B\u7F96\u7F92\u7FC3\u7FC2\u7FC0\u8016\u803E\u8039\u80FA\u80F2\u80F9\u80F5\u8101\u80FB\u8100\u8201\u822F\u8225\u8333\u832D\u8344\u8319\u8351\u8325\u8356\u833F\u8341\u8326\u831C\u8322"],
+ ["d3a1", "\u8342\u834E\u831B\u832A\u8308\u833C\u834D\u8316\u8324\u8320\u8337\u832F\u8329\u8347\u8345\u834C\u8353\u831E\u832C\u834B\u8327\u8348\u8653\u8652\u86A2\u86A8\u8696\u868D\u8691\u869E\u8687\u8697\u8686\u868B\u869A\u8685\u86A5\u8699\u86A1\u86A7\u8695\u8698\u868E\u869D\u8690\u8694\u8843\u8844\u886D\u8875\u8876\u8872\u8880\u8871\u887F\u886F\u8883\u887E\u8874\u887C\u8A12\u8C47\u8C57\u8C7B\u8CA4\u8CA3\u8D76\u8D78\u8DB5\u8DB7\u8DB6\u8ED1\u8ED3\u8FFE\u8FF5\u9002\u8FFF\u8FFB\u9004\u8FFC\u8FF6\u90D6\u90E0\u90D9\u90DA\u90E3\u90DF\u90E5\u90D8\u90DB\u90D7\u90DC\u90E4\u9150"],
+ ["d440", "\u914E\u914F\u91D5\u91E2\u91DA\u965C\u965F\u96BC\u98E3\u9ADF\u9B2F\u4E7F\u5070\u506A\u5061\u505E\u5060\u5053\u504B\u505D\u5072\u5048\u504D\u5041\u505B\u504A\u5062\u5015\u5045\u505F\u5069\u506B\u5063\u5064\u5046\u5040\u506E\u5073\u5057\u5051\u51D0\u526B\u526D\u526C\u526E\u52D6\u52D3\u532D\u539C\u5575\u5576\u553C\u554D\u5550\u5534\u552A\u5551\u5562\u5536\u5535\u5530\u5552\u5545"],
+ ["d4a1", "\u550C\u5532\u5565\u554E\u5539\u5548\u552D\u553B\u5540\u554B\u570A\u5707\u57FB\u5814\u57E2\u57F6\u57DC\u57F4\u5800\u57ED\u57FD\u5808\u57F8\u580B\u57F3\u57CF\u5807\u57EE\u57E3\u57F2\u57E5\u57EC\u57E1\u580E\u57FC\u5810\u57E7\u5801\u580C\u57F1\u57E9\u57F0\u580D\u5804\u595C\u5A60\u5A58\u5A55\u5A67\u5A5E\u5A38\u5A35\u5A6D\u5A50\u5A5F\u5A65\u5A6C\u5A53\u5A64\u5A57\u5A43\u5A5D\u5A52\u5A44\u5A5B\u5A48\u5A8E\u5A3E\u5A4D\u5A39\u5A4C\u5A70\u5A69\u5A47\u5A51\u5A56\u5A42\u5A5C\u5B72\u5B6E\u5BC1\u5BC0\u5C59\u5D1E\u5D0B\u5D1D\u5D1A\u5D20\u5D0C\u5D28\u5D0D\u5D26\u5D25\u5D0F"],
+ ["d540", "\u5D30\u5D12\u5D23\u5D1F\u5D2E\u5E3E\u5E34\u5EB1\u5EB4\u5EB9\u5EB2\u5EB3\u5F36\u5F38\u5F9B\u5F96\u5F9F\u608A\u6090\u6086\u60BE\u60B0\u60BA\u60D3\u60D4\u60CF\u60E4\u60D9\u60DD\u60C8\u60B1\u60DB\u60B7\u60CA\u60BF\u60C3\u60CD\u60C0\u6332\u6365\u638A\u6382\u637D\u63BD\u639E\u63AD\u639D\u6397\u63AB\u638E\u636F\u6387\u6390\u636E\u63AF\u6375\u639C\u636D\u63AE\u637C\u63A4\u633B\u639F"],
+ ["d5a1", "\u6378\u6385\u6381\u6391\u638D\u6370\u6553\u65CD\u6665\u6661\u665B\u6659\u665C\u6662\u6718\u6879\u6887\u6890\u689C\u686D\u686E\u68AE\u68AB\u6956\u686F\u68A3\u68AC\u68A9\u6875\u6874\u68B2\u688F\u6877\u6892\u687C\u686B\u6872\u68AA\u6880\u6871\u687E\u689B\u6896\u688B\u68A0\u6889\u68A4\u6878\u687B\u6891\u688C\u688A\u687D\u6B36\u6B33\u6B37\u6B38\u6B91\u6B8F\u6B8D\u6B8E\u6B8C\u6C2A\u6DC0\u6DAB\u6DB4\u6DB3\u6E74\u6DAC\u6DE9\u6DE2\u6DB7\u6DF6\u6DD4\u6E00\u6DC8\u6DE0\u6DDF\u6DD6\u6DBE\u6DE5\u6DDC\u6DDD\u6DDB\u6DF4\u6DCA\u6DBD\u6DED\u6DF0\u6DBA\u6DD5\u6DC2\u6DCF\u6DC9"],
+ ["d640", "\u6DD0\u6DF2\u6DD3\u6DFD\u6DD7\u6DCD\u6DE3\u6DBB\u70FA\u710D\u70F7\u7117\u70F4\u710C\u70F0\u7104\u70F3\u7110\u70FC\u70FF\u7106\u7113\u7100\u70F8\u70F6\u710B\u7102\u710E\u727E\u727B\u727C\u727F\u731D\u7317\u7307\u7311\u7318\u730A\u7308\u72FF\u730F\u731E\u7388\u73F6\u73F8\u73F5\u7404\u7401\u73FD\u7407\u7400\u73FA\u73FC\u73FF\u740C\u740B\u73F4\u7408\u7564\u7563\u75CE\u75D2\u75CF"],
+ ["d6a1", "\u75CB\u75CC\u75D1\u75D0\u768F\u7689\u76D3\u7739\u772F\u772D\u7731\u7732\u7734\u7733\u773D\u7725\u773B\u7735\u7848\u7852\u7849\u784D\u784A\u784C\u7826\u7845\u7850\u7964\u7967\u7969\u796A\u7963\u796B\u7961\u79BB\u79FA\u79F8\u79F6\u79F7\u7A8F\u7A94\u7A90\u7B35\u7B47\u7B34\u7B25\u7B30\u7B22\u7B24\u7B33\u7B18\u7B2A\u7B1D\u7B31\u7B2B\u7B2D\u7B2F\u7B32\u7B38\u7B1A\u7B23\u7C94\u7C98\u7C96\u7CA3\u7D35\u7D3D\u7D38\u7D36\u7D3A\u7D45\u7D2C\u7D29\u7D41\u7D47\u7D3E\u7D3F\u7D4A\u7D3B\u7D28\u7F63\u7F95\u7F9C\u7F9D\u7F9B\u7FCA\u7FCB\u7FCD\u7FD0\u7FD1\u7FC7\u7FCF\u7FC9\u801F"],
+ ["d740", "\u801E\u801B\u8047\u8043\u8048\u8118\u8125\u8119\u811B\u812D\u811F\u812C\u811E\u8121\u8115\u8127\u811D\u8122\u8211\u8238\u8233\u823A\u8234\u8232\u8274\u8390\u83A3\u83A8\u838D\u837A\u8373\u83A4\u8374\u838F\u8381\u8395\u8399\u8375\u8394\u83A9\u837D\u8383\u838C\u839D\u839B\u83AA\u838B\u837E\u83A5\u83AF\u8388\u8397\u83B0\u837F\u83A6\u8387\u83AE\u8376\u839A\u8659\u8656\u86BF\u86B7"],
+ ["d7a1", "\u86C2\u86C1\u86C5\u86BA\u86B0\u86C8\u86B9\u86B3\u86B8\u86CC\u86B4\u86BB\u86BC\u86C3\u86BD\u86BE\u8852\u8889\u8895\u88A8\u88A2\u88AA\u889A\u8891\u88A1\u889F\u8898\u88A7\u8899\u889B\u8897\u88A4\u88AC\u888C\u8893\u888E\u8982\u89D6\u89D9\u89D5\u8A30\u8A27\u8A2C\u8A1E\u8C39\u8C3B\u8C5C\u8C5D\u8C7D\u8CA5\u8D7D\u8D7B\u8D79\u8DBC\u8DC2\u8DB9\u8DBF\u8DC1\u8ED8\u8EDE\u8EDD\u8EDC\u8ED7\u8EE0\u8EE1\u9024\u900B\u9011\u901C\u900C\u9021\u90EF\u90EA\u90F0\u90F4\u90F2\u90F3\u90D4\u90EB\u90EC\u90E9\u9156\u9158\u915A\u9153\u9155\u91EC\u91F4\u91F1\u91F3\u91F8\u91E4\u91F9\u91EA"],
+ ["d840", "\u91EB\u91F7\u91E8\u91EE\u957A\u9586\u9588\u967C\u966D\u966B\u9671\u966F\u96BF\u976A\u9804\u98E5\u9997\u509B\u5095\u5094\u509E\u508B\u50A3\u5083\u508C\u508E\u509D\u5068\u509C\u5092\u5082\u5087\u515F\u51D4\u5312\u5311\u53A4\u53A7\u5591\u55A8\u55A5\u55AD\u5577\u5645\u55A2\u5593\u5588\u558F\u55B5\u5581\u55A3\u5592\u55A4\u557D\u558C\u55A6\u557F\u5595\u55A1\u558E\u570C\u5829\u5837"],
+ ["d8a1", "\u5819\u581E\u5827\u5823\u5828\u57F5\u5848\u5825\u581C\u581B\u5833\u583F\u5836\u582E\u5839\u5838\u582D\u582C\u583B\u5961\u5AAF\u5A94\u5A9F\u5A7A\u5AA2\u5A9E\u5A78\u5AA6\u5A7C\u5AA5\u5AAC\u5A95\u5AAE\u5A37\u5A84\u5A8A\u5A97\u5A83\u5A8B\u5AA9\u5A7B\u5A7D\u5A8C\u5A9C\u5A8F\u5A93\u5A9D\u5BEA\u5BCD\u5BCB\u5BD4\u5BD1\u5BCA\u5BCE\u5C0C\u5C30\u5D37\u5D43\u5D6B\u5D41\u5D4B\u5D3F\u5D35\u5D51\u5D4E\u5D55\u5D33\u5D3A\u5D52\u5D3D\u5D31\u5D59\u5D42\u5D39\u5D49\u5D38\u5D3C\u5D32\u5D36\u5D40\u5D45\u5E44\u5E41\u5F58\u5FA6\u5FA5\u5FAB\u60C9\u60B9\u60CC\u60E2\u60CE\u60C4\u6114"],
+ ["d940", "\u60F2\u610A\u6116\u6105\u60F5\u6113\u60F8\u60FC\u60FE\u60C1\u6103\u6118\u611D\u6110\u60FF\u6104\u610B\u624A\u6394\u63B1\u63B0\u63CE\u63E5\u63E8\u63EF\u63C3\u649D\u63F3\u63CA\u63E0\u63F6\u63D5\u63F2\u63F5\u6461\u63DF\u63BE\u63DD\u63DC\u63C4\u63D8\u63D3\u63C2\u63C7\u63CC\u63CB\u63C8\u63F0\u63D7\u63D9\u6532\u6567\u656A\u6564\u655C\u6568\u6565\u658C\u659D\u659E\u65AE\u65D0\u65D2"],
+ ["d9a1", "\u667C\u666C\u667B\u6680\u6671\u6679\u666A\u6672\u6701\u690C\u68D3\u6904\u68DC\u692A\u68EC\u68EA\u68F1\u690F\u68D6\u68F7\u68EB\u68E4\u68F6\u6913\u6910\u68F3\u68E1\u6907\u68CC\u6908\u6970\u68B4\u6911\u68EF\u68C6\u6914\u68F8\u68D0\u68FD\u68FC\u68E8\u690B\u690A\u6917\u68CE\u68C8\u68DD\u68DE\u68E6\u68F4\u68D1\u6906\u68D4\u68E9\u6915\u6925\u68C7\u6B39\u6B3B\u6B3F\u6B3C\u6B94\u6B97\u6B99\u6B95\u6BBD\u6BF0\u6BF2\u6BF3\u6C30\u6DFC\u6E46\u6E47\u6E1F\u6E49\u6E88\u6E3C\u6E3D\u6E45\u6E62\u6E2B\u6E3F\u6E41\u6E5D\u6E73\u6E1C\u6E33\u6E4B\u6E40\u6E51\u6E3B\u6E03\u6E2E\u6E5E"],
+ ["da40", "\u6E68\u6E5C\u6E61\u6E31\u6E28\u6E60\u6E71\u6E6B\u6E39\u6E22\u6E30\u6E53\u6E65\u6E27\u6E78\u6E64\u6E77\u6E55\u6E79\u6E52\u6E66\u6E35\u6E36\u6E5A\u7120\u711E\u712F\u70FB\u712E\u7131\u7123\u7125\u7122\u7132\u711F\u7128\u713A\u711B\u724B\u725A\u7288\u7289\u7286\u7285\u728B\u7312\u730B\u7330\u7322\u7331\u7333\u7327\u7332\u732D\u7326\u7323\u7335\u730C\u742E\u742C\u7430\u742B\u7416"],
+ ["daa1", "\u741A\u7421\u742D\u7431\u7424\u7423\u741D\u7429\u7420\u7432\u74FB\u752F\u756F\u756C\u75E7\u75DA\u75E1\u75E6\u75DD\u75DF\u75E4\u75D7\u7695\u7692\u76DA\u7746\u7747\u7744\u774D\u7745\u774A\u774E\u774B\u774C\u77DE\u77EC\u7860\u7864\u7865\u785C\u786D\u7871\u786A\u786E\u7870\u7869\u7868\u785E\u7862\u7974\u7973\u7972\u7970\u7A02\u7A0A\u7A03\u7A0C\u7A04\u7A99\u7AE6\u7AE4\u7B4A\u7B3B\u7B44\u7B48\u7B4C\u7B4E\u7B40\u7B58\u7B45\u7CA2\u7C9E\u7CA8\u7CA1\u7D58\u7D6F\u7D63\u7D53\u7D56\u7D67\u7D6A\u7D4F\u7D6D\u7D5C\u7D6B\u7D52\u7D54\u7D69\u7D51\u7D5F\u7D4E\u7F3E\u7F3F\u7F65"],
+ ["db40", "\u7F66\u7FA2\u7FA0\u7FA1\u7FD7\u8051\u804F\u8050\u80FE\u80D4\u8143\u814A\u8152\u814F\u8147\u813D\u814D\u813A\u81E6\u81EE\u81F7\u81F8\u81F9\u8204\u823C\u823D\u823F\u8275\u833B\u83CF\u83F9\u8423\u83C0\u83E8\u8412\u83E7\u83E4\u83FC\u83F6\u8410\u83C6\u83C8\u83EB\u83E3\u83BF\u8401\u83DD\u83E5\u83D8\u83FF\u83E1\u83CB\u83CE\u83D6\u83F5\u83C9\u8409\u840F\u83DE\u8411\u8406\u83C2\u83F3"],
+ ["dba1", "\u83D5\u83FA\u83C7\u83D1\u83EA\u8413\u83C3\u83EC\u83EE\u83C4\u83FB\u83D7\u83E2\u841B\u83DB\u83FE\u86D8\u86E2\u86E6\u86D3\u86E3\u86DA\u86EA\u86DD\u86EB\u86DC\u86EC\u86E9\u86D7\u86E8\u86D1\u8848\u8856\u8855\u88BA\u88D7\u88B9\u88B8\u88C0\u88BE\u88B6\u88BC\u88B7\u88BD\u88B2\u8901\u88C9\u8995\u8998\u8997\u89DD\u89DA\u89DB\u8A4E\u8A4D\u8A39\u8A59\u8A40\u8A57\u8A58\u8A44\u8A45\u8A52\u8A48\u8A51\u8A4A\u8A4C\u8A4F\u8C5F\u8C81\u8C80\u8CBA\u8CBE\u8CB0\u8CB9\u8CB5\u8D84\u8D80\u8D89\u8DD8\u8DD3\u8DCD\u8DC7\u8DD6\u8DDC\u8DCF\u8DD5\u8DD9\u8DC8\u8DD7\u8DC5\u8EEF\u8EF7\u8EFA"],
+ ["dc40", "\u8EF9\u8EE6\u8EEE\u8EE5\u8EF5\u8EE7\u8EE8\u8EF6\u8EEB\u8EF1\u8EEC\u8EF4\u8EE9\u902D\u9034\u902F\u9106\u912C\u9104\u90FF\u90FC\u9108\u90F9\u90FB\u9101\u9100\u9107\u9105\u9103\u9161\u9164\u915F\u9162\u9160\u9201\u920A\u9225\u9203\u921A\u9226\u920F\u920C\u9200\u9212\u91FF\u91FD\u9206\u9204\u9227\u9202\u921C\u9224\u9219\u9217\u9205\u9216\u957B\u958D\u958C\u9590\u9687\u967E\u9688"],
+ ["dca1", "\u9689\u9683\u9680\u96C2\u96C8\u96C3\u96F1\u96F0\u976C\u9770\u976E\u9807\u98A9\u98EB\u9CE6\u9EF9\u4E83\u4E84\u4EB6\u50BD\u50BF\u50C6\u50AE\u50C4\u50CA\u50B4\u50C8\u50C2\u50B0\u50C1\u50BA\u50B1\u50CB\u50C9\u50B6\u50B8\u51D7\u527A\u5278\u527B\u527C\u55C3\u55DB\u55CC\u55D0\u55CB\u55CA\u55DD\u55C0\u55D4\u55C4\u55E9\u55BF\u55D2\u558D\u55CF\u55D5\u55E2\u55D6\u55C8\u55F2\u55CD\u55D9\u55C2\u5714\u5853\u5868\u5864\u584F\u584D\u5849\u586F\u5855\u584E\u585D\u5859\u5865\u585B\u583D\u5863\u5871\u58FC\u5AC7\u5AC4\u5ACB\u5ABA\u5AB8\u5AB1\u5AB5\u5AB0\u5ABF\u5AC8\u5ABB\u5AC6"],
+ ["dd40", "\u5AB7\u5AC0\u5ACA\u5AB4\u5AB6\u5ACD\u5AB9\u5A90\u5BD6\u5BD8\u5BD9\u5C1F\u5C33\u5D71\u5D63\u5D4A\u5D65\u5D72\u5D6C\u5D5E\u5D68\u5D67\u5D62\u5DF0\u5E4F\u5E4E\u5E4A\u5E4D\u5E4B\u5EC5\u5ECC\u5EC6\u5ECB\u5EC7\u5F40\u5FAF\u5FAD\u60F7\u6149\u614A\u612B\u6145\u6136\u6132\u612E\u6146\u612F\u614F\u6129\u6140\u6220\u9168\u6223\u6225\u6224\u63C5\u63F1\u63EB\u6410\u6412\u6409\u6420\u6424"],
+ ["dda1", "\u6433\u6443\u641F\u6415\u6418\u6439\u6437\u6422\u6423\u640C\u6426\u6430\u6428\u6441\u6435\u642F\u640A\u641A\u6440\u6425\u6427\u640B\u63E7\u641B\u642E\u6421\u640E\u656F\u6592\u65D3\u6686\u668C\u6695\u6690\u668B\u668A\u6699\u6694\u6678\u6720\u6966\u695F\u6938\u694E\u6962\u6971\u693F\u6945\u696A\u6939\u6942\u6957\u6959\u697A\u6948\u6949\u6935\u696C\u6933\u693D\u6965\u68F0\u6978\u6934\u6969\u6940\u696F\u6944\u6976\u6958\u6941\u6974\u694C\u693B\u694B\u6937\u695C\u694F\u6951\u6932\u6952\u692F\u697B\u693C\u6B46\u6B45\u6B43\u6B42\u6B48\u6B41\u6B9B\uFA0D\u6BFB\u6BFC"],
+ ["de40", "\u6BF9\u6BF7\u6BF8\u6E9B\u6ED6\u6EC8\u6E8F\u6EC0\u6E9F\u6E93\u6E94\u6EA0\u6EB1\u6EB9\u6EC6\u6ED2\u6EBD\u6EC1\u6E9E\u6EC9\u6EB7\u6EB0\u6ECD\u6EA6\u6ECF\u6EB2\u6EBE\u6EC3\u6EDC\u6ED8\u6E99\u6E92\u6E8E\u6E8D\u6EA4\u6EA1\u6EBF\u6EB3\u6ED0\u6ECA\u6E97\u6EAE\u6EA3\u7147\u7154\u7152\u7163\u7160\u7141\u715D\u7162\u7172\u7178\u716A\u7161\u7142\u7158\u7143\u714B\u7170\u715F\u7150\u7153"],
+ ["dea1", "\u7144\u714D\u715A\u724F\u728D\u728C\u7291\u7290\u728E\u733C\u7342\u733B\u733A\u7340\u734A\u7349\u7444\u744A\u744B\u7452\u7451\u7457\u7440\u744F\u7450\u744E\u7442\u7446\u744D\u7454\u74E1\u74FF\u74FE\u74FD\u751D\u7579\u7577\u6983\u75EF\u760F\u7603\u75F7\u75FE\u75FC\u75F9\u75F8\u7610\u75FB\u75F6\u75ED\u75F5\u75FD\u7699\u76B5\u76DD\u7755\u775F\u7760\u7752\u7756\u775A\u7769\u7767\u7754\u7759\u776D\u77E0\u7887\u789A\u7894\u788F\u7884\u7895\u7885\u7886\u78A1\u7883\u7879\u7899\u7880\u7896\u787B\u797C\u7982\u797D\u7979\u7A11\u7A18\u7A19\u7A12\u7A17\u7A15\u7A22\u7A13"],
+ ["df40", "\u7A1B\u7A10\u7AA3\u7AA2\u7A9E\u7AEB\u7B66\u7B64\u7B6D\u7B74\u7B69\u7B72\u7B65\u7B73\u7B71\u7B70\u7B61\u7B78\u7B76\u7B63\u7CB2\u7CB4\u7CAF\u7D88\u7D86\u7D80\u7D8D\u7D7F\u7D85\u7D7A\u7D8E\u7D7B\u7D83\u7D7C\u7D8C\u7D94\u7D84\u7D7D\u7D92\u7F6D\u7F6B\u7F67\u7F68\u7F6C\u7FA6\u7FA5\u7FA7\u7FDB\u7FDC\u8021\u8164\u8160\u8177\u815C\u8169\u815B\u8162\u8172\u6721\u815E\u8176\u8167\u816F"],
+ ["dfa1", "\u8144\u8161\u821D\u8249\u8244\u8240\u8242\u8245\u84F1\u843F\u8456\u8476\u8479\u848F\u848D\u8465\u8451\u8440\u8486\u8467\u8430\u844D\u847D\u845A\u8459\u8474\u8473\u845D\u8507\u845E\u8437\u843A\u8434\u847A\u8443\u8478\u8432\u8445\u8429\u83D9\u844B\u842F\u8442\u842D\u845F\u8470\u8439\u844E\u844C\u8452\u846F\u84C5\u848E\u843B\u8447\u8436\u8433\u8468\u847E\u8444\u842B\u8460\u8454\u846E\u8450\u870B\u8704\u86F7\u870C\u86FA\u86D6\u86F5\u874D\u86F8\u870E\u8709\u8701\u86F6\u870D\u8705\u88D6\u88CB\u88CD\u88CE\u88DE\u88DB\u88DA\u88CC\u88D0\u8985\u899B\u89DF\u89E5\u89E4"],
+ ["e040", "\u89E1\u89E0\u89E2\u89DC\u89E6\u8A76\u8A86\u8A7F\u8A61\u8A3F\u8A77\u8A82\u8A84\u8A75\u8A83\u8A81\u8A74\u8A7A\u8C3C\u8C4B\u8C4A\u8C65\u8C64\u8C66\u8C86\u8C84\u8C85\u8CCC\u8D68\u8D69\u8D91\u8D8C\u8D8E\u8D8F\u8D8D\u8D93\u8D94\u8D90\u8D92\u8DF0\u8DE0\u8DEC\u8DF1\u8DEE\u8DD0\u8DE9\u8DE3\u8DE2\u8DE7\u8DF2\u8DEB\u8DF4\u8F06\u8EFF\u8F01\u8F00\u8F05\u8F07\u8F08\u8F02\u8F0B\u9052\u903F"],
+ ["e0a1", "\u9044\u9049\u903D\u9110\u910D\u910F\u9111\u9116\u9114\u910B\u910E\u916E\u916F\u9248\u9252\u9230\u923A\u9266\u9233\u9265\u925E\u9283\u922E\u924A\u9246\u926D\u926C\u924F\u9260\u9267\u926F\u9236\u9261\u9270\u9231\u9254\u9263\u9250\u9272\u924E\u9253\u924C\u9256\u9232\u959F\u959C\u959E\u959B\u9692\u9693\u9691\u9697\u96CE\u96FA\u96FD\u96F8\u96F5\u9773\u9777\u9778\u9772\u980F\u980D\u980E\u98AC\u98F6\u98F9\u99AF\u99B2\u99B0\u99B5\u9AAD\u9AAB\u9B5B\u9CEA\u9CED\u9CE7\u9E80\u9EFD\u50E6\u50D4\u50D7\u50E8\u50F3\u50DB\u50EA\u50DD\u50E4\u50D3\u50EC\u50F0\u50EF\u50E3\u50E0"],
+ ["e140", "\u51D8\u5280\u5281\u52E9\u52EB\u5330\u53AC\u5627\u5615\u560C\u5612\u55FC\u560F\u561C\u5601\u5613\u5602\u55FA\u561D\u5604\u55FF\u55F9\u5889\u587C\u5890\u5898\u5886\u5881\u587F\u5874\u588B\u587A\u5887\u5891\u588E\u5876\u5882\u5888\u587B\u5894\u588F\u58FE\u596B\u5ADC\u5AEE\u5AE5\u5AD5\u5AEA\u5ADA\u5AED\u5AEB\u5AF3\u5AE2\u5AE0\u5ADB\u5AEC\u5ADE\u5ADD\u5AD9\u5AE8\u5ADF\u5B77\u5BE0"],
+ ["e1a1", "\u5BE3\u5C63\u5D82\u5D80\u5D7D\u5D86\u5D7A\u5D81\u5D77\u5D8A\u5D89\u5D88\u5D7E\u5D7C\u5D8D\u5D79\u5D7F\u5E58\u5E59\u5E53\u5ED8\u5ED1\u5ED7\u5ECE\u5EDC\u5ED5\u5ED9\u5ED2\u5ED4\u5F44\u5F43\u5F6F\u5FB6\u612C\u6128\u6141\u615E\u6171\u6173\u6152\u6153\u6172\u616C\u6180\u6174\u6154\u617A\u615B\u6165\u613B\u616A\u6161\u6156\u6229\u6227\u622B\u642B\u644D\u645B\u645D\u6474\u6476\u6472\u6473\u647D\u6475\u6466\u64A6\u644E\u6482\u645E\u645C\u644B\u6453\u6460\u6450\u647F\u643F\u646C\u646B\u6459\u6465\u6477\u6573\u65A0\u66A1\u66A0\u669F\u6705\u6704\u6722\u69B1\u69B6\u69C9"],
+ ["e240", "\u69A0\u69CE\u6996\u69B0\u69AC\u69BC\u6991\u6999\u698E\u69A7\u698D\u69A9\u69BE\u69AF\u69BF\u69C4\u69BD\u69A4\u69D4\u69B9\u69CA\u699A\u69CF\u69B3\u6993\u69AA\u69A1\u699E\u69D9\u6997\u6990\u69C2\u69B5\u69A5\u69C6\u6B4A\u6B4D\u6B4B\u6B9E\u6B9F\u6BA0\u6BC3\u6BC4\u6BFE\u6ECE\u6EF5\u6EF1\u6F03\u6F25\u6EF8\u6F37\u6EFB\u6F2E\u6F09\u6F4E\u6F19\u6F1A\u6F27\u6F18\u6F3B\u6F12\u6EED\u6F0A"],
+ ["e2a1", "\u6F36\u6F73\u6EF9\u6EEE\u6F2D\u6F40\u6F30\u6F3C\u6F35\u6EEB\u6F07\u6F0E\u6F43\u6F05\u6EFD\u6EF6\u6F39\u6F1C\u6EFC\u6F3A\u6F1F\u6F0D\u6F1E\u6F08\u6F21\u7187\u7190\u7189\u7180\u7185\u7182\u718F\u717B\u7186\u7181\u7197\u7244\u7253\u7297\u7295\u7293\u7343\u734D\u7351\u734C\u7462\u7473\u7471\u7475\u7472\u7467\u746E\u7500\u7502\u7503\u757D\u7590\u7616\u7608\u760C\u7615\u7611\u760A\u7614\u76B8\u7781\u777C\u7785\u7782\u776E\u7780\u776F\u777E\u7783\u78B2\u78AA\u78B4\u78AD\u78A8\u787E\u78AB\u789E\u78A5\u78A0\u78AC\u78A2\u78A4\u7998\u798A\u798B\u7996\u7995\u7994\u7993"],
+ ["e340", "\u7997\u7988\u7992\u7990\u7A2B\u7A4A\u7A30\u7A2F\u7A28\u7A26\u7AA8\u7AAB\u7AAC\u7AEE\u7B88\u7B9C\u7B8A\u7B91\u7B90\u7B96\u7B8D\u7B8C\u7B9B\u7B8E\u7B85\u7B98\u5284\u7B99\u7BA4\u7B82\u7CBB\u7CBF\u7CBC\u7CBA\u7DA7\u7DB7\u7DC2\u7DA3\u7DAA\u7DC1\u7DC0\u7DC5\u7D9D\u7DCE\u7DC4\u7DC6\u7DCB\u7DCC\u7DAF\u7DB9\u7D96\u7DBC\u7D9F\u7DA6\u7DAE\u7DA9\u7DA1\u7DC9\u7F73\u7FE2\u7FE3\u7FE5\u7FDE"],
+ ["e3a1", "\u8024\u805D\u805C\u8189\u8186\u8183\u8187\u818D\u818C\u818B\u8215\u8497\u84A4\u84A1\u849F\u84BA\u84CE\u84C2\u84AC\u84AE\u84AB\u84B9\u84B4\u84C1\u84CD\u84AA\u849A\u84B1\u84D0\u849D\u84A7\u84BB\u84A2\u8494\u84C7\u84CC\u849B\u84A9\u84AF\u84A8\u84D6\u8498\u84B6\u84CF\u84A0\u84D7\u84D4\u84D2\u84DB\u84B0\u8491\u8661\u8733\u8723\u8728\u876B\u8740\u872E\u871E\u8721\u8719\u871B\u8743\u872C\u8741\u873E\u8746\u8720\u8732\u872A\u872D\u873C\u8712\u873A\u8731\u8735\u8742\u8726\u8727\u8738\u8724\u871A\u8730\u8711\u88F7\u88E7\u88F1\u88F2\u88FA\u88FE\u88EE\u88FC\u88F6\u88FB"],
+ ["e440", "\u88F0\u88EC\u88EB\u899D\u89A1\u899F\u899E\u89E9\u89EB\u89E8\u8AAB\u8A99\u8A8B\u8A92\u8A8F\u8A96\u8C3D\u8C68\u8C69\u8CD5\u8CCF\u8CD7\u8D96\u8E09\u8E02\u8DFF\u8E0D\u8DFD\u8E0A\u8E03\u8E07\u8E06\u8E05\u8DFE\u8E00\u8E04\u8F10\u8F11\u8F0E\u8F0D\u9123\u911C\u9120\u9122\u911F\u911D\u911A\u9124\u9121\u911B\u917A\u9172\u9179\u9173\u92A5\u92A4\u9276\u929B\u927A\u92A0\u9294\u92AA\u928D"],
+ ["e4a1", "\u92A6\u929A\u92AB\u9279\u9297\u927F\u92A3\u92EE\u928E\u9282\u9295\u92A2\u927D\u9288\u92A1\u928A\u9286\u928C\u9299\u92A7\u927E\u9287\u92A9\u929D\u928B\u922D\u969E\u96A1\u96FF\u9758\u977D\u977A\u977E\u9783\u9780\u9782\u977B\u9784\u9781\u977F\u97CE\u97CD\u9816\u98AD\u98AE\u9902\u9900\u9907\u999D\u999C\u99C3\u99B9\u99BB\u99BA\u99C2\u99BD\u99C7\u9AB1\u9AE3\u9AE7\u9B3E\u9B3F\u9B60\u9B61\u9B5F\u9CF1\u9CF2\u9CF5\u9EA7\u50FF\u5103\u5130\u50F8\u5106\u5107\u50F6\u50FE\u510B\u510C\u50FD\u510A\u528B\u528C\u52F1\u52EF\u5648\u5642\u564C\u5635\u5641\u564A\u5649\u5646\u5658"],
+ ["e540", "\u565A\u5640\u5633\u563D\u562C\u563E\u5638\u562A\u563A\u571A\u58AB\u589D\u58B1\u58A0\u58A3\u58AF\u58AC\u58A5\u58A1\u58FF\u5AFF\u5AF4\u5AFD\u5AF7\u5AF6\u5B03\u5AF8\u5B02\u5AF9\u5B01\u5B07\u5B05\u5B0F\u5C67\u5D99\u5D97\u5D9F\u5D92\u5DA2\u5D93\u5D95\u5DA0\u5D9C\u5DA1\u5D9A\u5D9E\u5E69\u5E5D\u5E60\u5E5C\u7DF3\u5EDB\u5EDE\u5EE1\u5F49\u5FB2\u618B\u6183\u6179\u61B1\u61B0\u61A2\u6189"],
+ ["e5a1", "\u619B\u6193\u61AF\u61AD\u619F\u6192\u61AA\u61A1\u618D\u6166\u61B3\u622D\u646E\u6470\u6496\u64A0\u6485\u6497\u649C\u648F\u648B\u648A\u648C\u64A3\u649F\u6468\u64B1\u6498\u6576\u657A\u6579\u657B\u65B2\u65B3\u66B5\u66B0\u66A9\u66B2\u66B7\u66AA\u66AF\u6A00\u6A06\u6A17\u69E5\u69F8\u6A15\u69F1\u69E4\u6A20\u69FF\u69EC\u69E2\u6A1B\u6A1D\u69FE\u6A27\u69F2\u69EE\u6A14\u69F7\u69E7\u6A40\u6A08\u69E6\u69FB\u6A0D\u69FC\u69EB\u6A09\u6A04\u6A18\u6A25\u6A0F\u69F6\u6A26\u6A07\u69F4\u6A16\u6B51\u6BA5\u6BA3\u6BA2\u6BA6\u6C01\u6C00\u6BFF\u6C02\u6F41\u6F26\u6F7E\u6F87\u6FC6\u6F92"],
+ ["e640", "\u6F8D\u6F89\u6F8C\u6F62\u6F4F\u6F85\u6F5A\u6F96\u6F76\u6F6C\u6F82\u6F55\u6F72\u6F52\u6F50\u6F57\u6F94\u6F93\u6F5D\u6F00\u6F61\u6F6B\u6F7D\u6F67\u6F90\u6F53\u6F8B\u6F69\u6F7F\u6F95\u6F63\u6F77\u6F6A\u6F7B\u71B2\u71AF\u719B\u71B0\u71A0\u719A\u71A9\u71B5\u719D\u71A5\u719E\u71A4\u71A1\u71AA\u719C\u71A7\u71B3\u7298\u729A\u7358\u7352\u735E\u735F\u7360\u735D\u735B\u7361\u735A\u7359"],
+ ["e6a1", "\u7362\u7487\u7489\u748A\u7486\u7481\u747D\u7485\u7488\u747C\u7479\u7508\u7507\u757E\u7625\u761E\u7619\u761D\u761C\u7623\u761A\u7628\u761B\u769C\u769D\u769E\u769B\u778D\u778F\u7789\u7788\u78CD\u78BB\u78CF\u78CC\u78D1\u78CE\u78D4\u78C8\u78C3\u78C4\u78C9\u799A\u79A1\u79A0\u799C\u79A2\u799B\u6B76\u7A39\u7AB2\u7AB4\u7AB3\u7BB7\u7BCB\u7BBE\u7BAC\u7BCE\u7BAF\u7BB9\u7BCA\u7BB5\u7CC5\u7CC8\u7CCC\u7CCB\u7DF7\u7DDB\u7DEA\u7DE7\u7DD7\u7DE1\u7E03\u7DFA\u7DE6\u7DF6\u7DF1\u7DF0\u7DEE\u7DDF\u7F76\u7FAC\u7FB0\u7FAD\u7FED\u7FEB\u7FEA\u7FEC\u7FE6\u7FE8\u8064\u8067\u81A3\u819F"],
+ ["e740", "\u819E\u8195\u81A2\u8199\u8197\u8216\u824F\u8253\u8252\u8250\u824E\u8251\u8524\u853B\u850F\u8500\u8529\u850E\u8509\u850D\u851F\u850A\u8527\u851C\u84FB\u852B\u84FA\u8508\u850C\u84F4\u852A\u84F2\u8515\u84F7\u84EB\u84F3\u84FC\u8512\u84EA\u84E9\u8516\u84FE\u8528\u851D\u852E\u8502\u84FD\u851E\u84F6\u8531\u8526\u84E7\u84E8\u84F0\u84EF\u84F9\u8518\u8520\u8530\u850B\u8519\u852F\u8662"],
+ ["e7a1", "\u8756\u8763\u8764\u8777\u87E1\u8773\u8758\u8754\u875B\u8752\u8761\u875A\u8751\u875E\u876D\u876A\u8750\u874E\u875F\u875D\u876F\u876C\u877A\u876E\u875C\u8765\u874F\u877B\u8775\u8762\u8767\u8769\u885A\u8905\u890C\u8914\u890B\u8917\u8918\u8919\u8906\u8916\u8911\u890E\u8909\u89A2\u89A4\u89A3\u89ED\u89F0\u89EC\u8ACF\u8AC6\u8AB8\u8AD3\u8AD1\u8AD4\u8AD5\u8ABB\u8AD7\u8ABE\u8AC0\u8AC5\u8AD8\u8AC3\u8ABA\u8ABD\u8AD9\u8C3E\u8C4D\u8C8F\u8CE5\u8CDF\u8CD9\u8CE8\u8CDA\u8CDD\u8CE7\u8DA0\u8D9C\u8DA1\u8D9B\u8E20\u8E23\u8E25\u8E24\u8E2E\u8E15\u8E1B\u8E16\u8E11\u8E19\u8E26\u8E27"],
+ ["e840", "\u8E14\u8E12\u8E18\u8E13\u8E1C\u8E17\u8E1A\u8F2C\u8F24\u8F18\u8F1A\u8F20\u8F23\u8F16\u8F17\u9073\u9070\u906F\u9067\u906B\u912F\u912B\u9129\u912A\u9132\u9126\u912E\u9185\u9186\u918A\u9181\u9182\u9184\u9180\u92D0\u92C3\u92C4\u92C0\u92D9\u92B6\u92CF\u92F1\u92DF\u92D8\u92E9\u92D7\u92DD\u92CC\u92EF\u92C2\u92E8\u92CA\u92C8\u92CE\u92E6\u92CD\u92D5\u92C9\u92E0\u92DE\u92E7\u92D1\u92D3"],
+ ["e8a1", "\u92B5\u92E1\u92C6\u92B4\u957C\u95AC\u95AB\u95AE\u95B0\u96A4\u96A2\u96D3\u9705\u9708\u9702\u975A\u978A\u978E\u9788\u97D0\u97CF\u981E\u981D\u9826\u9829\u9828\u9820\u981B\u9827\u98B2\u9908\u98FA\u9911\u9914\u9916\u9917\u9915\u99DC\u99CD\u99CF\u99D3\u99D4\u99CE\u99C9\u99D6\u99D8\u99CB\u99D7\u99CC\u9AB3\u9AEC\u9AEB\u9AF3\u9AF2\u9AF1\u9B46\u9B43\u9B67\u9B74\u9B71\u9B66\u9B76\u9B75\u9B70\u9B68\u9B64\u9B6C\u9CFC\u9CFA\u9CFD\u9CFF\u9CF7\u9D07\u9D00\u9CF9\u9CFB\u9D08\u9D05\u9D04\u9E83\u9ED3\u9F0F\u9F10\u511C\u5113\u5117\u511A\u5111\u51DE\u5334\u53E1\u5670\u5660\u566E"],
+ ["e940", "\u5673\u5666\u5663\u566D\u5672\u565E\u5677\u571C\u571B\u58C8\u58BD\u58C9\u58BF\u58BA\u58C2\u58BC\u58C6\u5B17\u5B19\u5B1B\u5B21\u5B14\u5B13\u5B10\u5B16\u5B28\u5B1A\u5B20\u5B1E\u5BEF\u5DAC\u5DB1\u5DA9\u5DA7\u5DB5\u5DB0\u5DAE\u5DAA\u5DA8\u5DB2\u5DAD\u5DAF\u5DB4\u5E67\u5E68\u5E66\u5E6F\u5EE9\u5EE7\u5EE6\u5EE8\u5EE5\u5F4B\u5FBC\u619D\u61A8\u6196\u61C5\u61B4\u61C6\u61C1\u61CC\u61BA"],
+ ["e9a1", "\u61BF\u61B8\u618C\u64D7\u64D6\u64D0\u64CF\u64C9\u64BD\u6489\u64C3\u64DB\u64F3\u64D9\u6533\u657F\u657C\u65A2\u66C8\u66BE\u66C0\u66CA\u66CB\u66CF\u66BD\u66BB\u66BA\u66CC\u6723\u6A34\u6A66\u6A49\u6A67\u6A32\u6A68\u6A3E\u6A5D\u6A6D\u6A76\u6A5B\u6A51\u6A28\u6A5A\u6A3B\u6A3F\u6A41\u6A6A\u6A64\u6A50\u6A4F\u6A54\u6A6F\u6A69\u6A60\u6A3C\u6A5E\u6A56\u6A55\u6A4D\u6A4E\u6A46\u6B55\u6B54\u6B56\u6BA7\u6BAA\u6BAB\u6BC8\u6BC7\u6C04\u6C03\u6C06\u6FAD\u6FCB\u6FA3\u6FC7\u6FBC\u6FCE\u6FC8\u6F5E\u6FC4\u6FBD\u6F9E\u6FCA\u6FA8\u7004\u6FA5\u6FAE\u6FBA\u6FAC\u6FAA\u6FCF\u6FBF\u6FB8"],
+ ["ea40", "\u6FA2\u6FC9\u6FAB\u6FCD\u6FAF\u6FB2\u6FB0\u71C5\u71C2\u71BF\u71B8\u71D6\u71C0\u71C1\u71CB\u71D4\u71CA\u71C7\u71CF\u71BD\u71D8\u71BC\u71C6\u71DA\u71DB\u729D\u729E\u7369\u7366\u7367\u736C\u7365\u736B\u736A\u747F\u749A\u74A0\u7494\u7492\u7495\u74A1\u750B\u7580\u762F\u762D\u7631\u763D\u7633\u763C\u7635\u7632\u7630\u76BB\u76E6\u779A\u779D\u77A1\u779C\u779B\u77A2\u77A3\u7795\u7799"],
+ ["eaa1", "\u7797\u78DD\u78E9\u78E5\u78EA\u78DE\u78E3\u78DB\u78E1\u78E2\u78ED\u78DF\u78E0\u79A4\u7A44\u7A48\u7A47\u7AB6\u7AB8\u7AB5\u7AB1\u7AB7\u7BDE\u7BE3\u7BE7\u7BDD\u7BD5\u7BE5\u7BDA\u7BE8\u7BF9\u7BD4\u7BEA\u7BE2\u7BDC\u7BEB\u7BD8\u7BDF\u7CD2\u7CD4\u7CD7\u7CD0\u7CD1\u7E12\u7E21\u7E17\u7E0C\u7E1F\u7E20\u7E13\u7E0E\u7E1C\u7E15\u7E1A\u7E22\u7E0B\u7E0F\u7E16\u7E0D\u7E14\u7E25\u7E24\u7F43\u7F7B\u7F7C\u7F7A\u7FB1\u7FEF\u802A\u8029\u806C\u81B1\u81A6\u81AE\u81B9\u81B5\u81AB\u81B0\u81AC\u81B4\u81B2\u81B7\u81A7\u81F2\u8255\u8256\u8257\u8556\u8545\u856B\u854D\u8553\u8561\u8558"],
+ ["eb40", "\u8540\u8546\u8564\u8541\u8562\u8544\u8551\u8547\u8563\u853E\u855B\u8571\u854E\u856E\u8575\u8555\u8567\u8560\u858C\u8566\u855D\u8554\u8565\u856C\u8663\u8665\u8664\u879B\u878F\u8797\u8793\u8792\u8788\u8781\u8796\u8798\u8779\u8787\u87A3\u8785\u8790\u8791\u879D\u8784\u8794\u879C\u879A\u8789\u891E\u8926\u8930\u892D\u892E\u8927\u8931\u8922\u8929\u8923\u892F\u892C\u891F\u89F1\u8AE0"],
+ ["eba1", "\u8AE2\u8AF2\u8AF4\u8AF5\u8ADD\u8B14\u8AE4\u8ADF\u8AF0\u8AC8\u8ADE\u8AE1\u8AE8\u8AFF\u8AEF\u8AFB\u8C91\u8C92\u8C90\u8CF5\u8CEE\u8CF1\u8CF0\u8CF3\u8D6C\u8D6E\u8DA5\u8DA7\u8E33\u8E3E\u8E38\u8E40\u8E45\u8E36\u8E3C\u8E3D\u8E41\u8E30\u8E3F\u8EBD\u8F36\u8F2E\u8F35\u8F32\u8F39\u8F37\u8F34\u9076\u9079\u907B\u9086\u90FA\u9133\u9135\u9136\u9193\u9190\u9191\u918D\u918F\u9327\u931E\u9308\u931F\u9306\u930F\u937A\u9338\u933C\u931B\u9323\u9312\u9301\u9346\u932D\u930E\u930D\u92CB\u931D\u92FA\u9325\u9313\u92F9\u92F7\u9334\u9302\u9324\u92FF\u9329\u9339\u9335\u932A\u9314\u930C"],
+ ["ec40", "\u930B\u92FE\u9309\u9300\u92FB\u9316\u95BC\u95CD\u95BE\u95B9\u95BA\u95B6\u95BF\u95B5\u95BD\u96A9\u96D4\u970B\u9712\u9710\u9799\u9797\u9794\u97F0\u97F8\u9835\u982F\u9832\u9924\u991F\u9927\u9929\u999E\u99EE\u99EC\u99E5\u99E4\u99F0\u99E3\u99EA\u99E9\u99E7\u9AB9\u9ABF\u9AB4\u9ABB\u9AF6\u9AFA\u9AF9\u9AF7\u9B33\u9B80\u9B85\u9B87\u9B7C\u9B7E\u9B7B\u9B82\u9B93\u9B92\u9B90\u9B7A\u9B95"],
+ ["eca1", "\u9B7D\u9B88\u9D25\u9D17\u9D20\u9D1E\u9D14\u9D29\u9D1D\u9D18\u9D22\u9D10\u9D19\u9D1F\u9E88\u9E86\u9E87\u9EAE\u9EAD\u9ED5\u9ED6\u9EFA\u9F12\u9F3D\u5126\u5125\u5122\u5124\u5120\u5129\u52F4\u5693\u568C\u568D\u5686\u5684\u5683\u567E\u5682\u567F\u5681\u58D6\u58D4\u58CF\u58D2\u5B2D\u5B25\u5B32\u5B23\u5B2C\u5B27\u5B26\u5B2F\u5B2E\u5B7B\u5BF1\u5BF2\u5DB7\u5E6C\u5E6A\u5FBE\u5FBB\u61C3\u61B5\u61BC\u61E7\u61E0\u61E5\u61E4\u61E8\u61DE\u64EF\u64E9\u64E3\u64EB\u64E4\u64E8\u6581\u6580\u65B6\u65DA\u66D2\u6A8D\u6A96\u6A81\u6AA5\u6A89\u6A9F\u6A9B\u6AA1\u6A9E\u6A87\u6A93\u6A8E"],
+ ["ed40", "\u6A95\u6A83\u6AA8\u6AA4\u6A91\u6A7F\u6AA6\u6A9A\u6A85\u6A8C\u6A92\u6B5B\u6BAD\u6C09\u6FCC\u6FA9\u6FF4\u6FD4\u6FE3\u6FDC\u6FED\u6FE7\u6FE6\u6FDE\u6FF2\u6FDD\u6FE2\u6FE8\u71E1\u71F1\u71E8\u71F2\u71E4\u71F0\u71E2\u7373\u736E\u736F\u7497\u74B2\u74AB\u7490\u74AA\u74AD\u74B1\u74A5\u74AF\u7510\u7511\u7512\u750F\u7584\u7643\u7648\u7649\u7647\u76A4\u76E9\u77B5\u77AB\u77B2\u77B7\u77B6"],
+ ["eda1", "\u77B4\u77B1\u77A8\u77F0\u78F3\u78FD\u7902\u78FB\u78FC\u78F2\u7905\u78F9\u78FE\u7904\u79AB\u79A8\u7A5C\u7A5B\u7A56\u7A58\u7A54\u7A5A\u7ABE\u7AC0\u7AC1\u7C05\u7C0F\u7BF2\u7C00\u7BFF\u7BFB\u7C0E\u7BF4\u7C0B\u7BF3\u7C02\u7C09\u7C03\u7C01\u7BF8\u7BFD\u7C06\u7BF0\u7BF1\u7C10\u7C0A\u7CE8\u7E2D\u7E3C\u7E42\u7E33\u9848\u7E38\u7E2A\u7E49\u7E40\u7E47\u7E29\u7E4C\u7E30\u7E3B\u7E36\u7E44\u7E3A\u7F45\u7F7F\u7F7E\u7F7D\u7FF4\u7FF2\u802C\u81BB\u81C4\u81CC\u81CA\u81C5\u81C7\u81BC\u81E9\u825B\u825A\u825C\u8583\u8580\u858F\u85A7\u8595\u85A0\u858B\u85A3\u857B\u85A4\u859A\u859E"],
+ ["ee40", "\u8577\u857C\u8589\u85A1\u857A\u8578\u8557\u858E\u8596\u8586\u858D\u8599\u859D\u8581\u85A2\u8582\u8588\u8585\u8579\u8576\u8598\u8590\u859F\u8668\u87BE\u87AA\u87AD\u87C5\u87B0\u87AC\u87B9\u87B5\u87BC\u87AE\u87C9\u87C3\u87C2\u87CC\u87B7\u87AF\u87C4\u87CA\u87B4\u87B6\u87BF\u87B8\u87BD\u87DE\u87B2\u8935\u8933\u893C\u893E\u8941\u8952\u8937\u8942\u89AD\u89AF\u89AE\u89F2\u89F3\u8B1E"],
+ ["eea1", "\u8B18\u8B16\u8B11\u8B05\u8B0B\u8B22\u8B0F\u8B12\u8B15\u8B07\u8B0D\u8B08\u8B06\u8B1C\u8B13\u8B1A\u8C4F\u8C70\u8C72\u8C71\u8C6F\u8C95\u8C94\u8CF9\u8D6F\u8E4E\u8E4D\u8E53\u8E50\u8E4C\u8E47\u8F43\u8F40\u9085\u907E\u9138\u919A\u91A2\u919B\u9199\u919F\u91A1\u919D\u91A0\u93A1\u9383\u93AF\u9364\u9356\u9347\u937C\u9358\u935C\u9376\u9349\u9350\u9351\u9360\u936D\u938F\u934C\u936A\u9379\u9357\u9355\u9352\u934F\u9371\u9377\u937B\u9361\u935E\u9363\u9367\u9380\u934E\u9359\u95C7\u95C0\u95C9\u95C3\u95C5\u95B7\u96AE\u96B0\u96AC\u9720\u971F\u9718\u971D\u9719\u979A\u97A1\u979C"],
+ ["ef40", "\u979E\u979D\u97D5\u97D4\u97F1\u9841\u9844\u984A\u9849\u9845\u9843\u9925\u992B\u992C\u992A\u9933\u9932\u992F\u992D\u9931\u9930\u9998\u99A3\u99A1\u9A02\u99FA\u99F4\u99F7\u99F9\u99F8\u99F6\u99FB\u99FD\u99FE\u99FC\u9A03\u9ABE\u9AFE\u9AFD\u9B01\u9AFC\u9B48\u9B9A\u9BA8\u9B9E\u9B9B\u9BA6\u9BA1\u9BA5\u9BA4\u9B86\u9BA2\u9BA0\u9BAF\u9D33\u9D41\u9D67\u9D36\u9D2E\u9D2F\u9D31\u9D38\u9D30"],
+ ["efa1", "\u9D45\u9D42\u9D43\u9D3E\u9D37\u9D40\u9D3D\u7FF5\u9D2D\u9E8A\u9E89\u9E8D\u9EB0\u9EC8\u9EDA\u9EFB\u9EFF\u9F24\u9F23\u9F22\u9F54\u9FA0\u5131\u512D\u512E\u5698\u569C\u5697\u569A\u569D\u5699\u5970\u5B3C\u5C69\u5C6A\u5DC0\u5E6D\u5E6E\u61D8\u61DF\u61ED\u61EE\u61F1\u61EA\u61F0\u61EB\u61D6\u61E9\u64FF\u6504\u64FD\u64F8\u6501\u6503\u64FC\u6594\u65DB\u66DA\u66DB\u66D8\u6AC5\u6AB9\u6ABD\u6AE1\u6AC6\u6ABA\u6AB6\u6AB7\u6AC7\u6AB4\u6AAD\u6B5E\u6BC9\u6C0B\u7007\u700C\u700D\u7001\u7005\u7014\u700E\u6FFF\u7000\u6FFB\u7026\u6FFC\u6FF7\u700A\u7201\u71FF\u71F9\u7203\u71FD\u7376"],
+ ["f040", "\u74B8\u74C0\u74B5\u74C1\u74BE\u74B6\u74BB\u74C2\u7514\u7513\u765C\u7664\u7659\u7650\u7653\u7657\u765A\u76A6\u76BD\u76EC\u77C2\u77BA\u78FF\u790C\u7913\u7914\u7909\u7910\u7912\u7911\u79AD\u79AC\u7A5F\u7C1C\u7C29\u7C19\u7C20\u7C1F\u7C2D\u7C1D\u7C26\u7C28\u7C22\u7C25\u7C30\u7E5C\u7E50\u7E56\u7E63\u7E58\u7E62\u7E5F\u7E51\u7E60\u7E57\u7E53\u7FB5\u7FB3\u7FF7\u7FF8\u8075\u81D1\u81D2"],
+ ["f0a1", "\u81D0\u825F\u825E\u85B4\u85C6\u85C0\u85C3\u85C2\u85B3\u85B5\u85BD\u85C7\u85C4\u85BF\u85CB\u85CE\u85C8\u85C5\u85B1\u85B6\u85D2\u8624\u85B8\u85B7\u85BE\u8669\u87E7\u87E6\u87E2\u87DB\u87EB\u87EA\u87E5\u87DF\u87F3\u87E4\u87D4\u87DC\u87D3\u87ED\u87D8\u87E3\u87A4\u87D7\u87D9\u8801\u87F4\u87E8\u87DD\u8953\u894B\u894F\u894C\u8946\u8950\u8951\u8949\u8B2A\u8B27\u8B23\u8B33\u8B30\u8B35\u8B47\u8B2F\u8B3C\u8B3E\u8B31\u8B25\u8B37\u8B26\u8B36\u8B2E\u8B24\u8B3B\u8B3D\u8B3A\u8C42\u8C75\u8C99\u8C98\u8C97\u8CFE\u8D04\u8D02\u8D00\u8E5C\u8E62\u8E60\u8E57\u8E56\u8E5E\u8E65\u8E67"],
+ ["f140", "\u8E5B\u8E5A\u8E61\u8E5D\u8E69\u8E54\u8F46\u8F47\u8F48\u8F4B\u9128\u913A\u913B\u913E\u91A8\u91A5\u91A7\u91AF\u91AA\u93B5\u938C\u9392\u93B7\u939B\u939D\u9389\u93A7\u938E\u93AA\u939E\u93A6\u9395\u9388\u9399\u939F\u938D\u93B1\u9391\u93B2\u93A4\u93A8\u93B4\u93A3\u93A5\u95D2\u95D3\u95D1\u96B3\u96D7\u96DA\u5DC2\u96DF\u96D8\u96DD\u9723\u9722\u9725\u97AC\u97AE\u97A8\u97AB\u97A4\u97AA"],
+ ["f1a1", "\u97A2\u97A5\u97D7\u97D9\u97D6\u97D8\u97FA\u9850\u9851\u9852\u98B8\u9941\u993C\u993A\u9A0F\u9A0B\u9A09\u9A0D\u9A04\u9A11\u9A0A\u9A05\u9A07\u9A06\u9AC0\u9ADC\u9B08\u9B04\u9B05\u9B29\u9B35\u9B4A\u9B4C\u9B4B\u9BC7\u9BC6\u9BC3\u9BBF\u9BC1\u9BB5\u9BB8\u9BD3\u9BB6\u9BC4\u9BB9\u9BBD\u9D5C\u9D53\u9D4F\u9D4A\u9D5B\u9D4B\u9D59\u9D56\u9D4C\u9D57\u9D52\u9D54\u9D5F\u9D58\u9D5A\u9E8E\u9E8C\u9EDF\u9F01\u9F00\u9F16\u9F25\u9F2B\u9F2A\u9F29\u9F28\u9F4C\u9F55\u5134\u5135\u5296\u52F7\u53B4\u56AB\u56AD\u56A6\u56A7\u56AA\u56AC\u58DA\u58DD\u58DB\u5912\u5B3D\u5B3E\u5B3F\u5DC3\u5E70"],
+ ["f240", "\u5FBF\u61FB\u6507\u6510\u650D\u6509\u650C\u650E\u6584\u65DE\u65DD\u66DE\u6AE7\u6AE0\u6ACC\u6AD1\u6AD9\u6ACB\u6ADF\u6ADC\u6AD0\u6AEB\u6ACF\u6ACD\u6ADE\u6B60\u6BB0\u6C0C\u7019\u7027\u7020\u7016\u702B\u7021\u7022\u7023\u7029\u7017\u7024\u701C\u702A\u720C\u720A\u7207\u7202\u7205\u72A5\u72A6\u72A4\u72A3\u72A1\u74CB\u74C5\u74B7\u74C3\u7516\u7660\u77C9\u77CA\u77C4\u77F1\u791D\u791B"],
+ ["f2a1", "\u7921\u791C\u7917\u791E\u79B0\u7A67\u7A68\u7C33\u7C3C\u7C39\u7C2C\u7C3B\u7CEC\u7CEA\u7E76\u7E75\u7E78\u7E70\u7E77\u7E6F\u7E7A\u7E72\u7E74\u7E68\u7F4B\u7F4A\u7F83\u7F86\u7FB7\u7FFD\u7FFE\u8078\u81D7\u81D5\u8264\u8261\u8263\u85EB\u85F1\u85ED\u85D9\u85E1\u85E8\u85DA\u85D7\u85EC\u85F2\u85F8\u85D8\u85DF\u85E3\u85DC\u85D1\u85F0\u85E6\u85EF\u85DE\u85E2\u8800\u87FA\u8803\u87F6\u87F7\u8809\u880C\u880B\u8806\u87FC\u8808\u87FF\u880A\u8802\u8962\u895A\u895B\u8957\u8961\u895C\u8958\u895D\u8959\u8988\u89B7\u89B6\u89F6\u8B50\u8B48\u8B4A\u8B40\u8B53\u8B56\u8B54\u8B4B\u8B55"],
+ ["f340", "\u8B51\u8B42\u8B52\u8B57\u8C43\u8C77\u8C76\u8C9A\u8D06\u8D07\u8D09\u8DAC\u8DAA\u8DAD\u8DAB\u8E6D\u8E78\u8E73\u8E6A\u8E6F\u8E7B\u8EC2\u8F52\u8F51\u8F4F\u8F50\u8F53\u8FB4\u9140\u913F\u91B0\u91AD\u93DE\u93C7\u93CF\u93C2\u93DA\u93D0\u93F9\u93EC\u93CC\u93D9\u93A9\u93E6\u93CA\u93D4\u93EE\u93E3\u93D5\u93C4\u93CE\u93C0\u93D2\u93E7\u957D\u95DA\u95DB\u96E1\u9729\u972B\u972C\u9728\u9726"],
+ ["f3a1", "\u97B3\u97B7\u97B6\u97DD\u97DE\u97DF\u985C\u9859\u985D\u9857\u98BF\u98BD\u98BB\u98BE\u9948\u9947\u9943\u99A6\u99A7\u9A1A\u9A15\u9A25\u9A1D\u9A24\u9A1B\u9A22\u9A20\u9A27\u9A23\u9A1E\u9A1C\u9A14\u9AC2\u9B0B\u9B0A\u9B0E\u9B0C\u9B37\u9BEA\u9BEB\u9BE0\u9BDE\u9BE4\u9BE6\u9BE2\u9BF0\u9BD4\u9BD7\u9BEC\u9BDC\u9BD9\u9BE5\u9BD5\u9BE1\u9BDA\u9D77\u9D81\u9D8A\u9D84\u9D88\u9D71\u9D80\u9D78\u9D86\u9D8B\u9D8C\u9D7D\u9D6B\u9D74\u9D75\u9D70\u9D69\u9D85\u9D73\u9D7B\u9D82\u9D6F\u9D79\u9D7F\u9D87\u9D68\u9E94\u9E91\u9EC0\u9EFC\u9F2D\u9F40\u9F41\u9F4D\u9F56\u9F57\u9F58\u5337\u56B2"],
+ ["f440", "\u56B5\u56B3\u58E3\u5B45\u5DC6\u5DC7\u5EEE\u5EEF\u5FC0\u5FC1\u61F9\u6517\u6516\u6515\u6513\u65DF\u66E8\u66E3\u66E4\u6AF3\u6AF0\u6AEA\u6AE8\u6AF9\u6AF1\u6AEE\u6AEF\u703C\u7035\u702F\u7037\u7034\u7031\u7042\u7038\u703F\u703A\u7039\u7040\u703B\u7033\u7041\u7213\u7214\u72A8\u737D\u737C\u74BA\u76AB\u76AA\u76BE\u76ED\u77CC\u77CE\u77CF\u77CD\u77F2\u7925\u7923\u7927\u7928\u7924\u7929"],
+ ["f4a1", "\u79B2\u7A6E\u7A6C\u7A6D\u7AF7\u7C49\u7C48\u7C4A\u7C47\u7C45\u7CEE\u7E7B\u7E7E\u7E81\u7E80\u7FBA\u7FFF\u8079\u81DB\u81D9\u820B\u8268\u8269\u8622\u85FF\u8601\u85FE\u861B\u8600\u85F6\u8604\u8609\u8605\u860C\u85FD\u8819\u8810\u8811\u8817\u8813\u8816\u8963\u8966\u89B9\u89F7\u8B60\u8B6A\u8B5D\u8B68\u8B63\u8B65\u8B67\u8B6D\u8DAE\u8E86\u8E88\u8E84\u8F59\u8F56\u8F57\u8F55\u8F58\u8F5A\u908D\u9143\u9141\u91B7\u91B5\u91B2\u91B3\u940B\u9413\u93FB\u9420\u940F\u9414\u93FE\u9415\u9410\u9428\u9419\u940D\u93F5\u9400\u93F7\u9407\u940E\u9416\u9412\u93FA\u9409\u93F8\u940A\u93FF"],
+ ["f540", "\u93FC\u940C\u93F6\u9411\u9406\u95DE\u95E0\u95DF\u972E\u972F\u97B9\u97BB\u97FD\u97FE\u9860\u9862\u9863\u985F\u98C1\u98C2\u9950\u994E\u9959\u994C\u994B\u9953\u9A32\u9A34\u9A31\u9A2C\u9A2A\u9A36\u9A29\u9A2E\u9A38\u9A2D\u9AC7\u9ACA\u9AC6\u9B10\u9B12\u9B11\u9C0B\u9C08\u9BF7\u9C05\u9C12\u9BF8\u9C40\u9C07\u9C0E\u9C06\u9C17\u9C14\u9C09\u9D9F\u9D99\u9DA4\u9D9D\u9D92\u9D98\u9D90\u9D9B"],
+ ["f5a1", "\u9DA0\u9D94\u9D9C\u9DAA\u9D97\u9DA1\u9D9A\u9DA2\u9DA8\u9D9E\u9DA3\u9DBF\u9DA9\u9D96\u9DA6\u9DA7\u9E99\u9E9B\u9E9A\u9EE5\u9EE4\u9EE7\u9EE6\u9F30\u9F2E\u9F5B\u9F60\u9F5E\u9F5D\u9F59\u9F91\u513A\u5139\u5298\u5297\u56C3\u56BD\u56BE\u5B48\u5B47\u5DCB\u5DCF\u5EF1\u61FD\u651B\u6B02\u6AFC\u6B03\u6AF8\u6B00\u7043\u7044\u704A\u7048\u7049\u7045\u7046\u721D\u721A\u7219\u737E\u7517\u766A\u77D0\u792D\u7931\u792F\u7C54\u7C53\u7CF2\u7E8A\u7E87\u7E88\u7E8B\u7E86\u7E8D\u7F4D\u7FBB\u8030\u81DD\u8618\u862A\u8626\u861F\u8623\u861C\u8619\u8627\u862E\u8621\u8620\u8629\u861E\u8625"],
+ ["f640", "\u8829\u881D\u881B\u8820\u8824\u881C\u882B\u884A\u896D\u8969\u896E\u896B\u89FA\u8B79\u8B78\u8B45\u8B7A\u8B7B\u8D10\u8D14\u8DAF\u8E8E\u8E8C\u8F5E\u8F5B\u8F5D\u9146\u9144\u9145\u91B9\u943F\u943B\u9436\u9429\u943D\u943C\u9430\u9439\u942A\u9437\u942C\u9440\u9431\u95E5\u95E4\u95E3\u9735\u973A\u97BF\u97E1\u9864\u98C9\u98C6\u98C0\u9958\u9956\u9A39\u9A3D\u9A46\u9A44\u9A42\u9A41\u9A3A"],
+ ["f6a1", "\u9A3F\u9ACD\u9B15\u9B17\u9B18\u9B16\u9B3A\u9B52\u9C2B\u9C1D\u9C1C\u9C2C\u9C23\u9C28\u9C29\u9C24\u9C21\u9DB7\u9DB6\u9DBC\u9DC1\u9DC7\u9DCA\u9DCF\u9DBE\u9DC5\u9DC3\u9DBB\u9DB5\u9DCE\u9DB9\u9DBA\u9DAC\u9DC8\u9DB1\u9DAD\u9DCC\u9DB3\u9DCD\u9DB2\u9E7A\u9E9C\u9EEB\u9EEE\u9EED\u9F1B\u9F18\u9F1A\u9F31\u9F4E\u9F65\u9F64\u9F92\u4EB9\u56C6\u56C5\u56CB\u5971\u5B4B\u5B4C\u5DD5\u5DD1\u5EF2\u6521\u6520\u6526\u6522\u6B0B\u6B08\u6B09\u6C0D\u7055\u7056\u7057\u7052\u721E\u721F\u72A9\u737F\u74D8\u74D5\u74D9\u74D7\u766D\u76AD\u7935\u79B4\u7A70\u7A71\u7C57\u7C5C\u7C59\u7C5B\u7C5A"],
+ ["f740", "\u7CF4\u7CF1\u7E91\u7F4F\u7F87\u81DE\u826B\u8634\u8635\u8633\u862C\u8632\u8636\u882C\u8828\u8826\u882A\u8825\u8971\u89BF\u89BE\u89FB\u8B7E\u8B84\u8B82\u8B86\u8B85\u8B7F\u8D15\u8E95\u8E94\u8E9A\u8E92\u8E90\u8E96\u8E97\u8F60\u8F62\u9147\u944C\u9450\u944A\u944B\u944F\u9447\u9445\u9448\u9449\u9446\u973F\u97E3\u986A\u9869\u98CB\u9954\u995B\u9A4E\u9A53\u9A54\u9A4C\u9A4F\u9A48\u9A4A"],
+ ["f7a1", "\u9A49\u9A52\u9A50\u9AD0\u9B19\u9B2B\u9B3B\u9B56\u9B55\u9C46\u9C48\u9C3F\u9C44\u9C39\u9C33\u9C41\u9C3C\u9C37\u9C34\u9C32\u9C3D\u9C36\u9DDB\u9DD2\u9DDE\u9DDA\u9DCB\u9DD0\u9DDC\u9DD1\u9DDF\u9DE9\u9DD9\u9DD8\u9DD6\u9DF5\u9DD5\u9DDD\u9EB6\u9EF0\u9F35\u9F33\u9F32\u9F42\u9F6B\u9F95\u9FA2\u513D\u5299\u58E8\u58E7\u5972\u5B4D\u5DD8\u882F\u5F4F\u6201\u6203\u6204\u6529\u6525\u6596\u66EB\u6B11\u6B12\u6B0F\u6BCA\u705B\u705A\u7222\u7382\u7381\u7383\u7670\u77D4\u7C67\u7C66\u7E95\u826C\u863A\u8640\u8639\u863C\u8631\u863B\u863E\u8830\u8832\u882E\u8833\u8976\u8974\u8973\u89FE"],
+ ["f840", "\u8B8C\u8B8E\u8B8B\u8B88\u8C45\u8D19\u8E98\u8F64\u8F63\u91BC\u9462\u9455\u945D\u9457\u945E\u97C4\u97C5\u9800\u9A56\u9A59\u9B1E\u9B1F\u9B20\u9C52\u9C58\u9C50\u9C4A\u9C4D\u9C4B\u9C55\u9C59\u9C4C\u9C4E\u9DFB\u9DF7\u9DEF\u9DE3\u9DEB\u9DF8\u9DE4\u9DF6\u9DE1\u9DEE\u9DE6\u9DF2\u9DF0\u9DE2\u9DEC\u9DF4\u9DF3\u9DE8\u9DED\u9EC2\u9ED0\u9EF2\u9EF3\u9F06\u9F1C\u9F38\u9F37\u9F36\u9F43\u9F4F"],
+ ["f8a1", "\u9F71\u9F70\u9F6E\u9F6F\u56D3\u56CD\u5B4E\u5C6D\u652D\u66ED\u66EE\u6B13\u705F\u7061\u705D\u7060\u7223\u74DB\u74E5\u77D5\u7938\u79B7\u79B6\u7C6A\u7E97\u7F89\u826D\u8643\u8838\u8837\u8835\u884B\u8B94\u8B95\u8E9E\u8E9F\u8EA0\u8E9D\u91BE\u91BD\u91C2\u946B\u9468\u9469\u96E5\u9746\u9743\u9747\u97C7\u97E5\u9A5E\u9AD5\u9B59\u9C63\u9C67\u9C66\u9C62\u9C5E\u9C60\u9E02\u9DFE\u9E07\u9E03\u9E06\u9E05\u9E00\u9E01\u9E09\u9DFF\u9DFD\u9E04\u9EA0\u9F1E\u9F46\u9F74\u9F75\u9F76\u56D4\u652E\u65B8\u6B18\u6B19\u6B17\u6B1A\u7062\u7226\u72AA\u77D8\u77D9\u7939\u7C69\u7C6B\u7CF6\u7E9A"],
+ ["f940", "\u7E98\u7E9B\u7E99\u81E0\u81E1\u8646\u8647\u8648\u8979\u897A\u897C\u897B\u89FF\u8B98\u8B99\u8EA5\u8EA4\u8EA3\u946E\u946D\u946F\u9471\u9473\u9749\u9872\u995F\u9C68\u9C6E\u9C6D\u9E0B\u9E0D\u9E10\u9E0F\u9E12\u9E11\u9EA1\u9EF5\u9F09\u9F47\u9F78\u9F7B\u9F7A\u9F79\u571E\u7066\u7C6F\u883C\u8DB2\u8EA6\u91C3\u9474\u9478\u9476\u9475\u9A60\u9C74\u9C73\u9C71\u9C75\u9E14\u9E13\u9EF6\u9F0A"],
+ ["f9a1", "\u9FA4\u7068\u7065\u7CF7\u866A\u883E\u883D\u883F\u8B9E\u8C9C\u8EA9\u8EC9\u974B\u9873\u9874\u98CC\u9961\u99AB\u9A64\u9A66\u9A67\u9B24\u9E15\u9E17\u9F48\u6207\u6B1E\u7227\u864C\u8EA8\u9482\u9480\u9481\u9A69\u9A68\u9B2E\u9E19\u7229\u864B\u8B9F\u9483\u9C79\u9EB7\u7675\u9A6B\u9C7A\u9E1D\u7069\u706A\u9EA4\u9F7E\u9F49\u9F98\u7881\u92B9\u88CF\u58BB\u6052\u7CA7\u5AFA\u2554\u2566\u2557\u2560\u256C\u2563\u255A\u2569\u255D\u2552\u2564\u2555\u255E\u256A\u2561\u2558\u2567\u255B\u2553\u2565\u2556\u255F\u256B\u2562\u2559\u2568\u255C\u2551\u2550\u256D\u256E\u2570\u256F\u2593"]
+ ];
+ }
+});
+
+// ../../node_modules/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/encodings/tables/big5-added.json
+var require_big5_added = __commonJS({
+ "../../node_modules/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/encodings/tables/big5-added.json"(exports2, module2) {
+ module2.exports = [
+ ["8740", "\u43F0\u4C32\u4603\u45A6\u4578\u{27267}\u4D77\u45B3\u{27CB1}\u4CE2\u{27CC5}\u3B95\u4736\u4744\u4C47\u4C40\u{242BF}\u{23617}\u{27352}\u{26E8B}\u{270D2}\u4C57\u{2A351}\u474F\u45DA\u4C85\u{27C6C}\u4D07\u4AA4\u46A1\u{26B23}\u7225\u{25A54}\u{21A63}\u{23E06}\u{23F61}\u664D\u56FB"],
+ ["8767", "\u7D95\u591D\u{28BB9}\u3DF4\u9734\u{27BEF}\u5BDB\u{21D5E}\u5AA4\u3625\u{29EB0}\u5AD1\u5BB7\u5CFC\u676E\u8593\u{29945}\u7461\u749D\u3875\u{21D53}\u{2369E}\u{26021}\u3EEC"],
+ ["87a1", "\u{258DE}\u3AF5\u7AFC\u9F97\u{24161}\u{2890D}\u{231EA}\u{20A8A}\u{2325E}\u430A\u8484\u9F96\u942F\u4930\u8613\u5896\u974A\u9218\u79D0\u7A32\u6660\u6A29\u889D\u744C\u7BC5\u6782\u7A2C\u524F\u9046\u34E6\u73C4\u{25DB9}\u74C6\u9FC7\u57B3\u492F\u544C\u4131\u{2368E}\u5818\u7A72\u{27B65}\u8B8F\u46AE\u{26E88}\u4181\u{25D99}\u7BAE\u{224BC}\u9FC8\u{224C1}\u{224C9}\u{224CC}\u9FC9\u8504\u{235BB}\u40B4\u9FCA\u44E1\u{2ADFF}\u62C1\u706E\u9FCB"],
+ ["8840", "\u31C0", 4, "\u{2010C}\u31C5\u{200D1}\u{200CD}\u31C6\u31C7\u{200CB}\u{21FE8}\u31C8\u{200CA}\u31C9\u31CA\u31CB\u31CC\u{2010E}\u31CD\u31CE\u0100\xC1\u01CD\xC0\u0112\xC9\u011A\xC8\u014C\xD3\u01D1\xD2\u0FFF\xCA\u0304\u1EBE\u0FFF\xCA\u030C\u1EC0\xCA\u0101\xE1\u01CE\xE0\u0251\u0113\xE9\u011B\xE8\u012B\xED\u01D0\xEC\u014D\xF3\u01D2\xF2\u016B\xFA\u01D4\xF9\u01D6\u01D8\u01DA"],
+ ["88a1", "\u01DC\xFC\u0FFF\xEA\u0304\u1EBF\u0FFF\xEA\u030C\u1EC1\xEA\u0261\u23DA\u23DB"],
+ ["8940", "\u{2A3A9}\u{21145}"],
+ ["8943", "\u650A"],
+ ["8946", "\u4E3D\u6EDD\u9D4E\u91DF"],
+ ["894c", "\u{27735}\u6491\u4F1A\u4F28\u4FA8\u5156\u5174\u519C\u51E4\u52A1\u52A8\u533B\u534E\u53D1\u53D8\u56E2\u58F0\u5904\u5907\u5932\u5934\u5B66\u5B9E\u5B9F\u5C9A\u5E86\u603B\u6589\u67FE\u6804\u6865\u6D4E\u70BC\u7535\u7EA4\u7EAC\u7EBA\u7EC7\u7ECF\u7EDF\u7F06\u7F37\u827A\u82CF\u836F\u89C6\u8BBE\u8BE2\u8F66\u8F67\u8F6E"],
+ ["89a1", "\u7411\u7CFC\u7DCD\u6946\u7AC9\u5227"],
+ ["89ab", "\u918C\u78B8\u915E\u80BC"],
+ ["89b0", "\u8D0B\u80F6\u{209E7}"],
+ ["89b5", "\u809F\u9EC7\u4CCD\u9DC9\u9E0C\u4C3E\u{29DF6}\u{2700E}\u9E0A\u{2A133}\u35C1"],
+ ["89c1", "\u6E9A\u823E\u7519"],
+ ["89c5", "\u4911\u9A6C\u9A8F\u9F99\u7987\u{2846C}\u{21DCA}\u{205D0}\u{22AE6}\u4E24\u4E81\u4E80\u4E87\u4EBF\u4EEB\u4F37\u344C\u4FBD\u3E48\u5003\u5088\u347D\u3493\u34A5\u5186\u5905\u51DB\u51FC\u5205\u4E89\u5279\u5290\u5327\u35C7\u53A9\u3551\u53B0\u3553\u53C2\u5423\u356D\u3572\u3681\u5493\u54A3\u54B4\u54B9\u54D0\u54EF\u5518\u5523\u5528\u3598\u553F\u35A5\u35BF\u55D7\u35C5"],
+ ["8a40", "\u{27D84}\u5525"],
+ ["8a43", "\u{20C42}\u{20D15}\u{2512B}\u5590\u{22CC6}\u39EC\u{20341}\u8E46\u{24DB8}\u{294E5}\u4053\u{280BE}\u777A\u{22C38}\u3A34\u47D5\u{2815D}\u{269F2}\u{24DEA}\u64DD\u{20D7C}\u{20FB4}\u{20CD5}\u{210F4}\u648D\u8E7E\u{20E96}\u{20C0B}\u{20F64}\u{22CA9}\u{28256}\u{244D3}"],
+ ["8a64", "\u{20D46}\u{29A4D}\u{280E9}\u47F4\u{24EA7}\u{22CC2}\u9AB2\u3A67\u{295F4}\u3FED\u3506\u{252C7}\u{297D4}\u{278C8}\u{22D44}\u9D6E\u9815"],
+ ["8a76", "\u43D9\u{260A5}\u64B4\u54E3\u{22D4C}\u{22BCA}\u{21077}\u39FB\u{2106F}"],
+ ["8aa1", "\u{266DA}\u{26716}\u{279A0}\u64EA\u{25052}\u{20C43}\u8E68\u{221A1}\u{28B4C}\u{20731}"],
+ ["8aac", "\u480B\u{201A9}\u3FFA\u5873\u{22D8D}"],
+ ["8ab2", "\u{245C8}\u{204FC}\u{26097}\u{20F4C}\u{20D96}\u5579\u40BB\u43BA"],
+ ["8abb", "\u4AB4\u{22A66}\u{2109D}\u81AA\u98F5\u{20D9C}\u6379\u39FE\u{22775}\u8DC0\u56A1\u647C\u3E43"],
+ ["8ac9", "\u{2A601}\u{20E09}\u{22ACF}\u{22CC9}"],
+ ["8ace", "\u{210C8}\u{239C2}\u3992\u3A06\u{2829B}\u3578\u{25E49}\u{220C7}\u5652\u{20F31}\u{22CB2}\u{29720}\u34BC\u6C3D\u{24E3B}"],
+ ["8adf", "\u{27574}\u{22E8B}\u{22208}\u{2A65B}\u{28CCD}\u{20E7A}\u{20C34}\u{2681C}\u7F93\u{210CF}\u{22803}\u{22939}\u35FB\u{251E3}\u{20E8C}\u{20F8D}\u{20EAA}\u3F93\u{20F30}\u{20D47}\u{2114F}\u{20E4C}"],
+ ["8af6", "\u{20EAB}\u{20BA9}\u{20D48}\u{210C0}\u{2113D}\u3FF9\u{22696}\u6432\u{20FAD}"],
+ ["8b40", "\u{233F4}\u{27639}\u{22BCE}\u{20D7E}\u{20D7F}\u{22C51}\u{22C55}\u3A18\u{20E98}\u{210C7}\u{20F2E}\u{2A632}\u{26B50}\u{28CD2}\u{28D99}\u{28CCA}\u95AA\u54CC\u82C4\u55B9"],
+ ["8b55", "\u{29EC3}\u9C26\u9AB6\u{2775E}\u{22DEE}\u7140\u816D\u80EC\u5C1C\u{26572}\u8134\u3797\u535F\u{280BD}\u91B6\u{20EFA}\u{20E0F}\u{20E77}\u{20EFB}\u35DD\u{24DEB}\u3609\u{20CD6}\u56AF\u{227B5}\u{210C9}\u{20E10}\u{20E78}\u{21078}\u{21148}\u{28207}\u{21455}\u{20E79}\u{24E50}\u{22DA4}\u5A54\u{2101D}\u{2101E}\u{210F5}\u{210F6}\u579C\u{20E11}"],
+ ["8ba1", "\u{27694}\u{282CD}\u{20FB5}\u{20E7B}\u{2517E}\u3703\u{20FB6}\u{21180}\u{252D8}\u{2A2BD}\u{249DA}\u{2183A}\u{24177}\u{2827C}\u5899\u5268\u361A\u{2573D}\u7BB2\u5B68\u4800\u4B2C\u9F27\u49E7\u9C1F\u9B8D\u{25B74}\u{2313D}\u55FB\u35F2\u5689\u4E28\u5902\u{21BC1}\u{2F878}\u9751\u{20086}\u4E5B\u4EBB\u353E\u5C23\u5F51\u5FC4\u38FA\u624C\u6535\u6B7A\u6C35\u6C3A\u706C\u722B\u4E2C\u72AD\u{248E9}\u7F52\u793B\u7CF9\u7F53\u{2626A}\u34C1"],
+ ["8bde", "\u{2634B}\u8002\u8080\u{26612}\u{26951}\u535D\u8864\u89C1\u{278B2}\u8BA0\u8D1D\u9485\u9578\u957F\u95E8\u{28E0F}\u97E6\u9875\u98CE\u98DE\u9963\u{29810}\u9C7C\u9E1F\u9EC4\u6B6F\uF907\u4E37\u{20087}\u961D\u6237\u94A2"],
+ ["8c40", "\u503B\u6DFE\u{29C73}\u9FA6\u3DC9\u888F\u{2414E}\u7077\u5CF5\u4B20\u{251CD}\u3559\u{25D30}\u6122\u{28A32}\u8FA7\u91F6\u7191\u6719\u73BA\u{23281}\u{2A107}\u3C8B\u{21980}\u4B10\u78E4\u7402\u51AE\u{2870F}\u4009\u6A63\u{2A2BA}\u4223\u860F\u{20A6F}\u7A2A\u{29947}\u{28AEA}\u9755\u704D\u5324\u{2207E}\u93F4\u76D9\u{289E3}\u9FA7\u77DD\u4EA3\u4FF0\u50BC\u4E2F\u4F17\u9FA8\u5434\u7D8B\u5892\u58D0\u{21DB6}\u5E92\u5E99\u5FC2\u{22712}\u658B"],
+ ["8ca1", "\u{233F9}\u6919\u6A43\u{23C63}\u6CFF"],
+ ["8ca7", "\u7200\u{24505}\u738C\u3EDB\u{24A13}\u5B15\u74B9\u8B83\u{25CA4}\u{25695}\u7A93\u7BEC\u7CC3\u7E6C\u82F8\u8597\u9FA9\u8890\u9FAA\u8EB9\u9FAB\u8FCF\u855F\u99E0\u9221\u9FAC\u{28DB9}\u{2143F}\u4071\u42A2\u5A1A"],
+ ["8cc9", "\u9868\u676B\u4276\u573D"],
+ ["8cce", "\u85D6\u{2497B}\u82BF\u{2710D}\u4C81\u{26D74}\u5D7B\u{26B15}\u{26FBE}\u9FAD\u9FAE\u5B96\u9FAF\u66E7\u7E5B\u6E57\u79CA\u3D88\u44C3\u{23256}\u{22796}\u439A\u4536"],
+ ["8ce6", "\u5CD5\u{23B1A}\u8AF9\u5C78\u3D12\u{23551}\u5D78\u9FB2\u7157\u4558\u{240EC}\u{21E23}\u4C77\u3978\u344A\u{201A4}\u{26C41}\u8ACC\u4FB4\u{20239}\u59BF\u816C\u9856\u{298FA}\u5F3B"],
+ ["8d40", "\u{20B9F}"],
+ ["8d42", "\u{221C1}\u{2896D}\u4102\u46BB\u{29079}\u3F07\u9FB3\u{2A1B5}\u40F8\u37D6\u46F7\u{26C46}\u417C\u{286B2}\u{273FF}\u456D\u38D4\u{2549A}\u4561\u451B\u4D89\u4C7B\u4D76\u45EA\u3FC8\u{24B0F}\u3661\u44DE\u44BD\u41ED\u5D3E\u5D48\u5D56\u3DFC\u380F\u5DA4\u5DB9\u3820\u3838\u5E42\u5EBD\u5F25\u5F83\u3908\u3914\u393F\u394D\u60D7\u613D\u5CE5\u3989\u61B7\u61B9\u61CF\u39B8\u622C\u6290\u62E5\u6318\u39F8\u56B1"],
+ ["8da1", "\u3A03\u63E2\u63FB\u6407\u645A\u3A4B\u64C0\u5D15\u5621\u9F9F\u3A97\u6586\u3ABD\u65FF\u6653\u3AF2\u6692\u3B22\u6716\u3B42\u67A4\u6800\u3B58\u684A\u6884\u3B72\u3B71\u3B7B\u6909\u6943\u725C\u6964\u699F\u6985\u3BBC\u69D6\u3BDD\u6A65\u6A74\u6A71\u6A82\u3BEC\u6A99\u3BF2\u6AAB\u6AB5\u6AD4\u6AF6\u6B81\u6BC1\u6BEA\u6C75\u6CAA\u3CCB\u6D02\u6D06\u6D26\u6D81\u3CEF\u6DA4\u6DB1\u6E15\u6E18\u6E29\u6E86\u{289C0}\u6EBB\u6EE2\u6EDA\u9F7F\u6EE8\u6EE9\u6F24\u6F34\u3D46\u{23F41}\u6F81\u6FBE\u3D6A\u3D75\u71B7\u5C99\u3D8A\u702C\u3D91\u7050\u7054\u706F\u707F\u7089\u{20325}\u43C1\u35F1\u{20ED8}"],
+ ["8e40", "\u{23ED7}\u57BE\u{26ED3}\u713E\u{257E0}\u364E\u69A2\u{28BE9}\u5B74\u7A49\u{258E1}\u{294D9}\u7A65\u7A7D\u{259AC}\u7ABB\u7AB0\u7AC2\u7AC3\u71D1\u{2648D}\u41CA\u7ADA\u7ADD\u7AEA\u41EF\u54B2\u{25C01}\u7B0B\u7B55\u7B29\u{2530E}\u{25CFE}\u7BA2\u7B6F\u839C\u{25BB4}\u{26C7F}\u7BD0\u8421\u7B92\u7BB8\u{25D20}\u3DAD\u{25C65}\u8492\u7BFA\u7C06\u7C35\u{25CC1}\u7C44\u7C83\u{24882}\u7CA6\u667D\u{24578}\u7CC9\u7CC7\u7CE6\u7C74\u7CF3\u7CF5\u7CCE"],
+ ["8ea1", "\u7E67\u451D\u{26E44}\u7D5D\u{26ED6}\u748D\u7D89\u7DAB\u7135\u7DB3\u7DD2\u{24057}\u{26029}\u7DE4\u3D13\u7DF5\u{217F9}\u7DE5\u{2836D}\u7E1D\u{26121}\u{2615A}\u7E6E\u7E92\u432B\u946C\u7E27\u7F40\u7F41\u7F47\u7936\u{262D0}\u99E1\u7F97\u{26351}\u7FA3\u{21661}\u{20068}\u455C\u{23766}\u4503\u{2833A}\u7FFA\u{26489}\u8005\u8008\u801D\u8028\u802F\u{2A087}\u{26CC3}\u803B\u803C\u8061\u{22714}\u4989\u{26626}\u{23DE3}\u{266E8}\u6725\u80A7\u{28A48}\u8107\u811A\u58B0\u{226F6}\u6C7F\u{26498}\u{24FB8}\u64E7\u{2148A}\u8218\u{2185E}\u6A53\u{24A65}\u{24A95}\u447A\u8229\u{20B0D}\u{26A52}\u{23D7E}\u4FF9\u{214FD}\u84E2\u8362\u{26B0A}\u{249A7}\u{23530}\u{21773}\u{23DF8}\u82AA\u691B\u{2F994}\u41DB"],
+ ["8f40", "\u854B\u82D0\u831A\u{20E16}\u{217B4}\u36C1\u{2317D}\u{2355A}\u827B\u82E2\u8318\u{23E8B}\u{26DA3}\u{26B05}\u{26B97}\u{235CE}\u3DBF\u831D\u55EC\u8385\u450B\u{26DA5}\u83AC\u83C1\u83D3\u347E\u{26ED4}\u6A57\u855A\u3496\u{26E42}\u{22EEF}\u8458\u{25BE4}\u8471\u3DD3\u44E4\u6AA7\u844A\u{23CB5}\u7958\u84A8\u{26B96}\u{26E77}\u{26E43}\u84DE\u840F\u8391\u44A0\u8493\u84E4\u{25C91}\u4240\u{25CC0}\u4543\u8534\u5AF2\u{26E99}\u4527\u8573\u4516\u67BF\u8616"],
+ ["8fa1", "\u{28625}\u{2863B}\u85C1\u{27088}\u8602\u{21582}\u{270CD}\u{2F9B2}\u456A\u8628\u3648\u{218A2}\u53F7\u{2739A}\u867E\u8771\u{2A0F8}\u87EE\u{22C27}\u87B1\u87DA\u880F\u5661\u866C\u6856\u460F\u8845\u8846\u{275E0}\u{23DB9}\u{275E4}\u885E\u889C\u465B\u88B4\u88B5\u63C1\u88C5\u7777\u{2770F}\u8987\u898A\u89A6\u89A9\u89A7\u89BC\u{28A25}\u89E7\u{27924}\u{27ABD}\u8A9C\u7793\u91FE\u8A90\u{27A59}\u7AE9\u{27B3A}\u{23F8F}\u4713\u{27B38}\u717C\u8B0C\u8B1F\u{25430}\u{25565}\u8B3F\u8B4C\u8B4D\u8AA9\u{24A7A}\u8B90\u8B9B\u8AAF\u{216DF}\u4615\u884F\u8C9B\u{27D54}\u{27D8F}\u{2F9D4}\u3725\u{27D53}\u8CD6\u{27D98}\u{27DBD}\u8D12\u8D03\u{21910}\u8CDB\u705C\u8D11\u{24CC9}\u3ED0\u8D77"],
+ ["9040", "\u8DA9\u{28002}\u{21014}\u{2498A}\u3B7C\u{281BC}\u{2710C}\u7AE7\u8EAD\u8EB6\u8EC3\u92D4\u8F19\u8F2D\u{28365}\u{28412}\u8FA5\u9303\u{2A29F}\u{20A50}\u8FB3\u492A\u{289DE}\u{2853D}\u{23DBB}\u5EF8\u{23262}\u8FF9\u{2A014}\u{286BC}\u{28501}\u{22325}\u3980\u{26ED7}\u9037\u{2853C}\u{27ABE}\u9061\u{2856C}\u{2860B}\u90A8\u{28713}\u90C4\u{286E6}\u90AE\u90FD\u9167\u3AF0\u91A9\u91C4\u7CAC\u{28933}\u{21E89}\u920E\u6C9F\u9241\u9262\u{255B9}\u92B9\u{28AC6}\u{23C9B}\u{28B0C}\u{255DB}"],
+ ["90a1", "\u{20D31}\u932C\u936B\u{28AE1}\u{28BEB}\u708F\u5AC3\u{28AE2}\u{28AE5}\u4965\u9244\u{28BEC}\u{28C39}\u{28BFF}\u9373\u945B\u8EBC\u9585\u95A6\u9426\u95A0\u6FF6\u42B9\u{2267A}\u{286D8}\u{2127C}\u{23E2E}\u49DF\u6C1C\u967B\u9696\u416C\u96A3\u{26ED5}\u61DA\u96B6\u78F5\u{28AE0}\u96BD\u53CC\u49A1\u{26CB8}\u{20274}\u{26410}\u{290AF}\u{290E5}\u{24AD1}\u{21915}\u{2330A}\u9731\u8642\u9736\u4A0F\u453D\u4585\u{24AE9}\u7075\u5B41\u971B\u975C\u{291D5}\u9757\u5B4A\u{291EB}\u975F\u9425\u50D0\u{230B7}\u{230BC}\u9789\u979F\u97B1\u97BE\u97C0\u97D2\u97E0\u{2546C}\u97EE\u741C\u{29433}\u97FF\u97F5\u{2941D}\u{2797A}\u4AD1\u9834\u9833\u984B\u9866\u3B0E\u{27175}\u3D51\u{20630}\u{2415C}"],
+ ["9140", "\u{25706}\u98CA\u98B7\u98C8\u98C7\u4AFF\u{26D27}\u{216D3}\u55B0\u98E1\u98E6\u98EC\u9378\u9939\u{24A29}\u4B72\u{29857}\u{29905}\u99F5\u9A0C\u9A3B\u9A10\u9A58\u{25725}\u36C4\u{290B1}\u{29BD5}\u9AE0\u9AE2\u{29B05}\u9AF4\u4C0E\u9B14\u9B2D\u{28600}\u5034\u9B34\u{269A8}\u38C3\u{2307D}\u9B50\u9B40\u{29D3E}\u5A45\u{21863}\u9B8E\u{2424B}\u9C02\u9BFF\u9C0C\u{29E68}\u9DD4\u{29FB7}\u{2A192}\u{2A1AB}\u{2A0E1}\u{2A123}\u{2A1DF}\u9D7E\u9D83\u{2A134}\u9E0E\u6888"],
+ ["91a1", "\u9DC4\u{2215B}\u{2A193}\u{2A220}\u{2193B}\u{2A233}\u9D39\u{2A0B9}\u{2A2B4}\u9E90\u9E95\u9E9E\u9EA2\u4D34\u9EAA\u9EAF\u{24364}\u9EC1\u3B60\u39E5\u3D1D\u4F32\u37BE\u{28C2B}\u9F02\u9F08\u4B96\u9424\u{26DA2}\u9F17\u9F16\u9F39\u569F\u568A\u9F45\u99B8\u{2908B}\u97F2\u847F\u9F62\u9F69\u7ADC\u9F8E\u7216\u4BBE\u{24975}\u{249BB}\u7177\u{249F8}\u{24348}\u{24A51}\u739E\u{28BDA}\u{218FA}\u799F\u{2897E}\u{28E36}\u9369\u93F3\u{28A44}\u92EC\u9381\u93CB\u{2896C}\u{244B9}\u7217\u3EEB\u7772\u7A43\u70D0\u{24473}\u{243F8}\u717E\u{217EF}\u70A3\u{218BE}\u{23599}\u3EC7\u{21885}\u{2542F}\u{217F8}\u3722\u{216FB}\u{21839}\u36E1\u{21774}\u{218D1}\u{25F4B}\u3723\u{216C0}\u575B\u{24A25}\u{213FE}\u{212A8}"],
+ ["9240", "\u{213C6}\u{214B6}\u8503\u{236A6}\u8503\u8455\u{24994}\u{27165}\u{23E31}\u{2555C}\u{23EFB}\u{27052}\u44F4\u{236EE}\u{2999D}\u{26F26}\u67F9\u3733\u3C15\u3DE7\u586C\u{21922}\u6810\u4057\u{2373F}\u{240E1}\u{2408B}\u{2410F}\u{26C21}\u54CB\u569E\u{266B1}\u5692\u{20FDF}\u{20BA8}\u{20E0D}\u93C6\u{28B13}\u939C\u4EF8\u512B\u3819\u{24436}\u4EBC\u{20465}\u{2037F}\u4F4B\u4F8A\u{25651}\u5A68\u{201AB}\u{203CB}\u3999\u{2030A}\u{20414}\u3435\u4F29\u{202C0}\u{28EB3}\u{20275}\u8ADA\u{2020C}\u4E98"],
+ ["92a1", "\u50CD\u510D\u4FA2\u4F03\u{24A0E}\u{23E8A}\u4F42\u502E\u506C\u5081\u4FCC\u4FE5\u5058\u50FC\u5159\u515B\u515D\u515E\u6E76\u{23595}\u{23E39}\u{23EBF}\u6D72\u{21884}\u{23E89}\u51A8\u51C3\u{205E0}\u44DD\u{204A3}\u{20492}\u{20491}\u8D7A\u{28A9C}\u{2070E}\u5259\u52A4\u{20873}\u52E1\u936E\u467A\u718C\u{2438C}\u{20C20}\u{249AC}\u{210E4}\u69D1\u{20E1D}\u7479\u3EDE\u7499\u7414\u7456\u7398\u4B8E\u{24ABC}\u{2408D}\u53D0\u3584\u720F\u{240C9}\u55B4\u{20345}\u54CD\u{20BC6}\u571D\u925D\u96F4\u9366\u57DD\u578D\u577F\u363E\u58CB\u5A99\u{28A46}\u{216FA}\u{2176F}\u{21710}\u5A2C\u59B8\u928F\u5A7E\u5ACF\u5A12\u{25946}\u{219F3}\u{21861}\u{24295}\u36F5\u6D05\u7443\u5A21\u{25E83}"],
+ ["9340", "\u5A81\u{28BD7}\u{20413}\u93E0\u748C\u{21303}\u7105\u4972\u9408\u{289FB}\u93BD\u37A0\u5C1E\u5C9E\u5E5E\u5E48\u{21996}\u{2197C}\u{23AEE}\u5ECD\u5B4F\u{21903}\u{21904}\u3701\u{218A0}\u36DD\u{216FE}\u36D3\u812A\u{28A47}\u{21DBA}\u{23472}\u{289A8}\u5F0C\u5F0E\u{21927}\u{217AB}\u5A6B\u{2173B}\u5B44\u8614\u{275FD}\u8860\u607E\u{22860}\u{2262B}\u5FDB\u3EB8\u{225AF}\u{225BE}\u{29088}\u{26F73}\u61C0\u{2003E}\u{20046}\u{2261B}\u6199\u6198\u6075\u{22C9B}\u{22D07}\u{246D4}\u{2914D}"],
+ ["93a1", "\u6471\u{24665}\u{22B6A}\u3A29\u{22B22}\u{23450}\u{298EA}\u{22E78}\u6337\u{2A45B}\u64B6\u6331\u63D1\u{249E3}\u{22D67}\u62A4\u{22CA1}\u643B\u656B\u6972\u3BF4\u{2308E}\u{232AD}\u{24989}\u{232AB}\u550D\u{232E0}\u{218D9}\u{2943F}\u66CE\u{23289}\u{231B3}\u3AE0\u4190\u{25584}\u{28B22}\u{2558F}\u{216FC}\u{2555B}\u{25425}\u78EE\u{23103}\u{2182A}\u{23234}\u3464\u{2320F}\u{23182}\u{242C9}\u668E\u{26D24}\u666B\u4B93\u6630\u{27870}\u{21DEB}\u6663\u{232D2}\u{232E1}\u661E\u{25872}\u38D1\u{2383A}\u{237BC}\u3B99\u{237A2}\u{233FE}\u74D0\u3B96\u678F\u{2462A}\u68B6\u681E\u3BC4\u6ABE\u3863\u{237D5}\u{24487}\u6A33\u6A52\u6AC9\u6B05\u{21912}\u6511\u6898\u6A4C\u3BD7\u6A7A\u6B57\u{23FC0}\u{23C9A}\u93A0\u92F2\u{28BEA}\u{28ACB}"],
+ ["9440", "\u9289\u{2801E}\u{289DC}\u9467\u6DA5\u6F0B\u{249EC}\u6D67\u{23F7F}\u3D8F\u6E04\u{2403C}\u5A3D\u6E0A\u5847\u6D24\u7842\u713B\u{2431A}\u{24276}\u70F1\u7250\u7287\u7294\u{2478F}\u{24725}\u5179\u{24AA4}\u{205EB}\u747A\u{23EF8}\u{2365F}\u{24A4A}\u{24917}\u{25FE1}\u3F06\u3EB1\u{24ADF}\u{28C23}\u{23F35}\u60A7\u3EF3\u74CC\u743C\u9387\u7437\u449F\u{26DEA}\u4551\u7583\u3F63\u{24CD9}\u{24D06}\u3F58\u7555\u7673\u{2A5C6}\u3B19\u7468\u{28ACC}\u{249AB}\u{2498E}\u3AFB"],
+ ["94a1", "\u3DCD\u{24A4E}\u3EFF\u{249C5}\u{248F3}\u91FA\u5732\u9342\u{28AE3}\u{21864}\u50DF\u{25221}\u{251E7}\u7778\u{23232}\u770E\u770F\u777B\u{24697}\u{23781}\u3A5E\u{248F0}\u7438\u749B\u3EBF\u{24ABA}\u{24AC7}\u40C8\u{24A96}\u{261AE}\u9307\u{25581}\u781E\u788D\u7888\u78D2\u73D0\u7959\u{27741}\u{256E3}\u410E\u799B\u8496\u79A5\u6A2D\u{23EFA}\u7A3A\u79F4\u416E\u{216E6}\u4132\u9235\u79F1\u{20D4C}\u{2498C}\u{20299}\u{23DBA}\u{2176E}\u3597\u556B\u3570\u36AA\u{201D4}\u{20C0D}\u7AE2\u5A59\u{226F5}\u{25AAF}\u{25A9C}\u5A0D\u{2025B}\u78F0\u5A2A\u{25BC6}\u7AFE\u41F9\u7C5D\u7C6D\u4211\u{25BB3}\u{25EBC}\u{25EA6}\u7CCD\u{249F9}\u{217B0}\u7C8E\u7C7C\u7CAE\u6AB2\u7DDC\u7E07\u7DD3\u7F4E\u{26261}"],
+ ["9540", "\u{2615C}\u{27B48}\u7D97\u{25E82}\u426A\u{26B75}\u{20916}\u67D6\u{2004E}\u{235CF}\u57C4\u{26412}\u{263F8}\u{24962}\u7FDD\u7B27\u{2082C}\u{25AE9}\u{25D43}\u7B0C\u{25E0E}\u99E6\u8645\u9A63\u6A1C\u{2343F}\u39E2\u{249F7}\u{265AD}\u9A1F\u{265A0}\u8480\u{27127}\u{26CD1}\u44EA\u8137\u4402\u80C6\u8109\u8142\u{267B4}\u98C3\u{26A42}\u8262\u8265\u{26A51}\u8453\u{26DA7}\u8610\u{2721B}\u5A86\u417F\u{21840}\u5B2B\u{218A1}\u5AE4\u{218D8}\u86A0\u{2F9BC}\u{23D8F}\u882D\u{27422}\u5A02"],
+ ["95a1", "\u886E\u4F45\u8887\u88BF\u88E6\u8965\u894D\u{25683}\u8954\u{27785}\u{27784}\u{28BF5}\u{28BD9}\u{28B9C}\u{289F9}\u3EAD\u84A3\u46F5\u46CF\u37F2\u8A3D\u8A1C\u{29448}\u5F4D\u922B\u{24284}\u65D4\u7129\u70C4\u{21845}\u9D6D\u8C9F\u8CE9\u{27DDC}\u599A\u77C3\u59F0\u436E\u36D4\u8E2A\u8EA7\u{24C09}\u8F30\u8F4A\u42F4\u6C58\u6FBB\u{22321}\u489B\u6F79\u6E8B\u{217DA}\u9BE9\u36B5\u{2492F}\u90BB\u9097\u5571\u4906\u91BB\u9404\u{28A4B}\u4062\u{28AFC}\u9427\u{28C1D}\u{28C3B}\u84E5\u8A2B\u9599\u95A7\u9597\u9596\u{28D34}\u7445\u3EC2\u{248FF}\u{24A42}\u{243EA}\u3EE7\u{23225}\u968F\u{28EE7}\u{28E66}\u{28E65}\u3ECC\u{249ED}\u{24A78}\u{23FEE}\u7412\u746B\u3EFC\u9741\u{290B0}"],
+ ["9640", "\u6847\u4A1D\u{29093}\u{257DF}\u975D\u9368\u{28989}\u{28C26}\u{28B2F}\u{263BE}\u92BA\u5B11\u8B69\u493C\u73F9\u{2421B}\u979B\u9771\u9938\u{20F26}\u5DC1\u{28BC5}\u{24AB2}\u981F\u{294DA}\u92F6\u{295D7}\u91E5\u44C0\u{28B50}\u{24A67}\u{28B64}\u98DC\u{28A45}\u3F00\u922A\u4925\u8414\u993B\u994D\u{27B06}\u3DFD\u999B\u4B6F\u99AA\u9A5C\u{28B65}\u{258C8}\u6A8F\u9A21\u5AFE\u9A2F\u{298F1}\u4B90\u{29948}\u99BC\u4BBD\u4B97\u937D\u5872\u{21302}\u5822\u{249B8}"],
+ ["96a1", "\u{214E8}\u7844\u{2271F}\u{23DB8}\u68C5\u3D7D\u9458\u3927\u6150\u{22781}\u{2296B}\u6107\u9C4F\u9C53\u9C7B\u9C35\u9C10\u9B7F\u9BCF\u{29E2D}\u9B9F\u{2A1F5}\u{2A0FE}\u9D21\u4CAE\u{24104}\u9E18\u4CB0\u9D0C\u{2A1B4}\u{2A0ED}\u{2A0F3}\u{2992F}\u9DA5\u84BD\u{26E12}\u{26FDF}\u{26B82}\u85FC\u4533\u{26DA4}\u{26E84}\u{26DF0}\u8420\u85EE\u{26E00}\u{237D7}\u{26064}\u79E2\u{2359C}\u{23640}\u492D\u{249DE}\u3D62\u93DB\u92BE\u9348\u{202BF}\u78B9\u9277\u944D\u4FE4\u3440\u9064\u{2555D}\u783D\u7854\u78B6\u784B\u{21757}\u{231C9}\u{24941}\u369A\u4F72\u6FDA\u6FD9\u701E\u701E\u5414\u{241B5}\u57BB\u58F3\u578A\u9D16\u57D7\u7134\u34AF\u{241AC}\u71EB\u{26C40}\u{24F97}\u5B28\u{217B5}\u{28A49}"],
+ ["9740", "\u610C\u5ACE\u5A0B\u42BC\u{24488}\u372C\u4B7B\u{289FC}\u93BB\u93B8\u{218D6}\u{20F1D}\u8472\u{26CC0}\u{21413}\u{242FA}\u{22C26}\u{243C1}\u5994\u{23DB7}\u{26741}\u7DA8\u{2615B}\u{260A4}\u{249B9}\u{2498B}\u{289FA}\u92E5\u73E2\u3EE9\u74B4\u{28B63}\u{2189F}\u3EE1\u{24AB3}\u6AD8\u73F3\u73FB\u3ED6\u{24A3E}\u{24A94}\u{217D9}\u{24A66}\u{203A7}\u{21424}\u{249E5}\u7448\u{24916}\u70A5\u{24976}\u9284\u73E6\u935F\u{204FE}\u9331\u{28ACE}\u{28A16}\u9386\u{28BE7}\u{255D5}\u4935\u{28A82}\u716B"],
+ ["97a1", "\u{24943}\u{20CFF}\u56A4\u{2061A}\u{20BEB}\u{20CB8}\u5502\u79C4\u{217FA}\u7DFE\u{216C2}\u{24A50}\u{21852}\u452E\u9401\u370A\u{28AC0}\u{249AD}\u59B0\u{218BF}\u{21883}\u{27484}\u5AA1\u36E2\u{23D5B}\u36B0\u925F\u5A79\u{28A81}\u{21862}\u9374\u3CCD\u{20AB4}\u4A96\u398A\u50F4\u3D69\u3D4C\u{2139C}\u7175\u42FB\u{28218}\u6E0F\u{290E4}\u44EB\u6D57\u{27E4F}\u7067\u6CAF\u3CD6\u{23FED}\u{23E2D}\u6E02\u6F0C\u3D6F\u{203F5}\u7551\u36BC\u34C8\u4680\u3EDA\u4871\u59C4\u926E\u493E\u8F41\u{28C1C}\u{26BC0}\u5812\u57C8\u36D6\u{21452}\u70FE\u{24362}\u{24A71}\u{22FE3}\u{212B0}\u{223BD}\u68B9\u6967\u{21398}\u{234E5}\u{27BF4}\u{236DF}\u{28A83}\u{237D6}\u{233FA}\u{24C9F}\u6A1A\u{236AD}\u{26CB7}\u843E\u44DF\u44CE"],
+ ["9840", "\u{26D26}\u{26D51}\u{26C82}\u{26FDE}\u6F17\u{27109}\u833D\u{2173A}\u83ED\u{26C80}\u{27053}\u{217DB}\u5989\u5A82\u{217B3}\u5A61\u5A71\u{21905}\u{241FC}\u372D\u59EF\u{2173C}\u36C7\u718E\u9390\u669A\u{242A5}\u5A6E\u5A2B\u{24293}\u6A2B\u{23EF9}\u{27736}\u{2445B}\u{242CA}\u711D\u{24259}\u{289E1}\u4FB0\u{26D28}\u5CC2\u{244CE}\u{27E4D}\u{243BD}\u6A0C\u{24256}\u{21304}\u70A6\u7133\u{243E9}\u3DA5\u6CDF\u{2F825}\u{24A4F}\u7E65\u59EB\u5D2F\u3DF3\u5F5C\u{24A5D}\u{217DF}\u7DA4\u8426"],
+ ["98a1", "\u5485\u{23AFA}\u{23300}\u{20214}\u577E\u{208D5}\u{20619}\u3FE5\u{21F9E}\u{2A2B6}\u7003\u{2915B}\u5D70\u738F\u7CD3\u{28A59}\u{29420}\u4FC8\u7FE7\u72CD\u7310\u{27AF4}\u7338\u7339\u{256F6}\u7341\u7348\u3EA9\u{27B18}\u906C\u71F5\u{248F2}\u73E1\u81F6\u3ECA\u770C\u3ED1\u6CA2\u56FD\u7419\u741E\u741F\u3EE2\u3EF0\u3EF4\u3EFA\u74D3\u3F0E\u3F53\u7542\u756D\u7572\u758D\u3F7C\u75C8\u75DC\u3FC0\u764D\u3FD7\u7674\u3FDC\u767A\u{24F5C}\u7188\u5623\u8980\u5869\u401D\u7743\u4039\u6761\u4045\u35DB\u7798\u406A\u406F\u5C5E\u77BE\u77CB\u58F2\u7818\u70B9\u781C\u40A8\u7839\u7847\u7851\u7866\u8448\u{25535}\u7933\u6803\u7932\u4103"],
+ ["9940", "\u4109\u7991\u7999\u8FBB\u7A06\u8FBC\u4167\u7A91\u41B2\u7ABC\u8279\u41C4\u7ACF\u7ADB\u41CF\u4E21\u7B62\u7B6C\u7B7B\u7C12\u7C1B\u4260\u427A\u7C7B\u7C9C\u428C\u7CB8\u4294\u7CED\u8F93\u70C0\u{20CCF}\u7DCF\u7DD4\u7DD0\u7DFD\u7FAE\u7FB4\u729F\u4397\u8020\u8025\u7B39\u802E\u8031\u8054\u3DCC\u57B4\u70A0\u80B7\u80E9\u43ED\u810C\u732A\u810E\u8112\u7560\u8114\u4401\u3B39\u8156\u8159\u815A"],
+ ["99a1", "\u4413\u583A\u817C\u8184\u4425\u8193\u442D\u81A5\u57EF\u81C1\u81E4\u8254\u448F\u82A6\u8276\u82CA\u82D8\u82FF\u44B0\u8357\u9669\u698A\u8405\u70F5\u8464\u60E3\u8488\u4504\u84BE\u84E1\u84F8\u8510\u8538\u8552\u453B\u856F\u8570\u85E0\u4577\u8672\u8692\u86B2\u86EF\u9645\u878B\u4606\u4617\u88AE\u88FF\u8924\u8947\u8991\u{27967}\u8A29\u8A38\u8A94\u8AB4\u8C51\u8CD4\u8CF2\u8D1C\u4798\u585F\u8DC3\u47ED\u4EEE\u8E3A\u55D8\u5754\u8E71\u55F5\u8EB0\u4837\u8ECE\u8EE2\u8EE4\u8EED\u8EF2\u8FB7\u8FC1\u8FCA\u8FCC\u9033\u99C4\u48AD\u98E0\u9213\u491E\u9228\u9258\u926B\u92B1\u92AE\u92BF"],
+ ["9a40", "\u92E3\u92EB\u92F3\u92F4\u92FD\u9343\u9384\u93AD\u4945\u4951\u9EBF\u9417\u5301\u941D\u942D\u943E\u496A\u9454\u9479\u952D\u95A2\u49A7\u95F4\u9633\u49E5\u67A0\u4A24\u9740\u4A35\u97B2\u97C2\u5654\u4AE4\u60E8\u98B9\u4B19\u98F1\u5844\u990E\u9919\u51B4\u991C\u9937\u9942\u995D\u9962\u4B70\u99C5\u4B9D\u9A3C\u9B0F\u7A83\u9B69\u9B81\u9BDD\u9BF1\u9BF4\u4C6D\u9C20\u376F\u{21BC2}\u9D49\u9C3A"],
+ ["9aa1", "\u9EFE\u5650\u9D93\u9DBD\u9DC0\u9DFC\u94F6\u8FB6\u9E7B\u9EAC\u9EB1\u9EBD\u9EC6\u94DC\u9EE2\u9EF1\u9EF8\u7AC8\u9F44\u{20094}\u{202B7}\u{203A0}\u691A\u94C3\u59AC\u{204D7}\u5840\u94C1\u37B9\u{205D5}\u{20615}\u{20676}\u{216BA}\u5757\u7173\u{20AC2}\u{20ACD}\u{20BBF}\u546A\u{2F83B}\u{20BCB}\u549E\u{20BFB}\u{20C3B}\u{20C53}\u{20C65}\u{20C7C}\u60E7\u{20C8D}\u567A\u{20CB5}\u{20CDD}\u{20CED}\u{20D6F}\u{20DB2}\u{20DC8}\u6955\u9C2F\u87A5\u{20E04}\u{20E0E}\u{20ED7}\u{20F90}\u{20F2D}\u{20E73}\u5C20\u{20FBC}\u5E0B\u{2105C}\u{2104F}\u{21076}\u671E\u{2107B}\u{21088}\u{21096}\u3647\u{210BF}\u{210D3}\u{2112F}\u{2113B}\u5364\u84AD\u{212E3}\u{21375}\u{21336}\u8B81\u{21577}\u{21619}\u{217C3}\u{217C7}\u4E78\u70BB\u{2182D}\u{2196A}"],
+ ["9b40", "\u{21A2D}\u{21A45}\u{21C2A}\u{21C70}\u{21CAC}\u{21EC8}\u62C3\u{21ED5}\u{21F15}\u7198\u6855\u{22045}\u69E9\u36C8\u{2227C}\u{223D7}\u{223FA}\u{2272A}\u{22871}\u{2294F}\u82FD\u{22967}\u{22993}\u{22AD5}\u89A5\u{22AE8}\u8FA0\u{22B0E}\u97B8\u{22B3F}\u9847\u9ABD\u{22C4C}"],
+ ["9b62", "\u{22C88}\u{22CB7}\u{25BE8}\u{22D08}\u{22D12}\u{22DB7}\u{22D95}\u{22E42}\u{22F74}\u{22FCC}\u{23033}\u{23066}\u{2331F}\u{233DE}\u5FB1\u6648\u66BF\u{27A79}\u{23567}\u{235F3}\u7201\u{249BA}\u77D7\u{2361A}\u{23716}\u7E87\u{20346}\u58B5\u670E"],
+ ["9ba1", "\u6918\u{23AA7}\u{27657}\u{25FE2}\u{23E11}\u{23EB9}\u{275FE}\u{2209A}\u48D0\u4AB8\u{24119}\u{28A9A}\u{242EE}\u{2430D}\u{2403B}\u{24334}\u{24396}\u{24A45}\u{205CA}\u51D2\u{20611}\u599F\u{21EA8}\u3BBE\u{23CFF}\u{24404}\u{244D6}\u5788\u{24674}\u399B\u{2472F}\u{285E8}\u{299C9}\u3762\u{221C3}\u8B5E\u{28B4E}\u99D6\u{24812}\u{248FB}\u{24A15}\u7209\u{24AC0}\u{20C78}\u5965\u{24EA5}\u{24F86}\u{20779}\u8EDA\u{2502C}\u528F\u573F\u7171\u{25299}\u{25419}\u{23F4A}\u{24AA7}\u55BC\u{25446}\u{2546E}\u{26B52}\u91D4\u3473\u{2553F}\u{27632}\u{2555E}\u4718\u{25562}\u{25566}\u{257C7}\u{2493F}\u{2585D}\u5066\u34FB\u{233CC}\u60DE\u{25903}\u477C\u{28948}\u{25AAE}\u{25B89}\u{25C06}\u{21D90}\u57A1\u7151\u6FB6\u{26102}\u{27C12}\u9056\u{261B2}\u{24F9A}\u8B62\u{26402}\u{2644A}"],
+ ["9c40", "\u5D5B\u{26BF7}\u8F36\u{26484}\u{2191C}\u8AEA\u{249F6}\u{26488}\u{23FEF}\u{26512}\u4BC0\u{265BF}\u{266B5}\u{2271B}\u9465\u{257E1}\u6195\u5A27\u{2F8CD}\u4FBB\u56B9\u{24521}\u{266FC}\u4E6A\u{24934}\u9656\u6D8F\u{26CBD}\u3618\u8977\u{26799}\u{2686E}\u{26411}\u{2685E}\u71DF\u{268C7}\u7B42\u{290C0}\u{20A11}\u{26926}\u9104\u{26939}\u7A45\u9DF0\u{269FA}\u9A26\u{26A2D}\u365F\u{26469}\u{20021}\u7983\u{26A34}\u{26B5B}\u5D2C\u{23519}\u83CF\u{26B9D}\u46D0\u{26CA4}\u753B\u8865\u{26DAE}\u58B6"],
+ ["9ca1", "\u371C\u{2258D}\u{2704B}\u{271CD}\u3C54\u{27280}\u{27285}\u9281\u{2217A}\u{2728B}\u9330\u{272E6}\u{249D0}\u6C39\u949F\u{27450}\u{20EF8}\u8827\u88F5\u{22926}\u{28473}\u{217B1}\u6EB8\u{24A2A}\u{21820}\u39A4\u36B9\u5C10\u79E3\u453F\u66B6\u{29CAD}\u{298A4}\u8943\u{277CC}\u{27858}\u56D6\u40DF\u{2160A}\u39A1\u{2372F}\u{280E8}\u{213C5}\u71AD\u8366\u{279DD}\u{291A8}\u5A67\u4CB7\u{270AF}\u{289AB}\u{279FD}\u{27A0A}\u{27B0B}\u{27D66}\u{2417A}\u7B43\u797E\u{28009}\u6FB5\u{2A2DF}\u6A03\u{28318}\u53A2\u{26E07}\u93BF\u6836\u975D\u{2816F}\u{28023}\u{269B5}\u{213ED}\u{2322F}\u{28048}\u5D85\u{28C30}\u{28083}\u5715\u9823\u{28949}\u5DAB\u{24988}\u65BE\u69D5\u53D2\u{24AA5}\u{23F81}\u3C11\u6736\u{28090}\u{280F4}\u{2812E}\u{21FA1}\u{2814F}"],
+ ["9d40", "\u{28189}\u{281AF}\u{2821A}\u{28306}\u{2832F}\u{2838A}\u35CA\u{28468}\u{286AA}\u48FA\u63E6\u{28956}\u7808\u9255\u{289B8}\u43F2\u{289E7}\u43DF\u{289E8}\u{28B46}\u{28BD4}\u59F8\u{28C09}\u8F0B\u{28FC5}\u{290EC}\u7B51\u{29110}\u{2913C}\u3DF7\u{2915E}\u{24ACA}\u8FD0\u728F\u568B\u{294E7}\u{295E9}\u{295B0}\u{295B8}\u{29732}\u{298D1}\u{29949}\u{2996A}\u{299C3}\u{29A28}\u{29B0E}\u{29D5A}\u{29D9B}\u7E9F\u{29EF8}\u{29F23}\u4CA4\u9547\u{2A293}\u71A2\u{2A2FF}\u4D91\u9012\u{2A5CB}\u4D9C\u{20C9C}\u8FBE\u55C1"],
+ ["9da1", "\u8FBA\u{224B0}\u8FB9\u{24A93}\u4509\u7E7F\u6F56\u6AB1\u4EEA\u34E4\u{28B2C}\u{2789D}\u373A\u8E80\u{217F5}\u{28024}\u{28B6C}\u{28B99}\u{27A3E}\u{266AF}\u3DEB\u{27655}\u{23CB7}\u{25635}\u{25956}\u4E9A\u{25E81}\u{26258}\u56BF\u{20E6D}\u8E0E\u5B6D\u{23E88}\u{24C9E}\u63DE\u62D0\u{217F6}\u{2187B}\u6530\u562D\u{25C4A}\u541A\u{25311}\u3DC6\u{29D98}\u4C7D\u5622\u561E\u7F49\u{25ED8}\u5975\u{23D40}\u8770\u4E1C\u{20FEA}\u{20D49}\u{236BA}\u8117\u9D5E\u8D18\u763B\u9C45\u764E\u77B9\u9345\u5432\u8148\u82F7\u5625\u8132\u8418\u80BD\u55EA\u7962\u5643\u5416\u{20E9D}\u35CE\u5605\u55F1\u66F1\u{282E2}\u362D\u7534\u55F0\u55BA\u5497\u5572\u{20C41}\u{20C96}\u5ED0\u{25148}\u{20E76}\u{22C62}"],
+ ["9e40", "\u{20EA2}\u9EAB\u7D5A\u55DE\u{21075}\u629D\u976D\u5494\u8CCD\u71F6\u9176\u63FC\u63B9\u63FE\u5569\u{22B43}\u9C72\u{22EB3}\u519A\u34DF\u{20DA7}\u51A7\u544D\u551E\u5513\u7666\u8E2D\u{2688A}\u75B1\u80B6\u8804\u8786\u88C7\u81B6\u841C\u{210C1}\u44EC\u7304\u{24706}\u5B90\u830B\u{26893}\u567B\u{226F4}\u{27D2F}\u{241A3}\u{27D73}\u{26ED0}\u{272B6}\u9170\u{211D9}\u9208\u{23CFC}\u{2A6A9}\u{20EAC}\u{20EF9}\u7266\u{21CA2}\u474E\u{24FC2}\u{27FF9}\u{20FEB}\u40FA"],
+ ["9ea1", "\u9C5D\u651F\u{22DA0}\u48F3\u{247E0}\u{29D7C}\u{20FEC}\u{20E0A}\u6062\u{275A3}\u{20FED}"],
+ ["9ead", "\u{26048}\u{21187}\u71A3\u7E8E\u9D50\u4E1A\u4E04\u3577\u5B0D\u6CB2\u5367\u36AC\u39DC\u537D\u36A5\u{24618}\u589A\u{24B6E}\u822D\u544B\u57AA\u{25A95}\u{20979}"],
+ ["9ec5", "\u3A52\u{22465}\u7374\u{29EAC}\u4D09\u9BED\u{23CFE}\u{29F30}\u4C5B\u{24FA9}\u{2959E}\u{29FDE}\u845C\u{23DB6}\u{272B2}\u{267B3}\u{23720}\u632E\u7D25\u{23EF7}\u{23E2C}\u3A2A\u9008\u52CC\u3E74\u367A\u45E9\u{2048E}\u7640\u5AF0\u{20EB6}\u787A\u{27F2E}\u58A7\u40BF\u567C\u9B8B\u5D74\u7654\u{2A434}\u9E85\u4CE1\u75F9\u37FB\u6119\u{230DA}\u{243F2}"],
+ ["9ef5", "\u565D\u{212A9}\u57A7\u{24963}\u{29E06}\u5234\u{270AE}\u35AD\u6C4A\u9D7C"],
+ ["9f40", "\u7C56\u9B39\u57DE\u{2176C}\u5C53\u64D3\u{294D0}\u{26335}\u{27164}\u86AD\u{20D28}\u{26D22}\u{24AE2}\u{20D71}"],
+ ["9f4f", "\u51FE\u{21F0F}\u5D8E\u9703\u{21DD1}\u9E81\u904C\u7B1F\u9B02\u5CD1\u7BA3\u6268\u6335\u9AFF\u7BCF\u9B2A\u7C7E\u9B2E\u7C42\u7C86\u9C15\u7BFC\u9B09\u9F17\u9C1B\u{2493E}\u9F5A\u5573\u5BC3\u4FFD\u9E98\u4FF2\u5260\u3E06\u52D1\u5767\u5056\u59B7\u5E12\u97C8\u9DAB\u8F5C\u5469\u97B4\u9940\u97BA\u532C\u6130"],
+ ["9fa1", "\u692C\u53DA\u9C0A\u9D02\u4C3B\u9641\u6980\u50A6\u7546\u{2176D}\u99DA\u5273"],
+ ["9fae", "\u9159\u9681\u915C"],
+ ["9fb2", "\u9151\u{28E97}\u637F\u{26D23}\u6ACA\u5611\u918E\u757A\u6285\u{203FC}\u734F\u7C70\u{25C21}\u{23CFD}"],
+ ["9fc1", "\u{24919}\u76D6\u9B9D\u4E2A\u{20CD4}\u83BE\u8842"],
+ ["9fc9", "\u5C4A\u69C0\u50ED\u577A\u521F\u5DF5\u4ECE\u6C31\u{201F2}\u4F39\u549C\u54DA\u529A\u8D82\u35FE\u5F0C\u35F3"],
+ ["9fdb", "\u6B52\u917C\u9FA5\u9B97\u982E\u98B4\u9ABA\u9EA8\u9E84\u717A\u7B14"],
+ ["9fe7", "\u6BFA\u8818\u7F78"],
+ ["9feb", "\u5620\u{2A64A}\u8E77\u9F53"],
+ ["9ff0", "\u8DD4\u8E4F\u9E1C\u8E01\u6282\u{2837D}\u8E28\u8E75\u7AD3\u{24A77}\u7A3E\u78D8\u6CEA\u8A67\u7607"],
+ ["a040", "\u{28A5A}\u9F26\u6CCE\u87D6\u75C3\u{2A2B2}\u7853\u{2F840}\u8D0C\u72E2\u7371\u8B2D\u7302\u74F1\u8CEB\u{24ABB}\u862F\u5FBA\u88A0\u44B7"],
+ ["a055", "\u{2183B}\u{26E05}"],
+ ["a058", "\u8A7E\u{2251B}"],
+ ["a05b", "\u60FD\u7667\u9AD7\u9D44\u936E\u9B8F\u87F5"],
+ ["a063", "\u880F\u8CF7\u732C\u9721\u9BB0\u35D6\u72B2\u4C07\u7C51\u994A\u{26159}\u6159\u4C04\u9E96\u617D"],
+ ["a073", "\u575F\u616F\u62A6\u6239\u62CE\u3A5C\u61E2\u53AA\u{233F5}\u6364\u6802\u35D2"],
+ ["a0a1", "\u5D57\u{28BC2}\u8FDA\u{28E39}"],
+ ["a0a6", "\u50D9\u{21D46}\u7906\u5332\u9638\u{20F3B}\u4065"],
+ ["a0ae", "\u77FE"],
+ ["a0b0", "\u7CC2\u{25F1A}\u7CDA\u7A2D\u8066\u8063\u7D4D\u7505\u74F2\u8994\u821A\u670C\u8062\u{27486}\u805B\u74F0\u8103\u7724\u8989\u{267CC}\u7553\u{26ED1}\u87A9\u87CE\u81C8\u878C\u8A49\u8CAD\u8B43\u772B\u74F8\u84DA\u3635\u69B2\u8DA6"],
+ ["a0d4", "\u89A9\u7468\u6DB9\u87C1\u{24011}\u74E7\u3DDB\u7176\u60A4\u619C\u3CD1\u7162\u6077"],
+ ["a0e2", "\u7F71\u{28B2D}\u7250\u60E9\u4B7E\u5220\u3C18\u{23CC7}\u{25ED7}\u{27656}\u{25531}\u{21944}\u{212FE}\u{29903}\u{26DDC}\u{270AD}\u5CC1\u{261AD}\u{28A0F}\u{23677}\u{200EE}\u{26846}\u{24F0E}\u4562\u5B1F\u{2634C}\u9F50\u9EA6\u{2626B}"],
+ ["a3c0", "\u2400", 31, "\u2421"],
+ ["c6a1", "\u2460", 9, "\u2474", 9, "\u2170", 9, "\u4E36\u4E3F\u4E85\u4EA0\u5182\u5196\u51AB\u52F9\u5338\u5369\u53B6\u590A\u5B80\u5DDB\u2F33\u5E7F\u5EF4\u5F50\u5F61\u6534\u65E0\u7592\u7676\u8FB5\u96B6\xA8\u02C6\u30FD\u30FE\u309D\u309E\u3003\u4EDD\u3005\u3006\u3007\u30FC\uFF3B\uFF3D\u273D\u3041", 23],
+ ["c740", "\u3059", 58, "\u30A1\u30A2\u30A3\u30A4"],
+ ["c7a1", "\u30A5", 81, "\u0410", 5, "\u0401\u0416", 4],
+ ["c840", "\u041B", 26, "\u0451\u0436", 25, "\u21E7\u21B8\u21B9\u31CF\u{200CC}\u4E5A\u{2008A}\u5202\u4491"],
+ ["c8a1", "\u9FB0\u5188\u9FB1\u{27607}"],
+ ["c8cd", "\uFFE2\uFFE4\uFF07\uFF02\u3231\u2116\u2121\u309B\u309C\u2E80\u2E84\u2E86\u2E87\u2E88\u2E8A\u2E8C\u2E8D\u2E95\u2E9C\u2E9D\u2EA5\u2EA7\u2EAA\u2EAC\u2EAE\u2EB6\u2EBC\u2EBE\u2EC6\u2ECA\u2ECC\u2ECD\u2ECF\u2ED6\u2ED7\u2EDE\u2EE3"],
+ ["c8f5", "\u0283\u0250\u025B\u0254\u0275\u0153\xF8\u014B\u028A\u026A"],
+ ["f9fe", "\uFFED"],
+ ["fa40", "\u{20547}\u92DB\u{205DF}\u{23FC5}\u854C\u42B5\u73EF\u51B5\u3649\u{24942}\u{289E4}\u9344\u{219DB}\u82EE\u{23CC8}\u783C\u6744\u62DF\u{24933}\u{289AA}\u{202A0}\u{26BB3}\u{21305}\u4FAB\u{224ED}\u5008\u{26D29}\u{27A84}\u{23600}\u{24AB1}\u{22513}\u5029\u{2037E}\u5FA4\u{20380}\u{20347}\u6EDB\u{2041F}\u507D\u5101\u347A\u510E\u986C\u3743\u8416\u{249A4}\u{20487}\u5160\u{233B4}\u516A\u{20BFF}\u{220FC}\u{202E5}\u{22530}\u{2058E}\u{23233}\u{21983}\u5B82\u877D\u{205B3}\u{23C99}\u51B2\u51B8"],
+ ["faa1", "\u9D34\u51C9\u51CF\u51D1\u3CDC\u51D3\u{24AA6}\u51B3\u51E2\u5342\u51ED\u83CD\u693E\u{2372D}\u5F7B\u520B\u5226\u523C\u52B5\u5257\u5294\u52B9\u52C5\u7C15\u8542\u52E0\u860D\u{26B13}\u5305\u{28ADE}\u5549\u6ED9\u{23F80}\u{20954}\u{23FEC}\u5333\u5344\u{20BE2}\u6CCB\u{21726}\u681B\u73D5\u604A\u3EAA\u38CC\u{216E8}\u71DD\u44A2\u536D\u5374\u{286AB}\u537E\u537F\u{21596}\u{21613}\u77E6\u5393\u{28A9B}\u53A0\u53AB\u53AE\u73A7\u{25772}\u3F59\u739C\u53C1\u53C5\u6C49\u4E49\u57FE\u53D9\u3AAB\u{20B8F}\u53E0\u{23FEB}\u{22DA3}\u53F6\u{20C77}\u5413\u7079\u552B\u6657\u6D5B\u546D\u{26B53}\u{20D74}\u555D\u548F\u54A4\u47A6\u{2170D}\u{20EDD}\u3DB4\u{20D4D}"],
+ ["fb40", "\u{289BC}\u{22698}\u5547\u4CED\u542F\u7417\u5586\u55A9\u5605\u{218D7}\u{2403A}\u4552\u{24435}\u66B3\u{210B4}\u5637\u66CD\u{2328A}\u66A4\u66AD\u564D\u564F\u78F1\u56F1\u9787\u53FE\u5700\u56EF\u56ED\u{28B66}\u3623\u{2124F}\u5746\u{241A5}\u6C6E\u708B\u5742\u36B1\u{26C7E}\u57E6\u{21416}\u5803\u{21454}\u{24363}\u5826\u{24BF5}\u585C\u58AA\u3561\u58E0\u58DC\u{2123C}\u58FB\u5BFF\u5743\u{2A150}\u{24278}\u93D3\u35A1\u591F\u68A6\u36C3\u6E59"],
+ ["fba1", "\u{2163E}\u5A24\u5553\u{21692}\u8505\u59C9\u{20D4E}\u{26C81}\u{26D2A}\u{217DC}\u59D9\u{217FB}\u{217B2}\u{26DA6}\u6D71\u{21828}\u{216D5}\u59F9\u{26E45}\u5AAB\u5A63\u36E6\u{249A9}\u5A77\u3708\u5A96\u7465\u5AD3\u{26FA1}\u{22554}\u3D85\u{21911}\u3732\u{216B8}\u5E83\u52D0\u5B76\u6588\u5B7C\u{27A0E}\u4004\u485D\u{20204}\u5BD5\u6160\u{21A34}\u{259CC}\u{205A5}\u5BF3\u5B9D\u4D10\u5C05\u{21B44}\u5C13\u73CE\u5C14\u{21CA5}\u{26B28}\u5C49\u48DD\u5C85\u5CE9\u5CEF\u5D8B\u{21DF9}\u{21E37}\u5D10\u5D18\u5D46\u{21EA4}\u5CBA\u5DD7\u82FC\u382D\u{24901}\u{22049}\u{22173}\u8287\u3836\u3BC2\u5E2E\u6A8A\u5E75\u5E7A\u{244BC}\u{20CD3}\u53A6\u4EB7\u5ED0\u53A8\u{21771}\u5E09\u5EF4\u{28482}"],
+ ["fc40", "\u5EF9\u5EFB\u38A0\u5EFC\u683E\u941B\u5F0D\u{201C1}\u{2F894}\u3ADE\u48AE\u{2133A}\u5F3A\u{26888}\u{223D0}\u5F58\u{22471}\u5F63\u97BD\u{26E6E}\u5F72\u9340\u{28A36}\u5FA7\u5DB6\u3D5F\u{25250}\u{21F6A}\u{270F8}\u{22668}\u91D6\u{2029E}\u{28A29}\u6031\u6685\u{21877}\u3963\u3DC7\u3639\u5790\u{227B4}\u7971\u3E40\u609E\u60A4\u60B3\u{24982}\u{2498F}\u{27A53}\u74A4\u50E1\u5AA0\u6164\u8424\u6142\u{2F8A6}\u{26ED2}\u6181\u51F4\u{20656}\u6187\u5BAA\u{23FB7}"],
+ ["fca1", "\u{2285F}\u61D3\u{28B9D}\u{2995D}\u61D0\u3932\u{22980}\u{228C1}\u6023\u615C\u651E\u638B\u{20118}\u62C5\u{21770}\u62D5\u{22E0D}\u636C\u{249DF}\u3A17\u6438\u63F8\u{2138E}\u{217FC}\u6490\u6F8A\u{22E36}\u9814\u{2408C}\u{2571D}\u64E1\u64E5\u947B\u3A66\u643A\u3A57\u654D\u6F16\u{24A28}\u{24A23}\u6585\u656D\u655F\u{2307E}\u65B5\u{24940}\u4B37\u65D1\u40D8\u{21829}\u65E0\u65E3\u5FDF\u{23400}\u6618\u{231F7}\u{231F8}\u6644\u{231A4}\u{231A5}\u664B\u{20E75}\u6667\u{251E6}\u6673\u6674\u{21E3D}\u{23231}\u{285F4}\u{231C8}\u{25313}\u77C5\u{228F7}\u99A4\u6702\u{2439C}\u{24A21}\u3B2B\u69FA\u{237C2}\u675E\u6767\u6762\u{241CD}\u{290ED}\u67D7\u44E9\u6822\u6E50\u923C\u6801\u{233E6}\u{26DA0}\u685D"],
+ ["fd40", "\u{2346F}\u69E1\u6A0B\u{28ADF}\u6973\u68C3\u{235CD}\u6901\u6900\u3D32\u3A01\u{2363C}\u3B80\u67AC\u6961\u{28A4A}\u42FC\u6936\u6998\u3BA1\u{203C9}\u8363\u5090\u69F9\u{23659}\u{2212A}\u6A45\u{23703}\u6A9D\u3BF3\u67B1\u6AC8\u{2919C}\u3C0D\u6B1D\u{20923}\u60DE\u6B35\u6B74\u{227CD}\u6EB5\u{23ADB}\u{203B5}\u{21958}\u3740\u5421\u{23B5A}\u6BE1\u{23EFC}\u6BDC\u6C37\u{2248B}\u{248F1}\u{26B51}\u6C5A\u8226\u6C79\u{23DBC}\u44C5\u{23DBD}\u{241A4}\u{2490C}\u{24900}"],
+ ["fda1", "\u{23CC9}\u36E5\u3CEB\u{20D32}\u9B83\u{231F9}\u{22491}\u7F8F\u6837\u{26D25}\u{26DA1}\u{26DEB}\u6D96\u6D5C\u6E7C\u6F04\u{2497F}\u{24085}\u{26E72}\u8533\u{26F74}\u51C7\u6C9C\u6E1D\u842E\u{28B21}\u6E2F\u{23E2F}\u7453\u{23F82}\u79CC\u6E4F\u5A91\u{2304B}\u6FF8\u370D\u6F9D\u{23E30}\u6EFA\u{21497}\u{2403D}\u4555\u93F0\u6F44\u6F5C\u3D4E\u6F74\u{29170}\u3D3B\u6F9F\u{24144}\u6FD3\u{24091}\u{24155}\u{24039}\u{23FF0}\u{23FB4}\u{2413F}\u51DF\u{24156}\u{24157}\u{24140}\u{261DD}\u704B\u707E\u70A7\u7081\u70CC\u70D5\u70D6\u70DF\u4104\u3DE8\u71B4\u7196\u{24277}\u712B\u7145\u5A88\u714A\u716E\u5C9C\u{24365}\u714F\u9362\u{242C1}\u712C\u{2445A}\u{24A27}\u{24A22}\u71BA\u{28BE8}\u70BD\u720E"],
+ ["fe40", "\u9442\u7215\u5911\u9443\u7224\u9341\u{25605}\u722E\u7240\u{24974}\u68BD\u7255\u7257\u3E55\u{23044}\u680D\u6F3D\u7282\u732A\u732B\u{24823}\u{2882B}\u48ED\u{28804}\u7328\u732E\u73CF\u73AA\u{20C3A}\u{26A2E}\u73C9\u7449\u{241E2}\u{216E7}\u{24A24}\u6623\u36C5\u{249B7}\u{2498D}\u{249FB}\u73F7\u7415\u6903\u{24A26}\u7439\u{205C3}\u3ED7\u745C\u{228AD}\u7460\u{28EB2}\u7447\u73E4\u7476\u83B9\u746C\u3730\u7474\u93F1\u6A2C\u7482\u4953\u{24A8C}"],
+ ["fea1", "\u{2415F}\u{24A79}\u{28B8F}\u5B46\u{28C03}\u{2189E}\u74C8\u{21988}\u750E\u74E9\u751E\u{28ED9}\u{21A4B}\u5BD7\u{28EAC}\u9385\u754D\u754A\u7567\u756E\u{24F82}\u3F04\u{24D13}\u758E\u745D\u759E\u75B4\u7602\u762C\u7651\u764F\u766F\u7676\u{263F5}\u7690\u81EF\u37F8\u{26911}\u{2690E}\u76A1\u76A5\u76B7\u76CC\u{26F9F}\u8462\u{2509D}\u{2517D}\u{21E1C}\u771E\u7726\u7740\u64AF\u{25220}\u7758\u{232AC}\u77AF\u{28964}\u{28968}\u{216C1}\u77F4\u7809\u{21376}\u{24A12}\u68CA\u78AF\u78C7\u78D3\u96A5\u792E\u{255E0}\u78D7\u7934\u78B1\u{2760C}\u8FB8\u8884\u{28B2B}\u{26083}\u{2261C}\u7986\u8900\u6902\u7980\u{25857}\u799D\u{27B39}\u793C\u79A9\u6E2A\u{27126}\u3EA8\u79C6\u{2910D}\u79D4"]
+ ];
+ }
+});
+
+// ../../node_modules/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/encodings/dbcs-data.js
+var require_dbcs_data = __commonJS({
+ "../../node_modules/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/encodings/dbcs-data.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ 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: [41676]
+ },
+ "cnbig5": "big5hkscs",
+ "csbig5": "big5hkscs",
+ "xxbig5": "big5hkscs"
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/encodings/index.js
+var require_encodings = __commonJS({
+ "../../node_modules/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/encodings/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var modules = [
+ require_internal(),
+ 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;
+ }
+});
+
+// ../../node_modules/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/lib/streams.js
+var require_streams = __commonJS({
+ "../../node_modules/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/lib/streams.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var Buffer3 = require("buffer").Buffer;
+ var Transform = require("stream").Transform;
+ module2.exports = function(iconv) {
+ iconv.encodeStream = /* @__PURE__ */ __name(function encodeStream(encoding, options14) {
+ return new IconvLiteEncoderStream(iconv.getEncoder(encoding, options14), options14);
+ }, "encodeStream");
+ iconv.decodeStream = /* @__PURE__ */ __name(function decodeStream(encoding, options14) {
+ return new IconvLiteDecoderStream(iconv.getDecoder(encoding, options14), options14);
+ }, "decodeStream");
+ iconv.supportsStreams = true;
+ iconv.IconvLiteEncoderStream = IconvLiteEncoderStream;
+ iconv.IconvLiteDecoderStream = IconvLiteDecoderStream;
+ iconv._collect = IconvLiteDecoderStream.prototype.collect;
+ };
+ function IconvLiteEncoderStream(conv, options14) {
+ this.conv = conv;
+ options14 = options14 || {};
+ options14.decodeStrings = false;
+ Transform.call(this, options14);
+ }
+ __name(IconvLiteEncoderStream, "IconvLiteEncoderStream");
+ 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 (e2) {
+ done(e2);
+ }
+ };
+ IconvLiteEncoderStream.prototype._flush = function(done) {
+ try {
+ var res = this.conv.end();
+ if (res && res.length)
+ this.push(res);
+ done();
+ } catch (e2) {
+ done(e2);
+ }
+ };
+ 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, Buffer3.concat(chunks));
+ });
+ return this;
+ };
+ function IconvLiteDecoderStream(conv, options14) {
+ this.conv = conv;
+ options14 = options14 || {};
+ options14.encoding = this.encoding = "utf8";
+ Transform.call(this, options14);
+ }
+ __name(IconvLiteDecoderStream, "IconvLiteDecoderStream");
+ IconvLiteDecoderStream.prototype = Object.create(Transform.prototype, {
+ constructor: { value: IconvLiteDecoderStream }
+ });
+ IconvLiteDecoderStream.prototype._transform = function(chunk, encoding, done) {
+ if (!Buffer3.isBuffer(chunk))
+ 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 (e2) {
+ done(e2);
+ }
+ };
+ IconvLiteDecoderStream.prototype._flush = function(done) {
+ try {
+ var res = this.conv.end();
+ if (res && res.length)
+ this.push(res, this.encoding);
+ done();
+ } catch (e2) {
+ done(e2);
+ }
+ };
+ 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;
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/lib/extend-node.js
+var require_extend_node = __commonJS({
+ "../../node_modules/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/lib/extend-node.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var Buffer3 = require("buffer").Buffer;
+ module2.exports = function(iconv) {
+ var original = void 0;
+ iconv.supportsNodeEncodingsExtension = !(Buffer3.from || new Buffer3(0) instanceof Uint8Array);
+ iconv.extendNodeEncodings = /* @__PURE__ */ __name(function extendNodeEncodings() {
+ if (original)
+ return;
+ original = {};
+ if (!iconv.supportsNodeEncodingsExtension) {
+ console.error("ACTION NEEDED: require('iconv-lite').extendNodeEncodings() is not supported in your version of Node");
+ console.error("See more info at https://github.com/ashtuchkin/iconv-lite/wiki/Node-v4-compatibility");
+ return;
+ }
+ var nodeNativeEncodings = {
+ "hex": true,
+ "utf8": true,
+ "utf-8": true,
+ "ascii": true,
+ "binary": true,
+ "base64": true,
+ "ucs2": true,
+ "ucs-2": true,
+ "utf16le": true,
+ "utf-16le": true
+ };
+ Buffer3.isNativeEncoding = function(enc) {
+ return enc && nodeNativeEncodings[enc.toLowerCase()];
+ };
+ var SlowBuffer = require("buffer").SlowBuffer;
+ original.SlowBufferToString = SlowBuffer.prototype.toString;
+ SlowBuffer.prototype.toString = function(encoding, start, end) {
+ encoding = String(encoding || "utf8").toLowerCase();
+ if (Buffer3.isNativeEncoding(encoding))
+ return original.SlowBufferToString.call(this, encoding, start, end);
+ if (typeof start == "undefined")
+ start = 0;
+ if (typeof end == "undefined")
+ end = this.length;
+ return iconv.decode(this.slice(start, end), encoding);
+ };
+ original.SlowBufferWrite = SlowBuffer.prototype.write;
+ SlowBuffer.prototype.write = function(string, offset, length, encoding) {
+ if (isFinite(offset)) {
+ if (!isFinite(length)) {
+ encoding = length;
+ length = void 0;
+ }
+ } else {
+ var swap = encoding;
+ encoding = offset;
+ offset = length;
+ length = swap;
+ }
+ offset = +offset || 0;
+ var remaining = this.length - offset;
+ if (!length) {
+ length = remaining;
+ } else {
+ length = +length;
+ if (length > remaining) {
+ length = remaining;
+ }
+ }
+ encoding = String(encoding || "utf8").toLowerCase();
+ if (Buffer3.isNativeEncoding(encoding))
+ return original.SlowBufferWrite.call(this, string, offset, length, encoding);
+ if (string.length > 0 && (length < 0 || offset < 0))
+ throw new RangeError("attempt to write beyond buffer bounds");
+ var buf = iconv.encode(string, encoding);
+ if (buf.length < length)
+ length = buf.length;
+ buf.copy(this, offset, 0, length);
+ return length;
+ };
+ original.BufferIsEncoding = Buffer3.isEncoding;
+ Buffer3.isEncoding = function(encoding) {
+ return Buffer3.isNativeEncoding(encoding) || iconv.encodingExists(encoding);
+ };
+ original.BufferByteLength = Buffer3.byteLength;
+ Buffer3.byteLength = SlowBuffer.byteLength = function(str, encoding) {
+ encoding = String(encoding || "utf8").toLowerCase();
+ if (Buffer3.isNativeEncoding(encoding))
+ return original.BufferByteLength.call(this, str, encoding);
+ return iconv.encode(str, encoding).length;
+ };
+ original.BufferToString = Buffer3.prototype.toString;
+ Buffer3.prototype.toString = function(encoding, start, end) {
+ encoding = String(encoding || "utf8").toLowerCase();
+ if (Buffer3.isNativeEncoding(encoding))
+ return original.BufferToString.call(this, encoding, start, end);
+ if (typeof start == "undefined")
+ start = 0;
+ if (typeof end == "undefined")
+ end = this.length;
+ return iconv.decode(this.slice(start, end), encoding);
+ };
+ original.BufferWrite = Buffer3.prototype.write;
+ Buffer3.prototype.write = function(string, offset, length, encoding) {
+ var _offset = offset, _length = length, _encoding = encoding;
+ if (isFinite(offset)) {
+ if (!isFinite(length)) {
+ encoding = length;
+ length = void 0;
+ }
+ } else {
+ var swap = encoding;
+ encoding = offset;
+ offset = length;
+ length = swap;
+ }
+ encoding = String(encoding || "utf8").toLowerCase();
+ if (Buffer3.isNativeEncoding(encoding))
+ return original.BufferWrite.call(this, string, _offset, _length, _encoding);
+ offset = +offset || 0;
+ var remaining = this.length - offset;
+ if (!length) {
+ length = remaining;
+ } else {
+ length = +length;
+ if (length > remaining) {
+ length = remaining;
+ }
+ }
+ if (string.length > 0 && (length < 0 || offset < 0))
+ throw new RangeError("attempt to write beyond buffer bounds");
+ var buf = iconv.encode(string, encoding);
+ if (buf.length < length)
+ length = buf.length;
+ buf.copy(this, offset, 0, length);
+ return length;
+ };
+ if (iconv.supportsStreams) {
+ var Readable = require("stream").Readable;
+ original.ReadableSetEncoding = Readable.prototype.setEncoding;
+ Readable.prototype.setEncoding = /* @__PURE__ */ __name(function setEncoding(enc, options14) {
+ this._readableState.decoder = iconv.getDecoder(enc, options14);
+ this._readableState.encoding = enc;
+ }, "setEncoding");
+ Readable.prototype.collect = iconv._collect;
+ }
+ }, "extendNodeEncodings");
+ iconv.undoExtendNodeEncodings = /* @__PURE__ */ __name(function undoExtendNodeEncodings() {
+ if (!iconv.supportsNodeEncodingsExtension)
+ return;
+ if (!original)
+ throw new Error("require('iconv-lite').undoExtendNodeEncodings(): Nothing to undo; extendNodeEncodings() is not called.");
+ delete Buffer3.isNativeEncoding;
+ var SlowBuffer = require("buffer").SlowBuffer;
+ SlowBuffer.prototype.toString = original.SlowBufferToString;
+ SlowBuffer.prototype.write = original.SlowBufferWrite;
+ Buffer3.isEncoding = original.BufferIsEncoding;
+ Buffer3.byteLength = original.BufferByteLength;
+ Buffer3.prototype.toString = original.BufferToString;
+ Buffer3.prototype.write = original.BufferWrite;
+ if (iconv.supportsStreams) {
+ var Readable = require("stream").Readable;
+ Readable.prototype.setEncoding = original.ReadableSetEncoding;
+ delete Readable.prototype.collect;
+ }
+ original = void 0;
+ }, "undoExtendNodeEncodings");
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/lib/index.js
+var require_lib3 = __commonJS({
+ "../../node_modules/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/lib/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var Buffer3 = require_safer().Buffer;
+ var bomHandling = require_bom_handling();
+ var iconv = module2.exports;
+ iconv.encodings = null;
+ iconv.defaultCharUnicode = "\uFFFD";
+ iconv.defaultCharSingleByte = "?";
+ iconv.encode = /* @__PURE__ */ __name(function encode(str, encoding, options14) {
+ str = "" + (str || "");
+ var encoder = iconv.getEncoder(encoding, options14);
+ var res = encoder.write(str);
+ var trail = encoder.end();
+ return trail && trail.length > 0 ? Buffer3.concat([res, trail]) : res;
+ }, "encode");
+ iconv.decode = /* @__PURE__ */ __name(function decode(buf, encoding, options14) {
+ 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 = Buffer3.from("" + (buf || ""), "binary");
+ }
+ var decoder = iconv.getDecoder(encoding, options14);
+ var res = decoder.write(buf);
+ var trail = decoder.end();
+ return trail ? res + trail : res;
+ }, "decode");
+ iconv.encodingExists = /* @__PURE__ */ __name(function encodingExists(enc) {
+ try {
+ iconv.getCodec(enc);
+ return true;
+ } catch (e2) {
+ return false;
+ }
+ }, "encodingExists");
+ iconv.toEncoding = iconv.encode;
+ iconv.fromEncoding = iconv.decode;
+ iconv._codecDataCache = {};
+ iconv.getCodec = /* @__PURE__ */ __name(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 + "')");
+ }
+ }
+ }, "getCodec");
+ iconv._canonicalizeEncoding = function(encoding) {
+ return ("" + encoding).toLowerCase().replace(/:\d{4}$|[^0-9a-z]/g, "");
+ };
+ iconv.getEncoder = /* @__PURE__ */ __name(function getEncoder(encoding, options14) {
+ var codec = iconv.getCodec(encoding), encoder = new codec.encoder(options14, codec);
+ if (codec.bomAware && options14 && options14.addBOM)
+ encoder = new bomHandling.PrependBOM(encoder, options14);
+ return encoder;
+ }, "getEncoder");
+ iconv.getDecoder = /* @__PURE__ */ __name(function getDecoder(encoding, options14) {
+ var codec = iconv.getCodec(encoding), decoder = new codec.decoder(options14, codec);
+ if (codec.bomAware && !(options14 && options14.stripBOM === false))
+ decoder = new bomHandling.StripBOM(decoder, options14);
+ return decoder;
+ }, "getDecoder");
+ var nodeVer = typeof process !== "undefined" && process.versions && process.versions.node;
+ if (nodeVer) {
+ nodeVerArr = nodeVer.split(".").map(Number);
+ if (nodeVerArr[0] > 0 || nodeVerArr[1] >= 10) {
+ require_streams()(iconv);
+ }
+ require_extend_node()(iconv);
+ }
+ var nodeVerArr;
+ if (false) {
+ console.error("iconv-lite warning: javascript files use encoding different from utf-8. See https://github.com/ashtuchkin/iconv-lite/wiki/Javascript-source-file-encodings for more info.");
+ }
+ }
+});
+
+// ../../node_modules/.pnpm/unpipe@1.0.0/node_modules/unpipe/index.js
+var require_unpipe = __commonJS({
+ "../../node_modules/.pnpm/unpipe@1.0.0/node_modules/unpipe/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ module2.exports = unpipe;
+ function hasPipeDataListeners(stream2) {
+ var listeners = stream2.listeners("data");
+ for (var i = 0; i < listeners.length; i++) {
+ if (listeners[i].name === "ondata") {
+ return true;
+ }
+ }
+ return false;
+ }
+ __name(hasPipeDataListeners, "hasPipeDataListeners");
+ function unpipe(stream2) {
+ if (!stream2) {
+ throw new TypeError("argument stream is required");
+ }
+ if (typeof stream2.unpipe === "function") {
+ stream2.unpipe();
+ return;
+ }
+ if (!hasPipeDataListeners(stream2)) {
+ return;
+ }
+ var listener;
+ var listeners = stream2.listeners("close");
+ for (var i = 0; i < listeners.length; i++) {
+ listener = listeners[i];
+ if (listener.name !== "cleanup" && listener.name !== "onclose") {
+ continue;
+ }
+ listener.call(stream2);
+ }
+ }
+ __name(unpipe, "unpipe");
+ }
+});
+
+// ../../node_modules/.pnpm/raw-body@2.5.1/node_modules/raw-body/index.js
+var require_raw_body = __commonJS({
+ "../../node_modules/.pnpm/raw-body@2.5.1/node_modules/raw-body/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var asyncHooks = tryRequireAsyncHooks();
+ var bytes = require_bytes();
+ var createError = require_http_errors();
+ var iconv = require_lib3();
+ var unpipe = require_unpipe();
+ module2.exports = getRawBody;
+ var ICONV_ENCODING_MESSAGE_REGEXP = /^Encoding not recognized: /;
+ function getDecoder(encoding) {
+ if (!encoding)
+ return null;
+ try {
+ return iconv.getDecoder(encoding);
+ } catch (e2) {
+ if (!ICONV_ENCODING_MESSAGE_REGEXP.test(e2.message))
+ throw e2;
+ throw createError(415, "specified encoding unsupported", {
+ encoding,
+ type: "encoding.unsupported"
+ });
+ }
+ }
+ __name(getDecoder, "getDecoder");
+ function getRawBody(stream2, options14, callback) {
+ var done = callback;
+ var opts = options14 || {};
+ if (options14 === true || typeof options14 === "string") {
+ opts = {
+ encoding: options14
+ };
+ }
+ if (typeof options14 === "function") {
+ done = options14;
+ 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(stream2, encoding, length, limit, wrap2(done));
+ }
+ return new Promise(/* @__PURE__ */ __name(function executor(resolve18, reject) {
+ readStream(stream2, encoding, length, limit, /* @__PURE__ */ __name(function onRead(err, buf) {
+ if (err)
+ return reject(err);
+ resolve18(buf);
+ }, "onRead"));
+ }, "executor"));
+ }
+ __name(getRawBody, "getRawBody");
+ function halt(stream2) {
+ unpipe(stream2);
+ if (typeof stream2.pause === "function") {
+ stream2.pause();
+ }
+ }
+ __name(halt, "halt");
+ function readStream(stream2, 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 = stream2._readableState;
+ if (stream2._decoder || state && (state.encoding || state.decoder)) {
+ return done(createError(500, "stream encoding should not be set", {
+ type: "stream.encoding.set"
+ }));
+ }
+ if (typeof stream2.readable !== "undefined" && !stream2.readable) {
+ return done(createError(500, "stream is not readable", {
+ type: "stream.not.readable"
+ }));
+ }
+ var received = 0;
+ var decoder;
+ try {
+ decoder = getDecoder(encoding);
+ } catch (err) {
+ return done(err);
+ }
+ var buffer = decoder ? "" : [];
+ stream2.on("aborted", onAborted);
+ stream2.on("close", cleanup);
+ stream2.on("data", onData);
+ stream2.on("end", onEnd);
+ stream2.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(stream2);
+ }
+ callback.apply(null, args);
+ }
+ __name(invokeCallback, "invokeCallback");
+ }
+ __name(done, "done");
+ function onAborted() {
+ if (complete)
+ return;
+ done(createError(400, "request aborted", {
+ code: "ECONNABORTED",
+ expected: length,
+ length,
+ received,
+ type: "request.aborted"
+ }));
+ }
+ __name(onAborted, "onAborted");
+ 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);
+ }
+ }
+ __name(onData, "onData");
+ function onEnd(err) {
+ if (complete)
+ return;
+ if (err)
+ return done(err);
+ 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);
+ }
+ }
+ __name(onEnd, "onEnd");
+ function cleanup() {
+ buffer = null;
+ stream2.removeListener("aborted", onAborted);
+ stream2.removeListener("data", onData);
+ stream2.removeListener("end", onEnd);
+ stream2.removeListener("error", onEnd);
+ stream2.removeListener("close", cleanup);
+ }
+ __name(cleanup, "cleanup");
+ }
+ __name(readStream, "readStream");
+ function tryRequireAsyncHooks() {
+ try {
+ return require("async_hooks");
+ } catch (e2) {
+ return {};
+ }
+ }
+ __name(tryRequireAsyncHooks, "tryRequireAsyncHooks");
+ function wrap2(fn2) {
+ var res;
+ if (asyncHooks.AsyncResource) {
+ res = new asyncHooks.AsyncResource(fn2.name || "bound-anonymous-fn");
+ }
+ if (!res || !res.runInAsyncScope) {
+ return fn2;
+ }
+ return res.runInAsyncScope.bind(res, fn2, null);
+ }
+ __name(wrap2, "wrap");
+ }
+});
+
+// ../../node_modules/.pnpm/ee-first@1.1.1/node_modules/ee-first/index.js
+var require_ee_first = __commonJS({
+ "../../node_modules/.pnpm/ee-first@1.1.1/node_modules/ee-first/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ 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 fn2 = listener(event, callback);
+ ee.on(event, fn2);
+ cleanups.push({
+ ee,
+ event,
+ fn: fn2
+ });
+ }
+ }
+ function callback() {
+ cleanup();
+ done.apply(null, arguments);
+ }
+ __name(callback, "callback");
+ function cleanup() {
+ var x;
+ for (var i2 = 0; i2 < cleanups.length; i2++) {
+ x = cleanups[i2];
+ x.ee.removeListener(x.event, x.fn);
+ }
+ }
+ __name(cleanup, "cleanup");
+ function thunk(fn3) {
+ done = fn3;
+ }
+ __name(thunk, "thunk");
+ thunk.cancel = cleanup;
+ return thunk;
+ }
+ __name(first, "first");
+ function listener(event, done) {
+ return /* @__PURE__ */ __name(function onevent(arg1) {
+ var args = new Array(arguments.length);
+ var ee = this;
+ var err = event === "error" ? arg1 : null;
+ for (var i = 0; i < args.length; i++) {
+ args[i] = arguments[i];
+ }
+ done(err, ee, event, args);
+ }, "onevent");
+ }
+ __name(listener, "listener");
+ }
+});
+
+// ../../node_modules/.pnpm/on-finished@2.4.1/node_modules/on-finished/index.js
+var require_on_finished = __commonJS({
+ "../../node_modules/.pnpm/on-finished@2.4.1/node_modules/on-finished/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ module2.exports = onFinished;
+ module2.exports.isFinished = isFinished;
+ var asyncHooks = tryRequireAsyncHooks();
+ var first = require_ee_first();
+ var defer = typeof setImmediate === "function" ? setImmediate : function(fn2) {
+ process.nextTick(fn2.bind.apply(fn2, arguments));
+ };
+ function onFinished(msg, listener) {
+ if (isFinished(msg) !== false) {
+ defer(listener, null, msg);
+ return msg;
+ }
+ attachListener(msg, wrap2(listener));
+ return msg;
+ }
+ __name(onFinished, "onFinished");
+ 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;
+ }
+ __name(isFinished, "isFinished");
+ function attachFinishedListener(msg, callback) {
+ var eeMsg;
+ var eeSocket;
+ var finished = false;
+ function onFinish(error) {
+ eeMsg.cancel();
+ eeSocket.cancel();
+ finished = true;
+ callback(error);
+ }
+ __name(onFinish, "onFinish");
+ 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);
+ }
+ __name(onSocket, "onSocket");
+ if (msg.socket) {
+ onSocket(msg.socket);
+ return;
+ }
+ msg.on("socket", onSocket);
+ if (msg.socket === void 0) {
+ patchAssignSocket(msg, onSocket);
+ }
+ }
+ __name(attachFinishedListener, "attachFinishedListener");
+ function attachListener(msg, listener) {
+ var attached = msg.__onFinished;
+ if (!attached || !attached.queue) {
+ attached = msg.__onFinished = createListener(msg);
+ attachFinishedListener(msg, attached);
+ }
+ attached.queue.push(listener);
+ }
+ __name(attachListener, "attachListener");
+ function createListener(msg) {
+ function listener(err) {
+ 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](err, msg);
+ }
+ }
+ __name(listener, "listener");
+ listener.queue = [];
+ return listener;
+ }
+ __name(createListener, "createListener");
+ function patchAssignSocket(res, callback) {
+ var assignSocket = res.assignSocket;
+ if (typeof assignSocket !== "function")
+ return;
+ res.assignSocket = /* @__PURE__ */ __name(function _assignSocket(socket) {
+ assignSocket.call(this, socket);
+ callback(socket);
+ }, "_assignSocket");
+ }
+ __name(patchAssignSocket, "patchAssignSocket");
+ function tryRequireAsyncHooks() {
+ try {
+ return require("async_hooks");
+ } catch (e2) {
+ return {};
+ }
+ }
+ __name(tryRequireAsyncHooks, "tryRequireAsyncHooks");
+ function wrap2(fn2) {
+ var res;
+ if (asyncHooks.AsyncResource) {
+ res = new asyncHooks.AsyncResource(fn2.name || "bound-anonymous-fn");
+ }
+ if (!res || !res.runInAsyncScope) {
+ return fn2;
+ }
+ return res.runInAsyncScope.bind(res, fn2, null);
+ }
+ __name(wrap2, "wrap");
+ }
+});
+
+// ../../node_modules/.pnpm/body-parser@1.20.0_supports-color@9.2.2/node_modules/body-parser/lib/read.js
+var require_read = __commonJS({
+ "../../node_modules/.pnpm/body-parser@1.20.0_supports-color@9.2.2/node_modules/body-parser/lib/read.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var createError = require_http_errors();
+ var destroy = require_destroy();
+ var getBody = require_raw_body();
+ var iconv = require_lib3();
+ var onFinished = require_on_finished();
+ var unpipe = require_unpipe();
+ var zlib = require("zlib");
+ module2.exports = read;
+ function read(req, res, next, parse4, debug, options14) {
+ var length;
+ var opts = options14;
+ var stream2;
+ req._body = true;
+ var encoding = opts.encoding !== null ? opts.encoding : null;
+ var verify = opts.verify;
+ try {
+ stream2 = contentstream(req, debug, opts.inflate);
+ length = stream2.length;
+ stream2.length = void 0;
+ } catch (err) {
+ return next(err);
+ }
+ 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(stream2, 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 (stream2 !== req) {
+ unpipe(req);
+ destroy(stream2, true);
+ }
+ dump(req, /* @__PURE__ */ __name(function onfinished() {
+ next(createError(400, _error));
+ }, "onfinished"));
+ return;
+ }
+ if (verify) {
+ try {
+ debug("verify body");
+ verify(req, res, body, encoding);
+ } catch (err) {
+ next(createError(403, err, {
+ body,
+ type: err.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 = parse4(str);
+ } catch (err) {
+ next(createError(400, err, {
+ body: str,
+ type: err.type || "entity.parse.failed"
+ }));
+ return;
+ }
+ next();
+ });
+ }
+ __name(read, "read");
+ function contentstream(req, debug, inflate) {
+ var encoding = (req.headers["content-encoding"] || "identity").toLowerCase();
+ var length = req.headers["content-length"];
+ var stream2;
+ debug('content-encoding "%s"', encoding);
+ if (inflate === false && encoding !== "identity") {
+ throw createError(415, "content encoding unsupported", {
+ encoding,
+ type: "encoding.unsupported"
+ });
+ }
+ switch (encoding) {
+ case "deflate":
+ stream2 = zlib.createInflate();
+ debug("inflate body");
+ req.pipe(stream2);
+ break;
+ case "gzip":
+ stream2 = zlib.createGunzip();
+ debug("gunzip body");
+ req.pipe(stream2);
+ break;
+ case "identity":
+ stream2 = req;
+ stream2.length = length;
+ break;
+ default:
+ throw createError(415, 'unsupported content encoding "' + encoding + '"', {
+ encoding,
+ type: "encoding.unsupported"
+ });
+ }
+ return stream2;
+ }
+ __name(contentstream, "contentstream");
+ function dump(req, callback) {
+ if (onFinished.isFinished(req)) {
+ callback(null);
+ } else {
+ onFinished(req, callback);
+ req.resume();
+ }
+ }
+ __name(dump, "dump");
+ }
+});
+
+// ../../node_modules/.pnpm/media-typer@0.3.0/node_modules/media-typer/index.js
+var require_media_typer = __commonJS({
+ "../../node_modules/.pnpm/media-typer@0.3.0/node_modules/media-typer/index.js"(exports2) {
+ init_import_meta_url();
+ var paramRegExp = /; *([!#$%&'\*\+\-\.0-9A-Z\^_`a-z\|~]+) *= *("(?:[ !\u0023-\u005b\u005d-\u007e\u0080-\u00ff]|\\[\u0020-\u007e])*"|[!#$%&'\*\+\-\.0-9A-Z\^_`a-z\|~]+) */g;
+ var textRegExp = /^[\u0020-\u007e\u0080-\u00ff]+$/;
+ var tokenRegExp = /^[!#$%&'\*\+\-\.0-9A-Z\^_`a-z\|~]+$/;
+ var qescRegExp = /\\([\u0000-\u007f])/g;
+ var quoteRegExp = /([\\"])/g;
+ var subtypeNameRegExp = /^[A-Za-z0-9][A-Za-z0-9!#$&^_.-]{0,126}$/;
+ var typeNameRegExp = /^[A-Za-z0-9][A-Za-z0-9!#$&^_-]{0,126}$/;
+ var typeRegExp = /^ *([A-Za-z0-9][A-Za-z0-9!#$&^_-]{0,126})\/([A-Za-z0-9][A-Za-z0-9!#$&^_.+-]{0,126}) *$/;
+ exports2.format = format8;
+ exports2.parse = parse4;
+ function format8(obj) {
+ if (!obj || typeof obj !== "object") {
+ throw new TypeError("argument obj is required");
+ }
+ var parameters = obj.parameters;
+ var subtype = obj.subtype;
+ var suffix = obj.suffix;
+ var type = obj.type;
+ if (!type || !typeNameRegExp.test(type)) {
+ throw new TypeError("invalid type");
+ }
+ if (!subtype || !subtypeNameRegExp.test(subtype)) {
+ throw new TypeError("invalid subtype");
+ }
+ var string = type + "/" + subtype;
+ if (suffix) {
+ if (!typeNameRegExp.test(suffix)) {
+ throw new TypeError("invalid suffix");
+ }
+ string += "+" + suffix;
+ }
+ 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 (!tokenRegExp.test(param)) {
+ throw new TypeError("invalid parameter name");
+ }
+ string += "; " + param + "=" + qstring(parameters[param]);
+ }
+ }
+ return string;
+ }
+ __name(format8, "format");
+ function parse4(string) {
+ if (!string) {
+ throw new TypeError("argument string is required");
+ }
+ if (typeof string === "object") {
+ string = getcontenttype(string);
+ }
+ if (typeof string !== "string") {
+ throw new TypeError("argument string is required to be a string");
+ }
+ var index = string.indexOf(";");
+ var type = index !== -1 ? string.substr(0, index) : string;
+ var key;
+ var match;
+ var obj = splitType(type);
+ var params = {};
+ var value;
+ paramRegExp.lastIndex = index;
+ while (match = paramRegExp.exec(string)) {
+ if (match.index !== index) {
+ throw new TypeError("invalid parameter format");
+ }
+ index += match[0].length;
+ key = match[1].toLowerCase();
+ value = match[2];
+ if (value[0] === '"') {
+ value = value.substr(1, value.length - 2).replace(qescRegExp, "$1");
+ }
+ params[key] = value;
+ }
+ if (index !== -1 && index !== string.length) {
+ throw new TypeError("invalid parameter format");
+ }
+ obj.parameters = params;
+ return obj;
+ }
+ __name(parse4, "parse");
+ function getcontenttype(obj) {
+ if (typeof obj.getHeader === "function") {
+ return obj.getHeader("content-type");
+ }
+ if (typeof obj.headers === "object") {
+ return obj.headers && obj.headers["content-type"];
+ }
+ }
+ __name(getcontenttype, "getcontenttype");
+ function qstring(val) {
+ var str = String(val);
+ if (tokenRegExp.test(str)) {
+ return str;
+ }
+ if (str.length > 0 && !textRegExp.test(str)) {
+ throw new TypeError("invalid parameter value");
+ }
+ return '"' + str.replace(quoteRegExp, "\\$1") + '"';
+ }
+ __name(qstring, "qstring");
+ function splitType(string) {
+ var match = typeRegExp.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);
+ }
+ var obj = {
+ type,
+ subtype,
+ suffix
+ };
+ return obj;
+ }
+ __name(splitType, "splitType");
+ }
+});
+
+// ../../node_modules/.pnpm/mime-db@1.52.0/node_modules/mime-db/db.json
+var require_db = __commonJS({
+ "../../node_modules/.pnpm/mime-db@1.52.0/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/activemessage": {
+ source: "iana"
+ },
+ "application/activity+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-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/applefile": {
+ source: "iana"
+ },
+ "application/applixware": {
+ source: "apache",
+ extensions: ["aw"]
+ },
+ "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/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/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/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/cea": {
+ source: "iana"
+ },
+ "application/cea-2018+xml": {
+ source: "iana",
+ compressible: true
+ },
+ "application/cellml+xml": {
+ source: "iana",
+ compressible: true
+ },
+ "application/cfw": {
+ source: "iana"
+ },
+ "application/city+json": {
+ source: "iana",
+ compressible: true
+ },
+ "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-group+json": {
+ source: "iana",
+ compressible: true
+ },
+ "application/coap-payload": {
+ source: "iana"
+ },
+ "application/commonground": {
+ 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/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/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"
+ },
+ "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/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/ecmascript": {
+ source: "iana",
+ compressible: true,
+ extensions: ["es", "ecma"]
+ },
+ "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.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/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/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/geoxacml+xml": {
+ source: "iana",
+ compressible: true
+ },
+ "application/gltf-buffer": {
+ source: "iana"
+ },
+ "application/gml+xml": {
+ source: "iana",
+ compressible: true,
+ extensions: ["gml"]
+ },
+ "application/gpx+xml": {
+ source: "apache",
+ compressible: true,
+ extensions: ["gpx"]
+ },
+ "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/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: "apache",
+ 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: "iana",
+ charset: "UTF-8",
+ compressible: true,
+ extensions: ["js", "mjs"]
+ },
+ "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/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/jwk+json": {
+ source: "iana",
+ compressible: true
+ },
+ "application/jwk-set+json": {
+ source: "iana",
+ compressible: true
+ },
+ "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/load-control+xml": {
+ source: "iana",
+ compressible: true
+ },
+ "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: ["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/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: false,
+ 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/omdoc+xml": {
+ source: "apache",
+ compressible: true,
+ extensions: ["omdoc"]
+ },
+ "application/onenote": {
+ source: "apache",
+ extensions: ["onetoc", "onetoc2", "onetmp", "onepkg"]
+ },
+ "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: ["asc", "sig"]
+ },
+ "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/problem+json": {
+ source: "iana",
+ compressible: true
+ },
+ "application/problem+xml": {
+ source: "iana",
+ compressible: true
+ },
+ "application/provenance+xml": {
+ source: "iana",
+ compressible: true,
+ extensions: ["provx"]
+ },
+ "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.nprend": {
+ source: "iana"
+ },
+ "application/prs.plucker": {
+ source: "iana"
+ },
+ "application/prs.rdf-xml-crypt": {
+ source: "iana"
+ },
+ "application/prs.xsf+xml": {
+ source: "iana",
+ compressible: true
+ },
+ "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: "iana"
+ },
+ "application/reputon+json": {
+ source: "iana",
+ compressible: true
+ },
+ "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-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-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: "iana"
+ },
+ "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"
+ },
+ "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/ssml+xml": {
+ source: "iana",
+ compressible: true,
+ extensions: ["ssml"]
+ },
+ "application/stix+json": {
+ source: "iana",
+ compressible: true
+ },
+ "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/tnauthlist": {
+ source: "iana"
+ },
+ "application/token-introspection+jwt": {
+ source: "iana"
+ },
+ "application/toml": {
+ compressible: true,
+ extensions: ["toml"]
+ },
+ "application/trickle-ice-sdpfrag": {
+ source: "iana"
+ },
+ "application/trig": {
+ source: "iana",
+ extensions: ["trig"]
+ },
+ "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/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/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.3gpp-prose+xml": {
+ source: "iana",
+ compressible: true
+ },
+ "application/vnd.3gpp-prose-pc3ch+xml": {
+ source: "iana",
+ compressible: true
+ },
+ "application/vnd.3gpp-v2x-local-service-information": {
+ source: "iana"
+ },
+ "application/vnd.3gpp.5gnas": {
+ 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.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-payload": {
+ source: "iana"
+ },
+ "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-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-affiliation-info+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-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.s1ap": {
+ source: "iana"
+ },
+ "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.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.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: "iana",
+ 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: "iana"
+ },
+ "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.thrift.binary": {
+ source: "iana"
+ },
+ "application/vnd.apache.thrift.compact": {
+ source: "iana"
+ },
+ "application/vnd.apache.thrift.json": {
+ 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: "iana"
+ },
+ "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.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.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.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.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.datapackage+json": {
+ source: "iana",
+ compressible: true
+ },
+ "application/vnd.dataresource+json": {
+ source: "iana",
+ compressible: true
+ },
+ "application/vnd.dbf": {
+ source: "iana",
+ extensions: ["dbf"]
+ },
+ "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.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.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: "iana",
+ extensions: ["fdf"]
+ },
+ "application/vnd.fdsn.mseed": {
+ source: "iana",
+ extensions: ["mseed"]
+ },
+ "application/vnd.fdsn.seed": {
+ source: "iana",
+ extensions: ["seed", "dataless"]
+ },
+ "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.frogans.fnc": {
+ source: "iana",
+ extensions: ["fnc"]
+ },
+ "application/vnd.frogans.ltf": {
+ source: "iana",
+ 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.genomatix.tuxedo": {
+ source: "iana",
+ extensions: ["txd"]
+ },
+ "application/vnd.gentics.grd+json": {
+ source: "iana",
+ compressible: true
+ },
+ "application/vnd.geo+json": {
+ source: "iana",
+ compressible: true
+ },
+ "application/vnd.geocube+xml": {
+ source: "iana",
+ compressible: true
+ },
+ "application/vnd.geogebra.file": {
+ source: "iana",
+ extensions: ["ggb"]
+ },
+ "application/vnd.geogebra.slides": {
+ source: "iana"
+ },
+ "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.google-apps.document": {
+ compressible: false,
+ extensions: ["gdoc"]
+ },
+ "application/vnd.google-apps.presentation": {
+ compressible: false,
+ extensions: ["gslides"]
+ },
+ "application/vnd.google-apps.spreadsheet": {
+ compressible: false,
+ extensions: ["gsheet"]
+ },
+ "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: "iana",
+ compressible: true
+ },
+ "application/vnd.gov.sk.e-form+zip": {
+ source: "iana",
+ compressible: false
+ },
+ "application/vnd.gov.sk.xmldatacontainer+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.hl7cda+xml": {
+ source: "iana",
+ charset: "UTF-8",
+ compressible: true
+ },
+ "application/vnd.hl7v2+xml": {
+ source: "iana",
+ charset: "UTF-8",
+ compressible: true
+ },
+ "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.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: "iana"
+ },
+ "application/vnd.ibm.electronic-media": {
+ source: "iana"
+ },
+ "application/vnd.ibm.minipay": {
+ source: "iana",
+ extensions: ["mpy"]
+ },
+ "application/vnd.ibm.modcap": {
+ source: "iana",
+ 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: "iana"
+ },
+ "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.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.kenameaapp": {
+ source: "iana",
+ extensions: ["htke"]
+ },
+ "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.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.medcalcdata": {
+ source: "iana",
+ extensions: ["mc1"]
+ },
+ "application/vnd.mediastation.cdkey": {
+ source: "iana",
+ extensions: ["cdkey"]
+ },
+ "application/vnd.meridian-slingshot": {
+ 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.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-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.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.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: "iana",
+ 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.oasis.opendocument.chart": {
+ source: "iana",
+ extensions: ["odc"]
+ },
+ "application/vnd.oasis.opendocument.chart-template": {
+ source: "iana",
+ extensions: ["otc"]
+ },
+ "application/vnd.oasis.opendocument.database": {
+ source: "iana",
+ 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-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: "iana",
+ 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: "iana",
+ 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.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.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.proteus.magazine": {
+ source: "iana",
+ extensions: ["mgz"]
+ },
+ "application/vnd.psfs": {
+ 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
+ },
+ "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.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.smaf": {
+ source: "iana",
+ extensions: ["mmf"]
+ },
+ "application/vnd.smart.notebook": {
+ source: "iana"
+ },
+ "application/vnd.smart.teacher": {
+ source: "iana",
+ extensions: ["teacher"]
+ },
+ "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.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.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"]
+ },
+ "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.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"]
+ },
+ "application/vnd.visionary": {
+ source: "iana",
+ extensions: ["vis"]
+ },
+ "application/vnd.vividence.scriptfile": {
+ 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.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.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.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.youtube.yt": {
+ source: "iana"
+ },
+ "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/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-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-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-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-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/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/yang": {
+ source: "iana",
+ extensions: ["yang"]
+ },
+ "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/yin+xml": {
+ source: "iana",
+ compressible: true,
+ extensions: ["yin"]
+ },
+ "application/zip": {
+ source: "iana",
+ compressible: false,
+ extensions: ["zip"]
+ },
+ "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"
+ },
+ "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/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/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/mobile-xmf": {
+ source: "iana",
+ extensions: ["mxmf"]
+ },
+ "audio/mp3": {
+ compressible: false,
+ extensions: ["mp3"]
+ },
+ "audio/mp4": {
+ source: "iana",
+ compressible: false,
+ extensions: ["m4a", "mp4a"]
+ },
+ "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: "iana"
+ },
+ "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": {
+ 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"]
+ },
+ "image/cgm": {
+ source: "iana",
+ extensions: ["cgm"]
+ },
+ "image/dicom-rle": {
+ source: "iana",
+ extensions: ["drle"]
+ },
+ "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/hsj2": {
+ source: "iana",
+ extensions: ["hsj2"]
+ },
+ "image/ief": {
+ source: "iana",
+ extensions: ["ief"]
+ },
+ "image/jls": {
+ source: "iana",
+ extensions: ["jls"]
+ },
+ "image/jp2": {
+ source: "iana",
+ compressible: false,
+ extensions: ["jp2", "jpg2"]
+ },
+ "image/jpeg": {
+ source: "iana",
+ compressible: false,
+ extensions: ["jpeg", "jpg", "jpe"]
+ },
+ "image/jph": {
+ source: "iana",
+ extensions: ["jph"]
+ },
+ "image/jphc": {
+ source: "iana",
+ extensions: ["jhc"]
+ },
+ "image/jpm": {
+ source: "iana",
+ compressible: false,
+ extensions: ["jpm"]
+ },
+ "image/jpx": {
+ source: "iana",
+ compressible: false,
+ extensions: ["jpx", "jpf"]
+ },
+ "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
+ },
+ "image/png": {
+ source: "iana",
+ compressible: false,
+ extensions: ["png"]
+ },
+ "image/prs.btif": {
+ source: "iana",
+ extensions: ["btif"]
+ },
+ "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.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: "apache",
+ extensions: ["webp"]
+ },
+ "image/wmf": {
+ source: "iana",
+ extensions: ["wmf"]
+ },
+ "image/x-3ds": {
+ source: "apache",
+ extensions: ["3ds"]
+ },
+ "image/x-cmu-raster": {
+ source: "apache",
+ extensions: ["ras"]
+ },
+ "image/x-cmx": {
+ source: "apache",
+ extensions: ["cmx"]
+ },
+ "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-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/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/news": {
+ source: "iana"
+ },
+ "message/partial": {
+ source: "iana",
+ compressible: false
+ },
+ "message/rfc822": {
+ source: "iana",
+ compressible: true,
+ extensions: ["eml", "mime"]
+ },
+ "message/s-http": {
+ source: "iana"
+ },
+ "message/sip": {
+ source: "iana"
+ },
+ "message/sipfrag": {
+ source: "iana"
+ },
+ "message/tracking-status": {
+ source: "iana"
+ },
+ "message/vnd.si.simp": {
+ source: "iana"
+ },
+ "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/mesh": {
+ source: "iana",
+ compressible: false,
+ extensions: ["msh", "mesh", "silo"]
+ },
+ "model/mtl": {
+ source: "iana",
+ extensions: ["mtl"]
+ },
+ "model/obj": {
+ source: "iana",
+ extensions: ["obj"]
+ },
+ "model/step": {
+ source: "iana"
+ },
+ "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/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"
+ },
+ "model/vnd.rosette.annotated-data-model": {
+ source: "iana"
+ },
+ "model/vnd.sap.vds": {
+ source: "iana",
+ extensions: ["vds"]
+ },
+ "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: "iana"
+ },
+ "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/html": {
+ source: "iana",
+ compressible: true,
+ extensions: ["html", "htm", "shtml"]
+ },
+ "text/jade": {
+ extensions: ["jade"]
+ },
+ "text/javascript": {
+ source: "iana",
+ compressible: true
+ },
+ "text/jcr-cnd": {
+ source: "iana"
+ },
+ "text/jsx": {
+ compressible: true,
+ extensions: ["jsx"]
+ },
+ "text/less": {
+ compressible: true,
+ extensions: ["less"]
+ },
+ "text/markdown": {
+ source: "iana",
+ compressible: true,
+ extensions: ["markdown", "md"]
+ },
+ "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/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.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: "iana"
+ },
+ "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.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/vtt": {
+ source: "iana",
+ charset: "UTF-8",
+ compressible: true,
+ extensions: ["vtt"]
+ },
+ "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/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/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/mj2": {
+ source: "iana",
+ extensions: ["mj2", "mjp2"]
+ },
+ "video/mp1s": {
+ source: "iana"
+ },
+ "video/mp2p": {
+ source: "iana"
+ },
+ "video/mp2t": {
+ source: "iana",
+ extensions: ["ts"]
+ },
+ "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.radgamettools.bink": {
+ source: "iana"
+ },
+ "video/vnd.radgamettools.smacker": {
+ source: "iana"
+ },
+ "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
+ }
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/mime-db@1.52.0/node_modules/mime-db/index.js
+var require_mime_db = __commonJS({
+ "../../node_modules/.pnpm/mime-db@1.52.0/node_modules/mime-db/index.js"(exports2, module2) {
+ init_import_meta_url();
+ module2.exports = require_db();
+ }
+});
+
+// ../../node_modules/.pnpm/mime-types@2.1.35/node_modules/mime-types/index.js
+var require_mime_types = __commonJS({
+ "../../node_modules/.pnpm/mime-types@2.1.35/node_modules/mime-types/index.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ var db = require_mime_db();
+ var extname4 = require("path").extname;
+ var EXTRACT_TYPE_REGEXP = /^\s*([^;\s]*)(?:;|\s|$)/;
+ var TEXT_TYPE_REGEXP = /^text\//i;
+ exports2.charset = charset;
+ exports2.charsets = { lookup: charset };
+ exports2.contentType = contentType;
+ exports2.extension = extension;
+ exports2.extensions = /* @__PURE__ */ Object.create(null);
+ exports2.lookup = lookup;
+ exports2.types = /* @__PURE__ */ Object.create(null);
+ 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;
+ }
+ __name(charset, "charset");
+ function contentType(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;
+ }
+ __name(contentType, "contentType");
+ 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];
+ }
+ __name(extension, "extension");
+ function lookup(path45) {
+ if (!path45 || typeof path45 !== "string") {
+ return false;
+ }
+ var extension2 = extname4("x." + path45).toLowerCase().substr(1);
+ if (!extension2) {
+ return false;
+ }
+ return exports2.types[extension2] || false;
+ }
+ __name(lookup, "lookup");
+ function populateMaps(extensions, types) {
+ var preference = ["nginx", "apache", void 0, "iana"];
+ Object.keys(db).forEach(/* @__PURE__ */ __name(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];
+ if (types[extension2]) {
+ var from = preference.indexOf(db[types[extension2]].source);
+ var to = preference.indexOf(mime.source);
+ if (types[extension2] !== "application/octet-stream" && (from > to || from === to && types[extension2].substr(0, 12) === "application/")) {
+ continue;
+ }
+ }
+ types[extension2] = type;
+ }
+ }, "forEachMimeType"));
+ }
+ __name(populateMaps, "populateMaps");
+ }
+});
+
+// ../../node_modules/.pnpm/type-is@1.6.18/node_modules/type-is/index.js
+var require_type_is = __commonJS({
+ "../../node_modules/.pnpm/type-is@1.6.18/node_modules/type-is/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var typer = require_media_typer();
+ var mime = require_mime_types();
+ module2.exports = typeofrequest;
+ module2.exports.is = typeis;
+ module2.exports.hasBody = hasbody;
+ module2.exports.normalize = normalize2;
+ 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(normalize2(type = types[i]), val)) {
+ return type[0] === "+" || type.indexOf("*") !== -1 ? val : type;
+ }
+ }
+ return false;
+ }
+ __name(typeis, "typeis");
+ function hasbody(req) {
+ return req.headers["transfer-encoding"] !== void 0 || !isNaN(req.headers["content-length"]);
+ }
+ __name(hasbody, "hasbody");
+ function typeofrequest(req, types_) {
+ var types = types_;
+ if (!hasbody(req)) {
+ return null;
+ }
+ if (arguments.length > 2) {
+ types = new Array(arguments.length - 1);
+ for (var i = 0; i < types.length; i++) {
+ types[i] = arguments[i + 1];
+ }
+ }
+ var value = req.headers["content-type"];
+ return typeis(value, types);
+ }
+ __name(typeofrequest, "typeofrequest");
+ function normalize2(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;
+ }
+ __name(normalize2, "normalize");
+ 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].substr(0, 2) === "*+") {
+ return expectedParts[1].length <= actualParts[1].length + 1 && expectedParts[1].substr(1) === actualParts[1].substr(1 - expectedParts[1].length);
+ }
+ if (expectedParts[1] !== "*" && expectedParts[1] !== actualParts[1]) {
+ return false;
+ }
+ return true;
+ }
+ __name(mimeMatch, "mimeMatch");
+ function normalizeType(value) {
+ var type = typer.parse(value);
+ type.parameters = void 0;
+ return typer.format(type);
+ }
+ __name(normalizeType, "normalizeType");
+ function tryNormalizeType(value) {
+ if (!value) {
+ return null;
+ }
+ try {
+ return normalizeType(value);
+ } catch (err) {
+ return null;
+ }
+ }
+ __name(tryNormalizeType, "tryNormalizeType");
+ }
+});
+
+// ../../node_modules/.pnpm/body-parser@1.20.0_supports-color@9.2.2/node_modules/body-parser/lib/types/json.js
+var require_json = __commonJS({
+ "../../node_modules/.pnpm/body-parser@1.20.0_supports-color@9.2.2/node_modules/body-parser/lib/types/json.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var bytes = require_bytes();
+ var contentType = require_content_type();
+ var createError = require_http_errors();
+ var debug = require_src2()("body-parser:json");
+ var read = require_read();
+ var typeis = require_type_is();
+ module2.exports = json;
+ var FIRST_CHAR_REGEXP = /^[\x20\x09\x0a\x0d]*([^\x20\x09\x0a\x0d])/;
+ function json(options14) {
+ var opts = options14 || {};
+ var limit = typeof opts.limit !== "number" ? bytes.parse(opts.limit || "100kb") : opts.limit;
+ var inflate = opts.inflate !== false;
+ var reviver = opts.reviver;
+ var strict = opts.strict !== false;
+ var type = opts.type || "application/json";
+ var verify = opts.verify || false;
+ if (verify !== false && typeof verify !== "function") {
+ throw new TypeError("option verify must be function");
+ }
+ var shouldParse = typeof type !== "function" ? typeChecker(type) : type;
+ function parse4(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 (e2) {
+ throw normalizeJsonSyntaxError(e2, {
+ message: e2.message,
+ stack: e2.stack
+ });
+ }
+ }
+ __name(parse4, "parse");
+ return /* @__PURE__ */ __name(function jsonParser(req, res, next) {
+ if (req._body) {
+ debug("body already parsed");
+ next();
+ return;
+ }
+ req.body = req.body || {};
+ 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, parse4, debug, {
+ encoding: charset,
+ inflate,
+ limit,
+ verify
+ });
+ }, "jsonParser");
+ }
+ __name(json, "json");
+ function createStrictSyntaxError(str, char) {
+ var index = str.indexOf(char);
+ var partial = index !== -1 ? str.substring(0, index) + "#" : "";
+ try {
+ JSON.parse(partial);
+ throw new SyntaxError("strict violation");
+ } catch (e2) {
+ return normalizeJsonSyntaxError(e2, {
+ message: e2.message.replace("#", char),
+ stack: e2.stack
+ });
+ }
+ }
+ __name(createStrictSyntaxError, "createStrictSyntaxError");
+ function firstchar(str) {
+ var match = FIRST_CHAR_REGEXP.exec(str);
+ return match ? match[1] : void 0;
+ }
+ __name(firstchar, "firstchar");
+ function getCharset(req) {
+ try {
+ return (contentType.parse(req).parameters.charset || "").toLowerCase();
+ } catch (e2) {
+ return void 0;
+ }
+ }
+ __name(getCharset, "getCharset");
+ 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;
+ }
+ __name(normalizeJsonSyntaxError, "normalizeJsonSyntaxError");
+ function typeChecker(type) {
+ return /* @__PURE__ */ __name(function checkType2(req) {
+ return Boolean(typeis(req, type));
+ }, "checkType");
+ }
+ __name(typeChecker, "typeChecker");
+ }
+});
+
+// ../../node_modules/.pnpm/body-parser@1.20.0_supports-color@9.2.2/node_modules/body-parser/lib/types/raw.js
+var require_raw = __commonJS({
+ "../../node_modules/.pnpm/body-parser@1.20.0_supports-color@9.2.2/node_modules/body-parser/lib/types/raw.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var bytes = require_bytes();
+ var debug = require_src2()("body-parser:raw");
+ var read = require_read();
+ var typeis = require_type_is();
+ module2.exports = raw;
+ function raw(options14) {
+ var opts = options14 || {};
+ var inflate = opts.inflate !== false;
+ var limit = typeof opts.limit !== "number" ? bytes.parse(opts.limit || "100kb") : opts.limit;
+ var type = opts.type || "application/octet-stream";
+ var verify = opts.verify || false;
+ if (verify !== false && typeof verify !== "function") {
+ throw new TypeError("option verify must be function");
+ }
+ var shouldParse = typeof type !== "function" ? typeChecker(type) : type;
+ function parse4(buf) {
+ return buf;
+ }
+ __name(parse4, "parse");
+ return /* @__PURE__ */ __name(function rawParser(req, res, next) {
+ if (req._body) {
+ debug("body already parsed");
+ next();
+ return;
+ }
+ req.body = req.body || {};
+ 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, parse4, debug, {
+ encoding: null,
+ inflate,
+ limit,
+ verify
+ });
+ }, "rawParser");
+ }
+ __name(raw, "raw");
+ function typeChecker(type) {
+ return /* @__PURE__ */ __name(function checkType2(req) {
+ return Boolean(typeis(req, type));
+ }, "checkType");
+ }
+ __name(typeChecker, "typeChecker");
+ }
+});
+
+// ../../node_modules/.pnpm/body-parser@1.20.0_supports-color@9.2.2/node_modules/body-parser/lib/types/text.js
+var require_text3 = __commonJS({
+ "../../node_modules/.pnpm/body-parser@1.20.0_supports-color@9.2.2/node_modules/body-parser/lib/types/text.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var bytes = require_bytes();
+ var contentType = require_content_type();
+ var debug = require_src2()("body-parser:text");
+ var read = require_read();
+ var typeis = require_type_is();
+ module2.exports = text;
+ function text(options14) {
+ var opts = options14 || {};
+ var defaultCharset = opts.defaultCharset || "utf-8";
+ var inflate = opts.inflate !== false;
+ var limit = typeof opts.limit !== "number" ? bytes.parse(opts.limit || "100kb") : opts.limit;
+ var type = opts.type || "text/plain";
+ var verify = opts.verify || false;
+ if (verify !== false && typeof verify !== "function") {
+ throw new TypeError("option verify must be function");
+ }
+ var shouldParse = typeof type !== "function" ? typeChecker(type) : type;
+ function parse4(buf) {
+ return buf;
+ }
+ __name(parse4, "parse");
+ return /* @__PURE__ */ __name(function textParser(req, res, next) {
+ if (req._body) {
+ debug("body already parsed");
+ next();
+ return;
+ }
+ req.body = req.body || {};
+ 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, parse4, debug, {
+ encoding: charset,
+ inflate,
+ limit,
+ verify
+ });
+ }, "textParser");
+ }
+ __name(text, "text");
+ function getCharset(req) {
+ try {
+ return (contentType.parse(req).parameters.charset || "").toLowerCase();
+ } catch (e2) {
+ return void 0;
+ }
+ }
+ __name(getCharset, "getCharset");
+ function typeChecker(type) {
+ return /* @__PURE__ */ __name(function checkType2(req) {
+ return Boolean(typeis(req, type));
+ }, "checkType");
+ }
+ __name(typeChecker, "typeChecker");
+ }
+});
+
+// ../../node_modules/.pnpm/has-symbols@1.0.3/node_modules/has-symbols/shams.js
+var require_shams = __commonJS({
+ "../../node_modules/.pnpm/has-symbols@1.0.3/node_modules/has-symbols/shams.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ module2.exports = /* @__PURE__ */ __name(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 (sym 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 descriptor2 = Object.getOwnPropertyDescriptor(obj, sym);
+ if (descriptor2.value !== symVal || descriptor2.enumerable !== true) {
+ return false;
+ }
+ }
+ return true;
+ }, "hasSymbols");
+ }
+});
+
+// ../../node_modules/.pnpm/has-symbols@1.0.3/node_modules/has-symbols/index.js
+var require_has_symbols = __commonJS({
+ "../../node_modules/.pnpm/has-symbols@1.0.3/node_modules/has-symbols/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var origSymbol = typeof Symbol !== "undefined" && Symbol;
+ var hasSymbolSham = require_shams();
+ module2.exports = /* @__PURE__ */ __name(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();
+ }, "hasNativeSymbols");
+ }
+});
+
+// ../../node_modules/.pnpm/has-proto@1.0.1/node_modules/has-proto/index.js
+var require_has_proto = __commonJS({
+ "../../node_modules/.pnpm/has-proto@1.0.1/node_modules/has-proto/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var test = {
+ foo: {}
+ };
+ var $Object = Object;
+ module2.exports = /* @__PURE__ */ __name(function hasProto() {
+ return { __proto__: test }.foo === test.foo && !({ __proto__: null } instanceof $Object);
+ }, "hasProto");
+ }
+});
+
+// ../../node_modules/.pnpm/function-bind@1.1.1/node_modules/function-bind/implementation.js
+var require_implementation = __commonJS({
+ "../../node_modules/.pnpm/function-bind@1.1.1/node_modules/function-bind/implementation.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var ERROR_MESSAGE = "Function.prototype.bind called on incompatible ";
+ var slice = Array.prototype.slice;
+ var toStr = Object.prototype.toString;
+ var funcType = "[object Function]";
+ module2.exports = /* @__PURE__ */ __name(function bind(that) {
+ var target = this;
+ if (typeof target !== "function" || toStr.call(target) !== funcType) {
+ throw new TypeError(ERROR_MESSAGE + target);
+ }
+ var args = slice.call(arguments, 1);
+ var bound;
+ var binder = /* @__PURE__ */ __name(function() {
+ if (this instanceof bound) {
+ var result = target.apply(
+ this,
+ args.concat(slice.call(arguments))
+ );
+ if (Object(result) === result) {
+ return result;
+ }
+ return this;
+ } else {
+ return target.apply(
+ that,
+ args.concat(slice.call(arguments))
+ );
+ }
+ }, "binder");
+ var boundLength = Math.max(0, target.length - args.length);
+ var boundArgs = [];
+ for (var i = 0; i < boundLength; i++) {
+ boundArgs.push("$" + i);
+ }
+ bound = Function("binder", "return function (" + boundArgs.join(",") + "){ return binder.apply(this,arguments); }")(binder);
+ if (target.prototype) {
+ var Empty = /* @__PURE__ */ __name(function Empty2() {
+ }, "Empty");
+ Empty.prototype = target.prototype;
+ bound.prototype = new Empty();
+ Empty.prototype = null;
+ }
+ return bound;
+ }, "bind");
+ }
+});
+
+// ../../node_modules/.pnpm/function-bind@1.1.1/node_modules/function-bind/index.js
+var require_function_bind = __commonJS({
+ "../../node_modules/.pnpm/function-bind@1.1.1/node_modules/function-bind/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var implementation = require_implementation();
+ module2.exports = Function.prototype.bind || implementation;
+ }
+});
+
+// ../../node_modules/.pnpm/has@1.0.3/node_modules/has/src/index.js
+var require_src3 = __commonJS({
+ "../../node_modules/.pnpm/has@1.0.3/node_modules/has/src/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var bind = require_function_bind();
+ module2.exports = bind.call(Function.call, Object.prototype.hasOwnProperty);
+ }
+});
+
+// ../../node_modules/.pnpm/get-intrinsic@1.2.1/node_modules/get-intrinsic/index.js
+var require_get_intrinsic = __commonJS({
+ "../../node_modules/.pnpm/get-intrinsic@1.2.1/node_modules/get-intrinsic/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var undefined2;
+ var $SyntaxError = SyntaxError;
+ var $Function = Function;
+ var $TypeError = TypeError;
+ var getEvalledConstructor = /* @__PURE__ */ __name(function(expressionSyntax) {
+ try {
+ return $Function('"use strict"; return (' + expressionSyntax + ").constructor;")();
+ } catch (e2) {
+ }
+ }, "getEvalledConstructor");
+ var $gOPD = Object.getOwnPropertyDescriptor;
+ if ($gOPD) {
+ try {
+ $gOPD({}, "");
+ } catch (e2) {
+ $gOPD = null;
+ }
+ }
+ var throwTypeError = /* @__PURE__ */ __name(function() {
+ throw new $TypeError();
+ }, "throwTypeError");
+ 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 hasProto = require_has_proto()();
+ var getProto = Object.getPrototypeOf || (hasProto ? function(x) {
+ return x.__proto__;
+ } : null);
+ var needsEval = {};
+ var TypedArray = typeof Uint8Array === "undefined" || !getProto ? undefined2 : getProto(Uint8Array);
+ var INTRINSICS = {
+ "%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,
+ "%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,
+ "%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
+ };
+ if (getProto) {
+ try {
+ null.error;
+ } catch (e2) {
+ errorProto = getProto(getProto(e2));
+ INTRINSICS["%Error.prototype%"] = errorProto;
+ }
+ }
+ var errorProto;
+ var doEval = /* @__PURE__ */ __name(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 fn2 = doEval2("%AsyncGeneratorFunction%");
+ if (fn2) {
+ value = fn2.prototype;
+ }
+ } else if (name === "%AsyncIteratorPrototype%") {
+ var gen = doEval2("%AsyncGenerator%");
+ if (gen && getProto) {
+ value = getProto(gen.prototype);
+ }
+ }
+ INTRINSICS[name] = value;
+ return value;
+ }, "doEval");
+ var LEGACY_ALIASES = {
+ "%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_src3();
+ var $concat = bind.call(Function.call, Array.prototype.concat);
+ var $spliceApply = bind.call(Function.apply, Array.prototype.splice);
+ var $replace = bind.call(Function.call, String.prototype.replace);
+ var $strSlice = bind.call(Function.call, String.prototype.slice);
+ var $exec = bind.call(Function.call, RegExp.prototype.exec);
+ var rePropName = /[^%.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|%$))/g;
+ var reEscapeChar = /\\(\\)?/g;
+ var stringToPath = /* @__PURE__ */ __name(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;
+ }, "stringToPath");
+ var getBaseIntrinsic = /* @__PURE__ */ __name(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!");
+ }, "getBaseIntrinsic");
+ module2.exports = /* @__PURE__ */ __name(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 0;
+ }
+ 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;
+ }, "GetIntrinsic");
+ }
+});
+
+// ../../node_modules/.pnpm/call-bind@1.0.2/node_modules/call-bind/index.js
+var require_call_bind = __commonJS({
+ "../../node_modules/.pnpm/call-bind@1.0.2/node_modules/call-bind/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var bind = require_function_bind();
+ var GetIntrinsic = require_get_intrinsic();
+ var $apply = GetIntrinsic("%Function.prototype.apply%");
+ var $call = GetIntrinsic("%Function.prototype.call%");
+ var $reflectApply = GetIntrinsic("%Reflect.apply%", true) || bind.call($call, $apply);
+ var $gOPD = GetIntrinsic("%Object.getOwnPropertyDescriptor%", true);
+ var $defineProperty = GetIntrinsic("%Object.defineProperty%", true);
+ var $max = GetIntrinsic("%Math.max%");
+ if ($defineProperty) {
+ try {
+ $defineProperty({}, "a", { value: 1 });
+ } catch (e2) {
+ $defineProperty = null;
+ }
+ }
+ module2.exports = /* @__PURE__ */ __name(function callBind(originalFunction) {
+ var func = $reflectApply(bind, $call, arguments);
+ if ($gOPD && $defineProperty) {
+ var desc = $gOPD(func, "length");
+ if (desc.configurable) {
+ $defineProperty(
+ func,
+ "length",
+ { value: 1 + $max(0, originalFunction.length - (arguments.length - 1)) }
+ );
+ }
+ }
+ return func;
+ }, "callBind");
+ var applyBind = /* @__PURE__ */ __name(function applyBind2() {
+ return $reflectApply(bind, $apply, arguments);
+ }, "applyBind");
+ if ($defineProperty) {
+ $defineProperty(module2.exports, "apply", { value: applyBind });
+ } else {
+ module2.exports.apply = applyBind;
+ }
+ }
+});
+
+// ../../node_modules/.pnpm/call-bind@1.0.2/node_modules/call-bind/callBound.js
+var require_callBound = __commonJS({
+ "../../node_modules/.pnpm/call-bind@1.0.2/node_modules/call-bind/callBound.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var GetIntrinsic = require_get_intrinsic();
+ var callBind = require_call_bind();
+ var $indexOf = callBind(GetIntrinsic("String.prototype.indexOf"));
+ module2.exports = /* @__PURE__ */ __name(function callBoundIntrinsic(name, allowMissing) {
+ var intrinsic = GetIntrinsic(name, !!allowMissing);
+ if (typeof intrinsic === "function" && $indexOf(name, ".prototype.") > -1) {
+ return callBind(intrinsic);
+ }
+ return intrinsic;
+ }, "callBoundIntrinsic");
+ }
+});
+
+// ../../node_modules/.pnpm/object-inspect@1.12.3/node_modules/object-inspect/util.inspect.js
+var require_util_inspect = __commonJS({
+ "../../node_modules/.pnpm/object-inspect@1.12.3/node_modules/object-inspect/util.inspect.js"(exports2, module2) {
+ init_import_meta_url();
+ module2.exports = require("util").inspect;
+ }
+});
+
+// ../../node_modules/.pnpm/object-inspect@1.12.3/node_modules/object-inspect/index.js
+var require_object_inspect = __commonJS({
+ "../../node_modules/.pnpm/object-inspect@1.12.3/node_modules/object-inspect/index.js"(exports2, module2) {
+ init_import_meta_url();
+ 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, "$&_");
+ }
+ __name(addNumericSeparator, "addNumericSeparator");
+ var utilInspect2 = require_util_inspect();
+ var inspectCustom = utilInspect2.custom;
+ var inspectSymbol = isSymbol(inspectCustom) ? inspectCustom : null;
+ module2.exports = /* @__PURE__ */ __name(function inspect_(obj, options14, depth, seen) {
+ var opts = options14 || {};
+ if (has(opts, "quoteStyle") && (opts.quoteStyle !== "single" && opts.quoteStyle !== "double")) {
+ 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 inspect2(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);
+ }
+ __name(inspect2, "inspect");
+ if (typeof obj === "function" && !isRegExp(obj)) {
+ var name = nameOf(obj);
+ var keys = arrObjKeys(obj, inspect2);
+ 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, inspect2);
+ if (indent && !singleLineValues(xs)) {
+ return "[" + indentedJoin(xs, indent) + "]";
+ }
+ return "[ " + $join.call(xs, ", ") + " ]";
+ }
+ if (isError(obj)) {
+ var parts = arrObjKeys(obj, inspect2);
+ if (!("cause" in Error.prototype) && "cause" in obj && !isEnumerable.call(obj, "cause")) {
+ return "{ [" + String(obj) + "] " + $join.call($concat.call("[cause]: " + inspect2(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" && utilInspect2) {
+ return utilInspect2(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(inspect2(key, obj, true) + " => " + inspect2(value, obj));
+ });
+ }
+ return collectionOf("Map", mapSize.call(obj), mapParts, indent);
+ }
+ if (isSet(obj)) {
+ var setParts = [];
+ if (setForEach) {
+ setForEach.call(obj, function(value) {
+ setParts.push(inspect2(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(inspect2(Number(obj)));
+ }
+ if (isBigInt(obj)) {
+ return markBoxed(inspect2(bigIntValueOf.call(obj)));
+ }
+ if (isBoolean3(obj)) {
+ return markBoxed(booleanValueOf.call(obj));
+ }
+ if (isString2(obj)) {
+ return markBoxed(inspect2(String(obj)));
+ }
+ if (!isDate(obj) && !isRegExp(obj)) {
+ var ys = arrObjKeys(obj, inspect2);
+ 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);
+ }, "inspect_");
+ function wrapQuotes(s, defaultStyle, opts) {
+ var quoteChar = (opts.quoteStyle || defaultStyle) === "double" ? '"' : "'";
+ return quoteChar + s + quoteChar;
+ }
+ __name(wrapQuotes, "wrapQuotes");
+ function quote(s) {
+ return $replace.call(String(s), /"/g, """);
+ }
+ __name(quote, "quote");
+ function isArray(obj) {
+ return toStr(obj) === "[object Array]" && (!toStringTag || !(typeof obj === "object" && toStringTag in obj));
+ }
+ __name(isArray, "isArray");
+ function isDate(obj) {
+ return toStr(obj) === "[object Date]" && (!toStringTag || !(typeof obj === "object" && toStringTag in obj));
+ }
+ __name(isDate, "isDate");
+ function isRegExp(obj) {
+ return toStr(obj) === "[object RegExp]" && (!toStringTag || !(typeof obj === "object" && toStringTag in obj));
+ }
+ __name(isRegExp, "isRegExp");
+ function isError(obj) {
+ return toStr(obj) === "[object Error]" && (!toStringTag || !(typeof obj === "object" && toStringTag in obj));
+ }
+ __name(isError, "isError");
+ function isString2(obj) {
+ return toStr(obj) === "[object String]" && (!toStringTag || !(typeof obj === "object" && toStringTag in obj));
+ }
+ __name(isString2, "isString");
+ function isNumber(obj) {
+ return toStr(obj) === "[object Number]" && (!toStringTag || !(typeof obj === "object" && toStringTag in obj));
+ }
+ __name(isNumber, "isNumber");
+ function isBoolean3(obj) {
+ return toStr(obj) === "[object Boolean]" && (!toStringTag || !(typeof obj === "object" && toStringTag in obj));
+ }
+ __name(isBoolean3, "isBoolean");
+ 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 (e2) {
+ }
+ return false;
+ }
+ __name(isSymbol, "isSymbol");
+ function isBigInt(obj) {
+ if (!obj || typeof obj !== "object" || !bigIntValueOf) {
+ return false;
+ }
+ try {
+ bigIntValueOf.call(obj);
+ return true;
+ } catch (e2) {
+ }
+ return false;
+ }
+ __name(isBigInt, "isBigInt");
+ var hasOwn = Object.prototype.hasOwnProperty || function(key) {
+ return key in this;
+ };
+ function has(obj, key) {
+ return hasOwn.call(obj, key);
+ }
+ __name(has, "has");
+ function toStr(obj) {
+ return objectToString.call(obj);
+ }
+ __name(toStr, "toStr");
+ 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;
+ }
+ __name(nameOf, "nameOf");
+ 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;
+ }
+ __name(indexOf, "indexOf");
+ 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 (e2) {
+ }
+ return false;
+ }
+ __name(isMap, "isMap");
+ 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 (e2) {
+ }
+ return false;
+ }
+ __name(isWeakMap, "isWeakMap");
+ function isWeakRef(x) {
+ if (!weakRefDeref || !x || typeof x !== "object") {
+ return false;
+ }
+ try {
+ weakRefDeref.call(x);
+ return true;
+ } catch (e2) {
+ }
+ return false;
+ }
+ __name(isWeakRef, "isWeakRef");
+ 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 (e2) {
+ }
+ return false;
+ }
+ __name(isSet, "isSet");
+ 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 (e2) {
+ }
+ return false;
+ }
+ __name(isWeakSet, "isWeakSet");
+ 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";
+ }
+ __name(isElement, "isElement");
+ 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 s = $replace.call($replace.call(str, /(['\\])/g, "\\$1"), /[\x00-\x1f]/g, lowbyte);
+ return wrapQuotes(s, "single", opts);
+ }
+ __name(inspectString, "inspectString");
+ 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));
+ }
+ __name(lowbyte, "lowbyte");
+ function markBoxed(str) {
+ return "Object(" + str + ")";
+ }
+ __name(markBoxed, "markBoxed");
+ function weakCollectionOf(type) {
+ return type + " { ? }";
+ }
+ __name(weakCollectionOf, "weakCollectionOf");
+ function collectionOf(type, size, entries, indent) {
+ var joinedEntries = indent ? indentedJoin(entries, indent) : $join.call(entries, ", ");
+ return type + " (" + size + ") {" + joinedEntries + "}";
+ }
+ __name(collectionOf, "collectionOf");
+ function singleLineValues(xs) {
+ for (var i = 0; i < xs.length; i++) {
+ if (indexOf(xs[i], "\n") >= 0) {
+ return false;
+ }
+ }
+ return true;
+ }
+ __name(singleLineValues, "singleLineValues");
+ 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)
+ };
+ }
+ __name(getIndent, "getIndent");
+ 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;
+ }
+ __name(indentedJoin, "indentedJoin");
+ function arrObjKeys(obj, inspect2) {
+ 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) ? inspect2(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(inspect2(key, obj) + ": " + inspect2(obj[key], obj));
+ } else {
+ xs.push(key + ": " + inspect2(obj[key], obj));
+ }
+ }
+ if (typeof gOPS === "function") {
+ for (var j = 0; j < syms.length; j++) {
+ if (isEnumerable.call(obj, syms[j])) {
+ xs.push("[" + inspect2(syms[j]) + "]: " + inspect2(obj[syms[j]], obj));
+ }
+ }
+ }
+ return xs;
+ }
+ __name(arrObjKeys, "arrObjKeys");
+ }
+});
+
+// ../../node_modules/.pnpm/side-channel@1.0.4/node_modules/side-channel/index.js
+var require_side_channel = __commonJS({
+ "../../node_modules/.pnpm/side-channel@1.0.4/node_modules/side-channel/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var GetIntrinsic = require_get_intrinsic();
+ var callBound = require_callBound();
+ var inspect2 = require_object_inspect();
+ var $TypeError = GetIntrinsic("%TypeError%");
+ var $WeakMap = GetIntrinsic("%WeakMap%", true);
+ var $Map = GetIntrinsic("%Map%", true);
+ var $weakMapGet = callBound("WeakMap.prototype.get", true);
+ var $weakMapSet = callBound("WeakMap.prototype.set", true);
+ var $weakMapHas = callBound("WeakMap.prototype.has", true);
+ var $mapGet = callBound("Map.prototype.get", true);
+ var $mapSet = callBound("Map.prototype.set", true);
+ var $mapHas = callBound("Map.prototype.has", true);
+ var listGetNode = /* @__PURE__ */ __name(function(list, key) {
+ for (var prev = list, curr; (curr = prev.next) !== null; prev = curr) {
+ if (curr.key === key) {
+ prev.next = curr.next;
+ curr.next = list.next;
+ list.next = curr;
+ return curr;
+ }
+ }
+ }, "listGetNode");
+ var listGet = /* @__PURE__ */ __name(function(objects, key) {
+ var node = listGetNode(objects, key);
+ return node && node.value;
+ }, "listGet");
+ var listSet = /* @__PURE__ */ __name(function(objects, key, value) {
+ var node = listGetNode(objects, key);
+ if (node) {
+ node.value = value;
+ } else {
+ objects.next = {
+ // eslint-disable-line no-param-reassign
+ key,
+ next: objects.next,
+ value
+ };
+ }
+ }, "listSet");
+ var listHas = /* @__PURE__ */ __name(function(objects, key) {
+ return !!listGetNode(objects, key);
+ }, "listHas");
+ module2.exports = /* @__PURE__ */ __name(function getSideChannel() {
+ var $wm;
+ var $m;
+ var $o;
+ var channel = {
+ assert: function(key) {
+ if (!channel.has(key)) {
+ throw new $TypeError("Side channel does not contain " + inspect2(key));
+ }
+ },
+ get: function(key) {
+ if ($WeakMap && key && (typeof key === "object" || typeof key === "function")) {
+ if ($wm) {
+ return $weakMapGet($wm, key);
+ }
+ } else if ($Map) {
+ if ($m) {
+ return $mapGet($m, key);
+ }
+ } else {
+ if ($o) {
+ return listGet($o, key);
+ }
+ }
+ },
+ has: function(key) {
+ if ($WeakMap && key && (typeof key === "object" || typeof key === "function")) {
+ if ($wm) {
+ return $weakMapHas($wm, key);
+ }
+ } else if ($Map) {
+ if ($m) {
+ return $mapHas($m, key);
+ }
+ } else {
+ if ($o) {
+ return listHas($o, key);
+ }
+ }
+ return false;
+ },
+ set: function(key, value) {
+ if ($WeakMap && key && (typeof key === "object" || typeof key === "function")) {
+ if (!$wm) {
+ $wm = new $WeakMap();
+ }
+ $weakMapSet($wm, key, value);
+ } else if ($Map) {
+ if (!$m) {
+ $m = new $Map();
+ }
+ $mapSet($m, key, value);
+ } else {
+ if (!$o) {
+ $o = { key: {}, next: null };
+ }
+ listSet($o, key, value);
+ }
+ }
+ };
+ return channel;
+ }, "getSideChannel");
+ }
+});
+
+// ../../node_modules/.pnpm/qs@6.10.3/node_modules/qs/lib/formats.js
+var require_formats = __commonJS({
+ "../../node_modules/.pnpm/qs@6.10.3/node_modules/qs/lib/formats.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ 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
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/qs@6.10.3/node_modules/qs/lib/utils.js
+var require_utils4 = __commonJS({
+ "../../node_modules/.pnpm/qs@6.10.3/node_modules/qs/lib/utils.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var formats = require_formats();
+ 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 = /* @__PURE__ */ __name(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;
+ }
+ }
+ }, "compactQueue");
+ var arrayToObject = /* @__PURE__ */ __name(function arrayToObject2(source, options14) {
+ var obj = options14 && options14.plainObjects ? /* @__PURE__ */ Object.create(null) : {};
+ for (var i = 0; i < source.length; ++i) {
+ if (typeof source[i] !== "undefined") {
+ obj[i] = source[i];
+ }
+ }
+ return obj;
+ }, "arrayToObject");
+ var merge = /* @__PURE__ */ __name(function merge2(target, source, options14) {
+ if (!source) {
+ return target;
+ }
+ if (typeof source !== "object") {
+ if (isArray(target)) {
+ target.push(source);
+ } else if (target && typeof target === "object") {
+ if (options14 && (options14.plainObjects || options14.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, options14);
+ }
+ 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, options14);
+ } 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, options14);
+ } else {
+ acc[key] = value;
+ }
+ return acc;
+ }, mergeTarget);
+ }, "merge");
+ var assign = /* @__PURE__ */ __name(function assignSingleSource(target, source) {
+ return Object.keys(source).reduce(function(acc, key) {
+ acc[key] = source[key];
+ return acc;
+ }, target);
+ }, "assignSingleSource");
+ var decode = /* @__PURE__ */ __name(function(str, decoder, 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 (e2) {
+ return strWithoutPlus;
+ }
+ }, "decode");
+ var encode = /* @__PURE__ */ __name(function encode2(str, defaultEncoder, charset, kind, format8) {
+ 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 i = 0; i < string.length; ++i) {
+ var c = string.charCodeAt(i);
+ if (c === 45 || c === 46 || c === 95 || c === 126 || c >= 48 && c <= 57 || c >= 65 && c <= 90 || c >= 97 && c <= 122 || format8 === formats.RFC1738 && (c === 40 || c === 41)) {
+ out += string.charAt(i);
+ continue;
+ }
+ if (c < 128) {
+ out = out + hexTable[c];
+ continue;
+ }
+ if (c < 2048) {
+ out = out + (hexTable[192 | c >> 6] + hexTable[128 | c & 63]);
+ continue;
+ }
+ if (c < 55296 || c >= 57344) {
+ out = out + (hexTable[224 | c >> 12] + hexTable[128 | c >> 6 & 63] + hexTable[128 | c & 63]);
+ continue;
+ }
+ i += 1;
+ c = 65536 + ((c & 1023) << 10 | string.charCodeAt(i) & 1023);
+ out += hexTable[240 | c >> 18] + hexTable[128 | c >> 12 & 63] + hexTable[128 | c >> 6 & 63] + hexTable[128 | c & 63];
+ }
+ return out;
+ }, "encode");
+ var compact = /* @__PURE__ */ __name(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;
+ }, "compact");
+ var isRegExp = /* @__PURE__ */ __name(function isRegExp2(obj) {
+ return Object.prototype.toString.call(obj) === "[object RegExp]";
+ }, "isRegExp");
+ var isBuffer = /* @__PURE__ */ __name(function isBuffer2(obj) {
+ if (!obj || typeof obj !== "object") {
+ return false;
+ }
+ return !!(obj.constructor && obj.constructor.isBuffer && obj.constructor.isBuffer(obj));
+ }, "isBuffer");
+ var combine = /* @__PURE__ */ __name(function combine2(a, b) {
+ return [].concat(a, b);
+ }, "combine");
+ var maybeMap = /* @__PURE__ */ __name(function maybeMap2(val, fn2) {
+ if (isArray(val)) {
+ var mapped = [];
+ for (var i = 0; i < val.length; i += 1) {
+ mapped.push(fn2(val[i]));
+ }
+ return mapped;
+ }
+ return fn2(val);
+ }, "maybeMap");
+ module2.exports = {
+ arrayToObject,
+ assign,
+ combine,
+ compact,
+ decode,
+ encode,
+ isBuffer,
+ isRegExp,
+ maybeMap,
+ merge
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/qs@6.10.3/node_modules/qs/lib/stringify.js
+var require_stringify2 = __commonJS({
+ "../../node_modules/.pnpm/qs@6.10.3/node_modules/qs/lib/stringify.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var getSideChannel = require_side_channel();
+ var utils = require_utils4();
+ var formats = require_formats();
+ var has = Object.prototype.hasOwnProperty;
+ var arrayPrefixGenerators = {
+ brackets: /* @__PURE__ */ __name(function brackets(prefix) {
+ return prefix + "[]";
+ }, "brackets"),
+ comma: "comma",
+ indices: /* @__PURE__ */ __name(function indices(prefix, key) {
+ return prefix + "[" + key + "]";
+ }, "indices"),
+ repeat: /* @__PURE__ */ __name(function repeat(prefix) {
+ return prefix;
+ }, "repeat")
+ };
+ var isArray = Array.isArray;
+ var split = String.prototype.split;
+ var push = Array.prototype.push;
+ var pushToArray = /* @__PURE__ */ __name(function(arr, valueOrArray) {
+ push.apply(arr, isArray(valueOrArray) ? valueOrArray : [valueOrArray]);
+ }, "pushToArray");
+ var toISO = Date.prototype.toISOString;
+ var defaultFormat = formats["default"];
+ var defaults = {
+ addQueryPrefix: false,
+ allowDots: false,
+ charset: "utf-8",
+ charsetSentinel: false,
+ delimiter: "&",
+ encode: true,
+ encoder: utils.encode,
+ encodeValuesOnly: false,
+ format: defaultFormat,
+ formatter: formats.formatters[defaultFormat],
+ // deprecated
+ indices: false,
+ serializeDate: /* @__PURE__ */ __name(function serializeDate(date) {
+ return toISO.call(date);
+ }, "serializeDate"),
+ skipNulls: false,
+ strictNullHandling: false
+ };
+ var isNonNullishPrimitive = /* @__PURE__ */ __name(function isNonNullishPrimitive2(v) {
+ return typeof v === "string" || typeof v === "number" || typeof v === "boolean" || typeof v === "symbol" || typeof v === "bigint";
+ }, "isNonNullishPrimitive");
+ var sentinel = {};
+ var stringify = /* @__PURE__ */ __name(function stringify2(object, prefix, generateArrayPrefix, strictNullHandling, skipNulls, encoder, filter, sort, allowDots, serializeDate, format8, 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", format8) : prefix;
+ }
+ obj = "";
+ }
+ if (isNonNullishPrimitive(obj) || utils.isBuffer(obj)) {
+ if (encoder) {
+ var keyValue = encodeValuesOnly ? prefix : encoder(prefix, defaults.encoder, charset, "key", format8);
+ if (generateArrayPrefix === "comma" && encodeValuesOnly) {
+ var valuesArray = split.call(String(obj), ",");
+ var valuesJoined = "";
+ for (var i = 0; i < valuesArray.length; ++i) {
+ valuesJoined += (i === 0 ? "" : ",") + formatter(encoder(valuesArray[i], defaults.encoder, charset, "value", format8));
+ }
+ return [formatter(keyValue) + "=" + valuesJoined];
+ }
+ return [formatter(keyValue) + "=" + formatter(encoder(obj, defaults.encoder, charset, "value", format8))];
+ }
+ return [formatter(prefix) + "=" + formatter(String(obj))];
+ }
+ var values = [];
+ if (typeof obj === "undefined") {
+ return values;
+ }
+ var objKeys;
+ if (generateArrayPrefix === "comma" && isArray(obj)) {
+ 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;
+ }
+ for (var j = 0; j < objKeys.length; ++j) {
+ var key = objKeys[j];
+ var value = typeof key === "object" && typeof key.value !== "undefined" ? key.value : obj[key];
+ if (skipNulls && value === null) {
+ continue;
+ }
+ var keyPrefix = isArray(obj) ? typeof generateArrayPrefix === "function" ? generateArrayPrefix(prefix, key) : prefix : prefix + (allowDots ? "." + key : "[" + key + "]");
+ sideChannel.set(object, step);
+ var valueSideChannel = getSideChannel();
+ valueSideChannel.set(sentinel, sideChannel);
+ pushToArray(values, stringify2(
+ value,
+ keyPrefix,
+ generateArrayPrefix,
+ strictNullHandling,
+ skipNulls,
+ encoder,
+ filter,
+ sort,
+ allowDots,
+ serializeDate,
+ format8,
+ formatter,
+ encodeValuesOnly,
+ charset,
+ valueSideChannel
+ ));
+ }
+ return values;
+ }, "stringify");
+ var normalizeStringifyOptions = /* @__PURE__ */ __name(function normalizeStringifyOptions2(opts) {
+ if (!opts) {
+ return defaults;
+ }
+ 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 format8 = formats["default"];
+ if (typeof opts.format !== "undefined") {
+ if (!has.call(formats.formatters, opts.format)) {
+ throw new TypeError("Unknown format option provided.");
+ }
+ format8 = opts.format;
+ }
+ var formatter = formats.formatters[format8];
+ var filter = defaults.filter;
+ if (typeof opts.filter === "function" || isArray(opts.filter)) {
+ filter = opts.filter;
+ }
+ return {
+ addQueryPrefix: typeof opts.addQueryPrefix === "boolean" ? opts.addQueryPrefix : defaults.addQueryPrefix,
+ allowDots: typeof opts.allowDots === "undefined" ? defaults.allowDots : !!opts.allowDots,
+ charset,
+ charsetSentinel: typeof opts.charsetSentinel === "boolean" ? opts.charsetSentinel : defaults.charsetSentinel,
+ delimiter: typeof opts.delimiter === "undefined" ? defaults.delimiter : opts.delimiter,
+ encode: typeof opts.encode === "boolean" ? opts.encode : defaults.encode,
+ encoder: typeof opts.encoder === "function" ? opts.encoder : defaults.encoder,
+ encodeValuesOnly: typeof opts.encodeValuesOnly === "boolean" ? opts.encodeValuesOnly : defaults.encodeValuesOnly,
+ filter,
+ format: format8,
+ 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
+ };
+ }, "normalizeStringifyOptions");
+ module2.exports = function(object, opts) {
+ var obj = object;
+ var options14 = normalizeStringifyOptions(opts);
+ var objKeys;
+ var filter;
+ if (typeof options14.filter === "function") {
+ filter = options14.filter;
+ obj = filter("", obj);
+ } else if (isArray(options14.filter)) {
+ filter = options14.filter;
+ objKeys = filter;
+ }
+ var keys = [];
+ if (typeof obj !== "object" || obj === null) {
+ return "";
+ }
+ var arrayFormat;
+ if (opts && opts.arrayFormat in arrayPrefixGenerators) {
+ arrayFormat = opts.arrayFormat;
+ } else if (opts && "indices" in opts) {
+ arrayFormat = opts.indices ? "indices" : "repeat";
+ } else {
+ arrayFormat = "indices";
+ }
+ var generateArrayPrefix = arrayPrefixGenerators[arrayFormat];
+ if (!objKeys) {
+ objKeys = Object.keys(obj);
+ }
+ if (options14.sort) {
+ objKeys.sort(options14.sort);
+ }
+ var sideChannel = getSideChannel();
+ for (var i = 0; i < objKeys.length; ++i) {
+ var key = objKeys[i];
+ if (options14.skipNulls && obj[key] === null) {
+ continue;
+ }
+ pushToArray(keys, stringify(
+ obj[key],
+ key,
+ generateArrayPrefix,
+ options14.strictNullHandling,
+ options14.skipNulls,
+ options14.encode ? options14.encoder : null,
+ options14.filter,
+ options14.sort,
+ options14.allowDots,
+ options14.serializeDate,
+ options14.format,
+ options14.formatter,
+ options14.encodeValuesOnly,
+ options14.charset,
+ sideChannel
+ ));
+ }
+ var joined = keys.join(options14.delimiter);
+ var prefix = options14.addQueryPrefix === true ? "?" : "";
+ if (options14.charsetSentinel) {
+ if (options14.charset === "iso-8859-1") {
+ prefix += "utf8=%26%2310003%3B&";
+ } else {
+ prefix += "utf8=%E2%9C%93&";
+ }
+ }
+ return joined.length > 0 ? prefix + joined : "";
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/qs@6.10.3/node_modules/qs/lib/parse.js
+var require_parse4 = __commonJS({
+ "../../node_modules/.pnpm/qs@6.10.3/node_modules/qs/lib/parse.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var utils = require_utils4();
+ var has = Object.prototype.hasOwnProperty;
+ var isArray = Array.isArray;
+ var defaults = {
+ allowDots: false,
+ allowPrototypes: false,
+ allowSparse: false,
+ arrayLimit: 20,
+ charset: "utf-8",
+ charsetSentinel: false,
+ comma: false,
+ decoder: utils.decode,
+ delimiter: "&",
+ depth: 5,
+ ignoreQueryPrefix: false,
+ interpretNumericEntities: false,
+ parameterLimit: 1e3,
+ parseArrays: true,
+ plainObjects: false,
+ strictNullHandling: false
+ };
+ var interpretNumericEntities = /* @__PURE__ */ __name(function(str) {
+ return str.replace(/&#(\d+);/g, function($0, numberStr) {
+ return String.fromCharCode(parseInt(numberStr, 10));
+ });
+ }, "interpretNumericEntities");
+ var parseArrayValue = /* @__PURE__ */ __name(function(val, options14) {
+ if (val && typeof val === "string" && options14.comma && val.indexOf(",") > -1) {
+ return val.split(",");
+ }
+ return val;
+ }, "parseArrayValue");
+ var isoSentinel = "utf8=%26%2310003%3B";
+ var charsetSentinel = "utf8=%E2%9C%93";
+ var parseValues = /* @__PURE__ */ __name(function parseQueryStringValues(str, options14) {
+ var obj = {};
+ var cleanStr = options14.ignoreQueryPrefix ? str.replace(/^\?/, "") : str;
+ var limit = options14.parameterLimit === Infinity ? void 0 : options14.parameterLimit;
+ var parts = cleanStr.split(options14.delimiter, limit);
+ var skipIndex = -1;
+ var i;
+ var charset = options14.charset;
+ if (options14.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, val;
+ if (pos === -1) {
+ key = options14.decoder(part, defaults.decoder, charset, "key");
+ val = options14.strictNullHandling ? null : "";
+ } else {
+ key = options14.decoder(part.slice(0, pos), defaults.decoder, charset, "key");
+ val = utils.maybeMap(
+ parseArrayValue(part.slice(pos + 1), options14),
+ function(encodedVal) {
+ return options14.decoder(encodedVal, defaults.decoder, charset, "value");
+ }
+ );
+ }
+ if (val && options14.interpretNumericEntities && charset === "iso-8859-1") {
+ val = interpretNumericEntities(val);
+ }
+ if (part.indexOf("[]=") > -1) {
+ val = isArray(val) ? [val] : val;
+ }
+ if (has.call(obj, key)) {
+ obj[key] = utils.combine(obj[key], val);
+ } else {
+ obj[key] = val;
+ }
+ }
+ return obj;
+ }, "parseQueryStringValues");
+ var parseObject = /* @__PURE__ */ __name(function(chain, val, options14, valuesParsed) {
+ var leaf = valuesParsed ? val : parseArrayValue(val, options14);
+ for (var i = chain.length - 1; i >= 0; --i) {
+ var obj;
+ var root = chain[i];
+ if (root === "[]" && options14.parseArrays) {
+ obj = [].concat(leaf);
+ } else {
+ obj = options14.plainObjects ? /* @__PURE__ */ Object.create(null) : {};
+ var cleanRoot = root.charAt(0) === "[" && root.charAt(root.length - 1) === "]" ? root.slice(1, -1) : root;
+ var index = parseInt(cleanRoot, 10);
+ if (!options14.parseArrays && cleanRoot === "") {
+ obj = { 0: leaf };
+ } else if (!isNaN(index) && root !== cleanRoot && String(index) === cleanRoot && index >= 0 && (options14.parseArrays && index <= options14.arrayLimit)) {
+ obj = [];
+ obj[index] = leaf;
+ } else if (cleanRoot !== "__proto__") {
+ obj[cleanRoot] = leaf;
+ }
+ }
+ leaf = obj;
+ }
+ return leaf;
+ }, "parseObject");
+ var parseKeys = /* @__PURE__ */ __name(function parseQueryStringKeys(givenKey, val, options14, valuesParsed) {
+ if (!givenKey) {
+ return;
+ }
+ var key = options14.allowDots ? givenKey.replace(/\.([^.[]+)/g, "[$1]") : givenKey;
+ var brackets = /(\[[^[\]]*])/;
+ var child = /(\[[^[\]]*])/g;
+ var segment = options14.depth > 0 && brackets.exec(key);
+ var parent = segment ? key.slice(0, segment.index) : key;
+ var keys = [];
+ if (parent) {
+ if (!options14.plainObjects && has.call(Object.prototype, parent)) {
+ if (!options14.allowPrototypes) {
+ return;
+ }
+ }
+ keys.push(parent);
+ }
+ var i = 0;
+ while (options14.depth > 0 && (segment = child.exec(key)) !== null && i < options14.depth) {
+ i += 1;
+ if (!options14.plainObjects && has.call(Object.prototype, segment[1].slice(1, -1))) {
+ if (!options14.allowPrototypes) {
+ return;
+ }
+ }
+ keys.push(segment[1]);
+ }
+ if (segment) {
+ keys.push("[" + key.slice(segment.index) + "]");
+ }
+ return parseObject(keys, val, options14, valuesParsed);
+ }, "parseQueryStringKeys");
+ var normalizeParseOptions = /* @__PURE__ */ __name(function normalizeParseOptions2(opts) {
+ if (!opts) {
+ return defaults;
+ }
+ if (opts.decoder !== null && opts.decoder !== void 0 && 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");
+ }
+ var charset = typeof opts.charset === "undefined" ? defaults.charset : opts.charset;
+ return {
+ allowDots: typeof opts.allowDots === "undefined" ? defaults.allowDots : !!opts.allowDots,
+ 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,
+ 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,
+ 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,
+ strictNullHandling: typeof opts.strictNullHandling === "boolean" ? opts.strictNullHandling : defaults.strictNullHandling
+ };
+ }, "normalizeParseOptions");
+ module2.exports = function(str, opts) {
+ var options14 = normalizeParseOptions(opts);
+ if (str === "" || str === null || typeof str === "undefined") {
+ return options14.plainObjects ? /* @__PURE__ */ Object.create(null) : {};
+ }
+ var tempObj = typeof str === "string" ? parseValues(str, options14) : str;
+ var obj = options14.plainObjects ? /* @__PURE__ */ Object.create(null) : {};
+ var keys = Object.keys(tempObj);
+ for (var i = 0; i < keys.length; ++i) {
+ var key = keys[i];
+ var newObj = parseKeys(key, tempObj[key], options14, typeof str === "string");
+ obj = utils.merge(obj, newObj, options14);
+ }
+ if (options14.allowSparse === true) {
+ return obj;
+ }
+ return utils.compact(obj);
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/qs@6.10.3/node_modules/qs/lib/index.js
+var require_lib4 = __commonJS({
+ "../../node_modules/.pnpm/qs@6.10.3/node_modules/qs/lib/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var stringify = require_stringify2();
+ var parse4 = require_parse4();
+ var formats = require_formats();
+ module2.exports = {
+ formats,
+ parse: parse4,
+ stringify
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/body-parser@1.20.0_supports-color@9.2.2/node_modules/body-parser/lib/types/urlencoded.js
+var require_urlencoded2 = __commonJS({
+ "../../node_modules/.pnpm/body-parser@1.20.0_supports-color@9.2.2/node_modules/body-parser/lib/types/urlencoded.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var bytes = require_bytes();
+ var contentType = require_content_type();
+ var createError = require_http_errors();
+ var debug = require_src2()("body-parser:urlencoded");
+ var deprecate = require_depd()("body-parser");
+ var read = require_read();
+ var typeis = require_type_is();
+ module2.exports = urlencoded;
+ var parsers = /* @__PURE__ */ Object.create(null);
+ function urlencoded(options14) {
+ var opts = options14 || {};
+ if (opts.extended === void 0) {
+ deprecate("undefined extended: provide extended option");
+ }
+ var extended = opts.extended !== false;
+ var inflate = opts.inflate !== false;
+ var limit = typeof opts.limit !== "number" ? bytes.parse(opts.limit || "100kb") : opts.limit;
+ var type = opts.type || "application/x-www-form-urlencoded";
+ var verify = opts.verify || false;
+ if (verify !== false && typeof verify !== "function") {
+ throw new TypeError("option verify must be function");
+ }
+ var queryparse = extended ? extendedparser(opts) : simpleparser(opts);
+ var shouldParse = typeof type !== "function" ? typeChecker(type) : type;
+ function parse4(body) {
+ return body.length ? queryparse(body) : {};
+ }
+ __name(parse4, "parse");
+ return /* @__PURE__ */ __name(function urlencodedParser(req, res, next) {
+ if (req._body) {
+ debug("body already parsed");
+ next();
+ return;
+ }
+ req.body = req.body || {};
+ 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 !== "utf-8") {
+ debug("invalid charset");
+ next(createError(415, 'unsupported charset "' + charset.toUpperCase() + '"', {
+ charset,
+ type: "charset.unsupported"
+ }));
+ return;
+ }
+ read(req, res, next, parse4, debug, {
+ debug,
+ encoding: charset,
+ inflate,
+ limit,
+ verify
+ });
+ }, "urlencodedParser");
+ }
+ __name(urlencoded, "urlencoded");
+ function extendedparser(options14) {
+ var parameterLimit = options14.parameterLimit !== void 0 ? options14.parameterLimit : 1e3;
+ var parse4 = parser2("qs");
+ if (isNaN(parameterLimit) || parameterLimit < 1) {
+ throw new TypeError("option parameterLimit must be a positive number");
+ }
+ if (isFinite(parameterLimit)) {
+ parameterLimit = parameterLimit | 0;
+ }
+ return /* @__PURE__ */ __name(function queryparse(body) {
+ 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 = Math.max(100, paramCount);
+ debug("parse extended urlencoding");
+ return parse4(body, {
+ allowPrototypes: true,
+ arrayLimit,
+ depth: Infinity,
+ parameterLimit
+ });
+ }, "queryparse");
+ }
+ __name(extendedparser, "extendedparser");
+ function getCharset(req) {
+ try {
+ return (contentType.parse(req).parameters.charset || "").toLowerCase();
+ } catch (e2) {
+ return void 0;
+ }
+ }
+ __name(getCharset, "getCharset");
+ function parameterCount(body, limit) {
+ var count = 0;
+ var index = 0;
+ while ((index = body.indexOf("&", index)) !== -1) {
+ count++;
+ index++;
+ if (count === limit) {
+ return void 0;
+ }
+ }
+ return count;
+ }
+ __name(parameterCount, "parameterCount");
+ function parser2(name) {
+ var mod = parsers[name];
+ if (mod !== void 0) {
+ return mod.parse;
+ }
+ switch (name) {
+ case "qs":
+ mod = require_lib4();
+ break;
+ case "querystring":
+ mod = require("querystring");
+ break;
+ }
+ parsers[name] = mod;
+ return mod.parse;
+ }
+ __name(parser2, "parser");
+ function simpleparser(options14) {
+ var parameterLimit = options14.parameterLimit !== void 0 ? options14.parameterLimit : 1e3;
+ var parse4 = parser2("querystring");
+ if (isNaN(parameterLimit) || parameterLimit < 1) {
+ throw new TypeError("option parameterLimit must be a positive number");
+ }
+ if (isFinite(parameterLimit)) {
+ parameterLimit = parameterLimit | 0;
+ }
+ return /* @__PURE__ */ __name(function queryparse(body) {
+ var paramCount = parameterCount(body, parameterLimit);
+ if (paramCount === void 0) {
+ debug("too many parameters");
+ throw createError(413, "too many parameters", {
+ type: "parameters.too.many"
+ });
+ }
+ debug("parse urlencoding");
+ return parse4(body, void 0, void 0, { maxKeys: parameterLimit });
+ }, "queryparse");
+ }
+ __name(simpleparser, "simpleparser");
+ function typeChecker(type) {
+ return /* @__PURE__ */ __name(function checkType2(req) {
+ return Boolean(typeis(req, type));
+ }, "checkType");
+ }
+ __name(typeChecker, "typeChecker");
+ }
+});
+
+// ../../node_modules/.pnpm/body-parser@1.20.0_supports-color@9.2.2/node_modules/body-parser/index.js
+var require_body_parser = __commonJS({
+ "../../node_modules/.pnpm/body-parser@1.20.0_supports-color@9.2.2/node_modules/body-parser/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var deprecate = require_depd()("body-parser");
+ var parsers = /* @__PURE__ */ Object.create(null);
+ exports2 = module2.exports = deprecate.function(
+ bodyParser2,
+ "bodyParser: use individual json/urlencoded middlewares"
+ );
+ Object.defineProperty(exports2, "json", {
+ configurable: true,
+ enumerable: true,
+ get: createParserGetter("json")
+ });
+ Object.defineProperty(exports2, "raw", {
+ configurable: true,
+ enumerable: true,
+ get: createParserGetter("raw")
+ });
+ Object.defineProperty(exports2, "text", {
+ configurable: true,
+ enumerable: true,
+ get: createParserGetter("text")
+ });
+ Object.defineProperty(exports2, "urlencoded", {
+ configurable: true,
+ enumerable: true,
+ get: createParserGetter("urlencoded")
+ });
+ function bodyParser2(options14) {
+ var opts = {};
+ if (options14) {
+ for (var prop in options14) {
+ if (prop !== "type") {
+ opts[prop] = options14[prop];
+ }
+ }
+ }
+ var _urlencoded = exports2.urlencoded(opts);
+ var _json = exports2.json(opts);
+ return /* @__PURE__ */ __name(function bodyParser3(req, res, next) {
+ _json(req, res, function(err) {
+ if (err)
+ return next(err);
+ _urlencoded(req, res, next);
+ });
+ }, "bodyParser");
+ }
+ __name(bodyParser2, "bodyParser");
+ function createParserGetter(name) {
+ return /* @__PURE__ */ __name(function get() {
+ return loadParser(name);
+ }, "get");
+ }
+ __name(createParserGetter, "createParserGetter");
+ function loadParser(parserName) {
+ var parser2 = parsers[parserName];
+ if (parser2 !== void 0) {
+ return parser2;
+ }
+ switch (parserName) {
+ case "json":
+ parser2 = require_json();
+ break;
+ case "raw":
+ parser2 = require_raw();
+ break;
+ case "text":
+ parser2 = require_text3();
+ break;
+ case "urlencoded":
+ parser2 = require_urlencoded2();
+ break;
+ }
+ return parsers[parserName] = parser2;
+ }
+ __name(loadParser, "loadParser");
+ }
+});
+
+// ../../node_modules/.pnpm/merge-descriptors@1.0.1/node_modules/merge-descriptors/index.js
+var require_merge_descriptors = __commonJS({
+ "../../node_modules/.pnpm/merge-descriptors@1.0.1/node_modules/merge-descriptors/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ module2.exports = merge;
+ var hasOwnProperty2 = Object.prototype.hasOwnProperty;
+ function merge(dest, src, redefine) {
+ if (!dest) {
+ throw new TypeError("argument dest is required");
+ }
+ if (!src) {
+ throw new TypeError("argument src is required");
+ }
+ if (redefine === void 0) {
+ redefine = true;
+ }
+ Object.getOwnPropertyNames(src).forEach(/* @__PURE__ */ __name(function forEachOwnPropertyName(name) {
+ if (!redefine && hasOwnProperty2.call(dest, name)) {
+ return;
+ }
+ var descriptor2 = Object.getOwnPropertyDescriptor(src, name);
+ Object.defineProperty(dest, name, descriptor2);
+ }, "forEachOwnPropertyName"));
+ return dest;
+ }
+ __name(merge, "merge");
+ }
+});
+
+// ../../node_modules/.pnpm/encodeurl@1.0.2/node_modules/encodeurl/index.js
+var require_encodeurl = __commonJS({
+ "../../node_modules/.pnpm/encodeurl@1.0.2/node_modules/encodeurl/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ module2.exports = encodeUrl;
+ var ENCODE_CHARS_REGEXP = /(?:[^\x21\x25\x26-\x3B\x3D\x3F-\x5B\x5D\x5F\x61-\x7A\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(url3) {
+ return String(url3).replace(UNMATCHED_SURROGATE_PAIR_REGEXP, UNMATCHED_SURROGATE_PAIR_REPLACE).replace(ENCODE_CHARS_REGEXP, encodeURI);
+ }
+ __name(encodeUrl, "encodeUrl");
+ }
+});
+
+// ../../node_modules/.pnpm/escape-html@1.0.3/node_modules/escape-html/index.js
+var require_escape_html = __commonJS({
+ "../../node_modules/.pnpm/escape-html@1.0.3/node_modules/escape-html/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ 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;
+ }
+ __name(escapeHtml, "escapeHtml");
+ }
+});
+
+// ../../node_modules/.pnpm/parseurl@1.3.3/node_modules/parseurl/index.js
+var require_parseurl = __commonJS({
+ "../../node_modules/.pnpm/parseurl@1.3.3/node_modules/parseurl/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var url3 = require("url");
+ var parse4 = url3.parse;
+ var Url = url3.Url;
+ module2.exports = parseurl;
+ module2.exports.original = originalurl;
+ function parseurl(req) {
+ var url4 = req.url;
+ if (url4 === void 0) {
+ return void 0;
+ }
+ var parsed = req._parsedUrl;
+ if (fresh(url4, parsed)) {
+ return parsed;
+ }
+ parsed = fastparse(url4);
+ parsed._raw = url4;
+ return req._parsedUrl = parsed;
+ }
+ __name(parseurl, "parseurl");
+ function originalurl(req) {
+ var url4 = req.originalUrl;
+ if (typeof url4 !== "string") {
+ return parseurl(req);
+ }
+ var parsed = req._parsedOriginalUrl;
+ if (fresh(url4, parsed)) {
+ return parsed;
+ }
+ parsed = fastparse(url4);
+ parsed._raw = url4;
+ return req._parsedOriginalUrl = parsed;
+ }
+ __name(originalurl, "originalurl");
+ function fastparse(str) {
+ if (typeof str !== "string" || str.charCodeAt(0) !== 47) {
+ return parse4(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:
+ case 10:
+ case 12:
+ case 13:
+ case 32:
+ case 35:
+ case 160:
+ case 65279:
+ return parse4(str);
+ }
+ }
+ var url4 = Url !== void 0 ? new Url() : {};
+ url4.path = str;
+ url4.href = str;
+ url4.pathname = pathname;
+ if (search !== null) {
+ url4.query = query;
+ url4.search = search;
+ }
+ return url4;
+ }
+ __name(fastparse, "fastparse");
+ function fresh(url4, parsedUrl) {
+ return typeof parsedUrl === "object" && parsedUrl !== null && (Url === void 0 || parsedUrl instanceof Url) && parsedUrl._raw === url4;
+ }
+ __name(fresh, "fresh");
+ }
+});
+
+// ../../node_modules/.pnpm/finalhandler@1.2.0_supports-color@9.2.2/node_modules/finalhandler/index.js
+var require_finalhandler = __commonJS({
+ "../../node_modules/.pnpm/finalhandler@1.2.0_supports-color@9.2.2/node_modules/finalhandler/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var debug = require_src2()("finalhandler");
+ var encodeUrl = require_encodeurl();
+ var escapeHtml = require_escape_html();
+ var onFinished = require_on_finished();
+ var parseUrl = require_parseurl();
+ var statuses = require_statuses();
+ var unpipe = require_unpipe();
+ var DOUBLE_SPACE_REGEXP = /\x20{2}/g;
+ var NEWLINE_REGEXP = /\n/g;
+ var defer = typeof setImmediate === "function" ? setImmediate : function(fn2) {
+ process.nextTick(fn2.bind.apply(fn2, arguments));
+ };
+ var isFinished = onFinished.isFinished;
+ function createHtmlDocument(message) {
+ var body = escapeHtml(message).replace(NEWLINE_REGEXP, "
").replace(DOUBLE_SPACE_REGEXP, " ");
+ return '\n\n\n\nError\n\n\n' + body + "
\n\n\n";
+ }
+ __name(createHtmlDocument, "createHtmlDocument");
+ module2.exports = finalhandler;
+ function finalhandler(req, res, options14) {
+ var opts = options14 || {};
+ var env5 = opts.env || "production";
+ var onerror = opts.onerror;
+ return function(err) {
+ var headers;
+ var msg;
+ var status;
+ if (!err && headersSent(res)) {
+ debug("cannot 404 after headers sent");
+ return;
+ }
+ if (err) {
+ status = getErrorStatusCode(err);
+ if (status === void 0) {
+ status = getResponseStatusCode(res);
+ } else {
+ headers = getErrorHeaders(err);
+ }
+ msg = getErrorMessage(err, status, env5);
+ } else {
+ status = 404;
+ msg = "Cannot " + req.method + " " + encodeUrl(getResourceName(req));
+ }
+ debug("default %s", status);
+ if (err && onerror) {
+ defer(onerror, err, req, res);
+ }
+ if (headersSent(res)) {
+ debug("cannot %d after headers sent", status);
+ req.socket.destroy();
+ return;
+ }
+ send(req, res, status, headers, msg);
+ };
+ }
+ __name(finalhandler, "finalhandler");
+ function getErrorHeaders(err) {
+ if (!err.headers || typeof err.headers !== "object") {
+ return void 0;
+ }
+ var headers = /* @__PURE__ */ Object.create(null);
+ var keys = Object.keys(err.headers);
+ for (var i = 0; i < keys.length; i++) {
+ var key = keys[i];
+ headers[key] = err.headers[key];
+ }
+ return headers;
+ }
+ __name(getErrorHeaders, "getErrorHeaders");
+ function getErrorMessage(err, status, env5) {
+ var msg;
+ if (env5 !== "production") {
+ msg = err.stack;
+ if (!msg && typeof err.toString === "function") {
+ msg = err.toString();
+ }
+ }
+ return msg || statuses.message[status];
+ }
+ __name(getErrorMessage, "getErrorMessage");
+ function getErrorStatusCode(err) {
+ if (typeof err.status === "number" && err.status >= 400 && err.status < 600) {
+ return err.status;
+ }
+ if (typeof err.statusCode === "number" && err.statusCode >= 400 && err.statusCode < 600) {
+ return err.statusCode;
+ }
+ return void 0;
+ }
+ __name(getErrorStatusCode, "getErrorStatusCode");
+ function getResourceName(req) {
+ try {
+ return parseUrl.original(req).pathname;
+ } catch (e2) {
+ return "resource";
+ }
+ }
+ __name(getResourceName, "getResourceName");
+ function getResponseStatusCode(res) {
+ var status = res.statusCode;
+ if (typeof status !== "number" || status < 400 || status > 599) {
+ status = 500;
+ }
+ return status;
+ }
+ __name(getResponseStatusCode, "getResponseStatusCode");
+ function headersSent(res) {
+ return typeof res.headersSent !== "boolean" ? Boolean(res._header) : res.headersSent;
+ }
+ __name(headersSent, "headersSent");
+ function send(req, res, status, headers, message) {
+ function write() {
+ var body = createHtmlDocument(message);
+ res.statusCode = status;
+ res.statusMessage = statuses.message[status];
+ res.removeHeader("Content-Encoding");
+ res.removeHeader("Content-Language");
+ res.removeHeader("Content-Range");
+ setHeaders(res, headers);
+ 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");
+ }
+ __name(write, "write");
+ if (isFinished(req)) {
+ write();
+ return;
+ }
+ unpipe(req);
+ onFinished(req, write);
+ req.resume();
+ }
+ __name(send, "send");
+ function setHeaders(res, headers) {
+ if (!headers) {
+ return;
+ }
+ var keys = Object.keys(headers);
+ for (var i = 0; i < keys.length; i++) {
+ var key = keys[i];
+ res.setHeader(key, headers[key]);
+ }
+ }
+ __name(setHeaders, "setHeaders");
+ }
+});
+
+// ../../node_modules/.pnpm/array-flatten@1.1.1/node_modules/array-flatten/array-flatten.js
+var require_array_flatten = __commonJS({
+ "../../node_modules/.pnpm/array-flatten@1.1.1/node_modules/array-flatten/array-flatten.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ module2.exports = arrayFlatten;
+ function flattenWithDepth(array, result, depth) {
+ for (var i = 0; i < array.length; i++) {
+ var value = array[i];
+ if (depth > 0 && Array.isArray(value)) {
+ flattenWithDepth(value, result, depth - 1);
+ } else {
+ result.push(value);
+ }
+ }
+ return result;
+ }
+ __name(flattenWithDepth, "flattenWithDepth");
+ function flattenForever(array, result) {
+ for (var i = 0; i < array.length; i++) {
+ var value = array[i];
+ if (Array.isArray(value)) {
+ flattenForever(value, result);
+ } else {
+ result.push(value);
+ }
+ }
+ return result;
+ }
+ __name(flattenForever, "flattenForever");
+ function arrayFlatten(array, depth) {
+ if (depth == null) {
+ return flattenForever(array, []);
+ }
+ return flattenWithDepth(array, [], depth);
+ }
+ __name(arrayFlatten, "arrayFlatten");
+ }
+});
+
+// ../../node_modules/.pnpm/path-to-regexp@0.1.7/node_modules/path-to-regexp/index.js
+var require_path_to_regexp = __commonJS({
+ "../../node_modules/.pnpm/path-to-regexp@0.1.7/node_modules/path-to-regexp/index.js"(exports2, module2) {
+ init_import_meta_url();
+ module2.exports = pathtoRegexp;
+ var MATCHING_GROUP_REGEXP = /\((?!\?)/g;
+ function pathtoRegexp(path45, keys, options14) {
+ options14 = options14 || {};
+ keys = keys || [];
+ var strict = options14.strict;
+ var end = options14.end !== false;
+ var flags = options14.sensitive ? "" : "i";
+ var extraOffset = 0;
+ var keysOffset = keys.length;
+ var i = 0;
+ var name = 0;
+ var m;
+ if (path45 instanceof RegExp) {
+ while (m = MATCHING_GROUP_REGEXP.exec(path45.source)) {
+ keys.push({
+ name: name++,
+ optional: false,
+ offset: m.index
+ });
+ }
+ return path45;
+ }
+ if (Array.isArray(path45)) {
+ path45 = path45.map(function(value) {
+ return pathtoRegexp(value, keys, options14).source;
+ });
+ return new RegExp("(?:" + path45.join("|") + ")", flags);
+ }
+ path45 = ("^" + path45 + (strict ? "" : path45[path45.length - 1] === "/" ? "?" : "/?")).replace(/\/\(/g, "/(?:").replace(/([\/\.])/g, "\\$1").replace(/(\\\/)?(\\\.)?:(\w+)(\(.*?\))?(\*)?(\?)?/g, function(match, slash, format8, key, capture, star, optional, offset) {
+ slash = slash || "";
+ format8 = format8 || "";
+ capture = capture || "([^\\/" + format8 + "]+?)";
+ optional = optional || "";
+ keys.push({
+ name: key,
+ optional: !!optional,
+ offset: offset + extraOffset
+ });
+ var result = "" + (optional ? "" : slash) + "(?:" + format8 + (optional ? slash : "") + capture + (star ? "((?:[\\/" + format8 + "].+?)?)" : "") + ")" + optional;
+ extraOffset += result.length - match.length;
+ return result;
+ }).replace(/\*/g, function(star, index2) {
+ var len = keys.length;
+ while (len-- > keysOffset && keys[len].offset > index2) {
+ keys[len].offset += 3;
+ }
+ return "(.*)";
+ });
+ while (m = MATCHING_GROUP_REGEXP.exec(path45)) {
+ var escapeCount = 0;
+ var index = m.index;
+ while (path45.charAt(--index) === "\\") {
+ escapeCount++;
+ }
+ if (escapeCount % 2 === 1) {
+ continue;
+ }
+ if (keysOffset + i === keys.length || keys[keysOffset + i].offset > m.index) {
+ keys.splice(keysOffset + i, 0, {
+ name: name++,
+ // Unnamed matching groups must be consistently linear.
+ optional: false,
+ offset: m.index
+ });
+ }
+ i++;
+ }
+ path45 += end ? "$" : path45[path45.length - 1] === "/" ? "" : "(?=\\/|$)";
+ return new RegExp(path45, flags);
+ }
+ __name(pathtoRegexp, "pathtoRegexp");
+ }
+});
+
+// ../../node_modules/.pnpm/express@4.18.1_supports-color@9.2.2/node_modules/express/lib/router/layer.js
+var require_layer = __commonJS({
+ "../../node_modules/.pnpm/express@4.18.1_supports-color@9.2.2/node_modules/express/lib/router/layer.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var pathRegexp = require_path_to_regexp();
+ var debug = require_src2()("express:router:layer");
+ var hasOwnProperty2 = Object.prototype.hasOwnProperty;
+ module2.exports = Layer;
+ function Layer(path45, options14, fn2) {
+ if (!(this instanceof Layer)) {
+ return new Layer(path45, options14, fn2);
+ }
+ debug("new %o", path45);
+ var opts = options14 || {};
+ this.handle = fn2;
+ this.name = fn2.name || "";
+ this.params = void 0;
+ this.path = void 0;
+ this.regexp = pathRegexp(path45, this.keys = [], opts);
+ this.regexp.fast_star = path45 === "*";
+ this.regexp.fast_slash = path45 === "/" && opts.end === false;
+ }
+ __name(Layer, "Layer");
+ Layer.prototype.handle_error = /* @__PURE__ */ __name(function handle_error(error, req, res, next) {
+ var fn2 = this.handle;
+ if (fn2.length !== 4) {
+ return next(error);
+ }
+ try {
+ fn2(error, req, res, next);
+ } catch (err) {
+ next(err);
+ }
+ }, "handle_error");
+ Layer.prototype.handle_request = /* @__PURE__ */ __name(function handle(req, res, next) {
+ var fn2 = this.handle;
+ if (fn2.length > 3) {
+ return next();
+ }
+ try {
+ fn2(req, res, next);
+ } catch (err) {
+ next(err);
+ }
+ }, "handle");
+ Layer.prototype.match = /* @__PURE__ */ __name(function match(path45) {
+ var match2;
+ if (path45 != null) {
+ if (this.regexp.fast_slash) {
+ this.params = {};
+ this.path = "";
+ return true;
+ }
+ if (this.regexp.fast_star) {
+ this.params = { "0": decode_param(path45) };
+ this.path = path45;
+ return true;
+ }
+ match2 = this.regexp.exec(path45);
+ }
+ if (!match2) {
+ this.params = void 0;
+ this.path = void 0;
+ return false;
+ }
+ this.params = {};
+ this.path = match2[0];
+ var keys = this.keys;
+ var params = this.params;
+ for (var i = 1; i < match2.length; i++) {
+ var key = keys[i - 1];
+ var prop = key.name;
+ var val = decode_param(match2[i]);
+ if (val !== void 0 || !hasOwnProperty2.call(params, prop)) {
+ params[prop] = val;
+ }
+ }
+ return true;
+ }, "match");
+ function decode_param(val) {
+ if (typeof val !== "string" || val.length === 0) {
+ return val;
+ }
+ try {
+ return decodeURIComponent(val);
+ } catch (err) {
+ if (err instanceof URIError) {
+ err.message = "Failed to decode param '" + val + "'";
+ err.status = err.statusCode = 400;
+ }
+ throw err;
+ }
+ }
+ __name(decode_param, "decode_param");
+ }
+});
+
+// ../../node_modules/.pnpm/methods@1.1.2/node_modules/methods/index.js
+var require_methods = __commonJS({
+ "../../node_modules/.pnpm/methods@1.1.2/node_modules/methods/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var http3 = require("http");
+ module2.exports = getCurrentNodeMethods() || getBasicNodeMethods();
+ function getCurrentNodeMethods() {
+ return http3.METHODS && http3.METHODS.map(/* @__PURE__ */ __name(function lowerCaseMethod(method) {
+ return method.toLowerCase();
+ }, "lowerCaseMethod"));
+ }
+ __name(getCurrentNodeMethods, "getCurrentNodeMethods");
+ function getBasicNodeMethods() {
+ return [
+ "get",
+ "post",
+ "put",
+ "head",
+ "delete",
+ "options",
+ "trace",
+ "copy",
+ "lock",
+ "mkcol",
+ "move",
+ "purge",
+ "propfind",
+ "proppatch",
+ "unlock",
+ "report",
+ "mkactivity",
+ "checkout",
+ "merge",
+ "m-search",
+ "notify",
+ "subscribe",
+ "unsubscribe",
+ "patch",
+ "search",
+ "connect"
+ ];
+ }
+ __name(getBasicNodeMethods, "getBasicNodeMethods");
+ }
+});
+
+// ../../node_modules/.pnpm/express@4.18.1_supports-color@9.2.2/node_modules/express/lib/router/route.js
+var require_route3 = __commonJS({
+ "../../node_modules/.pnpm/express@4.18.1_supports-color@9.2.2/node_modules/express/lib/router/route.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var debug = require_src2()("express:router:route");
+ var flatten = require_array_flatten();
+ var Layer = require_layer();
+ var methods = require_methods();
+ var slice = Array.prototype.slice;
+ var toString = Object.prototype.toString;
+ module2.exports = Route;
+ function Route(path45) {
+ this.path = path45;
+ this.stack = [];
+ debug("new %o", path45);
+ this.methods = {};
+ }
+ __name(Route, "Route");
+ Route.prototype._handles_method = /* @__PURE__ */ __name(function _handles_method(method) {
+ if (this.methods._all) {
+ return true;
+ }
+ var name = method.toLowerCase();
+ if (name === "head" && !this.methods["head"]) {
+ name = "get";
+ }
+ return Boolean(this.methods[name]);
+ }, "_handles_method");
+ Route.prototype._options = /* @__PURE__ */ __name(function _options() {
+ var methods2 = Object.keys(this.methods);
+ if (this.methods.get && !this.methods.head) {
+ methods2.push("head");
+ }
+ for (var i = 0; i < methods2.length; i++) {
+ methods2[i] = methods2[i].toUpperCase();
+ }
+ return methods2;
+ }, "_options");
+ Route.prototype.dispatch = /* @__PURE__ */ __name(function dispatch(req, res, done) {
+ var idx = 0;
+ var stack = this.stack;
+ var sync = 0;
+ if (stack.length === 0) {
+ return done();
+ }
+ var method = req.method.toLowerCase();
+ if (method === "head" && !this.methods["head"]) {
+ method = "get";
+ }
+ req.route = this;
+ next();
+ function next(err) {
+ if (err && err === "route") {
+ return done();
+ }
+ if (err && err === "router") {
+ return done(err);
+ }
+ var layer = stack[idx++];
+ if (!layer) {
+ return done(err);
+ }
+ if (++sync > 100) {
+ return setImmediate(next, err);
+ }
+ if (layer.method && layer.method !== method) {
+ return next(err);
+ }
+ if (err) {
+ layer.handle_error(err, req, res, next);
+ } else {
+ layer.handle_request(req, res, next);
+ }
+ sync = 0;
+ }
+ __name(next, "next");
+ }, "dispatch");
+ Route.prototype.all = /* @__PURE__ */ __name(function all2() {
+ var handles = flatten(slice.call(arguments));
+ for (var i = 0; i < handles.length; i++) {
+ var handle = handles[i];
+ if (typeof handle !== "function") {
+ var type = toString.call(handle);
+ var msg = "Route.all() requires a callback function but got a " + type;
+ throw new TypeError(msg);
+ }
+ var layer = Layer("/", {}, handle);
+ layer.method = void 0;
+ this.methods._all = true;
+ this.stack.push(layer);
+ }
+ return this;
+ }, "all");
+ methods.forEach(function(method) {
+ Route.prototype[method] = function() {
+ var handles = flatten(slice.call(arguments));
+ for (var i = 0; i < handles.length; i++) {
+ var handle = handles[i];
+ if (typeof handle !== "function") {
+ var type = toString.call(handle);
+ var msg = "Route." + method + "() requires a callback function but got a " + type;
+ throw new Error(msg);
+ }
+ debug("%s %o", method, this.path);
+ var layer = Layer("/", {}, handle);
+ layer.method = method;
+ this.methods[method] = true;
+ this.stack.push(layer);
+ }
+ return this;
+ };
+ });
+ }
+});
+
+// ../../node_modules/.pnpm/utils-merge@1.0.1/node_modules/utils-merge/index.js
+var require_utils_merge = __commonJS({
+ "../../node_modules/.pnpm/utils-merge@1.0.1/node_modules/utils-merge/index.js"(exports2, module2) {
+ init_import_meta_url();
+ exports2 = module2.exports = function(a, b) {
+ if (a && b) {
+ for (var key in b) {
+ a[key] = b[key];
+ }
+ }
+ return a;
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/express@4.18.1_supports-color@9.2.2/node_modules/express/lib/router/index.js
+var require_router = __commonJS({
+ "../../node_modules/.pnpm/express@4.18.1_supports-color@9.2.2/node_modules/express/lib/router/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var Route = require_route3();
+ var Layer = require_layer();
+ var methods = require_methods();
+ var mixin3 = require_utils_merge();
+ var debug = require_src2()("express:router");
+ var deprecate = require_depd()("express");
+ var flatten = require_array_flatten();
+ var parseUrl = require_parseurl();
+ var setPrototypeOf = require_setprototypeof();
+ var objectRegExp = /^\[object (\S+)\]$/;
+ var slice = Array.prototype.slice;
+ var toString = Object.prototype.toString;
+ var proto = module2.exports = function(options14) {
+ var opts = options14 || {};
+ function router(req, res, next) {
+ router.handle(req, res, next);
+ }
+ __name(router, "router");
+ setPrototypeOf(router, proto);
+ router.params = {};
+ router._params = [];
+ router.caseSensitive = opts.caseSensitive;
+ router.mergeParams = opts.mergeParams;
+ router.strict = opts.strict;
+ router.stack = [];
+ return router;
+ };
+ proto.param = /* @__PURE__ */ __name(function param(name, fn2) {
+ if (typeof name === "function") {
+ deprecate("router.param(fn): Refactor to use path params");
+ this._params.push(name);
+ return;
+ }
+ var params = this._params;
+ var len = params.length;
+ var ret;
+ if (name[0] === ":") {
+ deprecate("router.param(" + JSON.stringify(name) + ", fn): Use router.param(" + JSON.stringify(name.slice(1)) + ", fn) instead");
+ name = name.slice(1);
+ }
+ for (var i = 0; i < len; ++i) {
+ if (ret = params[i](name, fn2)) {
+ fn2 = ret;
+ }
+ }
+ if ("function" !== typeof fn2) {
+ throw new Error("invalid param() call for " + name + ", got " + fn2);
+ }
+ (this.params[name] = this.params[name] || []).push(fn2);
+ return this;
+ }, "param");
+ proto.handle = /* @__PURE__ */ __name(function handle(req, res, out) {
+ var self2 = this;
+ debug("dispatching %s %s", req.method, req.url);
+ var idx = 0;
+ var protohost = getProtohost(req.url) || "";
+ var removed = "";
+ var slashAdded = false;
+ var sync = 0;
+ var paramcalled = {};
+ var options14 = [];
+ var stack = self2.stack;
+ var parentParams = req.params;
+ var parentUrl = req.baseUrl || "";
+ var done = restore(out, req, "baseUrl", "next", "params");
+ req.next = next;
+ if (req.method === "OPTIONS") {
+ done = wrap2(done, function(old, err) {
+ if (err || options14.length === 0)
+ return old(err);
+ sendOptionsResponse(res, options14, old);
+ });
+ }
+ req.baseUrl = parentUrl;
+ req.originalUrl = req.originalUrl || req.url;
+ next();
+ function next(err) {
+ var layerError = err === "route" ? null : err;
+ 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, err);
+ }
+ var path45 = getPathname(req);
+ if (path45 == null) {
+ return done(layerError);
+ }
+ var layer;
+ var match;
+ var route2;
+ while (match !== true && idx < stack.length) {
+ layer = stack[idx++];
+ match = matchLayer(layer, path45);
+ route2 = layer.route;
+ if (typeof match !== "boolean") {
+ layerError = layerError || match;
+ }
+ if (match !== true) {
+ continue;
+ }
+ if (!route2) {
+ continue;
+ }
+ if (layerError) {
+ match = false;
+ continue;
+ }
+ var method = req.method;
+ var has_method = route2._handles_method(method);
+ if (!has_method && method === "OPTIONS") {
+ appendMethods(options14, route2._options());
+ }
+ if (!has_method && method !== "HEAD") {
+ match = false;
+ }
+ }
+ if (match !== true) {
+ return done(layerError);
+ }
+ if (route2) {
+ req.route = route2;
+ }
+ req.params = self2.mergeParams ? mergeParams(layer.params, parentParams) : layer.params;
+ var layerPath = layer.path;
+ self2.process_params(layer, paramcalled, req, res, function(err2) {
+ if (err2) {
+ next(layerError || err2);
+ } else if (route2) {
+ layer.handle_request(req, res, next);
+ } else {
+ trim_prefix(layer, layerError, layerPath, path45);
+ }
+ sync = 0;
+ });
+ }
+ __name(next, "next");
+ function trim_prefix(layer, layerError, layerPath, path45) {
+ if (layerPath.length !== 0) {
+ if (layerPath !== path45.slice(0, layerPath.length)) {
+ next(layerError);
+ return;
+ }
+ var c = path45[layerPath.length];
+ if (c && c !== "/" && c !== ".")
+ return next(layerError);
+ 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.handle_error(layerError, req, res, next);
+ } else {
+ layer.handle_request(req, res, next);
+ }
+ }
+ __name(trim_prefix, "trim_prefix");
+ }, "handle");
+ proto.process_params = /* @__PURE__ */ __name(function process_params(layer, called, req, res, done) {
+ var params = this.params;
+ var keys = layer.keys;
+ if (!keys || keys.length === 0) {
+ return done();
+ }
+ var i = 0;
+ var name;
+ var paramIndex = 0;
+ var key;
+ var paramVal;
+ var paramCallbacks;
+ var paramCalled;
+ function param(err) {
+ if (err) {
+ return done(err);
+ }
+ if (i >= keys.length) {
+ return done();
+ }
+ paramIndex = 0;
+ key = keys[i++];
+ name = key.name;
+ paramVal = req.params[name];
+ paramCallbacks = params[name];
+ paramCalled = called[name];
+ if (paramVal === void 0 || !paramCallbacks) {
+ return param();
+ }
+ if (paramCalled && (paramCalled.match === paramVal || paramCalled.error && paramCalled.error !== "route")) {
+ req.params[name] = paramCalled.value;
+ return param(paramCalled.error);
+ }
+ called[name] = paramCalled = {
+ error: null,
+ match: paramVal,
+ value: paramVal
+ };
+ paramCallback();
+ }
+ __name(param, "param");
+ function paramCallback(err) {
+ var fn2 = paramCallbacks[paramIndex++];
+ paramCalled.value = req.params[key.name];
+ if (err) {
+ paramCalled.error = err;
+ param(err);
+ return;
+ }
+ if (!fn2)
+ return param();
+ try {
+ fn2(req, res, paramCallback, paramVal, key.name);
+ } catch (e2) {
+ paramCallback(e2);
+ }
+ }
+ __name(paramCallback, "paramCallback");
+ param();
+ }, "process_params");
+ proto.use = /* @__PURE__ */ __name(function use(fn2) {
+ var offset = 0;
+ var path45 = "/";
+ if (typeof fn2 !== "function") {
+ var arg = fn2;
+ while (Array.isArray(arg) && arg.length !== 0) {
+ arg = arg[0];
+ }
+ if (typeof arg !== "function") {
+ offset = 1;
+ path45 = fn2;
+ }
+ }
+ var callbacks = flatten(slice.call(arguments, offset));
+ if (callbacks.length === 0) {
+ throw new TypeError("Router.use() requires a middleware function");
+ }
+ for (var i = 0; i < callbacks.length; i++) {
+ var fn2 = callbacks[i];
+ if (typeof fn2 !== "function") {
+ throw new TypeError("Router.use() requires a middleware function but got a " + gettype(fn2));
+ }
+ debug("use %o %s", path45, fn2.name || "");
+ var layer = new Layer(path45, {
+ sensitive: this.caseSensitive,
+ strict: false,
+ end: false
+ }, fn2);
+ layer.route = void 0;
+ this.stack.push(layer);
+ }
+ return this;
+ }, "use");
+ proto.route = /* @__PURE__ */ __name(function route2(path45) {
+ var route3 = new Route(path45);
+ var layer = new Layer(path45, {
+ sensitive: this.caseSensitive,
+ strict: this.strict,
+ end: true
+ }, route3.dispatch.bind(route3));
+ layer.route = route3;
+ this.stack.push(layer);
+ return route3;
+ }, "route");
+ methods.concat("all").forEach(function(method) {
+ proto[method] = function(path45) {
+ var route2 = this.route(path45);
+ route2[method].apply(route2, slice.call(arguments, 1));
+ return this;
+ };
+ });
+ function appendMethods(list, addition) {
+ for (var i = 0; i < addition.length; i++) {
+ var method = addition[i];
+ if (list.indexOf(method) === -1) {
+ list.push(method);
+ }
+ }
+ }
+ __name(appendMethods, "appendMethods");
+ function getPathname(req) {
+ try {
+ return parseUrl(req).pathname;
+ } catch (err) {
+ return void 0;
+ }
+ }
+ __name(getPathname, "getPathname");
+ function getProtohost(url3) {
+ if (typeof url3 !== "string" || url3.length === 0 || url3[0] === "/") {
+ return void 0;
+ }
+ var searchIndex = url3.indexOf("?");
+ var pathLength = searchIndex !== -1 ? searchIndex : url3.length;
+ var fqdnIndex = url3.slice(0, pathLength).indexOf("://");
+ return fqdnIndex !== -1 ? url3.substring(0, url3.indexOf("/", 3 + fqdnIndex)) : void 0;
+ }
+ __name(getProtohost, "getProtohost");
+ function gettype(obj) {
+ var type = typeof obj;
+ if (type !== "object") {
+ return type;
+ }
+ return toString.call(obj).replace(objectRegExp, "$1");
+ }
+ __name(gettype, "gettype");
+ function matchLayer(layer, path45) {
+ try {
+ return layer.match(path45);
+ } catch (err) {
+ return err;
+ }
+ }
+ __name(matchLayer, "matchLayer");
+ function mergeParams(params, parent) {
+ if (typeof parent !== "object" || !parent) {
+ return params;
+ }
+ var obj = mixin3({}, parent);
+ if (!(0 in params) || !(0 in parent)) {
+ return mixin3(obj, params);
+ }
+ var i = 0;
+ var 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 mixin3(obj, params);
+ }
+ __name(mergeParams, "mergeParams");
+ function restore(fn2, obj) {
+ var props = new Array(arguments.length - 2);
+ var vals = new Array(arguments.length - 2);
+ for (var i = 0; i < props.length; i++) {
+ props[i] = arguments[i + 2];
+ vals[i] = obj[props[i]];
+ }
+ return function() {
+ for (var i2 = 0; i2 < props.length; i2++) {
+ obj[props[i2]] = vals[i2];
+ }
+ return fn2.apply(this, arguments);
+ };
+ }
+ __name(restore, "restore");
+ function sendOptionsResponse(res, options14, next) {
+ try {
+ var body = options14.join(",");
+ res.set("Allow", body);
+ res.send(body);
+ } catch (err) {
+ next(err);
+ }
+ }
+ __name(sendOptionsResponse, "sendOptionsResponse");
+ function wrap2(old, fn2) {
+ return /* @__PURE__ */ __name(function proxy2() {
+ var args = new Array(arguments.length + 1);
+ args[0] = old;
+ for (var i = 0, len = arguments.length; i < len; i++) {
+ args[i + 1] = arguments[i];
+ }
+ fn2.apply(this, args);
+ }, "proxy");
+ }
+ __name(wrap2, "wrap");
+ }
+});
+
+// ../../node_modules/.pnpm/express@4.18.1_supports-color@9.2.2/node_modules/express/lib/middleware/init.js
+var require_init = __commonJS({
+ "../../node_modules/.pnpm/express@4.18.1_supports-color@9.2.2/node_modules/express/lib/middleware/init.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ var setPrototypeOf = require_setprototypeof();
+ exports2.init = function(app) {
+ return /* @__PURE__ */ __name(function expressInit(req, res, next) {
+ if (app.enabled("x-powered-by"))
+ res.setHeader("X-Powered-By", "Express");
+ req.res = res;
+ res.req = req;
+ req.next = next;
+ setPrototypeOf(req, app.request);
+ setPrototypeOf(res, app.response);
+ res.locals = res.locals || /* @__PURE__ */ Object.create(null);
+ next();
+ }, "expressInit");
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/express@4.18.1_supports-color@9.2.2/node_modules/express/lib/middleware/query.js
+var require_query = __commonJS({
+ "../../node_modules/.pnpm/express@4.18.1_supports-color@9.2.2/node_modules/express/lib/middleware/query.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var merge = require_utils_merge();
+ var parseUrl = require_parseurl();
+ var qs = require_lib4();
+ module2.exports = /* @__PURE__ */ __name(function query(options14) {
+ var opts = merge({}, options14);
+ var queryparse = qs.parse;
+ if (typeof options14 === "function") {
+ queryparse = options14;
+ opts = void 0;
+ }
+ if (opts !== void 0 && opts.allowPrototypes === void 0) {
+ opts.allowPrototypes = true;
+ }
+ return /* @__PURE__ */ __name(function query2(req, res, next) {
+ if (!req.query) {
+ var val = parseUrl(req).query;
+ req.query = queryparse(val, opts);
+ }
+ next();
+ }, "query");
+ }, "query");
+ }
+});
+
+// ../../node_modules/.pnpm/express@4.18.1_supports-color@9.2.2/node_modules/express/lib/view.js
+var require_view = __commonJS({
+ "../../node_modules/.pnpm/express@4.18.1_supports-color@9.2.2/node_modules/express/lib/view.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var debug = require_src2()("express:view");
+ var path45 = require("path");
+ var fs20 = require("fs");
+ var dirname10 = path45.dirname;
+ var basename6 = path45.basename;
+ var extname4 = path45.extname;
+ var join12 = path45.join;
+ var resolve18 = path45.resolve;
+ module2.exports = View;
+ function View(name, options14) {
+ var opts = options14 || {};
+ this.defaultEngine = opts.defaultEngine;
+ this.ext = extname4(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 fn2 = require(mod).__express;
+ if (typeof fn2 !== "function") {
+ throw new Error('Module "' + mod + '" does not provide a view engine.');
+ }
+ opts.engines[this.ext] = fn2;
+ }
+ this.engine = opts.engines[this.ext];
+ this.path = this.lookup(fileName);
+ }
+ __name(View, "View");
+ View.prototype.lookup = /* @__PURE__ */ __name(function lookup(name) {
+ var path46;
+ var roots = [].concat(this.root);
+ debug('lookup "%s"', name);
+ for (var i = 0; i < roots.length && !path46; i++) {
+ var root = roots[i];
+ var loc = resolve18(root, name);
+ var dir = dirname10(loc);
+ var file = basename6(loc);
+ path46 = this.resolve(dir, file);
+ }
+ return path46;
+ }, "lookup");
+ View.prototype.render = /* @__PURE__ */ __name(function render7(options14, callback) {
+ debug('render "%s"', this.path);
+ this.engine(this.path, options14, callback);
+ }, "render");
+ View.prototype.resolve = /* @__PURE__ */ __name(function resolve19(dir, file) {
+ var ext = this.ext;
+ var path46 = join12(dir, file);
+ var stat3 = tryStat(path46);
+ if (stat3 && stat3.isFile()) {
+ return path46;
+ }
+ path46 = join12(dir, basename6(file, ext), "index" + ext);
+ stat3 = tryStat(path46);
+ if (stat3 && stat3.isFile()) {
+ return path46;
+ }
+ }, "resolve");
+ function tryStat(path46) {
+ debug('stat "%s"', path46);
+ try {
+ return fs20.statSync(path46);
+ } catch (e2) {
+ return void 0;
+ }
+ }
+ __name(tryStat, "tryStat");
+ }
+});
+
+// ../../node_modules/.pnpm/safe-buffer@5.2.1/node_modules/safe-buffer/index.js
+var require_safe_buffer = __commonJS({
+ "../../node_modules/.pnpm/safe-buffer@5.2.1/node_modules/safe-buffer/index.js"(exports2, module2) {
+ init_import_meta_url();
+ var buffer = require("buffer");
+ var Buffer3 = buffer.Buffer;
+ function copyProps(src, dst) {
+ for (var key in src) {
+ dst[key] = src[key];
+ }
+ }
+ __name(copyProps, "copyProps");
+ if (Buffer3.from && Buffer3.alloc && Buffer3.allocUnsafe && Buffer3.allocUnsafeSlow) {
+ module2.exports = buffer;
+ } else {
+ copyProps(buffer, exports2);
+ exports2.Buffer = SafeBuffer;
+ }
+ function SafeBuffer(arg, encodingOrOffset, length) {
+ return Buffer3(arg, encodingOrOffset, length);
+ }
+ __name(SafeBuffer, "SafeBuffer");
+ SafeBuffer.prototype = Object.create(Buffer3.prototype);
+ copyProps(Buffer3, SafeBuffer);
+ SafeBuffer.from = function(arg, encodingOrOffset, length) {
+ if (typeof arg === "number") {
+ throw new TypeError("Argument must not be a number");
+ }
+ return Buffer3(arg, encodingOrOffset, length);
+ };
+ SafeBuffer.alloc = function(size, fill, encoding) {
+ if (typeof size !== "number") {
+ throw new TypeError("Argument must be a number");
+ }
+ var buf = Buffer3(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 Buffer3(size);
+ };
+ SafeBuffer.allocUnsafeSlow = function(size) {
+ if (typeof size !== "number") {
+ throw new TypeError("Argument must be a number");
+ }
+ return buffer.SlowBuffer(size);
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/content-disposition@0.5.4/node_modules/content-disposition/index.js
+var require_content_disposition = __commonJS({
+ "../../node_modules/.pnpm/content-disposition@0.5.4/node_modules/content-disposition/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ module2.exports = contentDisposition;
+ module2.exports.parse = parse4;
+ var basename6 = require("path").basename;
+ var Buffer3 = 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, options14) {
+ var opts = options14 || {};
+ var type = opts.type || "attachment";
+ var params = createparams(filename, opts.fallback);
+ return format8(new ContentDisposition(type, params));
+ }
+ __name(contentDisposition, "contentDisposition");
+ 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 = basename6(filename);
+ var isQuotedString = TEXT_REGEXP.test(name);
+ var fallbackName = typeof fallback !== "string" ? fallback && getlatin1(name) : basename6(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;
+ }
+ __name(createparams, "createparams");
+ function format8(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.substr(-1) === "*" ? ustring(parameters[param]) : qstring(parameters[param]);
+ string += "; " + param + "=" + val;
+ }
+ }
+ return string;
+ }
+ __name(format8, "format");
+ 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":
+ value = Buffer3.from(binary, "binary").toString("utf8");
+ break;
+ default:
+ throw new TypeError("unsupported charset in extended field");
+ }
+ return value;
+ }
+ __name(decodefield, "decodefield");
+ function getlatin1(val) {
+ return String(val).replace(NON_LATIN1_REGEXP, "?");
+ }
+ __name(getlatin1, "getlatin1");
+ function parse4(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].substr(-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.substr(1, value.length - 2).replace(QESC_REGEXP, "$1");
+ }
+ params[key] = value;
+ }
+ if (index !== -1 && index !== string.length) {
+ throw new TypeError("invalid parameter format");
+ }
+ return new ContentDisposition(type, params);
+ }
+ __name(parse4, "parse");
+ function pdecode(str, hex) {
+ return String.fromCharCode(parseInt(hex, 16));
+ }
+ __name(pdecode, "pdecode");
+ function pencode(char) {
+ return "%" + String(char).charCodeAt(0).toString(16).toUpperCase();
+ }
+ __name(pencode, "pencode");
+ function qstring(val) {
+ var str = String(val);
+ return '"' + str.replace(QUOTE_REGEXP, "\\$1") + '"';
+ }
+ __name(qstring, "qstring");
+ function ustring(val) {
+ var str = String(val);
+ var encoded = encodeURIComponent(str).replace(ENCODE_URL_ATTR_CHAR_REGEXP, pencode);
+ return "UTF-8''" + encoded;
+ }
+ __name(ustring, "ustring");
+ function ContentDisposition(type, parameters) {
+ this.type = type;
+ this.parameters = parameters;
+ }
+ __name(ContentDisposition, "ContentDisposition");
+ }
+});
+
+// ../../node_modules/.pnpm/etag@1.8.1/node_modules/etag/index.js
+var require_etag = __commonJS({
+ "../../node_modules/.pnpm/etag@1.8.1/node_modules/etag/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ module2.exports = etag;
+ var crypto6 = 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 = crypto6.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 + '"';
+ }
+ __name(entitytag, "entitytag");
+ function etag(entity, options14) {
+ if (entity == null) {
+ throw new TypeError("argument entity is required");
+ }
+ var isStats = isstats(entity);
+ var weak = options14 && typeof options14.weak === "boolean" ? options14.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;
+ }
+ __name(etag, "etag");
+ 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";
+ }
+ __name(isstats, "isstats");
+ function stattag(stat3) {
+ var mtime = stat3.mtime.getTime().toString(16);
+ var size = stat3.size.toString(16);
+ return '"' + size + "-" + mtime + '"';
+ }
+ __name(stattag, "stattag");
+ }
+});
+
+// ../../node_modules/.pnpm/fresh@0.5.2/node_modules/fresh/index.js
+var require_fresh = __commonJS({
+ "../../node_modules/.pnpm/fresh@0.5.2/node_modules/fresh/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ 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 && noneMatch !== "*") {
+ var etag = resHeaders["etag"];
+ if (!etag) {
+ return false;
+ }
+ var etagStale = true;
+ 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) {
+ etagStale = false;
+ break;
+ }
+ }
+ if (etagStale) {
+ return false;
+ }
+ }
+ if (modifiedSince) {
+ var lastModified = resHeaders["last-modified"];
+ var modifiedStale = !lastModified || !(parseHttpDate(lastModified) <= parseHttpDate(modifiedSince));
+ if (modifiedStale) {
+ return false;
+ }
+ }
+ return true;
+ }
+ __name(fresh, "fresh");
+ function parseHttpDate(date) {
+ var timestamp = date && Date.parse(date);
+ return typeof timestamp === "number" ? timestamp : NaN;
+ }
+ __name(parseHttpDate, "parseHttpDate");
+ 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;
+ }
+ __name(parseTokenList, "parseTokenList");
+ }
+});
+
+// ../../node_modules/.pnpm/mime@1.6.0/node_modules/mime/types.json
+var require_types = __commonJS({
+ "../../node_modules/.pnpm/mime@1.6.0/node_modules/mime/types.json"(exports2, module2) {
+ module2.exports = { "application/andrew-inset": ["ez"], "application/applixware": ["aw"], "application/atom+xml": ["atom"], "application/atomcat+xml": ["atomcat"], "application/atomsvc+xml": ["atomsvc"], "application/bdoc": ["bdoc"], "application/ccxml+xml": ["ccxml"], "application/cdmi-capability": ["cdmia"], "application/cdmi-container": ["cdmic"], "application/cdmi-domain": ["cdmid"], "application/cdmi-object": ["cdmio"], "application/cdmi-queue": ["cdmiq"], "application/cu-seeme": ["cu"], "application/dash+xml": ["mpd"], "application/davmount+xml": ["davmount"], "application/docbook+xml": ["dbk"], "application/dssc+der": ["dssc"], "application/dssc+xml": ["xdssc"], "application/ecmascript": ["ecma"], "application/emma+xml": ["emma"], "application/epub+zip": ["epub"], "application/exi": ["exi"], "application/font-tdpfr": ["pfr"], "application/font-woff": [], "application/font-woff2": [], "application/geo+json": ["geojson"], "application/gml+xml": ["gml"], "application/gpx+xml": ["gpx"], "application/gxf": ["gxf"], "application/gzip": ["gz"], "application/hyperstudio": ["stk"], "application/inkml+xml": ["ink", "inkml"], "application/ipfix": ["ipfix"], "application/java-archive": ["jar", "war", "ear"], "application/java-serialized-object": ["ser"], "application/java-vm": ["class"], "application/javascript": ["js", "mjs"], "application/json": ["json", "map"], "application/json5": ["json5"], "application/jsonml+json": ["jsonml"], "application/ld+json": ["jsonld"], "application/lost+xml": ["lostxml"], "application/mac-binhex40": ["hqx"], "application/mac-compactpro": ["cpt"], "application/mads+xml": ["mads"], "application/manifest+json": ["webmanifest"], "application/marc": ["mrc"], "application/marcxml+xml": ["mrcx"], "application/mathematica": ["ma", "nb", "mb"], "application/mathml+xml": ["mathml"], "application/mbox": ["mbox"], "application/mediaservercontrol+xml": ["mscml"], "application/metalink+xml": ["metalink"], "application/metalink4+xml": ["meta4"], "application/mets+xml": ["mets"], "application/mods+xml": ["mods"], "application/mp21": ["m21", "mp21"], "application/mp4": ["mp4s", "m4p"], "application/msword": ["doc", "dot"], "application/mxf": ["mxf"], "application/octet-stream": ["bin", "dms", "lrf", "mar", "so", "dist", "distz", "pkg", "bpk", "dump", "elc", "deploy", "exe", "dll", "deb", "dmg", "iso", "img", "msi", "msp", "msm", "buffer"], "application/oda": ["oda"], "application/oebps-package+xml": ["opf"], "application/ogg": ["ogx"], "application/omdoc+xml": ["omdoc"], "application/onenote": ["onetoc", "onetoc2", "onetmp", "onepkg"], "application/oxps": ["oxps"], "application/patch-ops-error+xml": ["xer"], "application/pdf": ["pdf"], "application/pgp-encrypted": ["pgp"], "application/pgp-signature": ["asc", "sig"], "application/pics-rules": ["prf"], "application/pkcs10": ["p10"], "application/pkcs7-mime": ["p7m", "p7c"], "application/pkcs7-signature": ["p7s"], "application/pkcs8": ["p8"], "application/pkix-attr-cert": ["ac"], "application/pkix-cert": ["cer"], "application/pkix-crl": ["crl"], "application/pkix-pkipath": ["pkipath"], "application/pkixcmp": ["pki"], "application/pls+xml": ["pls"], "application/postscript": ["ai", "eps", "ps"], "application/prs.cww": ["cww"], "application/pskc+xml": ["pskcxml"], "application/raml+yaml": ["raml"], "application/rdf+xml": ["rdf"], "application/reginfo+xml": ["rif"], "application/relax-ng-compact-syntax": ["rnc"], "application/resource-lists+xml": ["rl"], "application/resource-lists-diff+xml": ["rld"], "application/rls-services+xml": ["rs"], "application/rpki-ghostbusters": ["gbr"], "application/rpki-manifest": ["mft"], "application/rpki-roa": ["roa"], "application/rsd+xml": ["rsd"], "application/rss+xml": ["rss"], "application/rtf": ["rtf"], "application/sbml+xml": ["sbml"], "application/scvp-cv-request": ["scq"], "application/scvp-cv-response": ["scs"], "application/scvp-vp-request": ["spq"], "application/scvp-vp-response": ["spp"], "application/sdp": ["sdp"], "application/set-payment-initiation": ["setpay"], "application/set-registration-initiation": ["setreg"], "application/shf+xml": ["shf"], "application/smil+xml": ["smi", "smil"], "application/sparql-query": ["rq"], "application/sparql-results+xml": ["srx"], "application/srgs": ["gram"], "application/srgs+xml": ["grxml"], "application/sru+xml": ["sru"], "application/ssdl+xml": ["ssdl"], "application/ssml+xml": ["ssml"], "application/tei+xml": ["tei", "teicorpus"], "application/thraud+xml": ["tfi"], "application/timestamped-data": ["tsd"], "application/vnd.3gpp.pic-bw-large": ["plb"], "application/vnd.3gpp.pic-bw-small": ["psb"], "application/vnd.3gpp.pic-bw-var": ["pvb"], "application/vnd.3gpp2.tcap": ["tcap"], "application/vnd.3m.post-it-notes": ["pwn"], "application/vnd.accpac.simply.aso": ["aso"], "application/vnd.accpac.simply.imp": ["imp"], "application/vnd.acucobol": ["acu"], "application/vnd.acucorp": ["atc", "acutc"], "application/vnd.adobe.air-application-installer-package+zip": ["air"], "application/vnd.adobe.formscentral.fcdt": ["fcdt"], "application/vnd.adobe.fxp": ["fxp", "fxpl"], "application/vnd.adobe.xdp+xml": ["xdp"], "application/vnd.adobe.xfdf": ["xfdf"], "application/vnd.ahead.space": ["ahead"], "application/vnd.airzip.filesecure.azf": ["azf"], "application/vnd.airzip.filesecure.azs": ["azs"], "application/vnd.amazon.ebook": ["azw"], "application/vnd.americandynamics.acc": ["acc"], "application/vnd.amiga.ami": ["ami"], "application/vnd.android.package-archive": ["apk"], "application/vnd.anser-web-certificate-issue-initiation": ["cii"], "application/vnd.anser-web-funds-transfer-initiation": ["fti"], "application/vnd.antix.game-component": ["atx"], "application/vnd.apple.installer+xml": ["mpkg"], "application/vnd.apple.mpegurl": ["m3u8"], "application/vnd.apple.pkpass": ["pkpass"], "application/vnd.aristanetworks.swi": ["swi"], "application/vnd.astraea-software.iota": ["iota"], "application/vnd.audiograph": ["aep"], "application/vnd.blueice.multipass": ["mpm"], "application/vnd.bmi": ["bmi"], "application/vnd.businessobjects": ["rep"], "application/vnd.chemdraw+xml": ["cdxml"], "application/vnd.chipnuts.karaoke-mmd": ["mmd"], "application/vnd.cinderella": ["cdy"], "application/vnd.claymore": ["cla"], "application/vnd.cloanto.rp9": ["rp9"], "application/vnd.clonk.c4group": ["c4g", "c4d", "c4f", "c4p", "c4u"], "application/vnd.cluetrust.cartomobile-config": ["c11amc"], "application/vnd.cluetrust.cartomobile-config-pkg": ["c11amz"], "application/vnd.commonspace": ["csp"], "application/vnd.contact.cmsg": ["cdbcmsg"], "application/vnd.cosmocaller": ["cmc"], "application/vnd.crick.clicker": ["clkx"], "application/vnd.crick.clicker.keyboard": ["clkk"], "application/vnd.crick.clicker.palette": ["clkp"], "application/vnd.crick.clicker.template": ["clkt"], "application/vnd.crick.clicker.wordbank": ["clkw"], "application/vnd.criticaltools.wbs+xml": ["wbs"], "application/vnd.ctc-posml": ["pml"], "application/vnd.cups-ppd": ["ppd"], "application/vnd.curl.car": ["car"], "application/vnd.curl.pcurl": ["pcurl"], "application/vnd.dart": ["dart"], "application/vnd.data-vision.rdz": ["rdz"], "application/vnd.dece.data": ["uvf", "uvvf", "uvd", "uvvd"], "application/vnd.dece.ttml+xml": ["uvt", "uvvt"], "application/vnd.dece.unspecified": ["uvx", "uvvx"], "application/vnd.dece.zip": ["uvz", "uvvz"], "application/vnd.denovo.fcselayout-link": ["fe_launch"], "application/vnd.dna": ["dna"], "application/vnd.dolby.mlp": ["mlp"], "application/vnd.dpgraph": ["dpg"], "application/vnd.dreamfactory": ["dfac"], "application/vnd.ds-keypoint": ["kpxx"], "application/vnd.dvb.ait": ["ait"], "application/vnd.dvb.service": ["svc"], "application/vnd.dynageo": ["geo"], "application/vnd.ecowin.chart": ["mag"], "application/vnd.enliven": ["nml"], "application/vnd.epson.esf": ["esf"], "application/vnd.epson.msf": ["msf"], "application/vnd.epson.quickanime": ["qam"], "application/vnd.epson.salt": ["slt"], "application/vnd.epson.ssf": ["ssf"], "application/vnd.eszigno3+xml": ["es3", "et3"], "application/vnd.ezpix-album": ["ez2"], "application/vnd.ezpix-package": ["ez3"], "application/vnd.fdf": ["fdf"], "application/vnd.fdsn.mseed": ["mseed"], "application/vnd.fdsn.seed": ["seed", "dataless"], "application/vnd.flographit": ["gph"], "application/vnd.fluxtime.clip": ["ftc"], "application/vnd.framemaker": ["fm", "frame", "maker", "book"], "application/vnd.frogans.fnc": ["fnc"], "application/vnd.frogans.ltf": ["ltf"], "application/vnd.fsc.weblaunch": ["fsc"], "application/vnd.fujitsu.oasys": ["oas"], "application/vnd.fujitsu.oasys2": ["oa2"], "application/vnd.fujitsu.oasys3": ["oa3"], "application/vnd.fujitsu.oasysgp": ["fg5"], "application/vnd.fujitsu.oasysprs": ["bh2"], "application/vnd.fujixerox.ddd": ["ddd"], "application/vnd.fujixerox.docuworks": ["xdw"], "application/vnd.fujixerox.docuworks.binder": ["xbd"], "application/vnd.fuzzysheet": ["fzs"], "application/vnd.genomatix.tuxedo": ["txd"], "application/vnd.geogebra.file": ["ggb"], "application/vnd.geogebra.tool": ["ggt"], "application/vnd.geometry-explorer": ["gex", "gre"], "application/vnd.geonext": ["gxt"], "application/vnd.geoplan": ["g2w"], "application/vnd.geospace": ["g3w"], "application/vnd.gmx": ["gmx"], "application/vnd.google-apps.document": ["gdoc"], "application/vnd.google-apps.presentation": ["gslides"], "application/vnd.google-apps.spreadsheet": ["gsheet"], "application/vnd.google-earth.kml+xml": ["kml"], "application/vnd.google-earth.kmz": ["kmz"], "application/vnd.grafeq": ["gqf", "gqs"], "application/vnd.groove-account": ["gac"], "application/vnd.groove-help": ["ghf"], "application/vnd.groove-identity-message": ["gim"], "application/vnd.groove-injector": ["grv"], "application/vnd.groove-tool-message": ["gtm"], "application/vnd.groove-tool-template": ["tpl"], "application/vnd.groove-vcard": ["vcg"], "application/vnd.hal+xml": ["hal"], "application/vnd.handheld-entertainment+xml": ["zmm"], "application/vnd.hbci": ["hbci"], "application/vnd.hhe.lesson-player": ["les"], "application/vnd.hp-hpgl": ["hpgl"], "application/vnd.hp-hpid": ["hpid"], "application/vnd.hp-hps": ["hps"], "application/vnd.hp-jlyt": ["jlt"], "application/vnd.hp-pcl": ["pcl"], "application/vnd.hp-pclxl": ["pclxl"], "application/vnd.hydrostatix.sof-data": ["sfd-hdstx"], "application/vnd.ibm.minipay": ["mpy"], "application/vnd.ibm.modcap": ["afp", "listafp", "list3820"], "application/vnd.ibm.rights-management": ["irm"], "application/vnd.ibm.secure-container": ["sc"], "application/vnd.iccprofile": ["icc", "icm"], "application/vnd.igloader": ["igl"], "application/vnd.immervision-ivp": ["ivp"], "application/vnd.immervision-ivu": ["ivu"], "application/vnd.insors.igm": ["igm"], "application/vnd.intercon.formnet": ["xpw", "xpx"], "application/vnd.intergeo": ["i2g"], "application/vnd.intu.qbo": ["qbo"], "application/vnd.intu.qfx": ["qfx"], "application/vnd.ipunplugged.rcprofile": ["rcprofile"], "application/vnd.irepository.package+xml": ["irp"], "application/vnd.is-xpr": ["xpr"], "application/vnd.isac.fcs": ["fcs"], "application/vnd.jam": ["jam"], "application/vnd.jcp.javame.midlet-rms": ["rms"], "application/vnd.jisp": ["jisp"], "application/vnd.joost.joda-archive": ["joda"], "application/vnd.kahootz": ["ktz", "ktr"], "application/vnd.kde.karbon": ["karbon"], "application/vnd.kde.kchart": ["chrt"], "application/vnd.kde.kformula": ["kfo"], "application/vnd.kde.kivio": ["flw"], "application/vnd.kde.kontour": ["kon"], "application/vnd.kde.kpresenter": ["kpr", "kpt"], "application/vnd.kde.kspread": ["ksp"], "application/vnd.kde.kword": ["kwd", "kwt"], "application/vnd.kenameaapp": ["htke"], "application/vnd.kidspiration": ["kia"], "application/vnd.kinar": ["kne", "knp"], "application/vnd.koan": ["skp", "skd", "skt", "skm"], "application/vnd.kodak-descriptor": ["sse"], "application/vnd.las.las+xml": ["lasxml"], "application/vnd.llamagraphics.life-balance.desktop": ["lbd"], "application/vnd.llamagraphics.life-balance.exchange+xml": ["lbe"], "application/vnd.lotus-1-2-3": ["123"], "application/vnd.lotus-approach": ["apr"], "application/vnd.lotus-freelance": ["pre"], "application/vnd.lotus-notes": ["nsf"], "application/vnd.lotus-organizer": ["org"], "application/vnd.lotus-screencam": ["scm"], "application/vnd.lotus-wordpro": ["lwp"], "application/vnd.macports.portpkg": ["portpkg"], "application/vnd.mcd": ["mcd"], "application/vnd.medcalcdata": ["mc1"], "application/vnd.mediastation.cdkey": ["cdkey"], "application/vnd.mfer": ["mwf"], "application/vnd.mfmp": ["mfm"], "application/vnd.micrografx.flo": ["flo"], "application/vnd.micrografx.igx": ["igx"], "application/vnd.mif": ["mif"], "application/vnd.mobius.daf": ["daf"], "application/vnd.mobius.dis": ["dis"], "application/vnd.mobius.mbk": ["mbk"], "application/vnd.mobius.mqy": ["mqy"], "application/vnd.mobius.msl": ["msl"], "application/vnd.mobius.plc": ["plc"], "application/vnd.mobius.txf": ["txf"], "application/vnd.mophun.application": ["mpn"], "application/vnd.mophun.certificate": ["mpc"], "application/vnd.mozilla.xul+xml": ["xul"], "application/vnd.ms-artgalry": ["cil"], "application/vnd.ms-cab-compressed": ["cab"], "application/vnd.ms-excel": ["xls", "xlm", "xla", "xlc", "xlt", "xlw"], "application/vnd.ms-excel.addin.macroenabled.12": ["xlam"], "application/vnd.ms-excel.sheet.binary.macroenabled.12": ["xlsb"], "application/vnd.ms-excel.sheet.macroenabled.12": ["xlsm"], "application/vnd.ms-excel.template.macroenabled.12": ["xltm"], "application/vnd.ms-fontobject": ["eot"], "application/vnd.ms-htmlhelp": ["chm"], "application/vnd.ms-ims": ["ims"], "application/vnd.ms-lrm": ["lrm"], "application/vnd.ms-officetheme": ["thmx"], "application/vnd.ms-outlook": ["msg"], "application/vnd.ms-pki.seccat": ["cat"], "application/vnd.ms-pki.stl": ["stl"], "application/vnd.ms-powerpoint": ["ppt", "pps", "pot"], "application/vnd.ms-powerpoint.addin.macroenabled.12": ["ppam"], "application/vnd.ms-powerpoint.presentation.macroenabled.12": ["pptm"], "application/vnd.ms-powerpoint.slide.macroenabled.12": ["sldm"], "application/vnd.ms-powerpoint.slideshow.macroenabled.12": ["ppsm"], "application/vnd.ms-powerpoint.template.macroenabled.12": ["potm"], "application/vnd.ms-project": ["mpp", "mpt"], "application/vnd.ms-word.document.macroenabled.12": ["docm"], "application/vnd.ms-word.template.macroenabled.12": ["dotm"], "application/vnd.ms-works": ["wps", "wks", "wcm", "wdb"], "application/vnd.ms-wpl": ["wpl"], "application/vnd.ms-xpsdocument": ["xps"], "application/vnd.mseq": ["mseq"], "application/vnd.musician": ["mus"], "application/vnd.muvee.style": ["msty"], "application/vnd.mynfc": ["taglet"], "application/vnd.neurolanguage.nlu": ["nlu"], "application/vnd.nitf": ["ntf", "nitf"], "application/vnd.noblenet-directory": ["nnd"], "application/vnd.noblenet-sealer": ["nns"], "application/vnd.noblenet-web": ["nnw"], "application/vnd.nokia.n-gage.data": ["ngdat"], "application/vnd.nokia.n-gage.symbian.install": ["n-gage"], "application/vnd.nokia.radio-preset": ["rpst"], "application/vnd.nokia.radio-presets": ["rpss"], "application/vnd.novadigm.edm": ["edm"], "application/vnd.novadigm.edx": ["edx"], "application/vnd.novadigm.ext": ["ext"], "application/vnd.oasis.opendocument.chart": ["odc"], "application/vnd.oasis.opendocument.chart-template": ["otc"], "application/vnd.oasis.opendocument.database": ["odb"], "application/vnd.oasis.opendocument.formula": ["odf"], "application/vnd.oasis.opendocument.formula-template": ["odft"], "application/vnd.oasis.opendocument.graphics": ["odg"], "application/vnd.oasis.opendocument.graphics-template": ["otg"], "application/vnd.oasis.opendocument.image": ["odi"], "application/vnd.oasis.opendocument.image-template": ["oti"], "application/vnd.oasis.opendocument.presentation": ["odp"], "application/vnd.oasis.opendocument.presentation-template": ["otp"], "application/vnd.oasis.opendocument.spreadsheet": ["ods"], "application/vnd.oasis.opendocument.spreadsheet-template": ["ots"], "application/vnd.oasis.opendocument.text": ["odt"], "application/vnd.oasis.opendocument.text-master": ["odm"], "application/vnd.oasis.opendocument.text-template": ["ott"], "application/vnd.oasis.opendocument.text-web": ["oth"], "application/vnd.olpc-sugar": ["xo"], "application/vnd.oma.dd2+xml": ["dd2"], "application/vnd.openofficeorg.extension": ["oxt"], "application/vnd.openxmlformats-officedocument.presentationml.presentation": ["pptx"], "application/vnd.openxmlformats-officedocument.presentationml.slide": ["sldx"], "application/vnd.openxmlformats-officedocument.presentationml.slideshow": ["ppsx"], "application/vnd.openxmlformats-officedocument.presentationml.template": ["potx"], "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": ["xlsx"], "application/vnd.openxmlformats-officedocument.spreadsheetml.template": ["xltx"], "application/vnd.openxmlformats-officedocument.wordprocessingml.document": ["docx"], "application/vnd.openxmlformats-officedocument.wordprocessingml.template": ["dotx"], "application/vnd.osgeo.mapguide.package": ["mgp"], "application/vnd.osgi.dp": ["dp"], "application/vnd.osgi.subsystem": ["esa"], "application/vnd.palm": ["pdb", "pqa", "oprc"], "application/vnd.pawaafile": ["paw"], "application/vnd.pg.format": ["str"], "application/vnd.pg.osasli": ["ei6"], "application/vnd.picsel": ["efif"], "application/vnd.pmi.widget": ["wg"], "application/vnd.pocketlearn": ["plf"], "application/vnd.powerbuilder6": ["pbd"], "application/vnd.previewsystems.box": ["box"], "application/vnd.proteus.magazine": ["mgz"], "application/vnd.publishare-delta-tree": ["qps"], "application/vnd.pvi.ptid1": ["ptid"], "application/vnd.quark.quarkxpress": ["qxd", "qxt", "qwd", "qwt", "qxl", "qxb"], "application/vnd.realvnc.bed": ["bed"], "application/vnd.recordare.musicxml": ["mxl"], "application/vnd.recordare.musicxml+xml": ["musicxml"], "application/vnd.rig.cryptonote": ["cryptonote"], "application/vnd.rim.cod": ["cod"], "application/vnd.rn-realmedia": ["rm"], "application/vnd.rn-realmedia-vbr": ["rmvb"], "application/vnd.route66.link66+xml": ["link66"], "application/vnd.sailingtracker.track": ["st"], "application/vnd.seemail": ["see"], "application/vnd.sema": ["sema"], "application/vnd.semd": ["semd"], "application/vnd.semf": ["semf"], "application/vnd.shana.informed.formdata": ["ifm"], "application/vnd.shana.informed.formtemplate": ["itp"], "application/vnd.shana.informed.interchange": ["iif"], "application/vnd.shana.informed.package": ["ipk"], "application/vnd.simtech-mindmapper": ["twd", "twds"], "application/vnd.smaf": ["mmf"], "application/vnd.smart.teacher": ["teacher"], "application/vnd.solent.sdkm+xml": ["sdkm", "sdkd"], "application/vnd.spotfire.dxp": ["dxp"], "application/vnd.spotfire.sfs": ["sfs"], "application/vnd.stardivision.calc": ["sdc"], "application/vnd.stardivision.draw": ["sda"], "application/vnd.stardivision.impress": ["sdd"], "application/vnd.stardivision.math": ["smf"], "application/vnd.stardivision.writer": ["sdw", "vor"], "application/vnd.stardivision.writer-global": ["sgl"], "application/vnd.stepmania.package": ["smzip"], "application/vnd.stepmania.stepchart": ["sm"], "application/vnd.sun.wadl+xml": ["wadl"], "application/vnd.sun.xml.calc": ["sxc"], "application/vnd.sun.xml.calc.template": ["stc"], "application/vnd.sun.xml.draw": ["sxd"], "application/vnd.sun.xml.draw.template": ["std"], "application/vnd.sun.xml.impress": ["sxi"], "application/vnd.sun.xml.impress.template": ["sti"], "application/vnd.sun.xml.math": ["sxm"], "application/vnd.sun.xml.writer": ["sxw"], "application/vnd.sun.xml.writer.global": ["sxg"], "application/vnd.sun.xml.writer.template": ["stw"], "application/vnd.sus-calendar": ["sus", "susp"], "application/vnd.svd": ["svd"], "application/vnd.symbian.install": ["sis", "sisx"], "application/vnd.syncml+xml": ["xsm"], "application/vnd.syncml.dm+wbxml": ["bdm"], "application/vnd.syncml.dm+xml": ["xdm"], "application/vnd.tao.intent-module-archive": ["tao"], "application/vnd.tcpdump.pcap": ["pcap", "cap", "dmp"], "application/vnd.tmobile-livetv": ["tmo"], "application/vnd.trid.tpt": ["tpt"], "application/vnd.triscape.mxs": ["mxs"], "application/vnd.trueapp": ["tra"], "application/vnd.ufdl": ["ufd", "ufdl"], "application/vnd.uiq.theme": ["utz"], "application/vnd.umajin": ["umj"], "application/vnd.unity": ["unityweb"], "application/vnd.uoml+xml": ["uoml"], "application/vnd.vcx": ["vcx"], "application/vnd.visio": ["vsd", "vst", "vss", "vsw"], "application/vnd.visionary": ["vis"], "application/vnd.vsf": ["vsf"], "application/vnd.wap.wbxml": ["wbxml"], "application/vnd.wap.wmlc": ["wmlc"], "application/vnd.wap.wmlscriptc": ["wmlsc"], "application/vnd.webturbo": ["wtb"], "application/vnd.wolfram.player": ["nbp"], "application/vnd.wordperfect": ["wpd"], "application/vnd.wqd": ["wqd"], "application/vnd.wt.stf": ["stf"], "application/vnd.xara": ["xar"], "application/vnd.xfdl": ["xfdl"], "application/vnd.yamaha.hv-dic": ["hvd"], "application/vnd.yamaha.hv-script": ["hvs"], "application/vnd.yamaha.hv-voice": ["hvp"], "application/vnd.yamaha.openscoreformat": ["osf"], "application/vnd.yamaha.openscoreformat.osfpvg+xml": ["osfpvg"], "application/vnd.yamaha.smaf-audio": ["saf"], "application/vnd.yamaha.smaf-phrase": ["spf"], "application/vnd.yellowriver-custom-menu": ["cmp"], "application/vnd.zul": ["zir", "zirz"], "application/vnd.zzazz.deck+xml": ["zaz"], "application/voicexml+xml": ["vxml"], "application/wasm": ["wasm"], "application/widget": ["wgt"], "application/winhlp": ["hlp"], "application/wsdl+xml": ["wsdl"], "application/wspolicy+xml": ["wspolicy"], "application/x-7z-compressed": ["7z"], "application/x-abiword": ["abw"], "application/x-ace-compressed": ["ace"], "application/x-apple-diskimage": [], "application/x-arj": ["arj"], "application/x-authorware-bin": ["aab", "x32", "u32", "vox"], "application/x-authorware-map": ["aam"], "application/x-authorware-seg": ["aas"], "application/x-bcpio": ["bcpio"], "application/x-bdoc": [], "application/x-bittorrent": ["torrent"], "application/x-blorb": ["blb", "blorb"], "application/x-bzip": ["bz"], "application/x-bzip2": ["bz2", "boz"], "application/x-cbr": ["cbr", "cba", "cbt", "cbz", "cb7"], "application/x-cdlink": ["vcd"], "application/x-cfs-compressed": ["cfs"], "application/x-chat": ["chat"], "application/x-chess-pgn": ["pgn"], "application/x-chrome-extension": ["crx"], "application/x-cocoa": ["cco"], "application/x-conference": ["nsc"], "application/x-cpio": ["cpio"], "application/x-csh": ["csh"], "application/x-debian-package": ["udeb"], "application/x-dgc-compressed": ["dgc"], "application/x-director": ["dir", "dcr", "dxr", "cst", "cct", "cxt", "w3d", "fgd", "swa"], "application/x-doom": ["wad"], "application/x-dtbncx+xml": ["ncx"], "application/x-dtbook+xml": ["dtb"], "application/x-dtbresource+xml": ["res"], "application/x-dvi": ["dvi"], "application/x-envoy": ["evy"], "application/x-eva": ["eva"], "application/x-font-bdf": ["bdf"], "application/x-font-ghostscript": ["gsf"], "application/x-font-linux-psf": ["psf"], "application/x-font-pcf": ["pcf"], "application/x-font-snf": ["snf"], "application/x-font-type1": ["pfa", "pfb", "pfm", "afm"], "application/x-freearc": ["arc"], "application/x-futuresplash": ["spl"], "application/x-gca-compressed": ["gca"], "application/x-glulx": ["ulx"], "application/x-gnumeric": ["gnumeric"], "application/x-gramps-xml": ["gramps"], "application/x-gtar": ["gtar"], "application/x-hdf": ["hdf"], "application/x-httpd-php": ["php"], "application/x-install-instructions": ["install"], "application/x-iso9660-image": [], "application/x-java-archive-diff": ["jardiff"], "application/x-java-jnlp-file": ["jnlp"], "application/x-latex": ["latex"], "application/x-lua-bytecode": ["luac"], "application/x-lzh-compressed": ["lzh", "lha"], "application/x-makeself": ["run"], "application/x-mie": ["mie"], "application/x-mobipocket-ebook": ["prc", "mobi"], "application/x-ms-application": ["application"], "application/x-ms-shortcut": ["lnk"], "application/x-ms-wmd": ["wmd"], "application/x-ms-wmz": ["wmz"], "application/x-ms-xbap": ["xbap"], "application/x-msaccess": ["mdb"], "application/x-msbinder": ["obd"], "application/x-mscardfile": ["crd"], "application/x-msclip": ["clp"], "application/x-msdos-program": [], "application/x-msdownload": ["com", "bat"], "application/x-msmediaview": ["mvb", "m13", "m14"], "application/x-msmetafile": ["wmf", "emf", "emz"], "application/x-msmoney": ["mny"], "application/x-mspublisher": ["pub"], "application/x-msschedule": ["scd"], "application/x-msterminal": ["trm"], "application/x-mswrite": ["wri"], "application/x-netcdf": ["nc", "cdf"], "application/x-ns-proxy-autoconfig": ["pac"], "application/x-nzb": ["nzb"], "application/x-perl": ["pl", "pm"], "application/x-pilot": [], "application/x-pkcs12": ["p12", "pfx"], "application/x-pkcs7-certificates": ["p7b", "spc"], "application/x-pkcs7-certreqresp": ["p7r"], "application/x-rar-compressed": ["rar"], "application/x-redhat-package-manager": ["rpm"], "application/x-research-info-systems": ["ris"], "application/x-sea": ["sea"], "application/x-sh": ["sh"], "application/x-shar": ["shar"], "application/x-shockwave-flash": ["swf"], "application/x-silverlight-app": ["xap"], "application/x-sql": ["sql"], "application/x-stuffit": ["sit"], "application/x-stuffitx": ["sitx"], "application/x-subrip": ["srt"], "application/x-sv4cpio": ["sv4cpio"], "application/x-sv4crc": ["sv4crc"], "application/x-t3vm-image": ["t3"], "application/x-tads": ["gam"], "application/x-tar": ["tar"], "application/x-tcl": ["tcl", "tk"], "application/x-tex": ["tex"], "application/x-tex-tfm": ["tfm"], "application/x-texinfo": ["texinfo", "texi"], "application/x-tgif": ["obj"], "application/x-ustar": ["ustar"], "application/x-virtualbox-hdd": ["hdd"], "application/x-virtualbox-ova": ["ova"], "application/x-virtualbox-ovf": ["ovf"], "application/x-virtualbox-vbox": ["vbox"], "application/x-virtualbox-vbox-extpack": ["vbox-extpack"], "application/x-virtualbox-vdi": ["vdi"], "application/x-virtualbox-vhd": ["vhd"], "application/x-virtualbox-vmdk": ["vmdk"], "application/x-wais-source": ["src"], "application/x-web-app-manifest+json": ["webapp"], "application/x-x509-ca-cert": ["der", "crt", "pem"], "application/x-xfig": ["fig"], "application/x-xliff+xml": ["xlf"], "application/x-xpinstall": ["xpi"], "application/x-xz": ["xz"], "application/x-zmachine": ["z1", "z2", "z3", "z4", "z5", "z6", "z7", "z8"], "application/xaml+xml": ["xaml"], "application/xcap-diff+xml": ["xdf"], "application/xenc+xml": ["xenc"], "application/xhtml+xml": ["xhtml", "xht"], "application/xml": ["xml", "xsl", "xsd", "rng"], "application/xml-dtd": ["dtd"], "application/xop+xml": ["xop"], "application/xproc+xml": ["xpl"], "application/xslt+xml": ["xslt"], "application/xspf+xml": ["xspf"], "application/xv+xml": ["mxml", "xhvml", "xvml", "xvm"], "application/yang": ["yang"], "application/yin+xml": ["yin"], "application/zip": ["zip"], "audio/3gpp": [], "audio/adpcm": ["adp"], "audio/basic": ["au", "snd"], "audio/midi": ["mid", "midi", "kar", "rmi"], "audio/mp3": [], "audio/mp4": ["m4a", "mp4a"], "audio/mpeg": ["mpga", "mp2", "mp2a", "mp3", "m2a", "m3a"], "audio/ogg": ["oga", "ogg", "spx"], "audio/s3m": ["s3m"], "audio/silk": ["sil"], "audio/vnd.dece.audio": ["uva", "uvva"], "audio/vnd.digital-winds": ["eol"], "audio/vnd.dra": ["dra"], "audio/vnd.dts": ["dts"], "audio/vnd.dts.hd": ["dtshd"], "audio/vnd.lucent.voice": ["lvp"], "audio/vnd.ms-playready.media.pya": ["pya"], "audio/vnd.nuera.ecelp4800": ["ecelp4800"], "audio/vnd.nuera.ecelp7470": ["ecelp7470"], "audio/vnd.nuera.ecelp9600": ["ecelp9600"], "audio/vnd.rip": ["rip"], "audio/wav": ["wav"], "audio/wave": [], "audio/webm": ["weba"], "audio/x-aac": ["aac"], "audio/x-aiff": ["aif", "aiff", "aifc"], "audio/x-caf": ["caf"], "audio/x-flac": ["flac"], "audio/x-m4a": [], "audio/x-matroska": ["mka"], "audio/x-mpegurl": ["m3u"], "audio/x-ms-wax": ["wax"], "audio/x-ms-wma": ["wma"], "audio/x-pn-realaudio": ["ram", "ra"], "audio/x-pn-realaudio-plugin": ["rmp"], "audio/x-realaudio": [], "audio/x-wav": [], "audio/xm": ["xm"], "chemical/x-cdx": ["cdx"], "chemical/x-cif": ["cif"], "chemical/x-cmdf": ["cmdf"], "chemical/x-cml": ["cml"], "chemical/x-csml": ["csml"], "chemical/x-xyz": ["xyz"], "font/collection": ["ttc"], "font/otf": ["otf"], "font/ttf": ["ttf"], "font/woff": ["woff"], "font/woff2": ["woff2"], "image/apng": ["apng"], "image/bmp": ["bmp"], "image/cgm": ["cgm"], "image/g3fax": ["g3"], "image/gif": ["gif"], "image/ief": ["ief"], "image/jp2": ["jp2", "jpg2"], "image/jpeg": ["jpeg", "jpg", "jpe"], "image/jpm": ["jpm"], "image/jpx": ["jpx", "jpf"], "image/ktx": ["ktx"], "image/png": ["png"], "image/prs.btif": ["btif"], "image/sgi": ["sgi"], "image/svg+xml": ["svg", "svgz"], "image/tiff": ["tiff", "tif"], "image/vnd.adobe.photoshop": ["psd"], "image/vnd.dece.graphic": ["uvi", "uvvi", "uvg", "uvvg"], "image/vnd.djvu": ["djvu", "djv"], "image/vnd.dvb.subtitle": [], "image/vnd.dwg": ["dwg"], "image/vnd.dxf": ["dxf"], "image/vnd.fastbidsheet": ["fbs"], "image/vnd.fpx": ["fpx"], "image/vnd.fst": ["fst"], "image/vnd.fujixerox.edmics-mmr": ["mmr"], "image/vnd.fujixerox.edmics-rlc": ["rlc"], "image/vnd.ms-modi": ["mdi"], "image/vnd.ms-photo": ["wdp"], "image/vnd.net-fpx": ["npx"], "image/vnd.wap.wbmp": ["wbmp"], "image/vnd.xiff": ["xif"], "image/webp": ["webp"], "image/x-3ds": ["3ds"], "image/x-cmu-raster": ["ras"], "image/x-cmx": ["cmx"], "image/x-freehand": ["fh", "fhc", "fh4", "fh5", "fh7"], "image/x-icon": ["ico"], "image/x-jng": ["jng"], "image/x-mrsid-image": ["sid"], "image/x-ms-bmp": [], "image/x-pcx": ["pcx"], "image/x-pict": ["pic", "pct"], "image/x-portable-anymap": ["pnm"], "image/x-portable-bitmap": ["pbm"], "image/x-portable-graymap": ["pgm"], "image/x-portable-pixmap": ["ppm"], "image/x-rgb": ["rgb"], "image/x-tga": ["tga"], "image/x-xbitmap": ["xbm"], "image/x-xpixmap": ["xpm"], "image/x-xwindowdump": ["xwd"], "message/rfc822": ["eml", "mime"], "model/gltf+json": ["gltf"], "model/gltf-binary": ["glb"], "model/iges": ["igs", "iges"], "model/mesh": ["msh", "mesh", "silo"], "model/vnd.collada+xml": ["dae"], "model/vnd.dwf": ["dwf"], "model/vnd.gdl": ["gdl"], "model/vnd.gtw": ["gtw"], "model/vnd.mts": ["mts"], "model/vnd.vtu": ["vtu"], "model/vrml": ["wrl", "vrml"], "model/x3d+binary": ["x3db", "x3dbz"], "model/x3d+vrml": ["x3dv", "x3dvz"], "model/x3d+xml": ["x3d", "x3dz"], "text/cache-manifest": ["appcache", "manifest"], "text/calendar": ["ics", "ifb"], "text/coffeescript": ["coffee", "litcoffee"], "text/css": ["css"], "text/csv": ["csv"], "text/hjson": ["hjson"], "text/html": ["html", "htm", "shtml"], "text/jade": ["jade"], "text/jsx": ["jsx"], "text/less": ["less"], "text/markdown": ["markdown", "md"], "text/mathml": ["mml"], "text/n3": ["n3"], "text/plain": ["txt", "text", "conf", "def", "list", "log", "in", "ini"], "text/prs.lines.tag": ["dsc"], "text/richtext": ["rtx"], "text/rtf": [], "text/sgml": ["sgml", "sgm"], "text/slim": ["slim", "slm"], "text/stylus": ["stylus", "styl"], "text/tab-separated-values": ["tsv"], "text/troff": ["t", "tr", "roff", "man", "me", "ms"], "text/turtle": ["ttl"], "text/uri-list": ["uri", "uris", "urls"], "text/vcard": ["vcard"], "text/vnd.curl": ["curl"], "text/vnd.curl.dcurl": ["dcurl"], "text/vnd.curl.mcurl": ["mcurl"], "text/vnd.curl.scurl": ["scurl"], "text/vnd.dvb.subtitle": ["sub"], "text/vnd.fly": ["fly"], "text/vnd.fmi.flexstor": ["flx"], "text/vnd.graphviz": ["gv"], "text/vnd.in3d.3dml": ["3dml"], "text/vnd.in3d.spot": ["spot"], "text/vnd.sun.j2me.app-descriptor": ["jad"], "text/vnd.wap.wml": ["wml"], "text/vnd.wap.wmlscript": ["wmls"], "text/vtt": ["vtt"], "text/x-asm": ["s", "asm"], "text/x-c": ["c", "cc", "cxx", "cpp", "h", "hh", "dic"], "text/x-component": ["htc"], "text/x-fortran": ["f", "for", "f77", "f90"], "text/x-handlebars-template": ["hbs"], "text/x-java-source": ["java"], "text/x-lua": ["lua"], "text/x-markdown": ["mkd"], "text/x-nfo": ["nfo"], "text/x-opml": ["opml"], "text/x-org": [], "text/x-pascal": ["p", "pas"], "text/x-processing": ["pde"], "text/x-sass": ["sass"], "text/x-scss": ["scss"], "text/x-setext": ["etx"], "text/x-sfv": ["sfv"], "text/x-suse-ymp": ["ymp"], "text/x-uuencode": ["uu"], "text/x-vcalendar": ["vcs"], "text/x-vcard": ["vcf"], "text/xml": [], "text/yaml": ["yaml", "yml"], "video/3gpp": ["3gp", "3gpp"], "video/3gpp2": ["3g2"], "video/h261": ["h261"], "video/h263": ["h263"], "video/h264": ["h264"], "video/jpeg": ["jpgv"], "video/jpm": ["jpgm"], "video/mj2": ["mj2", "mjp2"], "video/mp2t": ["ts"], "video/mp4": ["mp4", "mp4v", "mpg4"], "video/mpeg": ["mpeg", "mpg", "mpe", "m1v", "m2v"], "video/ogg": ["ogv"], "video/quicktime": ["qt", "mov"], "video/vnd.dece.hd": ["uvh", "uvvh"], "video/vnd.dece.mobile": ["uvm", "uvvm"], "video/vnd.dece.pd": ["uvp", "uvvp"], "video/vnd.dece.sd": ["uvs", "uvvs"], "video/vnd.dece.video": ["uvv", "uvvv"], "video/vnd.dvb.file": ["dvb"], "video/vnd.fvt": ["fvt"], "video/vnd.mpegurl": ["mxu", "m4u"], "video/vnd.ms-playready.media.pyv": ["pyv"], "video/vnd.uvvu.mp4": ["uvu", "uvvu"], "video/vnd.vivo": ["viv"], "video/webm": ["webm"], "video/x-f4v": ["f4v"], "video/x-fli": ["fli"], "video/x-flv": ["flv"], "video/x-m4v": ["m4v"], "video/x-matroska": ["mkv", "mk3d", "mks"], "video/x-mng": ["mng"], "video/x-ms-asf": ["asf", "asx"], "video/x-ms-vob": ["vob"], "video/x-ms-wm": ["wm"], "video/x-ms-wmv": ["wmv"], "video/x-ms-wmx": ["wmx"], "video/x-ms-wvx": ["wvx"], "video/x-msvideo": ["avi"], "video/x-sgi-movie": ["movie"], "video/x-smv": ["smv"], "x-conference/x-cooltalk": ["ice"] };
+ }
+});
+
+// ../../node_modules/.pnpm/mime@1.6.0/node_modules/mime/mime.js
+var require_mime = __commonJS({
+ "../../node_modules/.pnpm/mime@1.6.0/node_modules/mime/mime.js"(exports2, module2) {
+ init_import_meta_url();
+ var path45 = require("path");
+ var fs20 = require("fs");
+ function Mime() {
+ this.types = /* @__PURE__ */ Object.create(null);
+ this.extensions = /* @__PURE__ */ Object.create(null);
+ }
+ __name(Mime, "Mime");
+ Mime.prototype.define = function(map) {
+ for (var type in map) {
+ var exts = map[type];
+ for (var i = 0; i < exts.length; i++) {
+ if (process.env.DEBUG_MIME && this.types[exts[i]]) {
+ console.warn((this._loading || "define()").replace(/.*\//, ""), 'changes "' + exts[i] + '" extension type from ' + this.types[exts[i]] + " to " + type);
+ }
+ this.types[exts[i]] = type;
+ }
+ if (!this.extensions[type]) {
+ this.extensions[type] = exts[0];
+ }
+ }
+ };
+ Mime.prototype.load = function(file) {
+ this._loading = file;
+ var map = {}, content = fs20.readFileSync(file, "ascii"), lines = content.split(/[\r\n]+/);
+ lines.forEach(function(line) {
+ var fields = line.replace(/\s*#.*|^\s*|\s*$/g, "").split(/\s+/);
+ map[fields.shift()] = fields;
+ });
+ this.define(map);
+ this._loading = null;
+ };
+ Mime.prototype.lookup = function(path46, fallback) {
+ var ext = path46.replace(/^.*[\.\/\\]/, "").toLowerCase();
+ return this.types[ext] || fallback || this.default_type;
+ };
+ Mime.prototype.extension = function(mimeType) {
+ var type = mimeType.match(/^\s*([^;\s]*)(?:;|\s|$)/)[1].toLowerCase();
+ return this.extensions[type];
+ };
+ var mime = new Mime();
+ mime.define(require_types());
+ mime.default_type = mime.lookup("bin");
+ mime.Mime = Mime;
+ mime.charsets = {
+ lookup: function(mimeType, fallback) {
+ return /^text\/|^application\/(javascript|json)/.test(mimeType) ? "UTF-8" : fallback;
+ }
+ };
+ module2.exports = mime;
+ }
+});
+
+// ../../node_modules/.pnpm/ms@2.1.3/node_modules/ms/index.js
+var require_ms2 = __commonJS({
+ "../../node_modules/.pnpm/ms@2.1.3/node_modules/ms/index.js"(exports2, module2) {
+ init_import_meta_url();
+ 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, options14) {
+ options14 = options14 || {};
+ var type = typeof val;
+ if (type === "string" && val.length > 0) {
+ return parse4(val);
+ } else if (type === "number" && isFinite(val)) {
+ return options14.long ? fmtLong(val) : fmtShort(val);
+ }
+ throw new Error(
+ "val is not a non-empty string or a valid number. val=" + JSON.stringify(val)
+ );
+ };
+ function parse4(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;
+ }
+ }
+ __name(parse4, "parse");
+ 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";
+ }
+ __name(fmtShort, "fmtShort");
+ 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";
+ }
+ __name(fmtLong, "fmtLong");
+ function plural(ms, msAbs, n, name) {
+ var isPlural = msAbs >= n * 1.5;
+ return Math.round(ms / n) + " " + name + (isPlural ? "s" : "");
+ }
+ __name(plural, "plural");
+ }
+});
+
+// ../../node_modules/.pnpm/range-parser@1.2.1/node_modules/range-parser/index.js
+var require_range_parser = __commonJS({
+ "../../node_modules/.pnpm/range-parser@1.2.1/node_modules/range-parser/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ module2.exports = rangeParser;
+ function rangeParser(size, str, options14) {
+ 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 options14 && options14.combine ? combineRanges(ranges) : ranges;
+ }
+ __name(rangeParser, "rangeParser");
+ 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;
+ }
+ __name(combineRanges, "combineRanges");
+ function mapWithIndex(range, index) {
+ return {
+ start: range.start,
+ end: range.end,
+ index
+ };
+ }
+ __name(mapWithIndex, "mapWithIndex");
+ function mapWithoutIndex(range) {
+ return {
+ start: range.start,
+ end: range.end
+ };
+ }
+ __name(mapWithoutIndex, "mapWithoutIndex");
+ function sortByRangeIndex(a, b) {
+ return a.index - b.index;
+ }
+ __name(sortByRangeIndex, "sortByRangeIndex");
+ function sortByRangeStart(a, b) {
+ return a.start - b.start;
+ }
+ __name(sortByRangeStart, "sortByRangeStart");
+ }
+});
+
+// ../../node_modules/.pnpm/send@0.18.0_supports-color@9.2.2/node_modules/send/index.js
+var require_send = __commonJS({
+ "../../node_modules/.pnpm/send@0.18.0_supports-color@9.2.2/node_modules/send/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var createError = require_http_errors();
+ var debug = require_src2()("send");
+ var deprecate = require_depd()("send");
+ var destroy = require_destroy();
+ var encodeUrl = require_encodeurl();
+ var escapeHtml = require_escape_html();
+ var etag = require_etag();
+ var fresh = require_fresh();
+ var fs20 = require("fs");
+ var mime = require_mime();
+ var ms = require_ms2();
+ var onFinished = require_on_finished();
+ var parseRange = require_range_parser();
+ var path45 = require("path");
+ var statuses = require_statuses();
+ var Stream = require("stream");
+ var util3 = require("util");
+ var extname4 = path45.extname;
+ var join12 = path45.join;
+ var normalize2 = path45.normalize;
+ var resolve18 = path45.resolve;
+ var sep2 = path45.sep;
+ var BYTES_RANGE_REGEXP = /^ *bytes=/;
+ var MAX_MAXAGE = 60 * 60 * 24 * 365 * 1e3;
+ var UP_PATH_REGEXP = /(?:^|[\\/])\.\.(?:[\\/]|$)/;
+ module2.exports = send;
+ module2.exports.mime = mime;
+ function send(req, path46, options14) {
+ return new SendStream(req, path46, options14);
+ }
+ __name(send, "send");
+ function SendStream(req, path46, options14) {
+ Stream.call(this);
+ var opts = options14 || {};
+ this.options = opts;
+ this.path = path46;
+ 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._hidden = Boolean(opts.hidden);
+ if (opts.hidden !== void 0) {
+ deprecate("hidden: use dotfiles: '" + (this._hidden ? "allow" : "ignore") + "' instead");
+ }
+ if (opts.dotfiles === void 0) {
+ this._dotfiles = void 0;
+ }
+ 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 ? resolve18(opts.root) : null;
+ if (!this._root && opts.from) {
+ this.from(opts.from);
+ }
+ }
+ __name(SendStream, "SendStream");
+ util3.inherits(SendStream, Stream);
+ SendStream.prototype.etag = deprecate.function(/* @__PURE__ */ __name(function etag2(val) {
+ this._etag = Boolean(val);
+ debug("etag %s", this._etag);
+ return this;
+ }, "etag"), "send.etag: pass etag as option");
+ SendStream.prototype.hidden = deprecate.function(/* @__PURE__ */ __name(function hidden(val) {
+ this._hidden = Boolean(val);
+ this._dotfiles = void 0;
+ debug("hidden %s", this._hidden);
+ return this;
+ }, "hidden"), "send.hidden: use dotfiles option");
+ SendStream.prototype.index = deprecate.function(/* @__PURE__ */ __name(function index(paths) {
+ var index2 = !paths ? [] : normalizeList(paths, "paths argument");
+ debug("index %o", paths);
+ this._index = index2;
+ return this;
+ }, "index"), "send.index: pass index as option");
+ SendStream.prototype.root = /* @__PURE__ */ __name(function root(path46) {
+ this._root = resolve18(String(path46));
+ debug("root %s", this._root);
+ return this;
+ }, "root");
+ SendStream.prototype.from = deprecate.function(
+ SendStream.prototype.root,
+ "send.from: pass root as option"
+ );
+ SendStream.prototype.root = deprecate.function(
+ SendStream.prototype.root,
+ "send.root: pass root as option"
+ );
+ SendStream.prototype.maxage = deprecate.function(/* @__PURE__ */ __name(function maxage(maxAge) {
+ this._maxage = typeof maxAge === "string" ? ms(maxAge) : Number(maxAge);
+ this._maxage = !isNaN(this._maxage) ? Math.min(Math.max(0, this._maxage), MAX_MAXAGE) : 0;
+ debug("max-age %d", this._maxage);
+ return this;
+ }, "maxage"), "send.maxage: pass maxAge as option");
+ SendStream.prototype.error = /* @__PURE__ */ __name(function error(status, err) {
+ if (hasListeners(this, "error")) {
+ return this.emit("error", createHttpError(status, err));
+ }
+ var res = this.res;
+ var msg = statuses.message[status] || String(status);
+ var doc = createHtmlDocument("Error", escapeHtml(msg));
+ clearHeaders(res);
+ if (err && err.headers) {
+ setHeaders(res, err.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);
+ }, "error");
+ SendStream.prototype.hasTrailingSlash = /* @__PURE__ */ __name(function hasTrailingSlash() {
+ return this.path[this.path.length - 1] === "/";
+ }, "hasTrailingSlash");
+ SendStream.prototype.isConditionalGET = /* @__PURE__ */ __name(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"];
+ }, "isConditionalGET");
+ SendStream.prototype.isPreconditionFailure = /* @__PURE__ */ __name(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;
+ }, "isPreconditionFailure");
+ SendStream.prototype.removeContentHeaderFields = /* @__PURE__ */ __name(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");
+ }, "removeContentHeaderFields");
+ SendStream.prototype.notModified = /* @__PURE__ */ __name(function notModified() {
+ var res = this.res;
+ debug("not modified");
+ this.removeContentHeaderFields();
+ res.statusCode = 304;
+ res.end();
+ }, "notModified");
+ SendStream.prototype.headersAlreadySent = /* @__PURE__ */ __name(function headersAlreadySent() {
+ var err = new Error("Can't set headers after they are sent.");
+ debug("headers already sent");
+ this.error(500, err);
+ }, "headersAlreadySent");
+ SendStream.prototype.isCachable = /* @__PURE__ */ __name(function isCachable() {
+ var statusCode = this.res.statusCode;
+ return statusCode >= 200 && statusCode < 300 || statusCode === 304;
+ }, "isCachable");
+ SendStream.prototype.onStatError = /* @__PURE__ */ __name(function onStatError(error) {
+ switch (error.code) {
+ case "ENAMETOOLONG":
+ case "ENOENT":
+ case "ENOTDIR":
+ this.error(404, error);
+ break;
+ default:
+ this.error(500, error);
+ break;
+ }
+ }, "onStatError");
+ SendStream.prototype.isFresh = /* @__PURE__ */ __name(function isFresh() {
+ return fresh(this.req.headers, {
+ etag: this.res.getHeader("ETag"),
+ "last-modified": this.res.getHeader("Last-Modified")
+ });
+ }, "isFresh");
+ SendStream.prototype.isRangeFresh = /* @__PURE__ */ __name(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);
+ }, "isRangeFresh");
+ SendStream.prototype.redirect = /* @__PURE__ */ __name(function redirect(path46) {
+ var res = this.res;
+ if (hasListeners(this, "directory")) {
+ this.emit("directory", res, path46);
+ 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);
+ }, "redirect");
+ SendStream.prototype.pipe = /* @__PURE__ */ __name(function pipe(res) {
+ var root = this._root;
+ this.res = res;
+ var path46 = decode(this.path);
+ if (path46 === -1) {
+ this.error(400);
+ return res;
+ }
+ if (~path46.indexOf("\0")) {
+ this.error(400);
+ return res;
+ }
+ var parts;
+ if (root !== null) {
+ if (path46) {
+ path46 = normalize2("." + sep2 + path46);
+ }
+ if (UP_PATH_REGEXP.test(path46)) {
+ debug('malicious path "%s"', path46);
+ this.error(403);
+ return res;
+ }
+ parts = path46.split(sep2);
+ path46 = normalize2(join12(root, path46));
+ } else {
+ if (UP_PATH_REGEXP.test(path46)) {
+ debug('malicious path "%s"', path46);
+ this.error(403);
+ return res;
+ }
+ parts = normalize2(path46).split(sep2);
+ path46 = resolve18(path46);
+ }
+ if (containsDotFile(parts)) {
+ var access3 = this._dotfiles;
+ if (access3 === void 0) {
+ access3 = parts[parts.length - 1][0] === "." ? this._hidden ? "allow" : "ignore" : "allow";
+ }
+ debug('%s dotfile "%s"', access3, path46);
+ switch (access3) {
+ 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(path46);
+ return res;
+ }
+ this.sendFile(path46);
+ return res;
+ }, "pipe");
+ SendStream.prototype.send = /* @__PURE__ */ __name(function send2(path46, stat3) {
+ var len = stat3.size;
+ var options14 = this.options;
+ var opts = {};
+ var res = this.res;
+ var req = this.req;
+ var ranges = req.headers.range;
+ var offset = options14.start || 0;
+ if (headersSent(res)) {
+ this.headersAlreadySent();
+ return;
+ }
+ debug('pipe "%s"', path46);
+ this.setHeader(path46, stat3);
+ this.type(path46);
+ 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 (options14.end !== void 0) {
+ var bytes = options14.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 options14) {
+ opts[prop] = options14[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(path46, opts);
+ }, "send");
+ SendStream.prototype.sendFile = /* @__PURE__ */ __name(function sendFile(path46) {
+ var i = 0;
+ var self2 = this;
+ debug('stat "%s"', path46);
+ fs20.stat(path46, /* @__PURE__ */ __name(function onstat(err, stat3) {
+ if (err && err.code === "ENOENT" && !extname4(path46) && path46[path46.length - 1] !== sep2) {
+ return next(err);
+ }
+ if (err)
+ return self2.onStatError(err);
+ if (stat3.isDirectory())
+ return self2.redirect(path46);
+ self2.emit("file", path46, stat3);
+ self2.send(path46, stat3);
+ }, "onstat"));
+ function next(err) {
+ if (self2._extensions.length <= i) {
+ return err ? self2.onStatError(err) : self2.error(404);
+ }
+ var p = path46 + "." + self2._extensions[i++];
+ debug('stat "%s"', p);
+ fs20.stat(p, function(err2, stat3) {
+ if (err2)
+ return next(err2);
+ if (stat3.isDirectory())
+ return next();
+ self2.emit("file", p, stat3);
+ self2.send(p, stat3);
+ });
+ }
+ __name(next, "next");
+ }, "sendFile");
+ SendStream.prototype.sendIndex = /* @__PURE__ */ __name(function sendIndex(path46) {
+ var i = -1;
+ var self2 = this;
+ function next(err) {
+ if (++i >= self2._index.length) {
+ if (err)
+ return self2.onStatError(err);
+ return self2.error(404);
+ }
+ var p = join12(path46, self2._index[i]);
+ debug('stat "%s"', p);
+ fs20.stat(p, function(err2, stat3) {
+ if (err2)
+ return next(err2);
+ if (stat3.isDirectory())
+ return next();
+ self2.emit("file", p, stat3);
+ self2.send(p, stat3);
+ });
+ }
+ __name(next, "next");
+ next();
+ }, "sendIndex");
+ SendStream.prototype.stream = /* @__PURE__ */ __name(function stream2(path46, options14) {
+ var self2 = this;
+ var res = this.res;
+ var stream3 = fs20.createReadStream(path46, options14);
+ this.emit("stream", stream3);
+ stream3.pipe(res);
+ function cleanup() {
+ destroy(stream3, true);
+ }
+ __name(cleanup, "cleanup");
+ onFinished(res, cleanup);
+ stream3.on("error", /* @__PURE__ */ __name(function onerror(err) {
+ cleanup();
+ self2.onStatError(err);
+ }, "onerror"));
+ stream3.on("end", /* @__PURE__ */ __name(function onend() {
+ self2.emit("end");
+ }, "onend"));
+ }, "stream");
+ SendStream.prototype.type = /* @__PURE__ */ __name(function type(path46) {
+ var res = this.res;
+ if (res.getHeader("Content-Type"))
+ return;
+ var type2 = mime.lookup(path46);
+ if (!type2) {
+ debug("no content-type");
+ return;
+ }
+ var charset = mime.charsets.lookup(type2);
+ debug("content-type %s", type2);
+ res.setHeader("Content-Type", type2 + (charset ? "; charset=" + charset : ""));
+ }, "type");
+ SendStream.prototype.setHeader = /* @__PURE__ */ __name(function setHeader(path46, stat3) {
+ var res = this.res;
+ this.emit("headers", res, path46, stat3);
+ 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 = stat3.mtime.toUTCString();
+ debug("modified %s", modified);
+ res.setHeader("Last-Modified", modified);
+ }
+ if (this._etag && !res.getHeader("ETag")) {
+ var val = etag(stat3);
+ debug("etag %s", val);
+ res.setHeader("ETag", val);
+ }
+ }, "setHeader");
+ function clearHeaders(res) {
+ var headers = getHeaderNames(res);
+ for (var i = 0; i < headers.length; i++) {
+ res.removeHeader(headers[i]);
+ }
+ }
+ __name(clearHeaders, "clearHeaders");
+ function collapseLeadingSlashes(str) {
+ for (var i = 0; i < str.length; i++) {
+ if (str[i] !== "/") {
+ break;
+ }
+ }
+ return i > 1 ? "/" + str.substr(i) : str;
+ }
+ __name(collapseLeadingSlashes, "collapseLeadingSlashes");
+ 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;
+ }
+ __name(containsDotFile, "containsDotFile");
+ function contentRange(type, size, range) {
+ return type + " " + (range ? range.start + "-" + range.end : "*") + "/" + size;
+ }
+ __name(contentRange, "contentRange");
+ function createHtmlDocument(title, body) {
+ return '\n\n\n\n' + title + "\n\n\n" + body + "
\n\n\n";
+ }
+ __name(createHtmlDocument, "createHtmlDocument");
+ function createHttpError(status, err) {
+ if (!err) {
+ return createError(status);
+ }
+ return err instanceof Error ? createError(status, err, { expose: false }) : createError(status, err);
+ }
+ __name(createHttpError, "createHttpError");
+ function decode(path46) {
+ try {
+ return decodeURIComponent(path46);
+ } catch (err) {
+ return -1;
+ }
+ }
+ __name(decode, "decode");
+ function getHeaderNames(res) {
+ return typeof res.getHeaderNames !== "function" ? Object.keys(res._headers || {}) : res.getHeaderNames();
+ }
+ __name(getHeaderNames, "getHeaderNames");
+ function hasListeners(emitter, type) {
+ var count = typeof emitter.listenerCount !== "function" ? emitter.listeners(type).length : emitter.listenerCount(type);
+ return count > 0;
+ }
+ __name(hasListeners, "hasListeners");
+ function headersSent(res) {
+ return typeof res.headersSent !== "boolean" ? Boolean(res._header) : res.headersSent;
+ }
+ __name(headersSent, "headersSent");
+ 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;
+ }
+ __name(normalizeList, "normalizeList");
+ function parseHttpDate(date) {
+ var timestamp = date && Date.parse(date);
+ return typeof timestamp === "number" ? timestamp : NaN;
+ }
+ __name(parseHttpDate, "parseHttpDate");
+ 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;
+ }
+ __name(parseTokenList, "parseTokenList");
+ 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]);
+ }
+ }
+ __name(setHeaders, "setHeaders");
+ }
+});
+
+// ../../node_modules/.pnpm/forwarded@0.2.0/node_modules/forwarded/index.js
+var require_forwarded = __commonJS({
+ "../../node_modules/.pnpm/forwarded@0.2.0/node_modules/forwarded/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ module2.exports = forwarded;
+ function forwarded(req) {
+ if (!req) {
+ throw new TypeError("argument req is required");
+ }
+ var proxyAddrs = parse4(req.headers["x-forwarded-for"] || "");
+ var socketAddr = getSocketAddr(req);
+ var addrs = [socketAddr].concat(proxyAddrs);
+ return addrs;
+ }
+ __name(forwarded, "forwarded");
+ function getSocketAddr(req) {
+ return req.socket ? req.socket.remoteAddress : req.connection.remoteAddress;
+ }
+ __name(getSocketAddr, "getSocketAddr");
+ function parse4(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;
+ }
+ __name(parse4, "parse");
+ }
+});
+
+// ../../node_modules/.pnpm/ipaddr.js@1.9.1/node_modules/ipaddr.js/lib/ipaddr.js
+var require_ipaddr = __commonJS({
+ "../../node_modules/.pnpm/ipaddr.js@1.9.1/node_modules/ipaddr.js/lib/ipaddr.js"(exports2, module2) {
+ init_import_meta_url();
+ (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 = /* @__PURE__ */ __name(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;
+ }, "matchCIDR");
+ 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;
+ }
+ __name(IPv4, "IPv4");
+ 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 = /* @__PURE__ */ __name(function(string2) {
+ if (string2[0] === "0" && string2[1] !== "x") {
+ return parseInt(string2, 8);
+ } else {
+ return parseInt(string2);
+ }
+ }, "parseIntAuto");
+ 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;
+ }
+ }
+ __name(IPv6, "IPv6");
+ 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 = /* @__PURE__ */ __name(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
+ };
+ }, "expandIPv6");
+ 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 e2;
+ try {
+ new this(this.parser(string));
+ return true;
+ } catch (error1) {
+ e2 = 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, e2;
+ if (typeof string === "string" && string.indexOf(":") === -1) {
+ return false;
+ }
+ try {
+ addr = this.parser(string);
+ new this(addr.parts, addr.zoneId);
+ return true;
+ } catch (error1) {
+ e2 = 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 e2;
+ try {
+ return ipaddr.IPv6.parseCIDR(string);
+ } catch (error1) {
+ e2 = error1;
+ try {
+ return ipaddr.IPv4.parseCIDR(string);
+ } catch (error12) {
+ e2 = 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);
+ }
+});
+
+// ../../node_modules/.pnpm/proxy-addr@2.0.7/node_modules/proxy-addr/index.js
+var require_proxy_addr = __commonJS({
+ "../../node_modules/.pnpm/proxy-addr@2.0.7/node_modules/proxy-addr/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ 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;
+ }
+ __name(alladdrs, "alladdrs");
+ 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));
+ }
+ __name(compile, "compile");
+ function compileRangeSubnets(arr) {
+ var rangeSubnets = new Array(arr.length);
+ for (var i = 0; i < arr.length; i++) {
+ rangeSubnets[i] = parseipNotation(arr[i]);
+ }
+ return rangeSubnets;
+ }
+ __name(compileRangeSubnets, "compileRangeSubnets");
+ function compileTrust(rangeSubnets) {
+ var len = rangeSubnets.length;
+ return len === 0 ? trustNone : len === 1 ? trustSingle(rangeSubnets[0]) : trustMulti(rangeSubnets);
+ }
+ __name(compileTrust, "compileTrust");
+ 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 ip2 = parseip(str);
+ if (pos === -1 && ip2.kind() === "ipv6" && ip2.isIPv4MappedAddress()) {
+ ip2 = ip2.toIPv4Address();
+ }
+ var max = ip2.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 (ip2.kind() === "ipv4" && isip(range)) {
+ range = parseNetmask(range);
+ } else {
+ range = null;
+ }
+ if (range <= 0 || range > max) {
+ throw new TypeError("invalid range on address: " + note);
+ }
+ return [ip2, range];
+ }
+ __name(parseipNotation, "parseipNotation");
+ function parseNetmask(netmask) {
+ var ip2 = parseip(netmask);
+ var kind = ip2.kind();
+ return kind === "ipv4" ? ip2.prefixLengthFromSubnetMask() : null;
+ }
+ __name(parseNetmask, "parseNetmask");
+ 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;
+ }
+ __name(proxyaddr, "proxyaddr");
+ function trustNone() {
+ return false;
+ }
+ __name(trustNone, "trustNone");
+ function trustMulti(subnets) {
+ return /* @__PURE__ */ __name(function trust(addr) {
+ if (!isip(addr))
+ return false;
+ var ip2 = parseip(addr);
+ var ipconv;
+ var kind = ip2.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 = ip2;
+ if (kind !== subnetkind) {
+ if (subnetkind === "ipv4" && !ip2.isIPv4MappedAddress()) {
+ continue;
+ }
+ if (!ipconv) {
+ ipconv = subnetkind === "ipv4" ? ip2.toIPv4Address() : ip2.toIPv4MappedAddress();
+ }
+ trusted = ipconv;
+ }
+ if (trusted.match(subnetip, subnetrange)) {
+ return true;
+ }
+ }
+ return false;
+ }, "trust");
+ }
+ __name(trustMulti, "trustMulti");
+ function trustSingle(subnet) {
+ var subnetip = subnet[0];
+ var subnetkind = subnetip.kind();
+ var subnetisipv4 = subnetkind === "ipv4";
+ var subnetrange = subnet[1];
+ return /* @__PURE__ */ __name(function trust(addr) {
+ if (!isip(addr))
+ return false;
+ var ip2 = parseip(addr);
+ var kind = ip2.kind();
+ if (kind !== subnetkind) {
+ if (subnetisipv4 && !ip2.isIPv4MappedAddress()) {
+ return false;
+ }
+ ip2 = subnetisipv4 ? ip2.toIPv4Address() : ip2.toIPv4MappedAddress();
+ }
+ return ip2.match(subnetip, subnetrange);
+ }, "trust");
+ }
+ __name(trustSingle, "trustSingle");
+ }
+});
+
+// ../../node_modules/.pnpm/express@4.18.1_supports-color@9.2.2/node_modules/express/lib/utils.js
+var require_utils5 = __commonJS({
+ "../../node_modules/.pnpm/express@4.18.1_supports-color@9.2.2/node_modules/express/lib/utils.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ var Buffer3 = require_safe_buffer().Buffer;
+ var contentDisposition = require_content_disposition();
+ var contentType = require_content_type();
+ var deprecate = require_depd()("express");
+ var flatten = require_array_flatten();
+ var mime = require_send().mime;
+ var etag = require_etag();
+ var proxyaddr = require_proxy_addr();
+ var qs = require_lib4();
+ var querystring = require("querystring");
+ exports2.etag = createETagGenerator({ weak: false });
+ exports2.wetag = createETagGenerator({ weak: true });
+ exports2.isAbsolute = function(path45) {
+ if ("/" === path45[0])
+ return true;
+ if (":" === path45[1] && ("\\" === path45[2] || "/" === path45[2]))
+ return true;
+ if ("\\\\" === path45.substring(0, 2))
+ return true;
+ };
+ exports2.flatten = deprecate.function(
+ flatten,
+ "utils.flatten: use array-flatten npm module instead"
+ );
+ exports2.normalizeType = function(type) {
+ return ~type.indexOf("/") ? acceptParams(type) : { value: mime.lookup(type), params: {} };
+ };
+ exports2.normalizeTypes = function(types) {
+ var ret = [];
+ for (var i = 0; i < types.length; ++i) {
+ ret.push(exports2.normalizeType(types[i]));
+ }
+ return ret;
+ };
+ exports2.contentDisposition = deprecate.function(
+ contentDisposition,
+ "utils.contentDisposition: use content-disposition npm module instead"
+ );
+ function acceptParams(str, index) {
+ var parts = str.split(/ *; */);
+ var ret = { value: parts[0], quality: 1, params: {}, originalIndex: index };
+ for (var i = 1; i < parts.length; ++i) {
+ var pms = parts[i].split(/ *= */);
+ if ("q" === pms[0]) {
+ ret.quality = parseFloat(pms[1]);
+ } else {
+ ret.params[pms[0]] = pms[1];
+ }
+ }
+ return ret;
+ }
+ __name(acceptParams, "acceptParams");
+ exports2.compileETag = function(val) {
+ var fn2;
+ if (typeof val === "function") {
+ return val;
+ }
+ switch (val) {
+ case true:
+ case "weak":
+ fn2 = exports2.wetag;
+ break;
+ case false:
+ break;
+ case "strong":
+ fn2 = exports2.etag;
+ break;
+ default:
+ throw new TypeError("unknown value for etag function: " + val);
+ }
+ return fn2;
+ };
+ exports2.compileQueryParser = /* @__PURE__ */ __name(function compileQueryParser(val) {
+ var fn2;
+ if (typeof val === "function") {
+ return val;
+ }
+ switch (val) {
+ case true:
+ case "simple":
+ fn2 = querystring.parse;
+ break;
+ case false:
+ fn2 = newObject;
+ break;
+ case "extended":
+ fn2 = parseExtendedQueryString;
+ break;
+ default:
+ throw new TypeError("unknown value for query parser function: " + val);
+ }
+ return fn2;
+ }, "compileQueryParser");
+ 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 = /* @__PURE__ */ __name(function setCharset(type, charset) {
+ if (!type || !charset) {
+ return type;
+ }
+ var parsed = contentType.parse(type);
+ parsed.parameters.charset = charset;
+ return contentType.format(parsed);
+ }, "setCharset");
+ function createETagGenerator(options14) {
+ return /* @__PURE__ */ __name(function generateETag(body, encoding) {
+ var buf = !Buffer3.isBuffer(body) ? Buffer3.from(body, encoding) : body;
+ return etag(buf, options14);
+ }, "generateETag");
+ }
+ __name(createETagGenerator, "createETagGenerator");
+ function parseExtendedQueryString(str) {
+ return qs.parse(str, {
+ allowPrototypes: true
+ });
+ }
+ __name(parseExtendedQueryString, "parseExtendedQueryString");
+ function newObject() {
+ return {};
+ }
+ __name(newObject, "newObject");
+ }
+});
+
+// ../../node_modules/.pnpm/express@4.18.1_supports-color@9.2.2/node_modules/express/lib/application.js
+var require_application = __commonJS({
+ "../../node_modules/.pnpm/express@4.18.1_supports-color@9.2.2/node_modules/express/lib/application.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var finalhandler = require_finalhandler();
+ var Router = require_router();
+ var methods = require_methods();
+ var middleware = require_init();
+ var query = require_query();
+ var debug = require_src2()("express:application");
+ var View = require_view();
+ var http3 = require("http");
+ var compileETag = require_utils5().compileETag;
+ var compileQueryParser = require_utils5().compileQueryParser;
+ var compileTrust = require_utils5().compileTrust;
+ var deprecate = require_depd()("express");
+ var flatten = require_array_flatten();
+ var merge = require_utils_merge();
+ var resolve18 = require("path").resolve;
+ var setPrototypeOf = require_setprototypeof();
+ var hasOwnProperty2 = Object.prototype.hasOwnProperty;
+ var slice = Array.prototype.slice;
+ var app = exports2 = module2.exports = {};
+ var trustProxyDefaultSymbol = "@@symbol:trust_proxy_default";
+ app.init = /* @__PURE__ */ __name(function init() {
+ this.cache = {};
+ this.engines = {};
+ this.settings = {};
+ this.defaultConfiguration();
+ }, "init");
+ app.defaultConfiguration = /* @__PURE__ */ __name(function defaultConfiguration() {
+ var env5 = "production";
+ this.enable("x-powered-by");
+ this.set("etag", "weak");
+ this.set("env", env5);
+ this.set("query parser", "extended");
+ this.set("subdomain offset", 2);
+ this.set("trust proxy", false);
+ Object.defineProperty(this.settings, trustProxyDefaultSymbol, {
+ configurable: true,
+ value: true
+ });
+ debug("booting in %s mode", env5);
+ this.on("mount", /* @__PURE__ */ __name(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"];
+ }
+ setPrototypeOf(this.request, parent.request);
+ setPrototypeOf(this.response, parent.response);
+ setPrototypeOf(this.engines, parent.engines);
+ setPrototypeOf(this.settings, parent.settings);
+ }, "onmount"));
+ this.locals = /* @__PURE__ */ Object.create(null);
+ this.mountpath = "/";
+ this.locals.settings = this.settings;
+ this.set("view", View);
+ this.set("views", resolve18("views"));
+ this.set("jsonp callback name", "callback");
+ if (env5 === "production") {
+ this.enable("view cache");
+ }
+ Object.defineProperty(this, "router", {
+ get: function() {
+ throw new Error("'app.router' is deprecated!\nPlease see the 3.x to 4.x migration guide for details on how to update your app.");
+ }
+ });
+ }, "defaultConfiguration");
+ app.lazyrouter = /* @__PURE__ */ __name(function lazyrouter() {
+ if (!this._router) {
+ this._router = new Router({
+ caseSensitive: this.enabled("case sensitive routing"),
+ strict: this.enabled("strict routing")
+ });
+ this._router.use(query(this.get("query parser fn")));
+ this._router.use(middleware.init(this));
+ }
+ }, "lazyrouter");
+ app.handle = /* @__PURE__ */ __name(function handle(req, res, callback) {
+ var router = this._router;
+ var done = callback || finalhandler(req, res, {
+ env: this.get("env"),
+ onerror: logerror.bind(this)
+ });
+ if (!router) {
+ debug("no routes defined on app");
+ done();
+ return;
+ }
+ router.handle(req, res, done);
+ }, "handle");
+ app.use = /* @__PURE__ */ __name(function use(fn2) {
+ var offset = 0;
+ var path45 = "/";
+ if (typeof fn2 !== "function") {
+ var arg = fn2;
+ while (Array.isArray(arg) && arg.length !== 0) {
+ arg = arg[0];
+ }
+ if (typeof arg !== "function") {
+ offset = 1;
+ path45 = fn2;
+ }
+ }
+ var fns = flatten(slice.call(arguments, offset));
+ if (fns.length === 0) {
+ throw new TypeError("app.use() requires a middleware function");
+ }
+ this.lazyrouter();
+ var router = this._router;
+ fns.forEach(function(fn3) {
+ if (!fn3 || !fn3.handle || !fn3.set) {
+ return router.use(path45, fn3);
+ }
+ debug(".use app under %s", path45);
+ fn3.mountpath = path45;
+ fn3.parent = this;
+ router.use(path45, /* @__PURE__ */ __name(function mounted_app(req, res, next) {
+ var orig = req.app;
+ fn3.handle(req, res, function(err) {
+ setPrototypeOf(req, orig.request);
+ setPrototypeOf(res, orig.response);
+ next(err);
+ });
+ }, "mounted_app"));
+ fn3.emit("mount", this);
+ }, this);
+ return this;
+ }, "use");
+ app.route = /* @__PURE__ */ __name(function route2(path45) {
+ this.lazyrouter();
+ return this._router.route(path45);
+ }, "route");
+ app.engine = /* @__PURE__ */ __name(function engine(ext, fn2) {
+ if (typeof fn2 !== "function") {
+ throw new Error("callback function required");
+ }
+ var extension = ext[0] !== "." ? "." + ext : ext;
+ this.engines[extension] = fn2;
+ return this;
+ }, "engine");
+ app.param = /* @__PURE__ */ __name(function param(name, fn2) {
+ this.lazyrouter();
+ if (Array.isArray(name)) {
+ for (var i = 0; i < name.length; i++) {
+ this.param(name[i], fn2);
+ }
+ return this;
+ }
+ this._router.param(name, fn2);
+ return this;
+ }, "param");
+ app.set = /* @__PURE__ */ __name(function set(setting, val) {
+ if (arguments.length === 1) {
+ var settings = this.settings;
+ while (settings && settings !== Object.prototype) {
+ if (hasOwnProperty2.call(settings, setting)) {
+ return settings[setting];
+ }
+ settings = Object.getPrototypeOf(settings);
+ }
+ return void 0;
+ }
+ 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;
+ }, "set");
+ app.path = /* @__PURE__ */ __name(function path45() {
+ return this.parent ? this.parent.path() + this.mountpath : "";
+ }, "path");
+ app.enabled = /* @__PURE__ */ __name(function enabled(setting) {
+ return Boolean(this.set(setting));
+ }, "enabled");
+ app.disabled = /* @__PURE__ */ __name(function disabled(setting) {
+ return !this.set(setting);
+ }, "disabled");
+ app.enable = /* @__PURE__ */ __name(function enable(setting) {
+ return this.set(setting, true);
+ }, "enable");
+ app.disable = /* @__PURE__ */ __name(function disable(setting) {
+ return this.set(setting, false);
+ }, "disable");
+ methods.forEach(function(method) {
+ app[method] = function(path45) {
+ if (method === "get" && arguments.length === 1) {
+ return this.set(path45);
+ }
+ this.lazyrouter();
+ var route2 = this._router.route(path45);
+ route2[method].apply(route2, slice.call(arguments, 1));
+ return this;
+ };
+ });
+ app.all = /* @__PURE__ */ __name(function all2(path45) {
+ this.lazyrouter();
+ var route2 = this._router.route(path45);
+ var args = slice.call(arguments, 1);
+ for (var i = 0; i < methods.length; i++) {
+ route2[methods[i]].apply(route2, args);
+ }
+ return this;
+ }, "all");
+ app.del = deprecate.function(app.delete, "app.del: Use app.delete instead");
+ app.render = /* @__PURE__ */ __name(function render7(name, options14, callback) {
+ var cache2 = this.cache;
+ var done = callback;
+ var engines = this.engines;
+ var opts = options14;
+ var renderOptions = {};
+ var view;
+ if (typeof options14 === "function") {
+ done = options14;
+ opts = {};
+ }
+ merge(renderOptions, this.locals);
+ if (opts._locals) {
+ merge(renderOptions, opts._locals);
+ }
+ merge(renderOptions, opts);
+ if (renderOptions.cache == null) {
+ renderOptions.cache = this.enabled("view cache");
+ }
+ if (renderOptions.cache) {
+ view = cache2[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 err = new Error('Failed to lookup view "' + name + '" in views ' + dirs);
+ err.view = view;
+ return done(err);
+ }
+ if (renderOptions.cache) {
+ cache2[name] = view;
+ }
+ }
+ tryRender(view, renderOptions, done);
+ }, "render");
+ app.listen = /* @__PURE__ */ __name(function listen() {
+ var server2 = http3.createServer(this);
+ return server2.listen.apply(server2, arguments);
+ }, "listen");
+ function logerror(err) {
+ if (this.get("env") !== "test")
+ console.error(err.stack || err.toString());
+ }
+ __name(logerror, "logerror");
+ function tryRender(view, options14, callback) {
+ try {
+ view.render(options14, callback);
+ } catch (err) {
+ callback(err);
+ }
+ }
+ __name(tryRender, "tryRender");
+ }
+});
+
+// ../../node_modules/.pnpm/negotiator@0.6.3/node_modules/negotiator/lib/charset.js
+var require_charset = __commonJS({
+ "../../node_modules/.pnpm/negotiator@0.6.3/node_modules/negotiator/lib/charset.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ 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;
+ }
+ __name(parseAcceptCharset, "parseAcceptCharset");
+ 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
+ };
+ }
+ __name(parseCharset, "parseCharset");
+ 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;
+ }
+ __name(getCharsetPriority, "getCharsetPriority");
+ 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
+ };
+ }
+ __name(specify, "specify");
+ 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(/* @__PURE__ */ __name(function getPriority(type, index) {
+ return getCharsetPriority(type, accepts, index);
+ }, "getPriority"));
+ return priorities.filter(isQuality).sort(compareSpecs).map(/* @__PURE__ */ __name(function getCharset(priority) {
+ return provided[priorities.indexOf(priority)];
+ }, "getCharset"));
+ }
+ __name(preferredCharsets, "preferredCharsets");
+ function compareSpecs(a, b) {
+ return b.q - a.q || b.s - a.s || a.o - b.o || a.i - b.i || 0;
+ }
+ __name(compareSpecs, "compareSpecs");
+ function getFullCharset(spec) {
+ return spec.charset;
+ }
+ __name(getFullCharset, "getFullCharset");
+ function isQuality(spec) {
+ return spec.q > 0;
+ }
+ __name(isQuality, "isQuality");
+ }
+});
+
+// ../../node_modules/.pnpm/negotiator@0.6.3/node_modules/negotiator/lib/encoding.js
+var require_encoding2 = __commonJS({
+ "../../node_modules/.pnpm/negotiator@0.6.3/node_modules/negotiator/lib/encoding.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ 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;
+ }
+ __name(parseAcceptEncoding, "parseAcceptEncoding");
+ 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
+ };
+ }
+ __name(parseEncoding, "parseEncoding");
+ function getEncodingPriority(encoding, accepted, index) {
+ var priority = { 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;
+ }
+ __name(getEncodingPriority, "getEncodingPriority");
+ function specify(encoding, spec, index) {
+ var s = 0;
+ if (spec.encoding.toLowerCase() === encoding.toLowerCase()) {
+ s |= 1;
+ } else if (spec.encoding !== "*") {
+ return null;
+ }
+ return {
+ i: index,
+ o: spec.i,
+ q: spec.q,
+ s
+ };
+ }
+ __name(specify, "specify");
+ function preferredEncodings(accept, provided) {
+ var accepts = parseAcceptEncoding(accept || "");
+ if (!provided) {
+ return accepts.filter(isQuality).sort(compareSpecs).map(getFullEncoding);
+ }
+ var priorities = provided.map(/* @__PURE__ */ __name(function getPriority(type, index) {
+ return getEncodingPriority(type, accepts, index);
+ }, "getPriority"));
+ return priorities.filter(isQuality).sort(compareSpecs).map(/* @__PURE__ */ __name(function getEncoding(priority) {
+ return provided[priorities.indexOf(priority)];
+ }, "getEncoding"));
+ }
+ __name(preferredEncodings, "preferredEncodings");
+ function compareSpecs(a, b) {
+ return b.q - a.q || b.s - a.s || a.o - b.o || a.i - b.i || 0;
+ }
+ __name(compareSpecs, "compareSpecs");
+ function getFullEncoding(spec) {
+ return spec.encoding;
+ }
+ __name(getFullEncoding, "getFullEncoding");
+ function isQuality(spec) {
+ return spec.q > 0;
+ }
+ __name(isQuality, "isQuality");
+ }
+});
+
+// ../../node_modules/.pnpm/negotiator@0.6.3/node_modules/negotiator/lib/language.js
+var require_language = __commonJS({
+ "../../node_modules/.pnpm/negotiator@0.6.3/node_modules/negotiator/lib/language.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ 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;
+ }
+ __name(parseAcceptLanguage, "parseAcceptLanguage");
+ 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
+ };
+ }
+ __name(parseLanguage, "parseLanguage");
+ 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;
+ }
+ __name(getLanguagePriority, "getLanguagePriority");
+ 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
+ };
+ }
+ __name(specify, "specify");
+ 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(/* @__PURE__ */ __name(function getPriority(type, index) {
+ return getLanguagePriority(type, accepts, index);
+ }, "getPriority"));
+ return priorities.filter(isQuality).sort(compareSpecs).map(/* @__PURE__ */ __name(function getLanguage(priority) {
+ return provided[priorities.indexOf(priority)];
+ }, "getLanguage"));
+ }
+ __name(preferredLanguages, "preferredLanguages");
+ function compareSpecs(a, b) {
+ return b.q - a.q || b.s - a.s || a.o - b.o || a.i - b.i || 0;
+ }
+ __name(compareSpecs, "compareSpecs");
+ function getFullLanguage(spec) {
+ return spec.full;
+ }
+ __name(getFullLanguage, "getFullLanguage");
+ function isQuality(spec) {
+ return spec.q > 0;
+ }
+ __name(isQuality, "isQuality");
+ }
+});
+
+// ../../node_modules/.pnpm/negotiator@0.6.3/node_modules/negotiator/lib/mediaType.js
+var require_mediaType = __commonJS({
+ "../../node_modules/.pnpm/negotiator@0.6.3/node_modules/negotiator/lib/mediaType.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ 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;
+ }
+ __name(parseAccept, "parseAccept");
+ 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.substr(1, val.length - 2) : val;
+ if (key === "q") {
+ q = parseFloat(value);
+ break;
+ }
+ params[key] = value;
+ }
+ }
+ return {
+ type,
+ subtype,
+ params,
+ q,
+ i
+ };
+ }
+ __name(parseMediaType, "parseMediaType");
+ 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;
+ }
+ __name(getMediaTypePriority, "getMediaTypePriority");
+ 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
+ };
+ }
+ __name(specify, "specify");
+ 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(/* @__PURE__ */ __name(function getPriority(type, index) {
+ return getMediaTypePriority(type, accepts, index);
+ }, "getPriority"));
+ return priorities.filter(isQuality).sort(compareSpecs).map(/* @__PURE__ */ __name(function getType3(priority) {
+ return provided[priorities.indexOf(priority)];
+ }, "getType"));
+ }
+ __name(preferredMediaTypes, "preferredMediaTypes");
+ function compareSpecs(a, b) {
+ return b.q - a.q || b.s - a.s || a.o - b.o || a.i - b.i || 0;
+ }
+ __name(compareSpecs, "compareSpecs");
+ function getFullType(spec) {
+ return spec.type + "/" + spec.subtype;
+ }
+ __name(getFullType, "getFullType");
+ function isQuality(spec) {
+ return spec.q > 0;
+ }
+ __name(isQuality, "isQuality");
+ function quoteCount(string) {
+ var count = 0;
+ var index = 0;
+ while ((index = string.indexOf('"', index)) !== -1) {
+ count++;
+ index++;
+ }
+ return count;
+ }
+ __name(quoteCount, "quoteCount");
+ function splitKeyValuePair(str) {
+ var index = str.indexOf("=");
+ var key;
+ var val;
+ if (index === -1) {
+ key = str;
+ } else {
+ key = str.substr(0, index);
+ val = str.substr(index + 1);
+ }
+ return [key, val];
+ }
+ __name(splitKeyValuePair, "splitKeyValuePair");
+ 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;
+ }
+ __name(splitMediaTypes, "splitMediaTypes");
+ 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;
+ }
+ __name(splitParameters, "splitParameters");
+ }
+});
+
+// ../../node_modules/.pnpm/negotiator@0.6.3/node_modules/negotiator/index.js
+var require_negotiator = __commonJS({
+ "../../node_modules/.pnpm/negotiator@0.6.3/node_modules/negotiator/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var preferredCharsets = require_charset();
+ var preferredEncodings = require_encoding2();
+ 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;
+ }
+ __name(Negotiator, "Negotiator");
+ Negotiator.prototype.charset = /* @__PURE__ */ __name(function charset(available) {
+ var set = this.charsets(available);
+ return set && set[0];
+ }, "charset");
+ Negotiator.prototype.charsets = /* @__PURE__ */ __name(function charsets(available) {
+ return preferredCharsets(this.request.headers["accept-charset"], available);
+ }, "charsets");
+ Negotiator.prototype.encoding = /* @__PURE__ */ __name(function encoding(available) {
+ var set = this.encodings(available);
+ return set && set[0];
+ }, "encoding");
+ Negotiator.prototype.encodings = /* @__PURE__ */ __name(function encodings(available) {
+ return preferredEncodings(this.request.headers["accept-encoding"], available);
+ }, "encodings");
+ Negotiator.prototype.language = /* @__PURE__ */ __name(function language(available) {
+ var set = this.languages(available);
+ return set && set[0];
+ }, "language");
+ Negotiator.prototype.languages = /* @__PURE__ */ __name(function languages(available) {
+ return preferredLanguages(this.request.headers["accept-language"], available);
+ }, "languages");
+ Negotiator.prototype.mediaType = /* @__PURE__ */ __name(function mediaType(available) {
+ var set = this.mediaTypes(available);
+ return set && set[0];
+ }, "mediaType");
+ Negotiator.prototype.mediaTypes = /* @__PURE__ */ __name(function mediaTypes(available) {
+ return preferredMediaTypes(this.request.headers.accept, available);
+ }, "mediaTypes");
+ 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;
+ }
+});
+
+// ../../node_modules/.pnpm/accepts@1.3.8/node_modules/accepts/index.js
+var require_accepts = __commonJS({
+ "../../node_modules/.pnpm/accepts@1.3.8/node_modules/accepts/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var Negotiator = require_negotiator();
+ var mime = require_mime_types();
+ module2.exports = Accepts;
+ function Accepts(req) {
+ if (!(this instanceof Accepts)) {
+ return new Accepts(req);
+ }
+ this.headers = req.headers;
+ this.negotiator = new Negotiator(req);
+ }
+ __name(Accepts, "Accepts");
+ 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;
+ }
+ __name(extToMime, "extToMime");
+ function validMime(type) {
+ return typeof type === "string";
+ }
+ __name(validMime, "validMime");
+ }
+});
+
+// ../../node_modules/.pnpm/express@4.18.1_supports-color@9.2.2/node_modules/express/lib/request.js
+var require_request3 = __commonJS({
+ "../../node_modules/.pnpm/express@4.18.1_supports-color@9.2.2/node_modules/express/lib/request.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var accepts = require_accepts();
+ var deprecate = require_depd()("express");
+ var isIP = require("net").isIP;
+ var typeis = require_type_is();
+ var http3 = require("http");
+ var fresh = require_fresh();
+ var parseRange = require_range_parser();
+ var parse4 = require_parseurl();
+ var proxyaddr = require_proxy_addr();
+ var req = Object.create(http3.IncomingMessage.prototype);
+ module2.exports = req;
+ req.get = req.header = /* @__PURE__ */ __name(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];
+ }
+ }, "header");
+ 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.acceptsEncoding = deprecate.function(
+ req.acceptsEncodings,
+ "req.acceptsEncoding: Use acceptsEncodings instead"
+ );
+ req.acceptsCharsets = function() {
+ var accept = accepts(this);
+ return accept.charsets.apply(accept, arguments);
+ };
+ req.acceptsCharset = deprecate.function(
+ req.acceptsCharsets,
+ "req.acceptsCharset: Use acceptsCharsets instead"
+ );
+ req.acceptsLanguages = function() {
+ var accept = accepts(this);
+ return accept.languages.apply(accept, arguments);
+ };
+ req.acceptsLanguage = deprecate.function(
+ req.acceptsLanguages,
+ "req.acceptsLanguage: Use acceptsLanguages instead"
+ );
+ req.range = /* @__PURE__ */ __name(function range(size, options14) {
+ var range2 = this.get("Range");
+ if (!range2)
+ return;
+ return parseRange(size, range2, options14);
+ }, "range");
+ req.param = /* @__PURE__ */ __name(function param(name, defaultValue) {
+ var params = this.params || {};
+ var body = this.body || {};
+ var query = this.query || {};
+ var args = arguments.length === 1 ? "name" : "name, default";
+ deprecate("req.param(" + args + "): Use req.params, req.body, or req.query instead");
+ if (null != params[name] && params.hasOwnProperty(name))
+ return params[name];
+ if (null != body[name])
+ return body[name];
+ if (null != query[name])
+ return query[name];
+ return defaultValue;
+ }, "param");
+ req.is = /* @__PURE__ */ __name(function is2(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);
+ }, "is");
+ defineGetter(req, "protocol", /* @__PURE__ */ __name(function protocol() {
+ var proto = this.connection.encrypted ? "https" : "http";
+ var trust = this.app.get("trust proxy fn");
+ if (!trust(this.connection.remoteAddress, 0)) {
+ return proto;
+ }
+ var header = this.get("X-Forwarded-Proto") || proto;
+ var index = header.indexOf(",");
+ return index !== -1 ? header.substring(0, index).trim() : header.trim();
+ }, "protocol"));
+ defineGetter(req, "secure", /* @__PURE__ */ __name(function secure() {
+ return this.protocol === "https";
+ }, "secure"));
+ defineGetter(req, "ip", /* @__PURE__ */ __name(function ip2() {
+ var trust = this.app.get("trust proxy fn");
+ return proxyaddr(this, trust);
+ }, "ip"));
+ defineGetter(req, "ips", /* @__PURE__ */ __name(function ips() {
+ var trust = this.app.get("trust proxy fn");
+ var addrs = proxyaddr.all(this, trust);
+ addrs.reverse().pop();
+ return addrs;
+ }, "ips"));
+ defineGetter(req, "subdomains", /* @__PURE__ */ __name(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);
+ }, "subdomains"));
+ defineGetter(req, "path", /* @__PURE__ */ __name(function path45() {
+ return parse4(this).pathname;
+ }, "path"));
+ defineGetter(req, "hostname", /* @__PURE__ */ __name(function hostname() {
+ var trust = this.app.get("trust proxy fn");
+ var host = this.get("X-Forwarded-Host");
+ if (!host || !trust(this.connection.remoteAddress, 0)) {
+ host = this.get("Host");
+ } else if (host.indexOf(",") !== -1) {
+ host = host.substring(0, host.indexOf(",")).trimRight();
+ }
+ if (!host)
+ return;
+ var offset = host[0] === "[" ? host.indexOf("]") + 1 : 0;
+ var index = host.indexOf(":", offset);
+ return index !== -1 ? host.substring(0, index) : host;
+ }, "hostname"));
+ defineGetter(req, "host", deprecate.function(/* @__PURE__ */ __name(function host() {
+ return this.hostname;
+ }, "host"), "req.host: Use req.hostname instead"));
+ 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", /* @__PURE__ */ __name(function stale() {
+ return !this.fresh;
+ }, "stale"));
+ defineGetter(req, "xhr", /* @__PURE__ */ __name(function xhr() {
+ var val = this.get("X-Requested-With") || "";
+ return val.toLowerCase() === "xmlhttprequest";
+ }, "xhr"));
+ function defineGetter(obj, name, getter) {
+ Object.defineProperty(obj, name, {
+ configurable: true,
+ enumerable: true,
+ get: getter
+ });
+ }
+ __name(defineGetter, "defineGetter");
+ }
+});
+
+// ../../node_modules/.pnpm/cookie-signature@1.0.6/node_modules/cookie-signature/index.js
+var require_cookie_signature = __commonJS({
+ "../../node_modules/.pnpm/cookie-signature@1.0.6/node_modules/cookie-signature/index.js"(exports2) {
+ init_import_meta_url();
+ var crypto6 = require("crypto");
+ exports2.sign = function(val, secret2) {
+ if ("string" != typeof val)
+ throw new TypeError("Cookie value must be provided as a string.");
+ if ("string" != typeof secret2)
+ throw new TypeError("Secret string must be provided.");
+ return val + "." + crypto6.createHmac("sha256", secret2).update(val).digest("base64").replace(/\=+$/, "");
+ };
+ exports2.unsign = function(val, secret2) {
+ if ("string" != typeof val)
+ throw new TypeError("Signed cookie string must be provided.");
+ if ("string" != typeof secret2)
+ throw new TypeError("Secret string must be provided.");
+ var str = val.slice(0, val.lastIndexOf(".")), mac = exports2.sign(str, secret2);
+ return sha1(mac) == sha1(val) ? str : false;
+ };
+ function sha1(str) {
+ return crypto6.createHash("sha1").update(str).digest("hex");
+ }
+ __name(sha1, "sha1");
+ }
+});
+
+// ../../node_modules/.pnpm/cookie@0.5.0/node_modules/cookie/index.js
+var require_cookie = __commonJS({
+ "../../node_modules/.pnpm/cookie@0.5.0/node_modules/cookie/index.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ exports2.parse = parse4;
+ exports2.serialize = serialize;
+ var __toString = Object.prototype.toString;
+ var fieldContentRegExp = /^[\u0009\u0020-\u007e\u0080-\u00ff]+$/;
+ function parse4(str, options14) {
+ if (typeof str !== "string") {
+ throw new TypeError("argument str must be a string");
+ }
+ var obj = {};
+ var opt = options14 || {};
+ var dec = opt.decode || decode;
+ var index = 0;
+ while (index < str.length) {
+ var eqIdx = str.indexOf("=", index);
+ if (eqIdx === -1) {
+ break;
+ }
+ var endIdx = str.indexOf(";", index);
+ if (endIdx === -1) {
+ endIdx = str.length;
+ } else if (endIdx < eqIdx) {
+ index = str.lastIndexOf(";", eqIdx - 1) + 1;
+ continue;
+ }
+ var key = str.slice(index, eqIdx).trim();
+ if (void 0 === obj[key]) {
+ var val = str.slice(eqIdx + 1, endIdx).trim();
+ if (val.charCodeAt(0) === 34) {
+ val = val.slice(1, -1);
+ }
+ obj[key] = tryDecode(val, dec);
+ }
+ index = endIdx + 1;
+ }
+ return obj;
+ }
+ __name(parse4, "parse");
+ function serialize(name, val, options14) {
+ var opt = options14 || {};
+ var enc = opt.encode || encode;
+ if (typeof enc !== "function") {
+ throw new TypeError("option encode is invalid");
+ }
+ if (!fieldContentRegExp.test(name)) {
+ throw new TypeError("argument name is invalid");
+ }
+ var value = enc(val);
+ if (value && !fieldContentRegExp.test(value)) {
+ throw new TypeError("argument val is invalid");
+ }
+ var str = name + "=" + value;
+ if (null != opt.maxAge) {
+ var maxAge = opt.maxAge - 0;
+ if (isNaN(maxAge) || !isFinite(maxAge)) {
+ throw new TypeError("option maxAge is invalid");
+ }
+ str += "; Max-Age=" + Math.floor(maxAge);
+ }
+ if (opt.domain) {
+ if (!fieldContentRegExp.test(opt.domain)) {
+ throw new TypeError("option domain is invalid");
+ }
+ str += "; Domain=" + opt.domain;
+ }
+ if (opt.path) {
+ if (!fieldContentRegExp.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.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;
+ }
+ __name(serialize, "serialize");
+ function decode(str) {
+ return str.indexOf("%") !== -1 ? decodeURIComponent(str) : str;
+ }
+ __name(decode, "decode");
+ function encode(val) {
+ return encodeURIComponent(val);
+ }
+ __name(encode, "encode");
+ function isDate(val) {
+ return __toString.call(val) === "[object Date]" || val instanceof Date;
+ }
+ __name(isDate, "isDate");
+ function tryDecode(str, decode2) {
+ try {
+ return decode2(str);
+ } catch (e2) {
+ return str;
+ }
+ }
+ __name(tryDecode, "tryDecode");
+ }
+});
+
+// ../../node_modules/.pnpm/vary@1.1.2/node_modules/vary/index.js
+var require_vary = __commonJS({
+ "../../node_modules/.pnpm/vary@1.1.2/node_modules/vary/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ 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) ? parse4(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 = parse4(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;
+ }
+ __name(append, "append");
+ function parse4(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;
+ }
+ __name(parse4, "parse");
+ 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);
+ }
+ }
+ __name(vary, "vary");
+ }
+});
+
+// ../../node_modules/.pnpm/express@4.18.1_supports-color@9.2.2/node_modules/express/lib/response.js
+var require_response2 = __commonJS({
+ "../../node_modules/.pnpm/express@4.18.1_supports-color@9.2.2/node_modules/express/lib/response.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var Buffer3 = require_safe_buffer().Buffer;
+ var contentDisposition = require_content_disposition();
+ var createError = require_http_errors();
+ var deprecate = require_depd()("express");
+ var encodeUrl = require_encodeurl();
+ var escapeHtml = require_escape_html();
+ var http3 = require("http");
+ var isAbsolute = require_utils5().isAbsolute;
+ var onFinished = require_on_finished();
+ var path45 = require("path");
+ var statuses = require_statuses();
+ var merge = require_utils_merge();
+ var sign = require_cookie_signature().sign;
+ var normalizeType = require_utils5().normalizeType;
+ var normalizeTypes = require_utils5().normalizeTypes;
+ var setCharset = require_utils5().setCharset;
+ var cookie = require_cookie();
+ var send = require_send();
+ var extname4 = path45.extname;
+ var mime = send.mime;
+ var resolve18 = path45.resolve;
+ var vary = require_vary();
+ var res = Object.create(http3.ServerResponse.prototype);
+ module2.exports = res;
+ var charsetRegExp = /;\s*charset\s*=/;
+ res.status = /* @__PURE__ */ __name(function status(code) {
+ if ((typeof code === "string" || Math.floor(code) !== code) && code > 99 && code < 1e3) {
+ deprecate("res.status(" + JSON.stringify(code) + "): use res.status(" + Math.floor(code) + ") instead");
+ }
+ this.statusCode = code;
+ return this;
+ }, "status");
+ res.links = function(links) {
+ var link = this.get("Link") || "";
+ if (link)
+ link += ", ";
+ return this.set("Link", link + Object.keys(links).map(function(rel) {
+ return "<" + links[rel] + '>; rel="' + rel + '"';
+ }).join(", "));
+ };
+ res.send = /* @__PURE__ */ __name(function send2(body) {
+ var chunk = body;
+ var encoding;
+ var req = this.req;
+ var type;
+ var app = this.app;
+ if (arguments.length === 2) {
+ if (typeof arguments[0] !== "number" && typeof arguments[1] === "number") {
+ deprecate("res.send(body, status): Use res.status(status).send(body) instead");
+ this.statusCode = arguments[1];
+ } else {
+ deprecate("res.send(status, body): Use res.status(status).send(body) instead");
+ this.statusCode = arguments[0];
+ chunk = arguments[1];
+ }
+ }
+ if (typeof chunk === "number" && arguments.length === 1) {
+ if (!this.get("Content-Type")) {
+ this.type("txt");
+ }
+ deprecate("res.send(status): Use res.sendStatus(status) instead");
+ this.statusCode = chunk;
+ chunk = statuses.message[chunk];
+ }
+ switch (typeof chunk) {
+ case "string":
+ if (!this.get("Content-Type")) {
+ this.type("html");
+ }
+ break;
+ case "boolean":
+ case "number":
+ case "object":
+ if (chunk === null) {
+ chunk = "";
+ } else if (Buffer3.isBuffer(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 (Buffer3.isBuffer(chunk)) {
+ len = chunk.length;
+ } else if (!generateETag && chunk.length < 1e3) {
+ len = Buffer3.byteLength(chunk, encoding);
+ } else {
+ chunk = Buffer3.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.statusCode = 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;
+ }, "send");
+ res.json = /* @__PURE__ */ __name(function json(obj) {
+ var val = obj;
+ if (arguments.length === 2) {
+ if (typeof arguments[1] === "number") {
+ deprecate("res.json(obj, status): Use res.status(status).json(obj) instead");
+ this.statusCode = arguments[1];
+ } else {
+ deprecate("res.json(status, obj): Use res.status(status).json(obj) instead");
+ this.statusCode = arguments[0];
+ val = arguments[1];
+ }
+ }
+ var app = this.app;
+ var escape2 = app.get("json escape");
+ var replacer2 = app.get("json replacer");
+ var spaces = app.get("json spaces");
+ var body = stringify(val, replacer2, spaces, escape2);
+ if (!this.get("Content-Type")) {
+ this.set("Content-Type", "application/json");
+ }
+ return this.send(body);
+ }, "json");
+ res.jsonp = /* @__PURE__ */ __name(function jsonp(obj) {
+ var val = obj;
+ if (arguments.length === 2) {
+ if (typeof arguments[1] === "number") {
+ deprecate("res.jsonp(obj, status): Use res.status(status).jsonp(obj) instead");
+ this.statusCode = arguments[1];
+ } else {
+ deprecate("res.jsonp(status, obj): Use res.status(status).jsonp(obj) instead");
+ this.statusCode = arguments[0];
+ val = arguments[1];
+ }
+ }
+ var app = this.app;
+ var escape2 = app.get("json escape");
+ var replacer2 = app.get("json replacer");
+ var spaces = app.get("json spaces");
+ var body = stringify(val, replacer2, 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);
+ }, "jsonp");
+ res.sendStatus = /* @__PURE__ */ __name(function sendStatus(statusCode) {
+ var body = statuses.message[statusCode] || String(statusCode);
+ this.statusCode = statusCode;
+ this.type("txt");
+ return this.send(body);
+ }, "sendStatus");
+ res.sendFile = /* @__PURE__ */ __name(function sendFile(path46, options14, callback) {
+ var done = callback;
+ var req = this.req;
+ var res2 = this;
+ var next = req.next;
+ var opts = options14 || {};
+ if (!path46) {
+ throw new TypeError("path argument is required to res.sendFile");
+ }
+ if (typeof path46 !== "string") {
+ throw new TypeError("path must be a string to res.sendFile");
+ }
+ if (typeof options14 === "function") {
+ done = options14;
+ opts = {};
+ }
+ if (!opts.root && !isAbsolute(path46)) {
+ throw new TypeError("path must be absolute or specify root to res.sendFile");
+ }
+ var pathname = encodeURI(path46);
+ var file = send(req, pathname, opts);
+ sendfile(res2, file, opts, function(err) {
+ if (done)
+ return done(err);
+ if (err && err.code === "EISDIR")
+ return next();
+ if (err && err.code !== "ECONNABORTED" && err.syscall !== "write") {
+ next(err);
+ }
+ });
+ }, "sendFile");
+ res.sendfile = function(path46, options14, callback) {
+ var done = callback;
+ var req = this.req;
+ var res2 = this;
+ var next = req.next;
+ var opts = options14 || {};
+ if (typeof options14 === "function") {
+ done = options14;
+ opts = {};
+ }
+ var file = send(req, path46, opts);
+ sendfile(res2, file, opts, function(err) {
+ if (done)
+ return done(err);
+ if (err && err.code === "EISDIR")
+ return next();
+ if (err && err.code !== "ECONNABORTED" && err.syscall !== "write") {
+ next(err);
+ }
+ });
+ };
+ res.sendfile = deprecate.function(
+ res.sendfile,
+ "res.sendfile: Use res.sendFile instead"
+ );
+ res.download = /* @__PURE__ */ __name(function download(path46, filename, options14, callback) {
+ var done = callback;
+ var name = filename;
+ var opts = options14 || null;
+ if (typeof filename === "function") {
+ done = filename;
+ name = null;
+ opts = null;
+ } else if (typeof options14 === "function") {
+ done = options14;
+ opts = null;
+ }
+ if (typeof filename === "object" && (typeof options14 === "function" || options14 === void 0)) {
+ name = null;
+ opts = filename;
+ }
+ var headers = {
+ "Content-Disposition": contentDisposition(name || path46)
+ };
+ 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 ? resolve18(path46) : path46;
+ return this.sendFile(fullPath, opts, done);
+ }, "download");
+ res.contentType = res.type = /* @__PURE__ */ __name(function contentType(type) {
+ var ct = type.indexOf("/") === -1 ? mime.lookup(type) : type;
+ return this.set("Content-Type", ct);
+ }, "contentType");
+ 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 = /* @__PURE__ */ __name(function attachment(filename) {
+ if (filename) {
+ this.type(extname4(filename));
+ }
+ this.set("Content-Disposition", contentDisposition(filename));
+ return this;
+ }, "attachment");
+ res.append = /* @__PURE__ */ __name(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);
+ }, "append");
+ res.set = res.header = /* @__PURE__ */ __name(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");
+ }
+ if (!charsetRegExp.test(value)) {
+ var charset = mime.charsets.lookup(value.split(";")[0]);
+ if (charset)
+ value += "; charset=" + charset.toLowerCase();
+ }
+ }
+ this.setHeader(field, value);
+ } else {
+ for (var key in field) {
+ this.set(key, field[key]);
+ }
+ }
+ return this;
+ }, "header");
+ res.get = function(field) {
+ return this.getHeader(field);
+ };
+ res.clearCookie = /* @__PURE__ */ __name(function clearCookie(name, options14) {
+ var opts = merge({ expires: /* @__PURE__ */ new Date(1), path: "/" }, options14);
+ return this.cookie(name, "", opts);
+ }, "clearCookie");
+ res.cookie = function(name, value, options14) {
+ var opts = merge({}, options14);
+ var secret2 = this.req.secret;
+ var signed = opts.signed;
+ if (signed && !secret2) {
+ 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, secret2);
+ }
+ 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 = /* @__PURE__ */ __name(function location(url3) {
+ var loc = url3;
+ if (url3 === "back") {
+ loc = this.req.get("Referrer") || "/";
+ }
+ return this.set("Location", encodeUrl(loc));
+ }, "location");
+ res.redirect = /* @__PURE__ */ __name(function redirect(url3) {
+ var address = url3;
+ var body;
+ var status = 302;
+ if (arguments.length === 2) {
+ if (typeof arguments[0] === "number") {
+ status = arguments[0];
+ address = arguments[1];
+ } else {
+ deprecate("res.redirect(url, status): Use res.redirect(status, url) instead");
+ status = 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.statusCode = status;
+ this.set("Content-Length", Buffer3.byteLength(body));
+ if (this.req.method === "HEAD") {
+ this.end();
+ } else {
+ this.end(body);
+ }
+ }, "redirect");
+ res.vary = function(field) {
+ if (!field || Array.isArray(field) && !field.length) {
+ deprecate("res.vary(): Provide a field name");
+ return this;
+ }
+ vary(this, field);
+ return this;
+ };
+ res.render = /* @__PURE__ */ __name(function render7(view, options14, callback) {
+ var app = this.req.app;
+ var done = callback;
+ var opts = options14 || {};
+ var req = this.req;
+ var self2 = this;
+ if (typeof options14 === "function") {
+ done = options14;
+ opts = {};
+ }
+ opts._locals = self2.locals;
+ done = done || function(err, str) {
+ if (err)
+ return req.next(err);
+ self2.send(str);
+ };
+ app.render(view, opts, done);
+ }, "render");
+ function sendfile(res2, file, options14, callback) {
+ var done = false;
+ var streaming;
+ function onaborted() {
+ if (done)
+ return;
+ done = true;
+ var err = new Error("Request aborted");
+ err.code = "ECONNABORTED";
+ callback(err);
+ }
+ __name(onaborted, "onaborted");
+ function ondirectory() {
+ if (done)
+ return;
+ done = true;
+ var err = new Error("EISDIR, read");
+ err.code = "EISDIR";
+ callback(err);
+ }
+ __name(ondirectory, "ondirectory");
+ function onerror(err) {
+ if (done)
+ return;
+ done = true;
+ callback(err);
+ }
+ __name(onerror, "onerror");
+ function onend() {
+ if (done)
+ return;
+ done = true;
+ callback();
+ }
+ __name(onend, "onend");
+ function onfile() {
+ streaming = false;
+ }
+ __name(onfile, "onfile");
+ function onfinish(err) {
+ if (err && err.code === "ECONNRESET")
+ return onaborted();
+ if (err)
+ return onerror(err);
+ if (done)
+ return;
+ setImmediate(function() {
+ if (streaming !== false && !done) {
+ onaborted();
+ return;
+ }
+ if (done)
+ return;
+ done = true;
+ callback();
+ });
+ }
+ __name(onfinish, "onfinish");
+ function onstream() {
+ streaming = true;
+ }
+ __name(onstream, "onstream");
+ file.on("directory", ondirectory);
+ file.on("end", onend);
+ file.on("error", onerror);
+ file.on("file", onfile);
+ file.on("stream", onstream);
+ onFinished(res2, onfinish);
+ if (options14.headers) {
+ file.on("headers", /* @__PURE__ */ __name(function headers(res3) {
+ var obj = options14.headers;
+ var keys = Object.keys(obj);
+ for (var i = 0; i < keys.length; i++) {
+ var k = keys[i];
+ res3.setHeader(k, obj[k]);
+ }
+ }, "headers"));
+ }
+ file.pipe(res2);
+ }
+ __name(sendfile, "sendfile");
+ function stringify(value, replacer2, spaces, escape2) {
+ var json = replacer2 || spaces ? JSON.stringify(value, replacer2, 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";
+ default:
+ return c;
+ }
+ });
+ }
+ return json;
+ }
+ __name(stringify, "stringify");
+ }
+});
+
+// ../../node_modules/.pnpm/serve-static@1.15.0_supports-color@9.2.2/node_modules/serve-static/index.js
+var require_serve_static = __commonJS({
+ "../../node_modules/.pnpm/serve-static@1.15.0_supports-color@9.2.2/node_modules/serve-static/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var encodeUrl = require_encodeurl();
+ var escapeHtml = require_escape_html();
+ var parseUrl = require_parseurl();
+ var resolve18 = require("path").resolve;
+ var send = require_send();
+ var url3 = require("url");
+ module2.exports = serveStatic2;
+ module2.exports.mime = send.mime;
+ function serveStatic2(root, options14) {
+ 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(options14 || 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 = resolve18(root);
+ var onDirectory = redirect ? createRedirectDirectoryListener() : createNotFoundDirectoryListener();
+ return /* @__PURE__ */ __name(function serveStatic3(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 path45 = parseUrl(req).pathname;
+ if (path45 === "/" && originalUrl.pathname.substr(-1) !== "/") {
+ path45 = "";
+ }
+ var stream2 = send(req, path45, opts);
+ stream2.on("directory", onDirectory);
+ if (setHeaders) {
+ stream2.on("headers", setHeaders);
+ }
+ if (fallthrough) {
+ stream2.on("file", /* @__PURE__ */ __name(function onFile() {
+ forwardError = true;
+ }, "onFile"));
+ }
+ stream2.on("error", /* @__PURE__ */ __name(function error(err) {
+ if (forwardError || !(err.statusCode < 500)) {
+ next(err);
+ return;
+ }
+ next();
+ }, "error"));
+ stream2.pipe(res);
+ }, "serveStatic");
+ }
+ __name(serveStatic2, "serveStatic");
+ function collapseLeadingSlashes(str) {
+ for (var i = 0; i < str.length; i++) {
+ if (str.charCodeAt(i) !== 47) {
+ break;
+ }
+ }
+ return i > 1 ? "/" + str.substr(i) : str;
+ }
+ __name(collapseLeadingSlashes, "collapseLeadingSlashes");
+ function createHtmlDocument(title, body) {
+ return '\n\n\n\n' + title + "\n\n\n" + body + "
\n\n\n";
+ }
+ __name(createHtmlDocument, "createHtmlDocument");
+ function createNotFoundDirectoryListener() {
+ return /* @__PURE__ */ __name(function notFound() {
+ this.error(404);
+ }, "notFound");
+ }
+ __name(createNotFoundDirectoryListener, "createNotFoundDirectoryListener");
+ function createRedirectDirectoryListener() {
+ return /* @__PURE__ */ __name(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(url3.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);
+ }, "redirect");
+ }
+ __name(createRedirectDirectoryListener, "createRedirectDirectoryListener");
+ }
+});
+
+// ../../node_modules/.pnpm/express@4.18.1_supports-color@9.2.2/node_modules/express/lib/express.js
+var require_express = __commonJS({
+ "../../node_modules/.pnpm/express@4.18.1_supports-color@9.2.2/node_modules/express/lib/express.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var bodyParser2 = require_body_parser();
+ var EventEmitter3 = require("events").EventEmitter;
+ var mixin3 = require_merge_descriptors();
+ var proto = require_application();
+ var Route = require_route3();
+ var Router = require_router();
+ var req = require_request3();
+ var res = require_response2();
+ exports2 = module2.exports = createApplication;
+ function createApplication() {
+ var app = /* @__PURE__ */ __name(function(req2, res2, next) {
+ app.handle(req2, res2, next);
+ }, "app");
+ mixin3(app, EventEmitter3.prototype, false);
+ mixin3(app, proto, 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;
+ }
+ __name(createApplication, "createApplication");
+ exports2.application = proto;
+ exports2.request = req;
+ exports2.response = res;
+ exports2.Route = Route;
+ exports2.Router = Router;
+ exports2.json = bodyParser2.json;
+ exports2.query = require_query();
+ exports2.raw = bodyParser2.raw;
+ exports2.static = require_serve_static();
+ exports2.text = bodyParser2.text;
+ exports2.urlencoded = bodyParser2.urlencoded;
+ var removedMiddlewares = [
+ "bodyParser",
+ "compress",
+ "cookieSession",
+ "session",
+ "logger",
+ "cookieParser",
+ "favicon",
+ "responseTime",
+ "errorHandler",
+ "timeout",
+ "methodOverride",
+ "vhost",
+ "csrf",
+ "directory",
+ "limit",
+ "multipart",
+ "staticCache"
+ ];
+ removedMiddlewares.forEach(function(name) {
+ Object.defineProperty(exports2, name, {
+ get: function() {
+ throw new Error("Most middleware (like " + name + ") is no longer bundled with Express and must be installed separately. Please see https://github.com/senchalabs/connect#middleware.");
+ },
+ configurable: true
+ });
+ });
+ }
+});
+
+// ../../node_modules/.pnpm/express@4.18.1_supports-color@9.2.2/node_modules/express/index.js
+var require_express2 = __commonJS({
+ "../../node_modules/.pnpm/express@4.18.1_supports-color@9.2.2/node_modules/express/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ module2.exports = require_express();
+ }
+});
+
+// ../../node_modules/.pnpm/p-finally@1.0.0/node_modules/p-finally/index.js
+var require_p_finally = __commonJS({
+ "../../node_modules/.pnpm/p-finally@1.0.0/node_modules/p-finally/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ module2.exports = (promise, onFinally) => {
+ onFinally = onFinally || (() => {
+ });
+ return promise.then(
+ (val) => new Promise((resolve18) => {
+ resolve18(onFinally());
+ }).then(() => val),
+ (err) => new Promise((resolve18) => {
+ resolve18(onFinally());
+ }).then(() => {
+ throw err;
+ })
+ );
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/p-timeout@3.2.0/node_modules/p-timeout/index.js
+var require_p_timeout = __commonJS({
+ "../../node_modules/.pnpm/p-timeout@3.2.0/node_modules/p-timeout/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var pFinally = require_p_finally();
+ var TimeoutError2 = class extends Error {
+ constructor(message) {
+ super(message);
+ this.name = "TimeoutError";
+ }
+ };
+ __name(TimeoutError2, "TimeoutError");
+ var pTimeout2 = /* @__PURE__ */ __name((promise, milliseconds, fallback) => new Promise((resolve18, reject) => {
+ if (typeof milliseconds !== "number" || milliseconds < 0) {
+ throw new TypeError("Expected `milliseconds` to be a positive number");
+ }
+ if (milliseconds === Infinity) {
+ resolve18(promise);
+ return;
+ }
+ const timer = setTimeout(() => {
+ if (typeof fallback === "function") {
+ try {
+ resolve18(fallback());
+ } catch (error) {
+ reject(error);
+ }
+ return;
+ }
+ const message = typeof fallback === "string" ? fallback : `Promise timed out after ${milliseconds} milliseconds`;
+ const timeoutError2 = fallback instanceof Error ? fallback : new TimeoutError2(message);
+ if (typeof promise.cancel === "function") {
+ promise.cancel();
+ }
+ reject(timeoutError2);
+ }, milliseconds);
+ pFinally(
+ // eslint-disable-next-line promise/prefer-await-to-then
+ promise.then(resolve18, reject),
+ () => {
+ clearTimeout(timer);
+ }
+ );
+ }), "pTimeout");
+ module2.exports = pTimeout2;
+ module2.exports.default = pTimeout2;
+ module2.exports.TimeoutError = TimeoutError2;
+ }
+});
+
+// ../../node_modules/.pnpm/p-wait-for@3.2.0/node_modules/p-wait-for/index.js
+var require_p_wait_for = __commonJS({
+ "../../node_modules/.pnpm/p-wait-for@3.2.0/node_modules/p-wait-for/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var pTimeout2 = require_p_timeout();
+ var pWaitFor = /* @__PURE__ */ __name(async (condition, options14) => {
+ options14 = {
+ interval: 20,
+ timeout: Infinity,
+ leadingCheck: true,
+ ...options14
+ };
+ let retryTimeout;
+ const promise = new Promise((resolve18, reject) => {
+ const check = /* @__PURE__ */ __name(async () => {
+ try {
+ const value = await condition();
+ if (typeof value !== "boolean") {
+ throw new TypeError("Expected condition to return a boolean");
+ }
+ if (value === true) {
+ resolve18();
+ } else {
+ retryTimeout = setTimeout(check, options14.interval);
+ }
+ } catch (error) {
+ reject(error);
+ }
+ }, "check");
+ if (options14.leadingCheck) {
+ check();
+ } else {
+ retryTimeout = setTimeout(check, options14.interval);
+ }
+ });
+ if (options14.timeout !== Infinity) {
+ try {
+ return await pTimeout2(promise, options14.timeout);
+ } catch (error) {
+ if (retryTimeout) {
+ clearTimeout(retryTimeout);
+ }
+ throw error;
+ }
+ }
+ return promise;
+ }, "pWaitFor");
+ module2.exports = pWaitFor;
+ module2.exports.default = pWaitFor;
+ }
+});
+
+// ../../node_modules/.pnpm/boolean@3.2.0/node_modules/boolean/build/lib/boolean.js
+var require_boolean = __commonJS({
+ "../../node_modules/.pnpm/boolean@3.2.0/node_modules/boolean/build/lib/boolean.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ Object.defineProperty(exports2, "__esModule", { value: true });
+ exports2.boolean = void 0;
+ var boolean = /* @__PURE__ */ __name(function(value) {
+ switch (Object.prototype.toString.call(value)) {
+ case "[object String]":
+ return ["true", "t", "yes", "y", "on", "1"].includes(value.trim().toLowerCase());
+ case "[object Number]":
+ return value.valueOf() === 1;
+ case "[object Boolean]":
+ return value.valueOf();
+ default:
+ return false;
+ }
+ }, "boolean");
+ exports2.boolean = boolean;
+ }
+});
+
+// ../../node_modules/.pnpm/boolean@3.2.0/node_modules/boolean/build/lib/isBooleanable.js
+var require_isBooleanable = __commonJS({
+ "../../node_modules/.pnpm/boolean@3.2.0/node_modules/boolean/build/lib/isBooleanable.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ Object.defineProperty(exports2, "__esModule", { value: true });
+ exports2.isBooleanable = void 0;
+ var isBooleanable = /* @__PURE__ */ __name(function(value) {
+ switch (Object.prototype.toString.call(value)) {
+ case "[object String]":
+ return [
+ "true",
+ "t",
+ "yes",
+ "y",
+ "on",
+ "1",
+ "false",
+ "f",
+ "no",
+ "n",
+ "off",
+ "0"
+ ].includes(value.trim().toLowerCase());
+ case "[object Number]":
+ return [0, 1].includes(value.valueOf());
+ case "[object Boolean]":
+ return true;
+ default:
+ return false;
+ }
+ }, "isBooleanable");
+ exports2.isBooleanable = isBooleanable;
+ }
+});
+
+// ../../node_modules/.pnpm/boolean@3.2.0/node_modules/boolean/build/lib/index.js
+var require_lib5 = __commonJS({
+ "../../node_modules/.pnpm/boolean@3.2.0/node_modules/boolean/build/lib/index.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ Object.defineProperty(exports2, "__esModule", { value: true });
+ exports2.isBooleanable = exports2.boolean = void 0;
+ var boolean_1 = require_boolean();
+ Object.defineProperty(exports2, "boolean", { enumerable: true, get: function() {
+ return boolean_1.boolean;
+ } });
+ var isBooleanable_1 = require_isBooleanable();
+ Object.defineProperty(exports2, "isBooleanable", { enumerable: true, get: function() {
+ return isBooleanable_1.isBooleanable;
+ } });
+ }
+});
+
+// ../../node_modules/.pnpm/uri-js@4.4.1/node_modules/uri-js/dist/es5/uri.all.js
+var require_uri_all = __commonJS({
+ "../../node_modules/.pnpm/uri-js@4.4.1/node_modules/uri-js/dist/es5/uri.all.js"(exports2, module2) {
+ init_import_meta_url();
+ (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];
+ }
+ }
+ __name(merge, "merge");
+ function subexp(str) {
+ return "(?:" + str + ")";
+ }
+ __name(subexp, "subexp");
+ function typeOf(o) {
+ return o === void 0 ? "undefined" : o === null ? "null" : Object.prototype.toString.call(o).split(" ").pop().split("]").shift().toLowerCase();
+ }
+ __name(typeOf, "typeOf");
+ function toUpperCase(str) {
+ return str.toUpperCase();
+ }
+ __name(toUpperCase, "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) : [];
+ }
+ __name(toArray, "toArray");
+ function assign(target, source) {
+ var obj = target;
+ if (source) {
+ for (var key in source) {
+ obj[key] = source[key];
+ }
+ }
+ return obj;
+ }
+ __name(assign, "assign");
+ 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
+ };
+ }
+ __name(buildExps, "buildExps");
+ var URI_PROTOCOL = buildExps(false);
+ var IRI_PROTOCOL = buildExps(true);
+ var slicedToArray = 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 (err) {
+ _d = true;
+ _e = err;
+ } finally {
+ try {
+ if (!_n && _i["return"])
+ _i["return"]();
+ } finally {
+ if (_d)
+ throw _e;
+ }
+ }
+ return _arr;
+ }
+ __name(sliceIterator, "sliceIterator");
+ 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 = /* @__PURE__ */ __name(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);
+ }
+ }, "toConsumableArray");
+ 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]);
+ }
+ __name(error$1, "error$1");
+ function map(array, fn2) {
+ var result = [];
+ var length = array.length;
+ while (length--) {
+ result[length] = fn2(array[length]);
+ }
+ return result;
+ }
+ __name(map, "map");
+ function mapDomain(string, fn2) {
+ 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, fn2).join(".");
+ return result + encoded;
+ }
+ __name(mapDomain, "mapDomain");
+ 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;
+ }
+ __name(ucs2decode, "ucs2decode");
+ var ucs2encode = /* @__PURE__ */ __name(function ucs2encode2(array) {
+ return String.fromCodePoint.apply(String, toConsumableArray(array));
+ }, "ucs2encode");
+ var basicToDigit = /* @__PURE__ */ __name(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;
+ }, "basicToDigit");
+ var digitToBasic = /* @__PURE__ */ __name(function digitToBasic2(digit, flag) {
+ return digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5);
+ }, "digitToBasic");
+ var adapt = /* @__PURE__ */ __name(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));
+ }, "adapt");
+ var decode = /* @__PURE__ */ __name(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 t2 = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias;
+ if (digit < t2) {
+ break;
+ }
+ var baseMinusT = base - t2;
+ 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);
+ }, "decode");
+ var encode = /* @__PURE__ */ __name(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 (err) {
+ _didIteratorError = true;
+ _iteratorError = err;
+ } 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 (err) {
+ _didIteratorError2 = true;
+ _iteratorError2 = err;
+ } 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 t2 = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias;
+ if (q < t2) {
+ break;
+ }
+ var qMinusT = q - t2;
+ var baseMinusT = base - t2;
+ output.push(stringFromCharCode(digitToBasic(t2 + qMinusT % baseMinusT, 0)));
+ q = floor(qMinusT / baseMinusT);
+ }
+ output.push(stringFromCharCode(digitToBasic(q, 0)));
+ bias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength);
+ delta = 0;
+ ++handledCPCount;
+ }
+ }
+ } catch (err) {
+ _didIteratorError3 = true;
+ _iteratorError3 = err;
+ } finally {
+ try {
+ if (!_iteratorNormalCompletion3 && _iterator3.return) {
+ _iterator3.return();
+ }
+ } finally {
+ if (_didIteratorError3) {
+ throw _iteratorError3;
+ }
+ }
+ }
+ ++delta;
+ ++n;
+ }
+ return output.join("");
+ }, "encode");
+ var toUnicode = /* @__PURE__ */ __name(function toUnicode2(input) {
+ return mapDomain(input, function(string) {
+ return regexPunycode.test(string) ? decode(string.slice(4).toLowerCase()) : string;
+ });
+ }, "toUnicode");
+ var toASCII = /* @__PURE__ */ __name(function toASCII2(input) {
+ return mapDomain(input, function(string) {
+ return regexNonASCII.test(string) ? "xn--" + encode(string) : string;
+ });
+ }, "toASCII");
+ 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 e2 = void 0;
+ if (c < 16)
+ e2 = "%0" + c.toString(16).toUpperCase();
+ else if (c < 128)
+ e2 = "%" + c.toString(16).toUpperCase();
+ else if (c < 2048)
+ e2 = "%" + (c >> 6 | 192).toString(16).toUpperCase() + "%" + (c & 63 | 128).toString(16).toUpperCase();
+ else
+ e2 = "%" + (c >> 12 | 224).toString(16).toUpperCase() + "%" + (c >> 6 & 63 | 128).toString(16).toUpperCase() + "%" + (c & 63 | 128).toString(16).toUpperCase();
+ return e2;
+ }
+ __name(pctEncChar, "pctEncChar");
+ 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 _c2 = parseInt(str.substr(i + 4, 2), 16);
+ var c3 = parseInt(str.substr(i + 7, 2), 16);
+ newStr += String.fromCharCode((c & 15) << 12 | (_c2 & 63) << 6 | c3 & 63);
+ } else {
+ newStr += str.substr(i, 9);
+ }
+ i += 9;
+ } else {
+ newStr += str.substr(i, 3);
+ i += 3;
+ }
+ }
+ return newStr;
+ }
+ __name(pctDecChars, "pctDecChars");
+ function _normalizeComponentEncoding(components, protocol) {
+ function decodeUnreserved2(str) {
+ var decStr = pctDecChars(str);
+ return !decStr.match(protocol.UNRESERVED) ? str : decStr;
+ }
+ __name(decodeUnreserved2, "decodeUnreserved");
+ 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;
+ }
+ __name(_normalizeComponentEncoding, "_normalizeComponentEncoding");
+ function _stripLeadingZeros(str) {
+ return str.replace(/^0*(.*)/, "$1") || "0";
+ }
+ __name(_stripLeadingZeros, "_stripLeadingZeros");
+ 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;
+ }
+ }
+ __name(_normalizeIPv4, "_normalizeIPv4");
+ 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;
+ }
+ }
+ __name(_normalizeIPv6, "_normalizeIPv6");
+ var URI_PARSE = /^(?:([^:\/?#]+):)?(?:\/\/((?:([^\/?#@]*)@)?(\[[^\/?#\]]+\]|[^\/?#:]*)(?:\:(\d*))?))?([^?#]*)(?:\?([^#]*))?(?:#((?:.|\n|\r)*))?/i;
+ var NO_MATCH_IS_UNDEFINED = "".match(/(){0}/)[1] === void 0;
+ function parse4(uriString) {
+ var options14 = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+ var components = {};
+ var protocol = options14.iri !== false ? IRI_PROTOCOL : URI_PROTOCOL;
+ if (options14.reference === "suffix")
+ uriString = (options14.scheme ? options14.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 (options14.reference && options14.reference !== "suffix" && options14.reference !== components.reference) {
+ components.error = components.error || "URI is not a " + options14.reference + " reference.";
+ }
+ var schemeHandler = SCHEMES[(options14.scheme || components.scheme || "").toLowerCase()];
+ if (!options14.unicodeSupport && (!schemeHandler || !schemeHandler.unicodeSupport)) {
+ if (components.host && (options14.domainHost || schemeHandler && schemeHandler.domainHost)) {
+ try {
+ components.host = punycode.toASCII(components.host.replace(protocol.PCT_ENCODED, pctDecChars).toLowerCase());
+ } catch (e2) {
+ components.error = components.error || "Host's domain name can not be converted to ASCII via punycode: " + e2;
+ }
+ }
+ _normalizeComponentEncoding(components, URI_PROTOCOL);
+ } else {
+ _normalizeComponentEncoding(components, protocol);
+ }
+ if (schemeHandler && schemeHandler.parse) {
+ schemeHandler.parse(components, options14);
+ }
+ } else {
+ components.error = components.error || "URI can not be parsed.";
+ }
+ return components;
+ }
+ __name(parse4, "parse");
+ function _recomposeAuthority(components, options14) {
+ var protocol = options14.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(_2, $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;
+ }
+ __name(_recomposeAuthority, "_recomposeAuthority");
+ 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("");
+ }
+ __name(removeDotSegments, "removeDotSegments");
+ function serialize(components) {
+ var options14 = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+ var protocol = options14.iri ? IRI_PROTOCOL : URI_PROTOCOL;
+ var uriTokens = [];
+ var schemeHandler = SCHEMES[(options14.scheme || components.scheme || "").toLowerCase()];
+ if (schemeHandler && schemeHandler.serialize)
+ schemeHandler.serialize(components, options14);
+ if (components.host) {
+ if (protocol.IPV6ADDRESS.test(components.host)) {
+ } else if (options14.domainHost || schemeHandler && schemeHandler.domainHost) {
+ try {
+ components.host = !options14.iri ? punycode.toASCII(components.host.replace(protocol.PCT_ENCODED, pctDecChars).toLowerCase()) : punycode.toUnicode(components.host);
+ } catch (e2) {
+ components.error = components.error || "Host's domain name can not be converted to " + (!options14.iri ? "ASCII" : "Unicode") + " via punycode: " + e2;
+ }
+ }
+ }
+ _normalizeComponentEncoding(components, protocol);
+ if (options14.reference !== "suffix" && components.scheme) {
+ uriTokens.push(components.scheme);
+ uriTokens.push(":");
+ }
+ var authority = _recomposeAuthority(components, options14);
+ if (authority !== void 0) {
+ if (options14.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 (!options14.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("");
+ }
+ __name(serialize, "serialize");
+ function resolveComponents(base2, relative12) {
+ var options14 = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
+ var skipNormalization = arguments[3];
+ var target = {};
+ if (!skipNormalization) {
+ base2 = parse4(serialize(base2, options14), options14);
+ relative12 = parse4(serialize(relative12, options14), options14);
+ }
+ options14 = options14 || {};
+ if (!options14.tolerant && relative12.scheme) {
+ target.scheme = relative12.scheme;
+ target.userinfo = relative12.userinfo;
+ target.host = relative12.host;
+ target.port = relative12.port;
+ target.path = removeDotSegments(relative12.path || "");
+ target.query = relative12.query;
+ } else {
+ if (relative12.userinfo !== void 0 || relative12.host !== void 0 || relative12.port !== void 0) {
+ target.userinfo = relative12.userinfo;
+ target.host = relative12.host;
+ target.port = relative12.port;
+ target.path = removeDotSegments(relative12.path || "");
+ target.query = relative12.query;
+ } else {
+ if (!relative12.path) {
+ target.path = base2.path;
+ if (relative12.query !== void 0) {
+ target.query = relative12.query;
+ } else {
+ target.query = base2.query;
+ }
+ } else {
+ if (relative12.path.charAt(0) === "/") {
+ target.path = removeDotSegments(relative12.path);
+ } else {
+ if ((base2.userinfo !== void 0 || base2.host !== void 0 || base2.port !== void 0) && !base2.path) {
+ target.path = "/" + relative12.path;
+ } else if (!base2.path) {
+ target.path = relative12.path;
+ } else {
+ target.path = base2.path.slice(0, base2.path.lastIndexOf("/") + 1) + relative12.path;
+ }
+ target.path = removeDotSegments(target.path);
+ }
+ target.query = relative12.query;
+ }
+ target.userinfo = base2.userinfo;
+ target.host = base2.host;
+ target.port = base2.port;
+ }
+ target.scheme = base2.scheme;
+ }
+ target.fragment = relative12.fragment;
+ return target;
+ }
+ __name(resolveComponents, "resolveComponents");
+ function resolve18(baseURI, relativeURI, options14) {
+ var schemelessOptions = assign({ scheme: "null" }, options14);
+ return serialize(resolveComponents(parse4(baseURI, schemelessOptions), parse4(relativeURI, schemelessOptions), schemelessOptions, true), schemelessOptions);
+ }
+ __name(resolve18, "resolve");
+ function normalize2(uri, options14) {
+ if (typeof uri === "string") {
+ uri = serialize(parse4(uri, options14), options14);
+ } else if (typeOf(uri) === "object") {
+ uri = parse4(serialize(uri, options14), options14);
+ }
+ return uri;
+ }
+ __name(normalize2, "normalize");
+ function equal(uriA, uriB, options14) {
+ if (typeof uriA === "string") {
+ uriA = serialize(parse4(uriA, options14), options14);
+ } else if (typeOf(uriA) === "object") {
+ uriA = serialize(uriA, options14);
+ }
+ if (typeof uriB === "string") {
+ uriB = serialize(parse4(uriB, options14), options14);
+ } else if (typeOf(uriB) === "object") {
+ uriB = serialize(uriB, options14);
+ }
+ return uriA === uriB;
+ }
+ __name(equal, "equal");
+ function escapeComponent(str, options14) {
+ return str && str.toString().replace(!options14 || !options14.iri ? URI_PROTOCOL.ESCAPE : IRI_PROTOCOL.ESCAPE, pctEncChar);
+ }
+ __name(escapeComponent, "escapeComponent");
+ function unescapeComponent(str, options14) {
+ return str && str.toString().replace(!options14 || !options14.iri ? URI_PROTOCOL.PCT_ENCODED : IRI_PROTOCOL.PCT_ENCODED, pctDecChars);
+ }
+ __name(unescapeComponent, "unescapeComponent");
+ var handler15 = {
+ scheme: "http",
+ domainHost: true,
+ parse: /* @__PURE__ */ __name(function parse5(components, options14) {
+ if (!components.host) {
+ components.error = components.error || "HTTP URIs must have a host.";
+ }
+ return components;
+ }, "parse"),
+ serialize: /* @__PURE__ */ __name(function serialize2(components, options14) {
+ 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;
+ }, "serialize")
+ };
+ var handler$1 = {
+ scheme: "https",
+ domainHost: handler15.domainHost,
+ parse: handler15.parse,
+ serialize: handler15.serialize
+ };
+ function isSecure(wsComponents) {
+ return typeof wsComponents.secure === "boolean" ? wsComponents.secure : String(wsComponents.scheme).toLowerCase() === "wss";
+ }
+ __name(isSecure, "isSecure");
+ var handler$2 = {
+ scheme: "ws",
+ domainHost: true,
+ parse: /* @__PURE__ */ __name(function parse5(components, options14) {
+ 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;
+ }, "parse"),
+ serialize: /* @__PURE__ */ __name(function serialize2(wsComponents, options14) {
+ 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), path45 = _wsComponents$resourc2[0], query = _wsComponents$resourc2[1];
+ wsComponents.path = path45 && path45 !== "/" ? path45 : void 0;
+ wsComponents.query = query;
+ wsComponents.resourceName = void 0;
+ }
+ wsComponents.fragment = void 0;
+ return wsComponents;
+ }, "serialize")
+ };
+ 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;
+ }
+ __name(decodeUnreserved, "decodeUnreserved");
+ var handler$4 = {
+ scheme: "mailto",
+ parse: /* @__PURE__ */ __name(function parse$$1(components, options14) {
+ 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], options14);
+ break;
+ case "body":
+ mailtoComponents.body = unescapeComponent(hfield[1], options14);
+ break;
+ default:
+ unknownHeaders = true;
+ headers[unescapeComponent(hfield[0], options14)] = unescapeComponent(hfield[1], options14);
+ 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 (!options14.unicodeSupport) {
+ try {
+ addr[1] = punycode.toASCII(unescapeComponent(addr[1], options14).toLowerCase());
+ } catch (e2) {
+ mailtoComponents.error = mailtoComponents.error || "Email address's domain name can not be converted to ASCII via punycode: " + e2;
+ }
+ } else {
+ addr[1] = unescapeComponent(addr[1], options14).toLowerCase();
+ }
+ to[_x2] = addr.join("@");
+ }
+ return mailtoComponents;
+ }, "parse$$1"),
+ serialize: /* @__PURE__ */ __name(function serialize$$1(mailtoComponents, options14) {
+ 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 = !options14.iri ? punycode.toASCII(unescapeComponent(domain, options14).toLowerCase()) : punycode.toUnicode(domain);
+ } catch (e2) {
+ components.error = components.error || "Email address's domain name can not be converted to " + (!options14.iri ? "ASCII" : "Unicode") + " via punycode: " + e2;
+ }
+ 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;
+ }, "serialize$$1")
+ };
+ var URN_PARSE = /^([^\:]+)\:(.*)/;
+ var handler$5 = {
+ scheme: "urn",
+ parse: /* @__PURE__ */ __name(function parse$$1(components, options14) {
+ var matches = components.path && components.path.match(URN_PARSE);
+ var urnComponents = components;
+ if (matches) {
+ var scheme = options14.scheme || urnComponents.scheme || "urn";
+ var nid = matches[1].toLowerCase();
+ var nss = matches[2];
+ var urnScheme = scheme + ":" + (options14.nid || nid);
+ var schemeHandler = SCHEMES[urnScheme];
+ urnComponents.nid = nid;
+ urnComponents.nss = nss;
+ urnComponents.path = void 0;
+ if (schemeHandler) {
+ urnComponents = schemeHandler.parse(urnComponents, options14);
+ }
+ } else {
+ urnComponents.error = urnComponents.error || "URN can not be parsed.";
+ }
+ return urnComponents;
+ }, "parse$$1"),
+ serialize: /* @__PURE__ */ __name(function serialize$$1(urnComponents, options14) {
+ var scheme = options14.scheme || urnComponents.scheme || "urn";
+ var nid = urnComponents.nid;
+ var urnScheme = scheme + ":" + (options14.nid || nid);
+ var schemeHandler = SCHEMES[urnScheme];
+ if (schemeHandler) {
+ urnComponents = schemeHandler.serialize(urnComponents, options14);
+ }
+ var uriComponents = urnComponents;
+ var nss = urnComponents.nss;
+ uriComponents.path = (nid || options14.nid) + ":" + nss;
+ return uriComponents;
+ }, "serialize$$1")
+ };
+ 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: /* @__PURE__ */ __name(function parse5(urnComponents, options14) {
+ var uuidComponents = urnComponents;
+ uuidComponents.uuid = uuidComponents.nss;
+ uuidComponents.nss = void 0;
+ if (!options14.tolerant && (!uuidComponents.uuid || !uuidComponents.uuid.match(UUID))) {
+ uuidComponents.error = uuidComponents.error || "UUID is not valid.";
+ }
+ return uuidComponents;
+ }, "parse"),
+ serialize: /* @__PURE__ */ __name(function serialize2(uuidComponents, options14) {
+ var urnComponents = uuidComponents;
+ urnComponents.nss = (uuidComponents.uuid || "").toLowerCase();
+ return urnComponents;
+ }, "serialize")
+ };
+ SCHEMES[handler15.scheme] = handler15;
+ 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 = parse4;
+ exports3.removeDotSegments = removeDotSegments;
+ exports3.serialize = serialize;
+ exports3.resolveComponents = resolveComponents;
+ exports3.resolve = resolve18;
+ exports3.normalize = normalize2;
+ exports3.equal = equal;
+ exports3.escapeComponent = escapeComponent;
+ exports3.unescapeComponent = unescapeComponent;
+ Object.defineProperty(exports3, "__esModule", { value: true });
+ });
+ }
+});
+
+// ../../node_modules/.pnpm/fast-deep-equal@3.1.3/node_modules/fast-deep-equal/index.js
+var require_fast_deep_equal = __commonJS({
+ "../../node_modules/.pnpm/fast-deep-equal@3.1.3/node_modules/fast-deep-equal/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ module2.exports = /* @__PURE__ */ __name(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;
+ }, "equal");
+ }
+});
+
+// ../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/compile/ucs2length.js
+var require_ucs2length = __commonJS({
+ "../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/compile/ucs2length.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ module2.exports = /* @__PURE__ */ __name(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;
+ }, "ucs2length");
+ }
+});
+
+// ../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/compile/util.js
+var require_util9 = __commonJS({
+ "../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/compile/util.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ 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;
+ }
+ __name(copy, "copy");
+ function checkDataType(dataType, data, strictNumbers, negate) {
+ var EQUAL = negate ? " !== " : " === ", AND = negate ? " || " : " && ", OK = negate ? "!" : "", NOT = negate ? "" : "!";
+ switch (dataType) {
+ case "null":
+ return data + EQUAL + "null";
+ case "array":
+ return OK + "Array.isArray(" + data + ")";
+ case "object":
+ return "(" + OK + 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 + OK + "isFinite(" + data + ")" : "") + ")";
+ case "number":
+ return "(typeof " + data + EQUAL + '"' + dataType + '"' + (strictNumbers ? AND + OK + "isFinite(" + data + ")" : "") + ")";
+ default:
+ return "typeof " + data + EQUAL + '"' + dataType + '"';
+ }
+ }
+ __name(checkDataType, "checkDataType");
+ 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 t2 in types)
+ code += (code ? " && " : "") + checkDataType(t2, data, strictNumbers, true);
+ return code;
+ }
+ }
+ __name(checkDataTypes, "checkDataTypes");
+ 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 t2 = dataTypes[i];
+ if (COERCE_TO_TYPES[t2])
+ types[types.length] = t2;
+ else if (optionCoerceTypes === "array" && t2 === "array")
+ types[types.length] = t2;
+ }
+ if (types.length)
+ return types;
+ } else if (COERCE_TO_TYPES[dataTypes]) {
+ return [dataTypes];
+ } else if (optionCoerceTypes === "array" && dataTypes === "array") {
+ return ["array"];
+ }
+ }
+ __name(coerceToTypes, "coerceToTypes");
+ function toHash(arr) {
+ var hash = {};
+ for (var i = 0; i < arr.length; i++)
+ hash[arr[i]] = true;
+ return hash;
+ }
+ __name(toHash, "toHash");
+ 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) + "']";
+ }
+ __name(getProperty, "getProperty");
+ function escapeQuotes(str) {
+ return str.replace(SINGLE_QUOTE, "\\$&").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\f/g, "\\f").replace(/\t/g, "\\t");
+ }
+ __name(escapeQuotes, "escapeQuotes");
+ function varOccurences(str, dataVar) {
+ dataVar += "[^0-9]";
+ var matches = str.match(new RegExp(dataVar, "g"));
+ return matches ? matches.length : 0;
+ }
+ __name(varOccurences, "varOccurences");
+ function varReplace(str, dataVar, expr) {
+ dataVar += "([^0-9])";
+ expr = expr.replace(/\$/g, "$$$$");
+ return str.replace(new RegExp(dataVar, "g"), expr + "$1");
+ }
+ __name(varReplace, "varReplace");
+ function schemaHasRules(schema, rules) {
+ if (typeof schema == "boolean")
+ return !schema;
+ for (var key in schema)
+ if (rules[key])
+ return true;
+ }
+ __name(schemaHasRules, "schemaHasRules");
+ 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;
+ }
+ __name(schemaHasRulesExcept, "schemaHasRulesExcept");
+ function schemaUnknownRules(schema, rules) {
+ if (typeof schema == "boolean")
+ return;
+ for (var key in schema)
+ if (!rules[key])
+ return key;
+ }
+ __name(schemaUnknownRules, "schemaUnknownRules");
+ function toQuotedString(str) {
+ return "'" + escapeQuotes(str) + "'";
+ }
+ __name(toQuotedString, "toQuotedString");
+ function getPathExpr(currentPath, expr, jsonPointers, isNumber) {
+ var path45 = jsonPointers ? "'/' + " + expr + (isNumber ? "" : ".replace(/~/g, '~0').replace(/\\//g, '~1')") : isNumber ? "'[' + " + expr + " + ']'" : "'[\\'' + " + expr + " + '\\']'";
+ return joinPaths(currentPath, path45);
+ }
+ __name(getPathExpr, "getPathExpr");
+ function getPath(currentPath, prop, jsonPointers) {
+ var path45 = jsonPointers ? toQuotedString("/" + escapeJsonPointer(prop)) : toQuotedString(getProperty(prop));
+ return joinPaths(currentPath, path45);
+ }
+ __name(getPath, "getPath");
+ 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;
+ }
+ __name(getData, "getData");
+ function joinPaths(a, b) {
+ if (a == '""')
+ return b;
+ return (a + " + " + b).replace(/([^\\])' \+ '/g, "$1");
+ }
+ __name(joinPaths, "joinPaths");
+ function unescapeFragment(str) {
+ return unescapeJsonPointer(decodeURIComponent(str));
+ }
+ __name(unescapeFragment, "unescapeFragment");
+ function escapeFragment(str) {
+ return encodeURIComponent(escapeJsonPointer(str));
+ }
+ __name(escapeFragment, "escapeFragment");
+ function escapeJsonPointer(str) {
+ return str.replace(/~/g, "~0").replace(/\//g, "~1");
+ }
+ __name(escapeJsonPointer, "escapeJsonPointer");
+ function unescapeJsonPointer(str) {
+ return str.replace(/~1/g, "/").replace(/~0/g, "~");
+ }
+ __name(unescapeJsonPointer, "unescapeJsonPointer");
+ }
+});
+
+// ../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/compile/schema_obj.js
+var require_schema_obj = __commonJS({
+ "../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/compile/schema_obj.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var util3 = require_util9();
+ module2.exports = SchemaObject;
+ function SchemaObject(obj) {
+ util3.copy(obj, this);
+ }
+ __name(SchemaObject, "SchemaObject");
+ }
+});
+
+// ../../node_modules/.pnpm/json-schema-traverse@0.4.1/node_modules/json-schema-traverse/index.js
+var require_json_schema_traverse = __commonJS({
+ "../../node_modules/.pnpm/json-schema-traverse@0.4.1/node_modules/json-schema-traverse/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ 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);
+ }
+ }
+ __name(_traverse, "_traverse");
+ function escapeJsonPtr(str) {
+ return str.replace(/~/g, "~0").replace(/\//g, "~1");
+ }
+ __name(escapeJsonPtr, "escapeJsonPtr");
+ }
+});
+
+// ../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/compile/resolve.js
+var require_resolve = __commonJS({
+ "../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/compile/resolve.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var URI = require_uri_all();
+ var equal = require_fast_deep_equal();
+ var util3 = require_util9();
+ var SchemaObject = require_schema_obj();
+ var traverse = require_json_schema_traverse();
+ module2.exports = resolve18;
+ resolve18.normalizeId = normalizeId;
+ resolve18.fullPath = getFullPath;
+ resolve18.url = resolveUrl;
+ resolve18.ids = resolveIds;
+ resolve18.inlineRef = inlineRef;
+ resolve18.schema = resolveSchema;
+ function resolve18(compile, root, ref) {
+ var refVal = this._refs[ref];
+ if (typeof refVal == "string") {
+ if (this._refs[refVal])
+ refVal = this._refs[refVal];
+ else
+ return resolve18.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;
+ }
+ __name(resolve18, "resolve");
+ 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);
+ }
+ __name(resolveSchema, "resolveSchema");
+ 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);
+ }
+ }
+ __name(resolveRecursive, "resolveRecursive");
+ 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 };
+ }
+ __name(getJsonPointer, "getJsonPointer");
+ 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;
+ }
+ __name(inlineRef, "inlineRef");
+ 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;
+ }
+ __name(checkNoRef, "checkNoRef");
+ 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;
+ }
+ __name(countKeys, "countKeys");
+ function getFullPath(id, normalize2) {
+ if (normalize2 !== false)
+ id = normalizeId(id);
+ var p = URI.parse(id);
+ return _getFullPath(p);
+ }
+ __name(getFullPath, "getFullPath");
+ function _getFullPath(p) {
+ return URI.serialize(p).split("#")[0] + "#";
+ }
+ __name(_getFullPath, "_getFullPath");
+ var TRAILING_SLASH_HASH = /#\/?$/;
+ function normalizeId(id) {
+ return id ? id.replace(TRAILING_SLASH_HASH, "") : "";
+ }
+ __name(normalizeId, "normalizeId");
+ function resolveUrl(baseId, id) {
+ id = normalizeId(id);
+ return URI.resolve(baseId, id);
+ }
+ __name(resolveUrl, "resolveUrl");
+ 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;
+ }
+ __name(resolveIds, "resolveIds");
+ }
+});
+
+// ../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/compile/error_classes.js
+var require_error_classes = __commonJS({
+ "../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/compile/error_classes.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var resolve18 = 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;
+ }
+ __name(ValidationError, "ValidationError");
+ 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 = resolve18.url(baseId, ref);
+ this.missingSchema = resolve18.normalizeId(resolve18.fullPath(this.missingRef));
+ }
+ __name(MissingRefError, "MissingRefError");
+ function errorSubclass(Subclass) {
+ Subclass.prototype = Object.create(Error.prototype);
+ Subclass.prototype.constructor = Subclass;
+ return Subclass;
+ }
+ __name(errorSubclass, "errorSubclass");
+ }
+});
+
+// ../../node_modules/.pnpm/fast-json-stable-stringify@2.1.0/node_modules/fast-json-stable-stringify/index.js
+var require_fast_json_stable_stringify = __commonJS({
+ "../../node_modules/.pnpm/fast-json-stable-stringify@2.1.0/node_modules/fast-json-stable-stringify/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ 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 && 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 (/* @__PURE__ */ __name(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 + "}";
+ }, "stringify"))(data);
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/validate.js
+var require_validate = __commonJS({
+ "../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/validate.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ module2.exports = /* @__PURE__ */ __name(function generate_validate(it2, $keyword, $ruleType) {
+ var out = "";
+ var $async = it2.schema.$async === true, $refKeywords = it2.util.schemaHasRulesExcept(it2.schema, it2.RULES.all, "$ref"), $id = it2.self._getId(it2.schema);
+ if (it2.opts.strictKeywords) {
+ var $unknownKwd = it2.util.schemaUnknownRules(it2.schema, it2.RULES.keywords);
+ if ($unknownKwd) {
+ var $keywordsMsg = "unknown keyword: " + $unknownKwd;
+ if (it2.opts.strictKeywords === "log")
+ it2.logger.warn($keywordsMsg);
+ else
+ throw new Error($keywordsMsg);
+ }
+ }
+ if (it2.isTop) {
+ out += " var validate = ";
+ if ($async) {
+ it2.async = true;
+ out += "async ";
+ }
+ out += "function(data, dataPath, parentData, parentDataProperty, rootData) { 'use strict'; ";
+ if ($id && (it2.opts.sourceCode || it2.opts.processCode)) {
+ out += " " + ("/*# sourceURL=" + $id + " */") + " ";
+ }
+ }
+ if (typeof it2.schema == "boolean" || !($refKeywords || it2.schema.$ref)) {
+ var $keyword = "false schema";
+ var $lvl = it2.level;
+ var $dataLvl = it2.dataLevel;
+ var $schema = it2.schema[$keyword];
+ var $schemaPath = it2.schemaPath + it2.util.getProperty($keyword);
+ var $errSchemaPath = it2.errSchemaPath + "/" + $keyword;
+ var $breakOnError = !it2.opts.allErrors;
+ var $errorKeyword;
+ var $data = "data" + ($dataLvl || "");
+ var $valid = "valid" + $lvl;
+ if (it2.schema === false) {
+ if (it2.isTop) {
+ $breakOnError = true;
+ } else {
+ out += " var " + $valid + " = false; ";
+ }
+ var $$outStack = $$outStack || [];
+ $$outStack.push(out);
+ out = "";
+ if (it2.createErrors !== false) {
+ out += " { keyword: '" + ($errorKeyword || "false schema") + "' , dataPath: (dataPath || '') + " + it2.errorPath + " , schemaPath: " + it2.util.toQuotedString($errSchemaPath) + " , params: {} ";
+ if (it2.opts.messages !== false) {
+ out += " , message: 'boolean schema is false' ";
+ }
+ if (it2.opts.verbose) {
+ out += " , schema: false , parentSchema: validate.schema" + it2.schemaPath + " , data: " + $data + " ";
+ }
+ out += " } ";
+ } else {
+ out += " {} ";
+ }
+ var __err = out;
+ out = $$outStack.pop();
+ if (!it2.compositeRule && $breakOnError) {
+ if (it2.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 (it2.isTop) {
+ if ($async) {
+ out += " return data; ";
+ } else {
+ out += " validate.errors = null; return true; ";
+ }
+ } else {
+ out += " var " + $valid + " = true; ";
+ }
+ }
+ if (it2.isTop) {
+ out += " }; return validate; ";
+ }
+ return out;
+ }
+ if (it2.isTop) {
+ var $top = it2.isTop, $lvl = it2.level = 0, $dataLvl = it2.dataLevel = 0, $data = "data";
+ it2.rootId = it2.resolve.fullPath(it2.self._getId(it2.root.schema));
+ it2.baseId = it2.baseId || it2.rootId;
+ delete it2.isTop;
+ it2.dataPathArr = [""];
+ if (it2.schema.default !== void 0 && it2.opts.useDefaults && it2.opts.strictDefaults) {
+ var $defaultMsg = "default is ignored in the schema root";
+ if (it2.opts.strictDefaults === "log")
+ it2.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 = it2.level, $dataLvl = it2.dataLevel, $data = "data" + ($dataLvl || "");
+ if ($id)
+ it2.baseId = it2.resolve.url(it2.baseId, $id);
+ if ($async && !it2.async)
+ throw new Error("async schema in sync schema");
+ out += " var errs_" + $lvl + " = errors;";
+ }
+ var $valid = "valid" + $lvl, $breakOnError = !it2.opts.allErrors, $closingBraces1 = "", $closingBraces2 = "";
+ var $errorKeyword;
+ var $typeSchema = it2.schema.type, $typeIsArray = Array.isArray($typeSchema);
+ if ($typeSchema && it2.opts.nullable && it2.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 (it2.schema.$ref && $refKeywords) {
+ if (it2.opts.extendRefs == "fail") {
+ throw new Error('$ref: validation keywords used in schema at path "' + it2.errSchemaPath + '" (see option extendRefs)');
+ } else if (it2.opts.extendRefs !== true) {
+ $refKeywords = false;
+ it2.logger.warn('$ref: keywords ignored in schema at path "' + it2.errSchemaPath + '"');
+ }
+ }
+ if (it2.schema.$comment && it2.opts.$comment) {
+ out += " " + it2.RULES.all.$comment.code(it2, "$comment");
+ }
+ if ($typeSchema) {
+ if (it2.opts.coerceTypes) {
+ var $coerceToTypes = it2.util.coerceToTypes(it2.opts.coerceTypes, $typeSchema);
+ }
+ var $rulesGroup = it2.RULES.types[$typeSchema];
+ if ($coerceToTypes || $typeIsArray || $rulesGroup === true || $rulesGroup && !$shouldUseGroup($rulesGroup)) {
+ var $schemaPath = it2.schemaPath + ".type", $errSchemaPath = it2.errSchemaPath + "/type";
+ var $schemaPath = it2.schemaPath + ".type", $errSchemaPath = it2.errSchemaPath + "/type", $method = $typeIsArray ? "checkDataTypes" : "checkDataType";
+ out += " if (" + it2.util[$method]($typeSchema, $data, it2.opts.strictNumbers, true) + ") { ";
+ if ($coerceToTypes) {
+ var $dataType = "dataType" + $lvl, $coerced = "coerced" + $lvl;
+ out += " var " + $dataType + " = typeof " + $data + "; var " + $coerced + " = undefined; ";
+ if (it2.opts.coerceTypes == "array") {
+ out += " if (" + $dataType + " == 'object' && Array.isArray(" + $data + ") && " + $data + ".length == 1) { " + $data + " = " + $data + "[0]; " + $dataType + " = typeof " + $data + "; if (" + it2.util.checkDataType(it2.schema.type, $data, it2.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 (it2.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 (it2.createErrors !== false) {
+ out += " { keyword: '" + ($errorKeyword || "type") + "' , dataPath: (dataPath || '') + " + it2.errorPath + " , schemaPath: " + it2.util.toQuotedString($errSchemaPath) + " , params: { type: '";
+ if ($typeIsArray) {
+ out += "" + $typeSchema.join(",");
+ } else {
+ out += "" + $typeSchema;
+ }
+ out += "' } ";
+ if (it2.opts.messages !== false) {
+ out += " , message: 'should be ";
+ if ($typeIsArray) {
+ out += "" + $typeSchema.join(",");
+ } else {
+ out += "" + $typeSchema;
+ }
+ out += "' ";
+ }
+ if (it2.opts.verbose) {
+ out += " , schema: validate.schema" + $schemaPath + " , parentSchema: validate.schema" + it2.schemaPath + " , data: " + $data + " ";
+ }
+ out += " } ";
+ } else {
+ out += " {} ";
+ }
+ var __err = out;
+ out = $$outStack.pop();
+ if (!it2.compositeRule && $breakOnError) {
+ if (it2.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 ? it2.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 (it2.createErrors !== false) {
+ out += " { keyword: '" + ($errorKeyword || "type") + "' , dataPath: (dataPath || '') + " + it2.errorPath + " , schemaPath: " + it2.util.toQuotedString($errSchemaPath) + " , params: { type: '";
+ if ($typeIsArray) {
+ out += "" + $typeSchema.join(",");
+ } else {
+ out += "" + $typeSchema;
+ }
+ out += "' } ";
+ if (it2.opts.messages !== false) {
+ out += " , message: 'should be ";
+ if ($typeIsArray) {
+ out += "" + $typeSchema.join(",");
+ } else {
+ out += "" + $typeSchema;
+ }
+ out += "' ";
+ }
+ if (it2.opts.verbose) {
+ out += " , schema: validate.schema" + $schemaPath + " , parentSchema: validate.schema" + it2.schemaPath + " , data: " + $data + " ";
+ }
+ out += " } ";
+ } else {
+ out += " {} ";
+ }
+ var __err = out;
+ out = $$outStack.pop();
+ if (!it2.compositeRule && $breakOnError) {
+ if (it2.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 (it2.schema.$ref && !$refKeywords) {
+ out += " " + it2.RULES.all.$ref.code(it2, "$ref") + " ";
+ if ($breakOnError) {
+ out += " } if (errors === ";
+ if ($top) {
+ out += "0";
+ } else {
+ out += "errs_" + $lvl;
+ }
+ out += ") { ";
+ $closingBraces2 += "}";
+ }
+ } else {
+ var arr2 = it2.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 (" + it2.util.checkDataType($rulesGroup.type, $data, it2.opts.strictNumbers) + ") { ";
+ }
+ if (it2.opts.useDefaults) {
+ if ($rulesGroup.type == "object" && it2.schema.properties) {
+ var $schema = it2.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 + it2.util.getProperty($propertyKey);
+ if (it2.compositeRule) {
+ if (it2.opts.strictDefaults) {
+ var $defaultMsg = "default is ignored for: " + $passData;
+ if (it2.opts.strictDefaults === "log")
+ it2.logger.warn($defaultMsg);
+ else
+ throw new Error($defaultMsg);
+ }
+ } else {
+ out += " if (" + $passData + " === undefined ";
+ if (it2.opts.useDefaults == "empty") {
+ out += " || " + $passData + " === null || " + $passData + " === '' ";
+ }
+ out += " ) " + $passData + " = ";
+ if (it2.opts.useDefaults == "shared") {
+ out += " " + it2.useDefault($sch.default) + " ";
+ } else {
+ out += " " + JSON.stringify($sch.default) + " ";
+ }
+ out += "; ";
+ }
+ }
+ }
+ }
+ } else if ($rulesGroup.type == "array" && Array.isArray(it2.schema.items)) {
+ var arr4 = it2.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 (it2.compositeRule) {
+ if (it2.opts.strictDefaults) {
+ var $defaultMsg = "default is ignored for: " + $passData;
+ if (it2.opts.strictDefaults === "log")
+ it2.logger.warn($defaultMsg);
+ else
+ throw new Error($defaultMsg);
+ }
+ } else {
+ out += " if (" + $passData + " === undefined ";
+ if (it2.opts.useDefaults == "empty") {
+ out += " || " + $passData + " === null || " + $passData + " === '' ";
+ }
+ out += " ) " + $passData + " = ";
+ if (it2.opts.useDefaults == "shared") {
+ out += " " + it2.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(it2, $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 = it2.schemaPath + ".type", $errSchemaPath = it2.errSchemaPath + "/type";
+ var $$outStack = $$outStack || [];
+ $$outStack.push(out);
+ out = "";
+ if (it2.createErrors !== false) {
+ out += " { keyword: '" + ($errorKeyword || "type") + "' , dataPath: (dataPath || '') + " + it2.errorPath + " , schemaPath: " + it2.util.toQuotedString($errSchemaPath) + " , params: { type: '";
+ if ($typeIsArray) {
+ out += "" + $typeSchema.join(",");
+ } else {
+ out += "" + $typeSchema;
+ }
+ out += "' } ";
+ if (it2.opts.messages !== false) {
+ out += " , message: 'should be ";
+ if ($typeIsArray) {
+ out += "" + $typeSchema.join(",");
+ } else {
+ out += "" + $typeSchema;
+ }
+ out += "' ";
+ }
+ if (it2.opts.verbose) {
+ out += " , schema: validate.schema" + $schemaPath + " , parentSchema: validate.schema" + it2.schemaPath + " , data: " + $data + " ";
+ }
+ out += " } ";
+ } else {
+ out += " {} ";
+ }
+ var __err = out;
+ out = $$outStack.pop();
+ if (!it2.compositeRule && $breakOnError) {
+ if (it2.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;
+ }
+ __name($shouldUseGroup, "$shouldUseGroup");
+ function $shouldUseRule($rule2) {
+ return it2.schema[$rule2.keyword] !== void 0 || $rule2.implements && $ruleImplementsSomeKeyword($rule2);
+ }
+ __name($shouldUseRule, "$shouldUseRule");
+ function $ruleImplementsSomeKeyword($rule2) {
+ var impl = $rule2.implements;
+ for (var i = 0; i < impl.length; i++)
+ if (it2.schema[impl[i]] !== void 0)
+ return true;
+ }
+ __name($ruleImplementsSomeKeyword, "$ruleImplementsSomeKeyword");
+ return out;
+ }, "generate_validate");
+ }
+});
+
+// ../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/compile/index.js
+var require_compile = __commonJS({
+ "../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/compile/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var resolve18 = require_resolve();
+ var util3 = require_util9();
+ 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 validate2 = compilation.validate;
+ var result = validate2.apply(this, arguments);
+ callValidate.errors = validate2.errors;
+ return result;
+ }
+ __name(callValidate, "callValidate");
+ 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: resolve18,
+ 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 validate2;
+ try {
+ var makeValidate = new Function(
+ "self",
+ "RULES",
+ "formats",
+ "root",
+ "refVal",
+ "defaults",
+ "customRules",
+ "equal",
+ "ucs2length",
+ "ValidationError",
+ sourceCode
+ );
+ validate2 = makeValidate(
+ self2,
+ RULES,
+ formats,
+ root,
+ refVal,
+ defaults,
+ customRules,
+ equal,
+ ucs2length,
+ ValidationError
+ );
+ refVal[0] = validate2;
+ } catch (e2) {
+ self2.logger.error("Error compiling schema, function code:", sourceCode);
+ throw e2;
+ }
+ validate2.schema = _schema;
+ validate2.errors = null;
+ validate2.refs = refs;
+ validate2.refVal = refVal;
+ validate2.root = isRoot ? validate2 : _root;
+ if ($async)
+ validate2.$async = true;
+ if (opts.sourceCode === true) {
+ validate2.source = {
+ code: sourceCode,
+ patterns,
+ defaults
+ };
+ }
+ return validate2;
+ }
+ __name(localCompile, "localCompile");
+ function resolveRef(baseId2, ref, isRoot) {
+ ref = resolve18.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 = resolve18.call(self2, localCompile, root, ref);
+ if (v2 === void 0) {
+ var localSchema = localRefs && localRefs[ref];
+ if (localSchema) {
+ v2 = resolve18.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);
+ }
+ }
+ __name(resolveRef, "resolveRef");
+ function addLocalRef(ref, v2) {
+ var refId = refVal.length;
+ refVal[refId] = v2;
+ refs[ref] = refId;
+ return "refVal" + refId;
+ }
+ __name(addLocalRef, "addLocalRef");
+ function removeLocalRef(ref) {
+ delete refs[ref];
+ }
+ __name(removeLocalRef, "removeLocalRef");
+ function replaceLocalRef(ref, v2) {
+ var refId = refs[ref];
+ refVal[refId] = v2;
+ }
+ __name(replaceLocalRef, "replaceLocalRef");
+ function resolvedRef(refVal2, code) {
+ return typeof refVal2 == "object" || typeof refVal2 == "boolean" ? { code, schema: refVal2, inline: true } : { code, $async: refVal2 && !!refVal2.$async };
+ }
+ __name(resolvedRef, "resolvedRef");
+ function usePattern(regexStr) {
+ var index = patternsHash[regexStr];
+ if (index === void 0) {
+ index = patternsHash[regexStr] = patterns.length;
+ patterns[index] = regexStr;
+ }
+ return "pattern" + index;
+ }
+ __name(usePattern, "usePattern");
+ 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;
+ }
+ }
+ __name(useDefault, "useDefault");
+ function useCustomRule(rule, schema2, parentSchema, it2) {
+ 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 validate2;
+ if (compile2) {
+ validate2 = compile2.call(self2, schema2, parentSchema, it2);
+ } else if (macro) {
+ validate2 = macro.call(self2, schema2, parentSchema, it2);
+ if (opts.validateSchema !== false)
+ self2.validateSchema(validate2, true);
+ } else if (inline) {
+ validate2 = inline.call(self2, it2, rule.keyword, schema2, parentSchema);
+ } else {
+ validate2 = rule.definition.validate;
+ if (!validate2)
+ return;
+ }
+ if (validate2 === void 0)
+ throw new Error('custom keyword "' + rule.keyword + '"failed to compile');
+ var index = customRules.length;
+ customRules[index] = validate2;
+ return {
+ code: "customRule" + index,
+ validate: validate2
+ };
+ }
+ __name(useCustomRule, "useCustomRule");
+ }
+ __name(compile, "compile");
+ 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 };
+ }
+ __name(checkCompiling, "checkCompiling");
+ function endCompiling(schema, root, baseId) {
+ var i = compIndex.call(this, schema, root, baseId);
+ if (i >= 0)
+ this._compilations.splice(i, 1);
+ }
+ __name(endCompiling, "endCompiling");
+ 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;
+ }
+ __name(compIndex, "compIndex");
+ function patternCode(i, patterns) {
+ return "var pattern" + i + " = new RegExp(" + util3.toQuotedString(patterns[i]) + ");";
+ }
+ __name(patternCode, "patternCode");
+ function defaultCode(i) {
+ return "var default" + i + " = defaults[" + i + "];";
+ }
+ __name(defaultCode, "defaultCode");
+ function refValCode(i, refVal) {
+ return refVal[i] === void 0 ? "" : "var refVal" + i + " = refVal[" + i + "];";
+ }
+ __name(refValCode, "refValCode");
+ function customRuleCode(i) {
+ return "var customRule" + i + " = customRules[" + i + "];";
+ }
+ __name(customRuleCode, "customRuleCode");
+ function vars(arr, statement) {
+ if (!arr.length)
+ return "";
+ var code = "";
+ for (var i = 0; i < arr.length; i++)
+ code += statement(i, arr);
+ return code;
+ }
+ __name(vars, "vars");
+ }
+});
+
+// ../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/cache.js
+var require_cache = __commonJS({
+ "../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/cache.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var Cache2 = module2.exports = /* @__PURE__ */ __name(function Cache3() {
+ this._cache = {};
+ }, "Cache");
+ Cache2.prototype.put = /* @__PURE__ */ __name(function Cache_put(key, value) {
+ this._cache[key] = value;
+ }, "Cache_put");
+ Cache2.prototype.get = /* @__PURE__ */ __name(function Cache_get(key) {
+ return this._cache[key];
+ }, "Cache_get");
+ Cache2.prototype.del = /* @__PURE__ */ __name(function Cache_del(key) {
+ delete this._cache[key];
+ }, "Cache_del");
+ Cache2.prototype.clear = /* @__PURE__ */ __name(function Cache_clear() {
+ this._cache = {};
+ }, "Cache_clear");
+ }
+});
+
+// ../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/compile/formats.js
+var require_formats2 = __commonJS({
+ "../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/compile/formats.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var util3 = require_util9();
+ 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 URL4 = /^(?:(?: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]);
+ }
+ __name(formats, "formats");
+ 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: URL4,
+ // 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: URL4,
+ 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(year2) {
+ return year2 % 4 === 0 && (year2 % 100 !== 0 || year2 % 400 === 0);
+ }
+ __name(isLeapYear, "isLeapYear");
+ function date(str) {
+ var matches = str.match(DATE);
+ if (!matches)
+ return false;
+ var year2 = +matches[1];
+ var month2 = +matches[2];
+ var day2 = +matches[3];
+ return month2 >= 1 && month2 <= 12 && day2 >= 1 && day2 <= (month2 == 2 && isLeapYear(year2) ? 29 : DAYS[month2]);
+ }
+ __name(date, "date");
+ function time(str, full) {
+ var matches = str.match(TIME);
+ if (!matches)
+ return false;
+ var hour2 = matches[1];
+ var minute2 = matches[2];
+ var second = matches[3];
+ var timeZone = matches[5];
+ return (hour2 <= 23 && minute2 <= 59 && second <= 59 || hour2 == 23 && minute2 == 59 && second == 60) && (!full || timeZone);
+ }
+ __name(time, "time");
+ 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);
+ }
+ __name(date_time, "date_time");
+ var NOT_URI_FRAGMENT = /\/|:/;
+ function uri(str) {
+ return NOT_URI_FRAGMENT.test(str) && URI.test(str);
+ }
+ __name(uri, "uri");
+ var Z_ANCHOR = /[^\\]\\Z/;
+ function regex(str) {
+ if (Z_ANCHOR.test(str))
+ return false;
+ try {
+ new RegExp(str);
+ return true;
+ } catch (e2) {
+ return false;
+ }
+ }
+ __name(regex, "regex");
+ }
+});
+
+// ../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/ref.js
+var require_ref = __commonJS({
+ "../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/ref.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ module2.exports = /* @__PURE__ */ __name(function generate_ref(it2, $keyword, $ruleType) {
+ var out = " ";
+ var $lvl = it2.level;
+ var $dataLvl = it2.dataLevel;
+ var $schema = it2.schema[$keyword];
+ var $errSchemaPath = it2.errSchemaPath + "/" + $keyword;
+ var $breakOnError = !it2.opts.allErrors;
+ var $data = "data" + ($dataLvl || "");
+ var $valid = "valid" + $lvl;
+ var $async, $refCode;
+ if ($schema == "#" || $schema == "#/") {
+ if (it2.isRoot) {
+ $async = it2.async;
+ $refCode = "validate";
+ } else {
+ $async = it2.root.schema.$async === true;
+ $refCode = "root.refVal[0]";
+ }
+ } else {
+ var $refVal = it2.resolveRef(it2.baseId, $schema, it2.isRoot);
+ if ($refVal === void 0) {
+ var $message = it2.MissingRefError.message(it2.baseId, $schema);
+ if (it2.opts.missingRefs == "fail") {
+ it2.logger.error($message);
+ var $$outStack = $$outStack || [];
+ $$outStack.push(out);
+ out = "";
+ if (it2.createErrors !== false) {
+ out += " { keyword: '$ref' , dataPath: (dataPath || '') + " + it2.errorPath + " , schemaPath: " + it2.util.toQuotedString($errSchemaPath) + " , params: { ref: '" + it2.util.escapeQuotes($schema) + "' } ";
+ if (it2.opts.messages !== false) {
+ out += " , message: 'can\\'t resolve reference " + it2.util.escapeQuotes($schema) + "' ";
+ }
+ if (it2.opts.verbose) {
+ out += " , schema: " + it2.util.toQuotedString($schema) + " , parentSchema: validate.schema" + it2.schemaPath + " , data: " + $data + " ";
+ }
+ out += " } ";
+ } else {
+ out += " {} ";
+ }
+ var __err = out;
+ out = $$outStack.pop();
+ if (!it2.compositeRule && $breakOnError) {
+ if (it2.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 (it2.opts.missingRefs == "ignore") {
+ it2.logger.warn($message);
+ if ($breakOnError) {
+ out += " if (true) { ";
+ }
+ } else {
+ throw new it2.MissingRefError(it2.baseId, $schema, $message);
+ }
+ } else if ($refVal.inline) {
+ var $it = it2.util.copy(it2);
+ $it.level++;
+ var $nextValid = "valid" + $it.level;
+ $it.schema = $refVal.schema;
+ $it.schemaPath = "";
+ $it.errSchemaPath = $schema;
+ var $code = it2.validate($it).replace(/validate\.schema/g, $refVal.code);
+ out += " " + $code + " ";
+ if ($breakOnError) {
+ out += " if (" + $nextValid + ") { ";
+ }
+ } else {
+ $async = $refVal.$async === true || it2.async && $refVal.$async !== false;
+ $refCode = $refVal.code;
+ }
+ }
+ if ($refCode) {
+ var $$outStack = $$outStack || [];
+ $$outStack.push(out);
+ out = "";
+ if (it2.opts.passContext) {
+ out += " " + $refCode + ".call(this, ";
+ } else {
+ out += " " + $refCode + "( ";
+ }
+ out += " " + $data + ", (dataPath || '')";
+ if (it2.errorPath != '""') {
+ out += " + " + it2.errorPath;
+ }
+ var $parentData = $dataLvl ? "data" + ($dataLvl - 1 || "") : "parentData", $parentDataProperty = $dataLvl ? it2.dataPathArr[$dataLvl] : "parentDataProperty";
+ out += " , " + $parentData + " , " + $parentDataProperty + ", rootData) ";
+ var __callValidate = out;
+ out = $$outStack.pop();
+ if ($async) {
+ if (!it2.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;
+ }, "generate_ref");
+ }
+});
+
+// ../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/allOf.js
+var require_allOf = __commonJS({
+ "../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/allOf.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ module2.exports = /* @__PURE__ */ __name(function generate_allOf(it2, $keyword, $ruleType) {
+ var out = " ";
+ var $schema = it2.schema[$keyword];
+ var $schemaPath = it2.schemaPath + it2.util.getProperty($keyword);
+ var $errSchemaPath = it2.errSchemaPath + "/" + $keyword;
+ var $breakOnError = !it2.opts.allErrors;
+ var $it = it2.util.copy(it2);
+ 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 (it2.opts.strictKeywords ? typeof $sch == "object" && Object.keys($sch).length > 0 || $sch === false : it2.util.schemaHasRules($sch, it2.RULES.all)) {
+ $allSchemasEmpty = false;
+ $it.schema = $sch;
+ $it.schemaPath = $schemaPath + "[" + $i + "]";
+ $it.errSchemaPath = $errSchemaPath + "/" + $i;
+ out += " " + it2.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;
+ }, "generate_allOf");
+ }
+});
+
+// ../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/anyOf.js
+var require_anyOf = __commonJS({
+ "../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/anyOf.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ module2.exports = /* @__PURE__ */ __name(function generate_anyOf(it2, $keyword, $ruleType) {
+ var out = " ";
+ var $lvl = it2.level;
+ var $dataLvl = it2.dataLevel;
+ var $schema = it2.schema[$keyword];
+ var $schemaPath = it2.schemaPath + it2.util.getProperty($keyword);
+ var $errSchemaPath = it2.errSchemaPath + "/" + $keyword;
+ var $breakOnError = !it2.opts.allErrors;
+ var $data = "data" + ($dataLvl || "");
+ var $valid = "valid" + $lvl;
+ var $errs = "errs__" + $lvl;
+ var $it = it2.util.copy(it2);
+ var $closingBraces = "";
+ $it.level++;
+ var $nextValid = "valid" + $it.level;
+ var $noEmptySchema = $schema.every(function($sch2) {
+ return it2.opts.strictKeywords ? typeof $sch2 == "object" && Object.keys($sch2).length > 0 || $sch2 === false : it2.util.schemaHasRules($sch2, it2.RULES.all);
+ });
+ if ($noEmptySchema) {
+ var $currentBaseId = $it.baseId;
+ out += " var " + $errs + " = errors; var " + $valid + " = false; ";
+ var $wasComposite = it2.compositeRule;
+ it2.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 += " " + it2.validate($it) + " ";
+ $it.baseId = $currentBaseId;
+ out += " " + $valid + " = " + $valid + " || " + $nextValid + "; if (!" + $valid + ") { ";
+ $closingBraces += "}";
+ }
+ }
+ it2.compositeRule = $it.compositeRule = $wasComposite;
+ out += " " + $closingBraces + " if (!" + $valid + ") { var err = ";
+ if (it2.createErrors !== false) {
+ out += " { keyword: 'anyOf' , dataPath: (dataPath || '') + " + it2.errorPath + " , schemaPath: " + it2.util.toQuotedString($errSchemaPath) + " , params: {} ";
+ if (it2.opts.messages !== false) {
+ out += " , message: 'should match some schema in anyOf' ";
+ }
+ if (it2.opts.verbose) {
+ out += " , schema: validate.schema" + $schemaPath + " , parentSchema: validate.schema" + it2.schemaPath + " , data: " + $data + " ";
+ }
+ out += " } ";
+ } else {
+ out += " {} ";
+ }
+ out += "; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ";
+ if (!it2.compositeRule && $breakOnError) {
+ if (it2.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 (it2.opts.allErrors) {
+ out += " } ";
+ }
+ } else {
+ if ($breakOnError) {
+ out += " if (true) { ";
+ }
+ }
+ return out;
+ }, "generate_anyOf");
+ }
+});
+
+// ../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/comment.js
+var require_comment = __commonJS({
+ "../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/comment.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ module2.exports = /* @__PURE__ */ __name(function generate_comment(it2, $keyword, $ruleType) {
+ var out = " ";
+ var $schema = it2.schema[$keyword];
+ var $errSchemaPath = it2.errSchemaPath + "/" + $keyword;
+ var $breakOnError = !it2.opts.allErrors;
+ var $comment = it2.util.toQuotedString($schema);
+ if (it2.opts.$comment === true) {
+ out += " console.log(" + $comment + ");";
+ } else if (typeof it2.opts.$comment == "function") {
+ out += " self._opts.$comment(" + $comment + ", " + it2.util.toQuotedString($errSchemaPath) + ", validate.root.schema);";
+ }
+ return out;
+ }, "generate_comment");
+ }
+});
+
+// ../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/const.js
+var require_const = __commonJS({
+ "../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/const.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ module2.exports = /* @__PURE__ */ __name(function generate_const(it2, $keyword, $ruleType) {
+ var out = " ";
+ var $lvl = it2.level;
+ var $dataLvl = it2.dataLevel;
+ var $schema = it2.schema[$keyword];
+ var $schemaPath = it2.schemaPath + it2.util.getProperty($keyword);
+ var $errSchemaPath = it2.errSchemaPath + "/" + $keyword;
+ var $breakOnError = !it2.opts.allErrors;
+ var $data = "data" + ($dataLvl || "");
+ var $valid = "valid" + $lvl;
+ var $isData = it2.opts.$data && $schema && $schema.$data, $schemaValue;
+ if ($isData) {
+ out += " var schema" + $lvl + " = " + it2.util.getData($schema.$data, $dataLvl, it2.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 (it2.createErrors !== false) {
+ out += " { keyword: 'const' , dataPath: (dataPath || '') + " + it2.errorPath + " , schemaPath: " + it2.util.toQuotedString($errSchemaPath) + " , params: { allowedValue: schema" + $lvl + " } ";
+ if (it2.opts.messages !== false) {
+ out += " , message: 'should be equal to constant' ";
+ }
+ if (it2.opts.verbose) {
+ out += " , schema: validate.schema" + $schemaPath + " , parentSchema: validate.schema" + it2.schemaPath + " , data: " + $data + " ";
+ }
+ out += " } ";
+ } else {
+ out += " {} ";
+ }
+ var __err = out;
+ out = $$outStack.pop();
+ if (!it2.compositeRule && $breakOnError) {
+ if (it2.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;
+ }, "generate_const");
+ }
+});
+
+// ../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/contains.js
+var require_contains = __commonJS({
+ "../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/contains.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ module2.exports = /* @__PURE__ */ __name(function generate_contains(it2, $keyword, $ruleType) {
+ var out = " ";
+ var $lvl = it2.level;
+ var $dataLvl = it2.dataLevel;
+ var $schema = it2.schema[$keyword];
+ var $schemaPath = it2.schemaPath + it2.util.getProperty($keyword);
+ var $errSchemaPath = it2.errSchemaPath + "/" + $keyword;
+ var $breakOnError = !it2.opts.allErrors;
+ var $data = "data" + ($dataLvl || "");
+ var $valid = "valid" + $lvl;
+ var $errs = "errs__" + $lvl;
+ var $it = it2.util.copy(it2);
+ var $closingBraces = "";
+ $it.level++;
+ var $nextValid = "valid" + $it.level;
+ var $idx = "i" + $lvl, $dataNxt = $it.dataLevel = it2.dataLevel + 1, $nextData = "data" + $dataNxt, $currentBaseId = it2.baseId, $nonEmptySchema = it2.opts.strictKeywords ? typeof $schema == "object" && Object.keys($schema).length > 0 || $schema === false : it2.util.schemaHasRules($schema, it2.RULES.all);
+ out += "var " + $errs + " = errors;var " + $valid + ";";
+ if ($nonEmptySchema) {
+ var $wasComposite = it2.compositeRule;
+ it2.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 = it2.util.getPathExpr(it2.errorPath, $idx, it2.opts.jsonPointers, true);
+ var $passData = $data + "[" + $idx + "]";
+ $it.dataPathArr[$dataNxt] = $idx;
+ var $code = it2.validate($it);
+ $it.baseId = $currentBaseId;
+ if (it2.util.varOccurences($code, $nextData) < 2) {
+ out += " " + it2.util.varReplace($code, $nextData, $passData) + " ";
+ } else {
+ out += " var " + $nextData + " = " + $passData + "; " + $code + " ";
+ }
+ out += " if (" + $nextValid + ") break; } ";
+ it2.compositeRule = $it.compositeRule = $wasComposite;
+ out += " " + $closingBraces + " if (!" + $nextValid + ") {";
+ } else {
+ out += " if (" + $data + ".length == 0) {";
+ }
+ var $$outStack = $$outStack || [];
+ $$outStack.push(out);
+ out = "";
+ if (it2.createErrors !== false) {
+ out += " { keyword: 'contains' , dataPath: (dataPath || '') + " + it2.errorPath + " , schemaPath: " + it2.util.toQuotedString($errSchemaPath) + " , params: {} ";
+ if (it2.opts.messages !== false) {
+ out += " , message: 'should contain a valid item' ";
+ }
+ if (it2.opts.verbose) {
+ out += " , schema: validate.schema" + $schemaPath + " , parentSchema: validate.schema" + it2.schemaPath + " , data: " + $data + " ";
+ }
+ out += " } ";
+ } else {
+ out += " {} ";
+ }
+ var __err = out;
+ out = $$outStack.pop();
+ if (!it2.compositeRule && $breakOnError) {
+ if (it2.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 (it2.opts.allErrors) {
+ out += " } ";
+ }
+ return out;
+ }, "generate_contains");
+ }
+});
+
+// ../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/dependencies.js
+var require_dependencies = __commonJS({
+ "../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/dependencies.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ module2.exports = /* @__PURE__ */ __name(function generate_dependencies(it2, $keyword, $ruleType) {
+ var out = " ";
+ var $lvl = it2.level;
+ var $dataLvl = it2.dataLevel;
+ var $schema = it2.schema[$keyword];
+ var $schemaPath = it2.schemaPath + it2.util.getProperty($keyword);
+ var $errSchemaPath = it2.errSchemaPath + "/" + $keyword;
+ var $breakOnError = !it2.opts.allErrors;
+ var $data = "data" + ($dataLvl || "");
+ var $errs = "errs__" + $lvl;
+ var $it = it2.util.copy(it2);
+ var $closingBraces = "";
+ $it.level++;
+ var $nextValid = "valid" + $it.level;
+ var $schemaDeps = {}, $propertyDeps = {}, $ownProperties = it2.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 = it2.errorPath;
+ out += "var missing" + $lvl + ";";
+ for (var $property in $propertyDeps) {
+ $deps = $propertyDeps[$property];
+ if ($deps.length) {
+ out += " if ( " + $data + it2.util.getProperty($property) + " !== undefined ";
+ if ($ownProperties) {
+ out += " && Object.prototype.hasOwnProperty.call(" + $data + ", '" + it2.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 = it2.util.getProperty($propertyKey), $useData = $data + $prop;
+ out += " ( ( " + $useData + " === undefined ";
+ if ($ownProperties) {
+ out += " || ! Object.prototype.hasOwnProperty.call(" + $data + ", '" + it2.util.escapeQuotes($propertyKey) + "') ";
+ }
+ out += ") && (missing" + $lvl + " = " + it2.util.toQuotedString(it2.opts.jsonPointers ? $propertyKey : $prop) + ") ) ";
+ }
+ }
+ out += ")) { ";
+ var $propertyPath = "missing" + $lvl, $missingProperty = "' + " + $propertyPath + " + '";
+ if (it2.opts._errorDataPathProperty) {
+ it2.errorPath = it2.opts.jsonPointers ? it2.util.getPathExpr($currentErrorPath, $propertyPath, true) : $currentErrorPath + " + " + $propertyPath;
+ }
+ var $$outStack = $$outStack || [];
+ $$outStack.push(out);
+ out = "";
+ if (it2.createErrors !== false) {
+ out += " { keyword: 'dependencies' , dataPath: (dataPath || '') + " + it2.errorPath + " , schemaPath: " + it2.util.toQuotedString($errSchemaPath) + " , params: { property: '" + it2.util.escapeQuotes($property) + "', missingProperty: '" + $missingProperty + "', depsCount: " + $deps.length + ", deps: '" + it2.util.escapeQuotes($deps.length == 1 ? $deps[0] : $deps.join(", ")) + "' } ";
+ if (it2.opts.messages !== false) {
+ out += " , message: 'should have ";
+ if ($deps.length == 1) {
+ out += "property " + it2.util.escapeQuotes($deps[0]);
+ } else {
+ out += "properties " + it2.util.escapeQuotes($deps.join(", "));
+ }
+ out += " when property " + it2.util.escapeQuotes($property) + " is present' ";
+ }
+ if (it2.opts.verbose) {
+ out += " , schema: validate.schema" + $schemaPath + " , parentSchema: validate.schema" + it2.schemaPath + " , data: " + $data + " ";
+ }
+ out += " } ";
+ } else {
+ out += " {} ";
+ }
+ var __err = out;
+ out = $$outStack.pop();
+ if (!it2.compositeRule && $breakOnError) {
+ if (it2.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 = it2.util.getProperty($propertyKey), $missingProperty = it2.util.escapeQuotes($propertyKey), $useData = $data + $prop;
+ if (it2.opts._errorDataPathProperty) {
+ it2.errorPath = it2.util.getPath($currentErrorPath, $propertyKey, it2.opts.jsonPointers);
+ }
+ out += " if ( " + $useData + " === undefined ";
+ if ($ownProperties) {
+ out += " || ! Object.prototype.hasOwnProperty.call(" + $data + ", '" + it2.util.escapeQuotes($propertyKey) + "') ";
+ }
+ out += ") { var err = ";
+ if (it2.createErrors !== false) {
+ out += " { keyword: 'dependencies' , dataPath: (dataPath || '') + " + it2.errorPath + " , schemaPath: " + it2.util.toQuotedString($errSchemaPath) + " , params: { property: '" + it2.util.escapeQuotes($property) + "', missingProperty: '" + $missingProperty + "', depsCount: " + $deps.length + ", deps: '" + it2.util.escapeQuotes($deps.length == 1 ? $deps[0] : $deps.join(", ")) + "' } ";
+ if (it2.opts.messages !== false) {
+ out += " , message: 'should have ";
+ if ($deps.length == 1) {
+ out += "property " + it2.util.escapeQuotes($deps[0]);
+ } else {
+ out += "properties " + it2.util.escapeQuotes($deps.join(", "));
+ }
+ out += " when property " + it2.util.escapeQuotes($property) + " is present' ";
+ }
+ if (it2.opts.verbose) {
+ out += " , schema: validate.schema" + $schemaPath + " , parentSchema: validate.schema" + it2.schemaPath + " , data: " + $data + " ";
+ }
+ out += " } ";
+ } else {
+ out += " {} ";
+ }
+ out += "; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; } ";
+ }
+ }
+ }
+ out += " } ";
+ if ($breakOnError) {
+ $closingBraces += "}";
+ out += " else { ";
+ }
+ }
+ }
+ it2.errorPath = $currentErrorPath;
+ var $currentBaseId = $it.baseId;
+ for (var $property in $schemaDeps) {
+ var $sch = $schemaDeps[$property];
+ if (it2.opts.strictKeywords ? typeof $sch == "object" && Object.keys($sch).length > 0 || $sch === false : it2.util.schemaHasRules($sch, it2.RULES.all)) {
+ out += " " + $nextValid + " = true; if ( " + $data + it2.util.getProperty($property) + " !== undefined ";
+ if ($ownProperties) {
+ out += " && Object.prototype.hasOwnProperty.call(" + $data + ", '" + it2.util.escapeQuotes($property) + "') ";
+ }
+ out += ") { ";
+ $it.schema = $sch;
+ $it.schemaPath = $schemaPath + it2.util.getProperty($property);
+ $it.errSchemaPath = $errSchemaPath + "/" + it2.util.escapeFragment($property);
+ out += " " + it2.validate($it) + " ";
+ $it.baseId = $currentBaseId;
+ out += " } ";
+ if ($breakOnError) {
+ out += " if (" + $nextValid + ") { ";
+ $closingBraces += "}";
+ }
+ }
+ }
+ if ($breakOnError) {
+ out += " " + $closingBraces + " if (" + $errs + " == errors) {";
+ }
+ return out;
+ }, "generate_dependencies");
+ }
+});
+
+// ../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/enum.js
+var require_enum = __commonJS({
+ "../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/enum.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ module2.exports = /* @__PURE__ */ __name(function generate_enum(it2, $keyword, $ruleType) {
+ var out = " ";
+ var $lvl = it2.level;
+ var $dataLvl = it2.dataLevel;
+ var $schema = it2.schema[$keyword];
+ var $schemaPath = it2.schemaPath + it2.util.getProperty($keyword);
+ var $errSchemaPath = it2.errSchemaPath + "/" + $keyword;
+ var $breakOnError = !it2.opts.allErrors;
+ var $data = "data" + ($dataLvl || "");
+ var $valid = "valid" + $lvl;
+ var $isData = it2.opts.$data && $schema && $schema.$data, $schemaValue;
+ if ($isData) {
+ out += " var schema" + $lvl + " = " + it2.util.getData($schema.$data, $dataLvl, it2.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 (it2.createErrors !== false) {
+ out += " { keyword: 'enum' , dataPath: (dataPath || '') + " + it2.errorPath + " , schemaPath: " + it2.util.toQuotedString($errSchemaPath) + " , params: { allowedValues: schema" + $lvl + " } ";
+ if (it2.opts.messages !== false) {
+ out += " , message: 'should be equal to one of the allowed values' ";
+ }
+ if (it2.opts.verbose) {
+ out += " , schema: validate.schema" + $schemaPath + " , parentSchema: validate.schema" + it2.schemaPath + " , data: " + $data + " ";
+ }
+ out += " } ";
+ } else {
+ out += " {} ";
+ }
+ var __err = out;
+ out = $$outStack.pop();
+ if (!it2.compositeRule && $breakOnError) {
+ if (it2.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;
+ }, "generate_enum");
+ }
+});
+
+// ../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/format.js
+var require_format = __commonJS({
+ "../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/format.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ module2.exports = /* @__PURE__ */ __name(function generate_format(it2, $keyword, $ruleType) {
+ var out = " ";
+ var $lvl = it2.level;
+ var $dataLvl = it2.dataLevel;
+ var $schema = it2.schema[$keyword];
+ var $schemaPath = it2.schemaPath + it2.util.getProperty($keyword);
+ var $errSchemaPath = it2.errSchemaPath + "/" + $keyword;
+ var $breakOnError = !it2.opts.allErrors;
+ var $data = "data" + ($dataLvl || "");
+ if (it2.opts.format === false) {
+ if ($breakOnError) {
+ out += " if (true) { ";
+ }
+ return out;
+ }
+ var $isData = it2.opts.$data && $schema && $schema.$data, $schemaValue;
+ if ($isData) {
+ out += " var schema" + $lvl + " = " + it2.util.getData($schema.$data, $dataLvl, it2.dataPathArr) + "; ";
+ $schemaValue = "schema" + $lvl;
+ } else {
+ $schemaValue = $schema;
+ }
+ var $unknownFormats = it2.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 (it2.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 (it2.async) {
+ out += " (async" + $lvl + " ? await " + $format + "(" + $data + ") : " + $format + "(" + $data + ")) ";
+ } else {
+ out += " " + $format + "(" + $data + ") ";
+ }
+ out += " : " + $format + ".test(" + $data + "))))) {";
+ } else {
+ var $format = it2.formats[$schema];
+ if (!$format) {
+ if ($unknownFormats == "ignore") {
+ it2.logger.warn('unknown format "' + $schema + '" ignored in schema at path "' + it2.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 "' + it2.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 (!it2.async)
+ throw new Error("async format in sync schema");
+ var $formatRef = "formats" + it2.util.getProperty($schema) + ".validate";
+ out += " if (!(await " + $formatRef + "(" + $data + "))) { ";
+ } else {
+ out += " if (! ";
+ var $formatRef = "formats" + it2.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 (it2.createErrors !== false) {
+ out += " { keyword: 'format' , dataPath: (dataPath || '') + " + it2.errorPath + " , schemaPath: " + it2.util.toQuotedString($errSchemaPath) + " , params: { format: ";
+ if ($isData) {
+ out += "" + $schemaValue;
+ } else {
+ out += "" + it2.util.toQuotedString($schema);
+ }
+ out += " } ";
+ if (it2.opts.messages !== false) {
+ out += ` , message: 'should match format "`;
+ if ($isData) {
+ out += "' + " + $schemaValue + " + '";
+ } else {
+ out += "" + it2.util.escapeQuotes($schema);
+ }
+ out += `"' `;
+ }
+ if (it2.opts.verbose) {
+ out += " , schema: ";
+ if ($isData) {
+ out += "validate.schema" + $schemaPath;
+ } else {
+ out += "" + it2.util.toQuotedString($schema);
+ }
+ out += " , parentSchema: validate.schema" + it2.schemaPath + " , data: " + $data + " ";
+ }
+ out += " } ";
+ } else {
+ out += " {} ";
+ }
+ var __err = out;
+ out = $$outStack.pop();
+ if (!it2.compositeRule && $breakOnError) {
+ if (it2.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;
+ }, "generate_format");
+ }
+});
+
+// ../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/if.js
+var require_if = __commonJS({
+ "../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/if.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ module2.exports = /* @__PURE__ */ __name(function generate_if(it2, $keyword, $ruleType) {
+ var out = " ";
+ var $lvl = it2.level;
+ var $dataLvl = it2.dataLevel;
+ var $schema = it2.schema[$keyword];
+ var $schemaPath = it2.schemaPath + it2.util.getProperty($keyword);
+ var $errSchemaPath = it2.errSchemaPath + "/" + $keyword;
+ var $breakOnError = !it2.opts.allErrors;
+ var $data = "data" + ($dataLvl || "");
+ var $valid = "valid" + $lvl;
+ var $errs = "errs__" + $lvl;
+ var $it = it2.util.copy(it2);
+ $it.level++;
+ var $nextValid = "valid" + $it.level;
+ var $thenSch = it2.schema["then"], $elseSch = it2.schema["else"], $thenPresent = $thenSch !== void 0 && (it2.opts.strictKeywords ? typeof $thenSch == "object" && Object.keys($thenSch).length > 0 || $thenSch === false : it2.util.schemaHasRules($thenSch, it2.RULES.all)), $elsePresent = $elseSch !== void 0 && (it2.opts.strictKeywords ? typeof $elseSch == "object" && Object.keys($elseSch).length > 0 || $elseSch === false : it2.util.schemaHasRules($elseSch, it2.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 = it2.compositeRule;
+ it2.compositeRule = $it.compositeRule = true;
+ out += " " + it2.validate($it) + " ";
+ $it.baseId = $currentBaseId;
+ $it.createErrors = true;
+ out += " errors = " + $errs + "; if (vErrors !== null) { if (" + $errs + ") vErrors.length = " + $errs + "; else vErrors = null; } ";
+ it2.compositeRule = $it.compositeRule = $wasComposite;
+ if ($thenPresent) {
+ out += " if (" + $nextValid + ") { ";
+ $it.schema = it2.schema["then"];
+ $it.schemaPath = it2.schemaPath + ".then";
+ $it.errSchemaPath = it2.errSchemaPath + "/then";
+ out += " " + it2.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 = it2.schema["else"];
+ $it.schemaPath = it2.schemaPath + ".else";
+ $it.errSchemaPath = it2.errSchemaPath + "/else";
+ out += " " + it2.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 (it2.createErrors !== false) {
+ out += " { keyword: 'if' , dataPath: (dataPath || '') + " + it2.errorPath + " , schemaPath: " + it2.util.toQuotedString($errSchemaPath) + " , params: { failingKeyword: " + $ifClause + " } ";
+ if (it2.opts.messages !== false) {
+ out += ` , message: 'should match "' + ` + $ifClause + ` + '" schema' `;
+ }
+ if (it2.opts.verbose) {
+ out += " , schema: validate.schema" + $schemaPath + " , parentSchema: validate.schema" + it2.schemaPath + " , data: " + $data + " ";
+ }
+ out += " } ";
+ } else {
+ out += " {} ";
+ }
+ out += "; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ";
+ if (!it2.compositeRule && $breakOnError) {
+ if (it2.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;
+ }, "generate_if");
+ }
+});
+
+// ../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/items.js
+var require_items = __commonJS({
+ "../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/items.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ module2.exports = /* @__PURE__ */ __name(function generate_items(it2, $keyword, $ruleType) {
+ var out = " ";
+ var $lvl = it2.level;
+ var $dataLvl = it2.dataLevel;
+ var $schema = it2.schema[$keyword];
+ var $schemaPath = it2.schemaPath + it2.util.getProperty($keyword);
+ var $errSchemaPath = it2.errSchemaPath + "/" + $keyword;
+ var $breakOnError = !it2.opts.allErrors;
+ var $data = "data" + ($dataLvl || "");
+ var $valid = "valid" + $lvl;
+ var $errs = "errs__" + $lvl;
+ var $it = it2.util.copy(it2);
+ var $closingBraces = "";
+ $it.level++;
+ var $nextValid = "valid" + $it.level;
+ var $idx = "i" + $lvl, $dataNxt = $it.dataLevel = it2.dataLevel + 1, $nextData = "data" + $dataNxt, $currentBaseId = it2.baseId;
+ out += "var " + $errs + " = errors;var " + $valid + ";";
+ if (Array.isArray($schema)) {
+ var $additionalItems = it2.schema.additionalItems;
+ if ($additionalItems === false) {
+ out += " " + $valid + " = " + $data + ".length <= " + $schema.length + "; ";
+ var $currErrSchemaPath = $errSchemaPath;
+ $errSchemaPath = it2.errSchemaPath + "/additionalItems";
+ out += " if (!" + $valid + ") { ";
+ var $$outStack = $$outStack || [];
+ $$outStack.push(out);
+ out = "";
+ if (it2.createErrors !== false) {
+ out += " { keyword: 'additionalItems' , dataPath: (dataPath || '') + " + it2.errorPath + " , schemaPath: " + it2.util.toQuotedString($errSchemaPath) + " , params: { limit: " + $schema.length + " } ";
+ if (it2.opts.messages !== false) {
+ out += " , message: 'should NOT have more than " + $schema.length + " items' ";
+ }
+ if (it2.opts.verbose) {
+ out += " , schema: false , parentSchema: validate.schema" + it2.schemaPath + " , data: " + $data + " ";
+ }
+ out += " } ";
+ } else {
+ out += " {} ";
+ }
+ var __err = out;
+ out = $$outStack.pop();
+ if (!it2.compositeRule && $breakOnError) {
+ if (it2.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 (it2.opts.strictKeywords ? typeof $sch == "object" && Object.keys($sch).length > 0 || $sch === false : it2.util.schemaHasRules($sch, it2.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 = it2.util.getPathExpr(it2.errorPath, $i, it2.opts.jsonPointers, true);
+ $it.dataPathArr[$dataNxt] = $i;
+ var $code = it2.validate($it);
+ $it.baseId = $currentBaseId;
+ if (it2.util.varOccurences($code, $nextData) < 2) {
+ out += " " + it2.util.varReplace($code, $nextData, $passData) + " ";
+ } else {
+ out += " var " + $nextData + " = " + $passData + "; " + $code + " ";
+ }
+ out += " } ";
+ if ($breakOnError) {
+ out += " if (" + $nextValid + ") { ";
+ $closingBraces += "}";
+ }
+ }
+ }
+ }
+ if (typeof $additionalItems == "object" && (it2.opts.strictKeywords ? typeof $additionalItems == "object" && Object.keys($additionalItems).length > 0 || $additionalItems === false : it2.util.schemaHasRules($additionalItems, it2.RULES.all))) {
+ $it.schema = $additionalItems;
+ $it.schemaPath = it2.schemaPath + ".additionalItems";
+ $it.errSchemaPath = it2.errSchemaPath + "/additionalItems";
+ out += " " + $nextValid + " = true; if (" + $data + ".length > " + $schema.length + ") { for (var " + $idx + " = " + $schema.length + "; " + $idx + " < " + $data + ".length; " + $idx + "++) { ";
+ $it.errorPath = it2.util.getPathExpr(it2.errorPath, $idx, it2.opts.jsonPointers, true);
+ var $passData = $data + "[" + $idx + "]";
+ $it.dataPathArr[$dataNxt] = $idx;
+ var $code = it2.validate($it);
+ $it.baseId = $currentBaseId;
+ if (it2.util.varOccurences($code, $nextData) < 2) {
+ out += " " + it2.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 (it2.opts.strictKeywords ? typeof $schema == "object" && Object.keys($schema).length > 0 || $schema === false : it2.util.schemaHasRules($schema, it2.RULES.all)) {
+ $it.schema = $schema;
+ $it.schemaPath = $schemaPath;
+ $it.errSchemaPath = $errSchemaPath;
+ out += " for (var " + $idx + " = 0; " + $idx + " < " + $data + ".length; " + $idx + "++) { ";
+ $it.errorPath = it2.util.getPathExpr(it2.errorPath, $idx, it2.opts.jsonPointers, true);
+ var $passData = $data + "[" + $idx + "]";
+ $it.dataPathArr[$dataNxt] = $idx;
+ var $code = it2.validate($it);
+ $it.baseId = $currentBaseId;
+ if (it2.util.varOccurences($code, $nextData) < 2) {
+ out += " " + it2.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;
+ }, "generate_items");
+ }
+});
+
+// ../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/_limit.js
+var require_limit = __commonJS({
+ "../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/_limit.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ module2.exports = /* @__PURE__ */ __name(function generate__limit(it2, $keyword, $ruleType) {
+ var out = " ";
+ var $lvl = it2.level;
+ var $dataLvl = it2.dataLevel;
+ var $schema = it2.schema[$keyword];
+ var $schemaPath = it2.schemaPath + it2.util.getProperty($keyword);
+ var $errSchemaPath = it2.errSchemaPath + "/" + $keyword;
+ var $breakOnError = !it2.opts.allErrors;
+ var $errorKeyword;
+ var $data = "data" + ($dataLvl || "");
+ var $isData = it2.opts.$data && $schema && $schema.$data, $schemaValue;
+ if ($isData) {
+ out += " var schema" + $lvl + " = " + it2.util.getData($schema.$data, $dataLvl, it2.dataPathArr) + "; ";
+ $schemaValue = "schema" + $lvl;
+ } else {
+ $schemaValue = $schema;
+ }
+ var $isMax = $keyword == "maximum", $exclusiveKeyword = $isMax ? "exclusiveMaximum" : "exclusiveMinimum", $schemaExcl = it2.schema[$exclusiveKeyword], $isDataExcl = it2.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 = it2.util.getData($schemaExcl.$data, $dataLvl, it2.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 (it2.createErrors !== false) {
+ out += " { keyword: '" + ($errorKeyword || "_exclusiveLimit") + "' , dataPath: (dataPath || '') + " + it2.errorPath + " , schemaPath: " + it2.util.toQuotedString($errSchemaPath) + " , params: {} ";
+ if (it2.opts.messages !== false) {
+ out += " , message: '" + $exclusiveKeyword + " should be boolean' ";
+ }
+ if (it2.opts.verbose) {
+ out += " , schema: validate.schema" + $schemaPath + " , parentSchema: validate.schema" + it2.schemaPath + " , data: " + $data + " ";
+ }
+ out += " } ";
+ } else {
+ out += " {} ";
+ }
+ var __err = out;
+ out = $$outStack.pop();
+ if (!it2.compositeRule && $breakOnError) {
+ if (it2.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 = it2.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 = it2.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 = it2.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 (it2.createErrors !== false) {
+ out += " { keyword: '" + ($errorKeyword || "_limit") + "' , dataPath: (dataPath || '') + " + it2.errorPath + " , schemaPath: " + it2.util.toQuotedString($errSchemaPath) + " , params: { comparison: " + $opExpr + ", limit: " + $schemaValue + ", exclusive: " + $exclusive + " } ";
+ if (it2.opts.messages !== false) {
+ out += " , message: 'should be " + $opStr + " ";
+ if ($isData) {
+ out += "' + " + $schemaValue;
+ } else {
+ out += "" + $schemaValue + "'";
+ }
+ }
+ if (it2.opts.verbose) {
+ out += " , schema: ";
+ if ($isData) {
+ out += "validate.schema" + $schemaPath;
+ } else {
+ out += "" + $schema;
+ }
+ out += " , parentSchema: validate.schema" + it2.schemaPath + " , data: " + $data + " ";
+ }
+ out += " } ";
+ } else {
+ out += " {} ";
+ }
+ var __err = out;
+ out = $$outStack.pop();
+ if (!it2.compositeRule && $breakOnError) {
+ if (it2.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;
+ }, "generate__limit");
+ }
+});
+
+// ../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/_limitItems.js
+var require_limitItems = __commonJS({
+ "../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/_limitItems.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ module2.exports = /* @__PURE__ */ __name(function generate__limitItems(it2, $keyword, $ruleType) {
+ var out = " ";
+ var $lvl = it2.level;
+ var $dataLvl = it2.dataLevel;
+ var $schema = it2.schema[$keyword];
+ var $schemaPath = it2.schemaPath + it2.util.getProperty($keyword);
+ var $errSchemaPath = it2.errSchemaPath + "/" + $keyword;
+ var $breakOnError = !it2.opts.allErrors;
+ var $errorKeyword;
+ var $data = "data" + ($dataLvl || "");
+ var $isData = it2.opts.$data && $schema && $schema.$data, $schemaValue;
+ if ($isData) {
+ out += " var schema" + $lvl + " = " + it2.util.getData($schema.$data, $dataLvl, it2.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 (it2.createErrors !== false) {
+ out += " { keyword: '" + ($errorKeyword || "_limitItems") + "' , dataPath: (dataPath || '') + " + it2.errorPath + " , schemaPath: " + it2.util.toQuotedString($errSchemaPath) + " , params: { limit: " + $schemaValue + " } ";
+ if (it2.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 (it2.opts.verbose) {
+ out += " , schema: ";
+ if ($isData) {
+ out += "validate.schema" + $schemaPath;
+ } else {
+ out += "" + $schema;
+ }
+ out += " , parentSchema: validate.schema" + it2.schemaPath + " , data: " + $data + " ";
+ }
+ out += " } ";
+ } else {
+ out += " {} ";
+ }
+ var __err = out;
+ out = $$outStack.pop();
+ if (!it2.compositeRule && $breakOnError) {
+ if (it2.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;
+ }, "generate__limitItems");
+ }
+});
+
+// ../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/_limitLength.js
+var require_limitLength = __commonJS({
+ "../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/_limitLength.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ module2.exports = /* @__PURE__ */ __name(function generate__limitLength(it2, $keyword, $ruleType) {
+ var out = " ";
+ var $lvl = it2.level;
+ var $dataLvl = it2.dataLevel;
+ var $schema = it2.schema[$keyword];
+ var $schemaPath = it2.schemaPath + it2.util.getProperty($keyword);
+ var $errSchemaPath = it2.errSchemaPath + "/" + $keyword;
+ var $breakOnError = !it2.opts.allErrors;
+ var $errorKeyword;
+ var $data = "data" + ($dataLvl || "");
+ var $isData = it2.opts.$data && $schema && $schema.$data, $schemaValue;
+ if ($isData) {
+ out += " var schema" + $lvl + " = " + it2.util.getData($schema.$data, $dataLvl, it2.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 (it2.opts.unicode === false) {
+ out += " " + $data + ".length ";
+ } else {
+ out += " ucs2length(" + $data + ") ";
+ }
+ out += " " + $op + " " + $schemaValue + ") { ";
+ var $errorKeyword = $keyword;
+ var $$outStack = $$outStack || [];
+ $$outStack.push(out);
+ out = "";
+ if (it2.createErrors !== false) {
+ out += " { keyword: '" + ($errorKeyword || "_limitLength") + "' , dataPath: (dataPath || '') + " + it2.errorPath + " , schemaPath: " + it2.util.toQuotedString($errSchemaPath) + " , params: { limit: " + $schemaValue + " } ";
+ if (it2.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 (it2.opts.verbose) {
+ out += " , schema: ";
+ if ($isData) {
+ out += "validate.schema" + $schemaPath;
+ } else {
+ out += "" + $schema;
+ }
+ out += " , parentSchema: validate.schema" + it2.schemaPath + " , data: " + $data + " ";
+ }
+ out += " } ";
+ } else {
+ out += " {} ";
+ }
+ var __err = out;
+ out = $$outStack.pop();
+ if (!it2.compositeRule && $breakOnError) {
+ if (it2.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;
+ }, "generate__limitLength");
+ }
+});
+
+// ../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/_limitProperties.js
+var require_limitProperties = __commonJS({
+ "../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/_limitProperties.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ module2.exports = /* @__PURE__ */ __name(function generate__limitProperties(it2, $keyword, $ruleType) {
+ var out = " ";
+ var $lvl = it2.level;
+ var $dataLvl = it2.dataLevel;
+ var $schema = it2.schema[$keyword];
+ var $schemaPath = it2.schemaPath + it2.util.getProperty($keyword);
+ var $errSchemaPath = it2.errSchemaPath + "/" + $keyword;
+ var $breakOnError = !it2.opts.allErrors;
+ var $errorKeyword;
+ var $data = "data" + ($dataLvl || "");
+ var $isData = it2.opts.$data && $schema && $schema.$data, $schemaValue;
+ if ($isData) {
+ out += " var schema" + $lvl + " = " + it2.util.getData($schema.$data, $dataLvl, it2.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 (it2.createErrors !== false) {
+ out += " { keyword: '" + ($errorKeyword || "_limitProperties") + "' , dataPath: (dataPath || '') + " + it2.errorPath + " , schemaPath: " + it2.util.toQuotedString($errSchemaPath) + " , params: { limit: " + $schemaValue + " } ";
+ if (it2.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 (it2.opts.verbose) {
+ out += " , schema: ";
+ if ($isData) {
+ out += "validate.schema" + $schemaPath;
+ } else {
+ out += "" + $schema;
+ }
+ out += " , parentSchema: validate.schema" + it2.schemaPath + " , data: " + $data + " ";
+ }
+ out += " } ";
+ } else {
+ out += " {} ";
+ }
+ var __err = out;
+ out = $$outStack.pop();
+ if (!it2.compositeRule && $breakOnError) {
+ if (it2.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;
+ }, "generate__limitProperties");
+ }
+});
+
+// ../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/multipleOf.js
+var require_multipleOf = __commonJS({
+ "../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/multipleOf.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ module2.exports = /* @__PURE__ */ __name(function generate_multipleOf(it2, $keyword, $ruleType) {
+ var out = " ";
+ var $lvl = it2.level;
+ var $dataLvl = it2.dataLevel;
+ var $schema = it2.schema[$keyword];
+ var $schemaPath = it2.schemaPath + it2.util.getProperty($keyword);
+ var $errSchemaPath = it2.errSchemaPath + "/" + $keyword;
+ var $breakOnError = !it2.opts.allErrors;
+ var $data = "data" + ($dataLvl || "");
+ var $isData = it2.opts.$data && $schema && $schema.$data, $schemaValue;
+ if ($isData) {
+ out += " var schema" + $lvl + " = " + it2.util.getData($schema.$data, $dataLvl, it2.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 (it2.opts.multipleOfPrecision) {
+ out += " Math.abs(Math.round(division" + $lvl + ") - division" + $lvl + ") > 1e-" + it2.opts.multipleOfPrecision + " ";
+ } else {
+ out += " division" + $lvl + " !== parseInt(division" + $lvl + ") ";
+ }
+ out += " ) ";
+ if ($isData) {
+ out += " ) ";
+ }
+ out += " ) { ";
+ var $$outStack = $$outStack || [];
+ $$outStack.push(out);
+ out = "";
+ if (it2.createErrors !== false) {
+ out += " { keyword: 'multipleOf' , dataPath: (dataPath || '') + " + it2.errorPath + " , schemaPath: " + it2.util.toQuotedString($errSchemaPath) + " , params: { multipleOf: " + $schemaValue + " } ";
+ if (it2.opts.messages !== false) {
+ out += " , message: 'should be multiple of ";
+ if ($isData) {
+ out += "' + " + $schemaValue;
+ } else {
+ out += "" + $schemaValue + "'";
+ }
+ }
+ if (it2.opts.verbose) {
+ out += " , schema: ";
+ if ($isData) {
+ out += "validate.schema" + $schemaPath;
+ } else {
+ out += "" + $schema;
+ }
+ out += " , parentSchema: validate.schema" + it2.schemaPath + " , data: " + $data + " ";
+ }
+ out += " } ";
+ } else {
+ out += " {} ";
+ }
+ var __err = out;
+ out = $$outStack.pop();
+ if (!it2.compositeRule && $breakOnError) {
+ if (it2.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;
+ }, "generate_multipleOf");
+ }
+});
+
+// ../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/not.js
+var require_not = __commonJS({
+ "../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/not.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ module2.exports = /* @__PURE__ */ __name(function generate_not(it2, $keyword, $ruleType) {
+ var out = " ";
+ var $lvl = it2.level;
+ var $dataLvl = it2.dataLevel;
+ var $schema = it2.schema[$keyword];
+ var $schemaPath = it2.schemaPath + it2.util.getProperty($keyword);
+ var $errSchemaPath = it2.errSchemaPath + "/" + $keyword;
+ var $breakOnError = !it2.opts.allErrors;
+ var $data = "data" + ($dataLvl || "");
+ var $errs = "errs__" + $lvl;
+ var $it = it2.util.copy(it2);
+ $it.level++;
+ var $nextValid = "valid" + $it.level;
+ if (it2.opts.strictKeywords ? typeof $schema == "object" && Object.keys($schema).length > 0 || $schema === false : it2.util.schemaHasRules($schema, it2.RULES.all)) {
+ $it.schema = $schema;
+ $it.schemaPath = $schemaPath;
+ $it.errSchemaPath = $errSchemaPath;
+ out += " var " + $errs + " = errors; ";
+ var $wasComposite = it2.compositeRule;
+ it2.compositeRule = $it.compositeRule = true;
+ $it.createErrors = false;
+ var $allErrorsOption;
+ if ($it.opts.allErrors) {
+ $allErrorsOption = $it.opts.allErrors;
+ $it.opts.allErrors = false;
+ }
+ out += " " + it2.validate($it) + " ";
+ $it.createErrors = true;
+ if ($allErrorsOption)
+ $it.opts.allErrors = $allErrorsOption;
+ it2.compositeRule = $it.compositeRule = $wasComposite;
+ out += " if (" + $nextValid + ") { ";
+ var $$outStack = $$outStack || [];
+ $$outStack.push(out);
+ out = "";
+ if (it2.createErrors !== false) {
+ out += " { keyword: 'not' , dataPath: (dataPath || '') + " + it2.errorPath + " , schemaPath: " + it2.util.toQuotedString($errSchemaPath) + " , params: {} ";
+ if (it2.opts.messages !== false) {
+ out += " , message: 'should NOT be valid' ";
+ }
+ if (it2.opts.verbose) {
+ out += " , schema: validate.schema" + $schemaPath + " , parentSchema: validate.schema" + it2.schemaPath + " , data: " + $data + " ";
+ }
+ out += " } ";
+ } else {
+ out += " {} ";
+ }
+ var __err = out;
+ out = $$outStack.pop();
+ if (!it2.compositeRule && $breakOnError) {
+ if (it2.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 (it2.opts.allErrors) {
+ out += " } ";
+ }
+ } else {
+ out += " var err = ";
+ if (it2.createErrors !== false) {
+ out += " { keyword: 'not' , dataPath: (dataPath || '') + " + it2.errorPath + " , schemaPath: " + it2.util.toQuotedString($errSchemaPath) + " , params: {} ";
+ if (it2.opts.messages !== false) {
+ out += " , message: 'should NOT be valid' ";
+ }
+ if (it2.opts.verbose) {
+ out += " , schema: validate.schema" + $schemaPath + " , parentSchema: validate.schema" + it2.schemaPath + " , data: " + $data + " ";
+ }
+ out += " } ";
+ } else {
+ out += " {} ";
+ }
+ out += "; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ";
+ if ($breakOnError) {
+ out += " if (false) { ";
+ }
+ }
+ return out;
+ }, "generate_not");
+ }
+});
+
+// ../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/oneOf.js
+var require_oneOf = __commonJS({
+ "../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/oneOf.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ module2.exports = /* @__PURE__ */ __name(function generate_oneOf(it2, $keyword, $ruleType) {
+ var out = " ";
+ var $lvl = it2.level;
+ var $dataLvl = it2.dataLevel;
+ var $schema = it2.schema[$keyword];
+ var $schemaPath = it2.schemaPath + it2.util.getProperty($keyword);
+ var $errSchemaPath = it2.errSchemaPath + "/" + $keyword;
+ var $breakOnError = !it2.opts.allErrors;
+ var $data = "data" + ($dataLvl || "");
+ var $valid = "valid" + $lvl;
+ var $errs = "errs__" + $lvl;
+ var $it = it2.util.copy(it2);
+ 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 = it2.compositeRule;
+ it2.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 (it2.opts.strictKeywords ? typeof $sch == "object" && Object.keys($sch).length > 0 || $sch === false : it2.util.schemaHasRules($sch, it2.RULES.all)) {
+ $it.schema = $sch;
+ $it.schemaPath = $schemaPath + "[" + $i + "]";
+ $it.errSchemaPath = $errSchemaPath + "/" + $i;
+ out += " " + it2.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 + "; }";
+ }
+ }
+ it2.compositeRule = $it.compositeRule = $wasComposite;
+ out += "" + $closingBraces + "if (!" + $valid + ") { var err = ";
+ if (it2.createErrors !== false) {
+ out += " { keyword: 'oneOf' , dataPath: (dataPath || '') + " + it2.errorPath + " , schemaPath: " + it2.util.toQuotedString($errSchemaPath) + " , params: { passingSchemas: " + $passingSchemas + " } ";
+ if (it2.opts.messages !== false) {
+ out += " , message: 'should match exactly one schema in oneOf' ";
+ }
+ if (it2.opts.verbose) {
+ out += " , schema: validate.schema" + $schemaPath + " , parentSchema: validate.schema" + it2.schemaPath + " , data: " + $data + " ";
+ }
+ out += " } ";
+ } else {
+ out += " {} ";
+ }
+ out += "; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ";
+ if (!it2.compositeRule && $breakOnError) {
+ if (it2.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 (it2.opts.allErrors) {
+ out += " } ";
+ }
+ return out;
+ }, "generate_oneOf");
+ }
+});
+
+// ../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/pattern.js
+var require_pattern = __commonJS({
+ "../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/pattern.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ module2.exports = /* @__PURE__ */ __name(function generate_pattern(it2, $keyword, $ruleType) {
+ var out = " ";
+ var $lvl = it2.level;
+ var $dataLvl = it2.dataLevel;
+ var $schema = it2.schema[$keyword];
+ var $schemaPath = it2.schemaPath + it2.util.getProperty($keyword);
+ var $errSchemaPath = it2.errSchemaPath + "/" + $keyword;
+ var $breakOnError = !it2.opts.allErrors;
+ var $data = "data" + ($dataLvl || "");
+ var $isData = it2.opts.$data && $schema && $schema.$data, $schemaValue;
+ if ($isData) {
+ out += " var schema" + $lvl + " = " + it2.util.getData($schema.$data, $dataLvl, it2.dataPathArr) + "; ";
+ $schemaValue = "schema" + $lvl;
+ } else {
+ $schemaValue = $schema;
+ }
+ var $regexp = $isData ? "(new RegExp(" + $schemaValue + "))" : it2.usePattern($schema);
+ out += "if ( ";
+ if ($isData) {
+ out += " (" + $schemaValue + " !== undefined && typeof " + $schemaValue + " != 'string') || ";
+ }
+ out += " !" + $regexp + ".test(" + $data + ") ) { ";
+ var $$outStack = $$outStack || [];
+ $$outStack.push(out);
+ out = "";
+ if (it2.createErrors !== false) {
+ out += " { keyword: 'pattern' , dataPath: (dataPath || '') + " + it2.errorPath + " , schemaPath: " + it2.util.toQuotedString($errSchemaPath) + " , params: { pattern: ";
+ if ($isData) {
+ out += "" + $schemaValue;
+ } else {
+ out += "" + it2.util.toQuotedString($schema);
+ }
+ out += " } ";
+ if (it2.opts.messages !== false) {
+ out += ` , message: 'should match pattern "`;
+ if ($isData) {
+ out += "' + " + $schemaValue + " + '";
+ } else {
+ out += "" + it2.util.escapeQuotes($schema);
+ }
+ out += `"' `;
+ }
+ if (it2.opts.verbose) {
+ out += " , schema: ";
+ if ($isData) {
+ out += "validate.schema" + $schemaPath;
+ } else {
+ out += "" + it2.util.toQuotedString($schema);
+ }
+ out += " , parentSchema: validate.schema" + it2.schemaPath + " , data: " + $data + " ";
+ }
+ out += " } ";
+ } else {
+ out += " {} ";
+ }
+ var __err = out;
+ out = $$outStack.pop();
+ if (!it2.compositeRule && $breakOnError) {
+ if (it2.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;
+ }, "generate_pattern");
+ }
+});
+
+// ../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/properties.js
+var require_properties = __commonJS({
+ "../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/properties.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ module2.exports = /* @__PURE__ */ __name(function generate_properties(it2, $keyword, $ruleType) {
+ var out = " ";
+ var $lvl = it2.level;
+ var $dataLvl = it2.dataLevel;
+ var $schema = it2.schema[$keyword];
+ var $schemaPath = it2.schemaPath + it2.util.getProperty($keyword);
+ var $errSchemaPath = it2.errSchemaPath + "/" + $keyword;
+ var $breakOnError = !it2.opts.allErrors;
+ var $data = "data" + ($dataLvl || "");
+ var $errs = "errs__" + $lvl;
+ var $it = it2.util.copy(it2);
+ var $closingBraces = "";
+ $it.level++;
+ var $nextValid = "valid" + $it.level;
+ var $key = "key" + $lvl, $idx = "idx" + $lvl, $dataNxt = $it.dataLevel = it2.dataLevel + 1, $nextData = "data" + $dataNxt, $dataProperties = "dataProperties" + $lvl;
+ var $schemaKeys = Object.keys($schema || {}).filter(notProto), $pProperties = it2.schema.patternProperties || {}, $pPropertyKeys = Object.keys($pProperties).filter(notProto), $aProperties = it2.schema.additionalProperties, $someProperties = $schemaKeys.length || $pPropertyKeys.length, $noAdditional = $aProperties === false, $additionalIsSchema = typeof $aProperties == "object" && Object.keys($aProperties).length, $removeAdditional = it2.opts.removeAdditional, $checkAdditional = $noAdditional || $additionalIsSchema || $removeAdditional, $ownProperties = it2.opts.ownProperties, $currentBaseId = it2.baseId;
+ var $required = it2.schema.required;
+ if ($required && !(it2.opts.$data && $required.$data) && $required.length < it2.opts.loopRequired) {
+ var $requiredHash = it2.util.toHash($required);
+ }
+ function notProto(p) {
+ return p !== "__proto__";
+ }
+ __name(notProto, "notProto");
+ 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 + " == " + it2.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 += " || " + it2.usePattern($pProperty) + ".test(" + $key + ") ";
+ }
+ }
+ }
+ out += " ); if (isAdditional" + $lvl + ") { ";
+ }
+ if ($removeAdditional == "all") {
+ out += " delete " + $data + "[" + $key + "]; ";
+ } else {
+ var $currentErrorPath = it2.errorPath;
+ var $additionalProperty = "' + " + $key + " + '";
+ if (it2.opts._errorDataPathProperty) {
+ it2.errorPath = it2.util.getPathExpr(it2.errorPath, $key, it2.opts.jsonPointers);
+ }
+ if ($noAdditional) {
+ if ($removeAdditional) {
+ out += " delete " + $data + "[" + $key + "]; ";
+ } else {
+ out += " " + $nextValid + " = false; ";
+ var $currErrSchemaPath = $errSchemaPath;
+ $errSchemaPath = it2.errSchemaPath + "/additionalProperties";
+ var $$outStack = $$outStack || [];
+ $$outStack.push(out);
+ out = "";
+ if (it2.createErrors !== false) {
+ out += " { keyword: 'additionalProperties' , dataPath: (dataPath || '') + " + it2.errorPath + " , schemaPath: " + it2.util.toQuotedString($errSchemaPath) + " , params: { additionalProperty: '" + $additionalProperty + "' } ";
+ if (it2.opts.messages !== false) {
+ out += " , message: '";
+ if (it2.opts._errorDataPathProperty) {
+ out += "is an invalid additional property";
+ } else {
+ out += "should NOT have additional properties";
+ }
+ out += "' ";
+ }
+ if (it2.opts.verbose) {
+ out += " , schema: false , parentSchema: validate.schema" + it2.schemaPath + " , data: " + $data + " ";
+ }
+ out += " } ";
+ } else {
+ out += " {} ";
+ }
+ var __err = out;
+ out = $$outStack.pop();
+ if (!it2.compositeRule && $breakOnError) {
+ if (it2.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 = it2.compositeRule;
+ it2.compositeRule = $it.compositeRule = true;
+ $it.schema = $aProperties;
+ $it.schemaPath = it2.schemaPath + ".additionalProperties";
+ $it.errSchemaPath = it2.errSchemaPath + "/additionalProperties";
+ $it.errorPath = it2.opts._errorDataPathProperty ? it2.errorPath : it2.util.getPathExpr(it2.errorPath, $key, it2.opts.jsonPointers);
+ var $passData = $data + "[" + $key + "]";
+ $it.dataPathArr[$dataNxt] = $key;
+ var $code = it2.validate($it);
+ $it.baseId = $currentBaseId;
+ if (it2.util.varOccurences($code, $nextData) < 2) {
+ out += " " + it2.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 + "]; } ";
+ it2.compositeRule = $it.compositeRule = $wasComposite;
+ } else {
+ $it.schema = $aProperties;
+ $it.schemaPath = it2.schemaPath + ".additionalProperties";
+ $it.errSchemaPath = it2.errSchemaPath + "/additionalProperties";
+ $it.errorPath = it2.opts._errorDataPathProperty ? it2.errorPath : it2.util.getPathExpr(it2.errorPath, $key, it2.opts.jsonPointers);
+ var $passData = $data + "[" + $key + "]";
+ $it.dataPathArr[$dataNxt] = $key;
+ var $code = it2.validate($it);
+ $it.baseId = $currentBaseId;
+ if (it2.util.varOccurences($code, $nextData) < 2) {
+ out += " " + it2.util.varReplace($code, $nextData, $passData) + " ";
+ } else {
+ out += " var " + $nextData + " = " + $passData + "; " + $code + " ";
+ }
+ if ($breakOnError) {
+ out += " if (!" + $nextValid + ") break; ";
+ }
+ }
+ }
+ it2.errorPath = $currentErrorPath;
+ }
+ if ($someProperties) {
+ out += " } ";
+ }
+ out += " } ";
+ if ($breakOnError) {
+ out += " if (" + $nextValid + ") { ";
+ $closingBraces += "}";
+ }
+ }
+ var $useDefaults = it2.opts.useDefaults && !it2.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 (it2.opts.strictKeywords ? typeof $sch == "object" && Object.keys($sch).length > 0 || $sch === false : it2.util.schemaHasRules($sch, it2.RULES.all)) {
+ var $prop = it2.util.getProperty($propertyKey), $passData = $data + $prop, $hasDefault = $useDefaults && $sch.default !== void 0;
+ $it.schema = $sch;
+ $it.schemaPath = $schemaPath + $prop;
+ $it.errSchemaPath = $errSchemaPath + "/" + it2.util.escapeFragment($propertyKey);
+ $it.errorPath = it2.util.getPath(it2.errorPath, $propertyKey, it2.opts.jsonPointers);
+ $it.dataPathArr[$dataNxt] = it2.util.toQuotedString($propertyKey);
+ var $code = it2.validate($it);
+ $it.baseId = $currentBaseId;
+ if (it2.util.varOccurences($code, $nextData) < 2) {
+ $code = it2.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 + ", '" + it2.util.escapeQuotes($propertyKey) + "') ";
+ }
+ out += ") { " + $nextValid + " = false; ";
+ var $currentErrorPath = it2.errorPath, $currErrSchemaPath = $errSchemaPath, $missingProperty = it2.util.escapeQuotes($propertyKey);
+ if (it2.opts._errorDataPathProperty) {
+ it2.errorPath = it2.util.getPath($currentErrorPath, $propertyKey, it2.opts.jsonPointers);
+ }
+ $errSchemaPath = it2.errSchemaPath + "/required";
+ var $$outStack = $$outStack || [];
+ $$outStack.push(out);
+ out = "";
+ if (it2.createErrors !== false) {
+ out += " { keyword: 'required' , dataPath: (dataPath || '') + " + it2.errorPath + " , schemaPath: " + it2.util.toQuotedString($errSchemaPath) + " , params: { missingProperty: '" + $missingProperty + "' } ";
+ if (it2.opts.messages !== false) {
+ out += " , message: '";
+ if (it2.opts._errorDataPathProperty) {
+ out += "is a required property";
+ } else {
+ out += "should have required property \\'" + $missingProperty + "\\'";
+ }
+ out += "' ";
+ }
+ if (it2.opts.verbose) {
+ out += " , schema: validate.schema" + $schemaPath + " , parentSchema: validate.schema" + it2.schemaPath + " , data: " + $data + " ";
+ }
+ out += " } ";
+ } else {
+ out += " {} ";
+ }
+ var __err = out;
+ out = $$outStack.pop();
+ if (!it2.compositeRule && $breakOnError) {
+ if (it2.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;
+ it2.errorPath = $currentErrorPath;
+ out += " } else { ";
+ } else {
+ if ($breakOnError) {
+ out += " if ( " + $useData + " === undefined ";
+ if ($ownProperties) {
+ out += " || ! Object.prototype.hasOwnProperty.call(" + $data + ", '" + it2.util.escapeQuotes($propertyKey) + "') ";
+ }
+ out += ") { " + $nextValid + " = true; } else { ";
+ } else {
+ out += " if (" + $useData + " !== undefined ";
+ if ($ownProperties) {
+ out += " && Object.prototype.hasOwnProperty.call(" + $data + ", '" + it2.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 (it2.opts.strictKeywords ? typeof $sch == "object" && Object.keys($sch).length > 0 || $sch === false : it2.util.schemaHasRules($sch, it2.RULES.all)) {
+ $it.schema = $sch;
+ $it.schemaPath = it2.schemaPath + ".patternProperties" + it2.util.getProperty($pProperty);
+ $it.errSchemaPath = it2.errSchemaPath + "/patternProperties/" + it2.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 (" + it2.usePattern($pProperty) + ".test(" + $key + ")) { ";
+ $it.errorPath = it2.util.getPathExpr(it2.errorPath, $key, it2.opts.jsonPointers);
+ var $passData = $data + "[" + $key + "]";
+ $it.dataPathArr[$dataNxt] = $key;
+ var $code = it2.validate($it);
+ $it.baseId = $currentBaseId;
+ if (it2.util.varOccurences($code, $nextData) < 2) {
+ out += " " + it2.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;
+ }, "generate_properties");
+ }
+});
+
+// ../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/propertyNames.js
+var require_propertyNames = __commonJS({
+ "../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/propertyNames.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ module2.exports = /* @__PURE__ */ __name(function generate_propertyNames(it2, $keyword, $ruleType) {
+ var out = " ";
+ var $lvl = it2.level;
+ var $dataLvl = it2.dataLevel;
+ var $schema = it2.schema[$keyword];
+ var $schemaPath = it2.schemaPath + it2.util.getProperty($keyword);
+ var $errSchemaPath = it2.errSchemaPath + "/" + $keyword;
+ var $breakOnError = !it2.opts.allErrors;
+ var $data = "data" + ($dataLvl || "");
+ var $errs = "errs__" + $lvl;
+ var $it = it2.util.copy(it2);
+ var $closingBraces = "";
+ $it.level++;
+ var $nextValid = "valid" + $it.level;
+ out += "var " + $errs + " = errors;";
+ if (it2.opts.strictKeywords ? typeof $schema == "object" && Object.keys($schema).length > 0 || $schema === false : it2.util.schemaHasRules($schema, it2.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 = it2.dataLevel + 1, $nextData = "data" + $dataNxt, $dataProperties = "dataProperties" + $lvl, $ownProperties = it2.opts.ownProperties, $currentBaseId = it2.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 = it2.compositeRule;
+ it2.compositeRule = $it.compositeRule = true;
+ var $code = it2.validate($it);
+ $it.baseId = $currentBaseId;
+ if (it2.util.varOccurences($code, $nextData) < 2) {
+ out += " " + it2.util.varReplace($code, $nextData, $passData) + " ";
+ } else {
+ out += " var " + $nextData + " = " + $passData + "; " + $code + " ";
+ }
+ it2.compositeRule = $it.compositeRule = $wasComposite;
+ out += " if (!" + $nextValid + ") { for (var " + $i + "=startErrs" + $lvl + "; " + $i + " 0 || $propertySch === false : it2.util.schemaHasRules($propertySch, it2.RULES.all)))) {
+ $required[$required.length] = $property;
+ }
+ }
+ }
+ } else {
+ var $required = $schema;
+ }
+ }
+ if ($isData || $required.length) {
+ var $currentErrorPath = it2.errorPath, $loopRequired = $isData || $required.length >= it2.opts.loopRequired, $ownProperties = it2.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 (it2.opts._errorDataPathProperty) {
+ it2.errorPath = it2.util.getPathExpr($currentErrorPath, $propertyPath, it2.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 (it2.createErrors !== false) {
+ out += " { keyword: 'required' , dataPath: (dataPath || '') + " + it2.errorPath + " , schemaPath: " + it2.util.toQuotedString($errSchemaPath) + " , params: { missingProperty: '" + $missingProperty + "' } ";
+ if (it2.opts.messages !== false) {
+ out += " , message: '";
+ if (it2.opts._errorDataPathProperty) {
+ out += "is a required property";
+ } else {
+ out += "should have required property \\'" + $missingProperty + "\\'";
+ }
+ out += "' ";
+ }
+ if (it2.opts.verbose) {
+ out += " , schema: validate.schema" + $schemaPath + " , parentSchema: validate.schema" + it2.schemaPath + " , data: " + $data + " ";
+ }
+ out += " } ";
+ } else {
+ out += " {} ";
+ }
+ var __err = out;
+ out = $$outStack.pop();
+ if (!it2.compositeRule && $breakOnError) {
+ if (it2.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 = it2.util.getProperty($propertyKey), $useData = $data + $prop;
+ out += " ( ( " + $useData + " === undefined ";
+ if ($ownProperties) {
+ out += " || ! Object.prototype.hasOwnProperty.call(" + $data + ", '" + it2.util.escapeQuotes($propertyKey) + "') ";
+ }
+ out += ") && (missing" + $lvl + " = " + it2.util.toQuotedString(it2.opts.jsonPointers ? $propertyKey : $prop) + ") ) ";
+ }
+ }
+ out += ") { ";
+ var $propertyPath = "missing" + $lvl, $missingProperty = "' + " + $propertyPath + " + '";
+ if (it2.opts._errorDataPathProperty) {
+ it2.errorPath = it2.opts.jsonPointers ? it2.util.getPathExpr($currentErrorPath, $propertyPath, true) : $currentErrorPath + " + " + $propertyPath;
+ }
+ var $$outStack = $$outStack || [];
+ $$outStack.push(out);
+ out = "";
+ if (it2.createErrors !== false) {
+ out += " { keyword: 'required' , dataPath: (dataPath || '') + " + it2.errorPath + " , schemaPath: " + it2.util.toQuotedString($errSchemaPath) + " , params: { missingProperty: '" + $missingProperty + "' } ";
+ if (it2.opts.messages !== false) {
+ out += " , message: '";
+ if (it2.opts._errorDataPathProperty) {
+ out += "is a required property";
+ } else {
+ out += "should have required property \\'" + $missingProperty + "\\'";
+ }
+ out += "' ";
+ }
+ if (it2.opts.verbose) {
+ out += " , schema: validate.schema" + $schemaPath + " , parentSchema: validate.schema" + it2.schemaPath + " , data: " + $data + " ";
+ }
+ out += " } ";
+ } else {
+ out += " {} ";
+ }
+ var __err = out;
+ out = $$outStack.pop();
+ if (!it2.compositeRule && $breakOnError) {
+ if (it2.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 (it2.opts._errorDataPathProperty) {
+ it2.errorPath = it2.util.getPathExpr($currentErrorPath, $propertyPath, it2.opts.jsonPointers);
+ }
+ if ($isData) {
+ out += " if (" + $vSchema + " && !Array.isArray(" + $vSchema + ")) { var err = ";
+ if (it2.createErrors !== false) {
+ out += " { keyword: 'required' , dataPath: (dataPath || '') + " + it2.errorPath + " , schemaPath: " + it2.util.toQuotedString($errSchemaPath) + " , params: { missingProperty: '" + $missingProperty + "' } ";
+ if (it2.opts.messages !== false) {
+ out += " , message: '";
+ if (it2.opts._errorDataPathProperty) {
+ out += "is a required property";
+ } else {
+ out += "should have required property \\'" + $missingProperty + "\\'";
+ }
+ out += "' ";
+ }
+ if (it2.opts.verbose) {
+ out += " , schema: validate.schema" + $schemaPath + " , parentSchema: validate.schema" + it2.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 (it2.createErrors !== false) {
+ out += " { keyword: 'required' , dataPath: (dataPath || '') + " + it2.errorPath + " , schemaPath: " + it2.util.toQuotedString($errSchemaPath) + " , params: { missingProperty: '" + $missingProperty + "' } ";
+ if (it2.opts.messages !== false) {
+ out += " , message: '";
+ if (it2.opts._errorDataPathProperty) {
+ out += "is a required property";
+ } else {
+ out += "should have required property \\'" + $missingProperty + "\\'";
+ }
+ out += "' ";
+ }
+ if (it2.opts.verbose) {
+ out += " , schema: validate.schema" + $schemaPath + " , parentSchema: validate.schema" + it2.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 = it2.util.getProperty($propertyKey), $missingProperty = it2.util.escapeQuotes($propertyKey), $useData = $data + $prop;
+ if (it2.opts._errorDataPathProperty) {
+ it2.errorPath = it2.util.getPath($currentErrorPath, $propertyKey, it2.opts.jsonPointers);
+ }
+ out += " if ( " + $useData + " === undefined ";
+ if ($ownProperties) {
+ out += " || ! Object.prototype.hasOwnProperty.call(" + $data + ", '" + it2.util.escapeQuotes($propertyKey) + "') ";
+ }
+ out += ") { var err = ";
+ if (it2.createErrors !== false) {
+ out += " { keyword: 'required' , dataPath: (dataPath || '') + " + it2.errorPath + " , schemaPath: " + it2.util.toQuotedString($errSchemaPath) + " , params: { missingProperty: '" + $missingProperty + "' } ";
+ if (it2.opts.messages !== false) {
+ out += " , message: '";
+ if (it2.opts._errorDataPathProperty) {
+ out += "is a required property";
+ } else {
+ out += "should have required property \\'" + $missingProperty + "\\'";
+ }
+ out += "' ";
+ }
+ if (it2.opts.verbose) {
+ out += " , schema: validate.schema" + $schemaPath + " , parentSchema: validate.schema" + it2.schemaPath + " , data: " + $data + " ";
+ }
+ out += " } ";
+ } else {
+ out += " {} ";
+ }
+ out += "; if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; } ";
+ }
+ }
+ }
+ }
+ it2.errorPath = $currentErrorPath;
+ } else if ($breakOnError) {
+ out += " if (true) {";
+ }
+ return out;
+ }, "generate_required");
+ }
+});
+
+// ../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/uniqueItems.js
+var require_uniqueItems = __commonJS({
+ "../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/uniqueItems.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ module2.exports = /* @__PURE__ */ __name(function generate_uniqueItems(it2, $keyword, $ruleType) {
+ var out = " ";
+ var $lvl = it2.level;
+ var $dataLvl = it2.dataLevel;
+ var $schema = it2.schema[$keyword];
+ var $schemaPath = it2.schemaPath + it2.util.getProperty($keyword);
+ var $errSchemaPath = it2.errSchemaPath + "/" + $keyword;
+ var $breakOnError = !it2.opts.allErrors;
+ var $data = "data" + ($dataLvl || "");
+ var $valid = "valid" + $lvl;
+ var $isData = it2.opts.$data && $schema && $schema.$data, $schemaValue;
+ if ($isData) {
+ out += " var schema" + $lvl + " = " + it2.util.getData($schema.$data, $dataLvl, it2.dataPathArr) + "; ";
+ $schemaValue = "schema" + $lvl;
+ } else {
+ $schemaValue = $schema;
+ }
+ if (($schema || $isData) && it2.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 = it2.schema.items && it2.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 (" + it2.util[$method]($itemType, "item", it2.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 (it2.createErrors !== false) {
+ out += " { keyword: 'uniqueItems' , dataPath: (dataPath || '') + " + it2.errorPath + " , schemaPath: " + it2.util.toQuotedString($errSchemaPath) + " , params: { i: i, j: j } ";
+ if (it2.opts.messages !== false) {
+ out += " , message: 'should NOT have duplicate items (items ## ' + j + ' and ' + i + ' are identical)' ";
+ }
+ if (it2.opts.verbose) {
+ out += " , schema: ";
+ if ($isData) {
+ out += "validate.schema" + $schemaPath;
+ } else {
+ out += "" + $schema;
+ }
+ out += " , parentSchema: validate.schema" + it2.schemaPath + " , data: " + $data + " ";
+ }
+ out += " } ";
+ } else {
+ out += " {} ";
+ }
+ var __err = out;
+ out = $$outStack.pop();
+ if (!it2.compositeRule && $breakOnError) {
+ if (it2.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;
+ }, "generate_uniqueItems");
+ }
+});
+
+// ../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/index.js
+var require_dotjs = __commonJS({
+ "../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ 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/.pnpm/ajv@6.12.6/node_modules/ajv/lib/compile/rules.js
+var require_rules = __commonJS({
+ "../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/compile/rules.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var ruleModules = require_dotjs();
+ var toHash = require_util9().toHash;
+ module2.exports = /* @__PURE__ */ __name(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;
+ }, "rules");
+ }
+});
+
+// ../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/data.js
+var require_data = __commonJS({
+ "../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/data.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ 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/.pnpm/ajv@6.12.6/node_modules/ajv/lib/compile/async.js
+var require_async = __commonJS({
+ "../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/compile/async.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ 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();
+ }
+ __name(loadMetaSchemaOf, "loadMetaSchemaOf");
+ function _compileAsync(schemaObj) {
+ try {
+ return self2._compile(schemaObj);
+ } catch (e2) {
+ if (e2 instanceof MissingRefError)
+ return loadMissingSchema(e2);
+ throw e2;
+ }
+ function loadMissingSchema(e2) {
+ var ref = e2.missingSchema;
+ if (added(ref))
+ throw new Error("Schema " + ref + " is loaded but " + e2.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];
+ }
+ __name(removePromise, "removePromise");
+ function added(ref2) {
+ return self2._refs[ref2] || self2._schemas[ref2];
+ }
+ __name(added, "added");
+ }
+ __name(loadMissingSchema, "loadMissingSchema");
+ }
+ __name(_compileAsync, "_compileAsync");
+ }
+ __name(compileAsync, "compileAsync");
+ }
+});
+
+// ../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/custom.js
+var require_custom = __commonJS({
+ "../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/custom.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ module2.exports = /* @__PURE__ */ __name(function generate_custom(it2, $keyword, $ruleType) {
+ var out = " ";
+ var $lvl = it2.level;
+ var $dataLvl = it2.dataLevel;
+ var $schema = it2.schema[$keyword];
+ var $schemaPath = it2.schemaPath + it2.util.getProperty($keyword);
+ var $errSchemaPath = it2.errSchemaPath + "/" + $keyword;
+ var $breakOnError = !it2.opts.allErrors;
+ var $errorKeyword;
+ var $data = "data" + ($dataLvl || "");
+ var $valid = "valid" + $lvl;
+ var $errs = "errs__" + $lvl;
+ var $isData = it2.opts.$data && $schema && $schema.$data, $schemaValue;
+ if ($isData) {
+ out += " var schema" + $lvl + " = " + it2.util.getData($schema.$data, $dataLvl, it2.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 = it2.useCustomRule($rule, $schema, it2.schema, it2);
+ 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 && !it2.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 = it2.util.copy(it2);
+ var $closingBraces = "";
+ $it.level++;
+ var $nextValid = "valid" + $it.level;
+ $it.schema = $ruleValidate.validate;
+ $it.schemaPath = "";
+ var $wasComposite = it2.compositeRule;
+ it2.compositeRule = $it.compositeRule = true;
+ var $code = it2.validate($it).replace(/validate\.schema/g, $validateCode);
+ it2.compositeRule = $it.compositeRule = $wasComposite;
+ out += " " + $code;
+ } else {
+ var $$outStack = $$outStack || [];
+ $$outStack.push(out);
+ out = "";
+ out += " " + $validateCode + ".call( ";
+ if (it2.opts.passContext) {
+ out += "this";
+ } else {
+ out += "self";
+ }
+ if ($compile || $rDef.schema === false) {
+ out += " , " + $data + " ";
+ } else {
+ out += " , " + $schemaValue + " , " + $data + " , validate.schema" + it2.schemaPath + " ";
+ }
+ out += " , (dataPath || '')";
+ if (it2.errorPath != '""') {
+ out += " + " + it2.errorPath;
+ }
+ var $parentData = $dataLvl ? "data" + ($dataLvl - 1 || "") : "parentData", $parentDataProperty = $dataLvl ? it2.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 (it2.createErrors !== false) {
+ out += " { keyword: '" + ($errorKeyword || "custom") + "' , dataPath: (dataPath || '') + " + it2.errorPath + " , schemaPath: " + it2.util.toQuotedString($errSchemaPath) + " , params: { keyword: '" + $rule.keyword + "' } ";
+ if (it2.opts.messages !== false) {
+ out += ` , message: 'should pass "` + $rule.keyword + `" keyword validation' `;
+ }
+ if (it2.opts.verbose) {
+ out += " , schema: validate.schema" + $schemaPath + " , parentSchema: validate.schema" + it2.schemaPath + " , data: " + $data + " ";
+ }
+ out += " } ";
+ } else {
+ out += " {} ";
+ }
+ var __err = out;
+ out = $$outStack.pop();
+ if (!it2.compositeRule && $breakOnError) {
+ if (it2.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 + "=",
+ limit: 0,
+ exclusive: false
+ },
+ message: "should be >= 0"
+ }];
+ return false;
+ }
+ }
+ var valid2 = errors === errs_2;
+ var valid1 = errors === errs_1;
+ validate3.errors = vErrors;
+ return errors === 0;
+ }, "validate");
+ }();
+ refVal2.schema = {
+ "allOf": [{
+ "$ref": "#/definitions/nonNegativeInteger"
+ }, {
+ "default": 0
+ }]
+ };
+ refVal2.errors = null;
+ refVal[2] = refVal2;
+ var refVal3 = function() {
+ return /* @__PURE__ */ __name(function validate3(data, dataPath, parentData, parentDataProperty, rootData) {
+ "use strict";
+ var vErrors = null;
+ var errors = 0;
+ if (rootData === void 0)
+ rootData = data;
+ if (Array.isArray(data)) {
+ if (data.length < 1) {
+ validate3.errors = [{
+ keyword: "minItems",
+ dataPath: (dataPath || "") + "",
+ schemaPath: "#/minItems",
+ params: {
+ limit: 1
+ },
+ message: "should NOT have fewer than 1 items"
+ }];
+ return false;
+ } else {
+ var errs__0 = errors;
+ var valid0;
+ for (var i0 = 0; i0 < data.length; i0++) {
+ var errs_1 = errors;
+ if (!nop(data[i0], (dataPath || "") + "[" + i0 + "]", data, i0, rootData)) {
+ if (vErrors === null)
+ vErrors = nop.errors;
+ else
+ vErrors = vErrors.concat(nop.errors);
+ errors = vErrors.length;
+ }
+ var valid1 = errors === errs_1;
+ if (!valid1)
+ break;
+ }
+ }
+ } else {
+ validate3.errors = [{
+ keyword: "type",
+ dataPath: (dataPath || "") + "",
+ schemaPath: "#/type",
+ params: {
+ type: "array"
+ },
+ message: "should be array"
+ }];
+ return false;
+ }
+ validate3.errors = vErrors;
+ return errors === 0;
+ }, "validate");
+ }();
+ refVal3.schema = {
+ "type": "array",
+ "minItems": 1,
+ "items": {
+ "$ref": "#"
+ }
+ };
+ refVal3.errors = null;
+ refVal[3] = refVal3;
+ var refVal4 = {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "uniqueItems": true,
+ "default": []
+ };
+ refVal[4] = refVal4;
+ var refVal5 = {
+ "enum": ["array", "boolean", "integer", "null", "number", "object", "string"]
+ };
+ refVal[5] = refVal5;
+ return /* @__PURE__ */ __name(function validate3(data, dataPath, parentData, parentDataProperty, rootData) {
+ "use strict";
+ var vErrors = null;
+ var errors = 0;
+ if (rootData === void 0)
+ rootData = data;
+ if ((!data || typeof data !== "object" || Array.isArray(data)) && typeof data !== "boolean") {
+ validate3.errors = [{
+ keyword: "type",
+ dataPath: (dataPath || "") + "",
+ schemaPath: "#/type",
+ params: {
+ type: "object,boolean"
+ },
+ message: "should be object,boolean"
+ }];
+ return false;
+ }
+ if (data && typeof data === "object" && !Array.isArray(data)) {
+ var errs__0 = errors;
+ var valid1 = true;
+ var data1 = data.$id;
+ if (data1 === void 0) {
+ valid1 = true;
+ } else {
+ var errs_1 = errors;
+ if (errors === errs_1) {
+ if (typeof data1 === "string") {
+ if (!formats["uri-reference"].test(data1)) {
+ validate3.errors = [{
+ keyword: "format",
+ dataPath: (dataPath || "") + ".$id",
+ schemaPath: "#/properties/%24id/format",
+ params: {
+ format: "uri-reference"
+ },
+ message: 'should match format "uri-reference"'
+ }];
+ return false;
+ }
+ } else {
+ validate3.errors = [{
+ keyword: "type",
+ dataPath: (dataPath || "") + ".$id",
+ schemaPath: "#/properties/%24id/type",
+ params: {
+ type: "string"
+ },
+ message: "should be string"
+ }];
+ return false;
+ }
+ }
+ var valid1 = errors === errs_1;
+ }
+ if (valid1) {
+ var data1 = data.$schema;
+ if (data1 === void 0) {
+ valid1 = true;
+ } else {
+ var errs_1 = errors;
+ if (errors === errs_1) {
+ if (typeof data1 === "string") {
+ if (!formats.uri.test(data1)) {
+ validate3.errors = [{
+ keyword: "format",
+ dataPath: (dataPath || "") + ".$schema",
+ schemaPath: "#/properties/%24schema/format",
+ params: {
+ format: "uri"
+ },
+ message: 'should match format "uri"'
+ }];
+ return false;
+ }
+ } else {
+ validate3.errors = [{
+ keyword: "type",
+ dataPath: (dataPath || "") + ".$schema",
+ schemaPath: "#/properties/%24schema/type",
+ params: {
+ type: "string"
+ },
+ message: "should be string"
+ }];
+ return false;
+ }
+ }
+ var valid1 = errors === errs_1;
+ }
+ if (valid1) {
+ var data1 = data.$ref;
+ if (data1 === void 0) {
+ valid1 = true;
+ } else {
+ var errs_1 = errors;
+ if (errors === errs_1) {
+ if (typeof data1 === "string") {
+ if (!formats["uri-reference"].test(data1)) {
+ validate3.errors = [{
+ keyword: "format",
+ dataPath: (dataPath || "") + ".$ref",
+ schemaPath: "#/properties/%24ref/format",
+ params: {
+ format: "uri-reference"
+ },
+ message: 'should match format "uri-reference"'
+ }];
+ return false;
+ }
+ } else {
+ validate3.errors = [{
+ keyword: "type",
+ dataPath: (dataPath || "") + ".$ref",
+ schemaPath: "#/properties/%24ref/type",
+ params: {
+ type: "string"
+ },
+ message: "should be string"
+ }];
+ return false;
+ }
+ }
+ var valid1 = errors === errs_1;
+ }
+ if (valid1) {
+ if (data.$comment === void 0) {
+ valid1 = true;
+ } else {
+ var errs_1 = errors;
+ if (typeof data.$comment !== "string") {
+ validate3.errors = [{
+ keyword: "type",
+ dataPath: (dataPath || "") + ".$comment",
+ schemaPath: "#/properties/%24comment/type",
+ params: {
+ type: "string"
+ },
+ message: "should be string"
+ }];
+ return false;
+ }
+ var valid1 = errors === errs_1;
+ }
+ if (valid1) {
+ if (data.title === void 0) {
+ valid1 = true;
+ } else {
+ var errs_1 = errors;
+ if (typeof data.title !== "string") {
+ validate3.errors = [{
+ keyword: "type",
+ dataPath: (dataPath || "") + ".title",
+ schemaPath: "#/properties/title/type",
+ params: {
+ type: "string"
+ },
+ message: "should be string"
+ }];
+ return false;
+ }
+ var valid1 = errors === errs_1;
+ }
+ if (valid1) {
+ if (data.description === void 0) {
+ valid1 = true;
+ } else {
+ var errs_1 = errors;
+ if (typeof data.description !== "string") {
+ validate3.errors = [{
+ keyword: "type",
+ dataPath: (dataPath || "") + ".description",
+ schemaPath: "#/properties/description/type",
+ params: {
+ type: "string"
+ },
+ message: "should be string"
+ }];
+ return false;
+ }
+ var valid1 = errors === errs_1;
+ }
+ if (valid1) {
+ if (valid1) {
+ if (data.readOnly === void 0) {
+ valid1 = true;
+ } else {
+ var errs_1 = errors;
+ if (typeof data.readOnly !== "boolean") {
+ validate3.errors = [{
+ keyword: "type",
+ dataPath: (dataPath || "") + ".readOnly",
+ schemaPath: "#/properties/readOnly/type",
+ params: {
+ type: "boolean"
+ },
+ message: "should be boolean"
+ }];
+ return false;
+ }
+ var valid1 = errors === errs_1;
+ }
+ if (valid1) {
+ if (data.examples === void 0) {
+ valid1 = true;
+ } else {
+ var errs_1 = errors;
+ if (Array.isArray(data.examples)) {
+ var errs__1 = errors;
+ var valid1;
+ } else {
+ validate3.errors = [{
+ keyword: "type",
+ dataPath: (dataPath || "") + ".examples",
+ schemaPath: "#/properties/examples/type",
+ params: {
+ type: "array"
+ },
+ message: "should be array"
+ }];
+ return false;
+ }
+ var valid1 = errors === errs_1;
+ }
+ if (valid1) {
+ var data1 = data.multipleOf;
+ if (data1 === void 0) {
+ valid1 = true;
+ } else {
+ var errs_1 = errors;
+ if (typeof data1 === "number") {
+ if (data1 <= 0 || data1 !== data1) {
+ validate3.errors = [{
+ keyword: "exclusiveMinimum",
+ dataPath: (dataPath || "") + ".multipleOf",
+ schemaPath: "#/properties/multipleOf/exclusiveMinimum",
+ params: {
+ comparison: ">",
+ limit: 0,
+ exclusive: true
+ },
+ message: "should be > 0"
+ }];
+ return false;
+ }
+ } else {
+ validate3.errors = [{
+ keyword: "type",
+ dataPath: (dataPath || "") + ".multipleOf",
+ schemaPath: "#/properties/multipleOf/type",
+ params: {
+ type: "number"
+ },
+ message: "should be number"
+ }];
+ return false;
+ }
+ var valid1 = errors === errs_1;
+ }
+ if (valid1) {
+ if (data.maximum === void 0) {
+ valid1 = true;
+ } else {
+ var errs_1 = errors;
+ if (typeof data.maximum !== "number") {
+ validate3.errors = [{
+ keyword: "type",
+ dataPath: (dataPath || "") + ".maximum",
+ schemaPath: "#/properties/maximum/type",
+ params: {
+ type: "number"
+ },
+ message: "should be number"
+ }];
+ return false;
+ }
+ var valid1 = errors === errs_1;
+ }
+ if (valid1) {
+ if (data.exclusiveMaximum === void 0) {
+ valid1 = true;
+ } else {
+ var errs_1 = errors;
+ if (typeof data.exclusiveMaximum !== "number") {
+ validate3.errors = [{
+ keyword: "type",
+ dataPath: (dataPath || "") + ".exclusiveMaximum",
+ schemaPath: "#/properties/exclusiveMaximum/type",
+ params: {
+ type: "number"
+ },
+ message: "should be number"
+ }];
+ return false;
+ }
+ var valid1 = errors === errs_1;
+ }
+ if (valid1) {
+ if (data.minimum === void 0) {
+ valid1 = true;
+ } else {
+ var errs_1 = errors;
+ if (typeof data.minimum !== "number") {
+ validate3.errors = [{
+ keyword: "type",
+ dataPath: (dataPath || "") + ".minimum",
+ schemaPath: "#/properties/minimum/type",
+ params: {
+ type: "number"
+ },
+ message: "should be number"
+ }];
+ return false;
+ }
+ var valid1 = errors === errs_1;
+ }
+ if (valid1) {
+ if (data.exclusiveMinimum === void 0) {
+ valid1 = true;
+ } else {
+ var errs_1 = errors;
+ if (typeof data.exclusiveMinimum !== "number") {
+ validate3.errors = [{
+ keyword: "type",
+ dataPath: (dataPath || "") + ".exclusiveMinimum",
+ schemaPath: "#/properties/exclusiveMinimum/type",
+ params: {
+ type: "number"
+ },
+ message: "should be number"
+ }];
+ return false;
+ }
+ var valid1 = errors === errs_1;
+ }
+ if (valid1) {
+ var data1 = data.maxLength;
+ if (data1 === void 0) {
+ valid1 = true;
+ } else {
+ var errs_1 = errors;
+ var errs_2 = errors;
+ if (typeof data1 !== "number" || data1 % 1 || data1 !== data1) {
+ validate3.errors = [{
+ keyword: "type",
+ dataPath: (dataPath || "") + ".maxLength",
+ schemaPath: "#/definitions/nonNegativeInteger/type",
+ params: {
+ type: "integer"
+ },
+ message: "should be integer"
+ }];
+ return false;
+ }
+ if (typeof data1 === "number") {
+ if (data1 < 0 || data1 !== data1) {
+ validate3.errors = [{
+ keyword: "minimum",
+ dataPath: (dataPath || "") + ".maxLength",
+ schemaPath: "#/definitions/nonNegativeInteger/minimum",
+ params: {
+ comparison: ">=",
+ limit: 0,
+ exclusive: false
+ },
+ message: "should be >= 0"
+ }];
+ return false;
+ }
+ }
+ var valid2 = errors === errs_2;
+ var valid1 = errors === errs_1;
+ }
+ if (valid1) {
+ if (data.minLength === void 0) {
+ valid1 = true;
+ } else {
+ var errs_1 = errors;
+ if (!refVal2(data.minLength, (dataPath || "") + ".minLength", data, "minLength", rootData)) {
+ if (vErrors === null)
+ vErrors = refVal2.errors;
+ else
+ vErrors = vErrors.concat(refVal2.errors);
+ errors = vErrors.length;
+ }
+ var valid1 = errors === errs_1;
+ }
+ if (valid1) {
+ var data1 = data.pattern;
+ if (data1 === void 0) {
+ valid1 = true;
+ } else {
+ var errs_1 = errors;
+ if (errors === errs_1) {
+ if (typeof data1 === "string") {
+ if (!formats.regex(data1)) {
+ validate3.errors = [{
+ keyword: "format",
+ dataPath: (dataPath || "") + ".pattern",
+ schemaPath: "#/properties/pattern/format",
+ params: {
+ format: "regex"
+ },
+ message: 'should match format "regex"'
+ }];
+ return false;
+ }
+ } else {
+ validate3.errors = [{
+ keyword: "type",
+ dataPath: (dataPath || "") + ".pattern",
+ schemaPath: "#/properties/pattern/type",
+ params: {
+ type: "string"
+ },
+ message: "should be string"
+ }];
+ return false;
+ }
+ }
+ var valid1 = errors === errs_1;
+ }
+ if (valid1) {
+ if (data.additionalItems === void 0) {
+ valid1 = true;
+ } else {
+ var errs_1 = errors;
+ if (!validate3(data.additionalItems, (dataPath || "") + ".additionalItems", data, "additionalItems", rootData)) {
+ if (vErrors === null)
+ vErrors = validate3.errors;
+ else
+ vErrors = vErrors.concat(validate3.errors);
+ errors = vErrors.length;
+ }
+ var valid1 = errors === errs_1;
+ }
+ if (valid1) {
+ var data1 = data.items;
+ if (data1 === void 0) {
+ valid1 = true;
+ } else {
+ var errs_1 = errors;
+ var errs__1 = errors;
+ var valid1 = false;
+ var errs_2 = errors;
+ if (!validate3(data1, (dataPath || "") + ".items", data, "items", rootData)) {
+ if (vErrors === null)
+ vErrors = validate3.errors;
+ else
+ vErrors = vErrors.concat(validate3.errors);
+ errors = vErrors.length;
+ }
+ var valid2 = errors === errs_2;
+ valid1 = valid1 || valid2;
+ if (!valid1) {
+ var errs_2 = errors;
+ if (!refVal3(data1, (dataPath || "") + ".items", data, "items", rootData)) {
+ if (vErrors === null)
+ vErrors = refVal3.errors;
+ else
+ vErrors = vErrors.concat(refVal3.errors);
+ errors = vErrors.length;
+ }
+ var valid2 = errors === errs_2;
+ valid1 = valid1 || valid2;
+ }
+ if (!valid1) {
+ var err = {
+ keyword: "anyOf",
+ dataPath: (dataPath || "") + ".items",
+ schemaPath: "#/properties/items/anyOf",
+ params: {},
+ message: "should match some schema in anyOf"
+ };
+ if (vErrors === null)
+ vErrors = [err];
+ else
+ vErrors.push(err);
+ errors++;
+ validate3.errors = vErrors;
+ return false;
+ } else {
+ errors = errs__1;
+ if (vErrors !== null) {
+ if (errs__1)
+ vErrors.length = errs__1;
+ else
+ vErrors = null;
+ }
+ }
+ var valid1 = errors === errs_1;
+ }
+ if (valid1) {
+ var data1 = data.maxItems;
+ if (data1 === void 0) {
+ valid1 = true;
+ } else {
+ var errs_1 = errors;
+ var errs_2 = errors;
+ if (typeof data1 !== "number" || data1 % 1 || data1 !== data1) {
+ validate3.errors = [{
+ keyword: "type",
+ dataPath: (dataPath || "") + ".maxItems",
+ schemaPath: "#/definitions/nonNegativeInteger/type",
+ params: {
+ type: "integer"
+ },
+ message: "should be integer"
+ }];
+ return false;
+ }
+ if (typeof data1 === "number") {
+ if (data1 < 0 || data1 !== data1) {
+ validate3.errors = [{
+ keyword: "minimum",
+ dataPath: (dataPath || "") + ".maxItems",
+ schemaPath: "#/definitions/nonNegativeInteger/minimum",
+ params: {
+ comparison: ">=",
+ limit: 0,
+ exclusive: false
+ },
+ message: "should be >= 0"
+ }];
+ return false;
+ }
+ }
+ var valid2 = errors === errs_2;
+ var valid1 = errors === errs_1;
+ }
+ if (valid1) {
+ if (data.minItems === void 0) {
+ valid1 = true;
+ } else {
+ var errs_1 = errors;
+ if (!refVal[2](data.minItems, (dataPath || "") + ".minItems", data, "minItems", rootData)) {
+ if (vErrors === null)
+ vErrors = refVal[2].errors;
+ else
+ vErrors = vErrors.concat(refVal[2].errors);
+ errors = vErrors.length;
+ }
+ var valid1 = errors === errs_1;
+ }
+ if (valid1) {
+ if (data.uniqueItems === void 0) {
+ valid1 = true;
+ } else {
+ var errs_1 = errors;
+ if (typeof data.uniqueItems !== "boolean") {
+ validate3.errors = [{
+ keyword: "type",
+ dataPath: (dataPath || "") + ".uniqueItems",
+ schemaPath: "#/properties/uniqueItems/type",
+ params: {
+ type: "boolean"
+ },
+ message: "should be boolean"
+ }];
+ return false;
+ }
+ var valid1 = errors === errs_1;
+ }
+ if (valid1) {
+ if (data.contains === void 0) {
+ valid1 = true;
+ } else {
+ var errs_1 = errors;
+ if (!validate3(data.contains, (dataPath || "") + ".contains", data, "contains", rootData)) {
+ if (vErrors === null)
+ vErrors = validate3.errors;
+ else
+ vErrors = vErrors.concat(validate3.errors);
+ errors = vErrors.length;
+ }
+ var valid1 = errors === errs_1;
+ }
+ if (valid1) {
+ var data1 = data.maxProperties;
+ if (data1 === void 0) {
+ valid1 = true;
+ } else {
+ var errs_1 = errors;
+ var errs_2 = errors;
+ if (typeof data1 !== "number" || data1 % 1 || data1 !== data1) {
+ validate3.errors = [{
+ keyword: "type",
+ dataPath: (dataPath || "") + ".maxProperties",
+ schemaPath: "#/definitions/nonNegativeInteger/type",
+ params: {
+ type: "integer"
+ },
+ message: "should be integer"
+ }];
+ return false;
+ }
+ if (typeof data1 === "number") {
+ if (data1 < 0 || data1 !== data1) {
+ validate3.errors = [{
+ keyword: "minimum",
+ dataPath: (dataPath || "") + ".maxProperties",
+ schemaPath: "#/definitions/nonNegativeInteger/minimum",
+ params: {
+ comparison: ">=",
+ limit: 0,
+ exclusive: false
+ },
+ message: "should be >= 0"
+ }];
+ return false;
+ }
+ }
+ var valid2 = errors === errs_2;
+ var valid1 = errors === errs_1;
+ }
+ if (valid1) {
+ if (data.minProperties === void 0) {
+ valid1 = true;
+ } else {
+ var errs_1 = errors;
+ if (!refVal[2](data.minProperties, (dataPath || "") + ".minProperties", data, "minProperties", rootData)) {
+ if (vErrors === null)
+ vErrors = refVal[2].errors;
+ else
+ vErrors = vErrors.concat(refVal[2].errors);
+ errors = vErrors.length;
+ }
+ var valid1 = errors === errs_1;
+ }
+ if (valid1) {
+ var data1 = data.required;
+ if (data1 === void 0) {
+ valid1 = true;
+ } else {
+ var errs_1 = errors;
+ var errs_2 = errors;
+ if (Array.isArray(data1)) {
+ var errs__2 = errors;
+ var valid2;
+ for (var i2 = 0; i2 < data1.length; i2++) {
+ var errs_3 = errors;
+ if (typeof data1[i2] !== "string") {
+ validate3.errors = [{
+ keyword: "type",
+ dataPath: (dataPath || "") + ".required[" + i2 + "]",
+ schemaPath: "#/definitions/stringArray/items/type",
+ params: {
+ type: "string"
+ },
+ message: "should be string"
+ }];
+ return false;
+ }
+ var valid3 = errors === errs_3;
+ if (!valid3)
+ break;
+ }
+ if (errs__2 == errors) {
+ var i = data1.length, valid2 = true, j;
+ if (i > 1) {
+ var itemIndices = {}, item;
+ for (; i--; ) {
+ var item = data1[i];
+ if (typeof item !== "string")
+ continue;
+ if (typeof itemIndices[item] == "number") {
+ valid2 = false;
+ j = itemIndices[item];
+ break;
+ }
+ itemIndices[item] = i;
+ }
+ }
+ if (!valid2) {
+ validate3.errors = [{
+ keyword: "uniqueItems",
+ dataPath: (dataPath || "") + ".required",
+ schemaPath: "#/definitions/stringArray/uniqueItems",
+ params: {
+ i,
+ j
+ },
+ message: "should NOT have duplicate items (items ## " + j + " and " + i + " are identical)"
+ }];
+ return false;
+ }
+ }
+ } else {
+ validate3.errors = [{
+ keyword: "type",
+ dataPath: (dataPath || "") + ".required",
+ schemaPath: "#/definitions/stringArray/type",
+ params: {
+ type: "array"
+ },
+ message: "should be array"
+ }];
+ return false;
+ }
+ var valid2 = errors === errs_2;
+ var valid1 = errors === errs_1;
+ }
+ if (valid1) {
+ if (data.additionalProperties === void 0) {
+ valid1 = true;
+ } else {
+ var errs_1 = errors;
+ if (!validate3(data.additionalProperties, (dataPath || "") + ".additionalProperties", data, "additionalProperties", rootData)) {
+ if (vErrors === null)
+ vErrors = validate3.errors;
+ else
+ vErrors = vErrors.concat(validate3.errors);
+ errors = vErrors.length;
+ }
+ var valid1 = errors === errs_1;
+ }
+ if (valid1) {
+ var data1 = data.definitions;
+ if (data1 === void 0) {
+ valid1 = true;
+ } else {
+ var errs_1 = errors;
+ if (data1 && typeof data1 === "object" && !Array.isArray(data1)) {
+ var errs__1 = errors;
+ var valid2 = true;
+ for (var key1 in data1) {
+ var errs_2 = errors;
+ if (!validate3(data1[key1], (dataPath || "") + ".definitions['" + key1 + "']", data1, key1, rootData)) {
+ if (vErrors === null)
+ vErrors = validate3.errors;
+ else
+ vErrors = vErrors.concat(validate3.errors);
+ errors = vErrors.length;
+ }
+ var valid2 = errors === errs_2;
+ if (!valid2)
+ break;
+ }
+ } else {
+ validate3.errors = [{
+ keyword: "type",
+ dataPath: (dataPath || "") + ".definitions",
+ schemaPath: "#/properties/definitions/type",
+ params: {
+ type: "object"
+ },
+ message: "should be object"
+ }];
+ return false;
+ }
+ var valid1 = errors === errs_1;
+ }
+ if (valid1) {
+ var data1 = data.properties;
+ if (data1 === void 0) {
+ valid1 = true;
+ } else {
+ var errs_1 = errors;
+ if (data1 && typeof data1 === "object" && !Array.isArray(data1)) {
+ var errs__1 = errors;
+ var valid2 = true;
+ for (var key1 in data1) {
+ var errs_2 = errors;
+ if (!validate3(data1[key1], (dataPath || "") + ".properties['" + key1 + "']", data1, key1, rootData)) {
+ if (vErrors === null)
+ vErrors = validate3.errors;
+ else
+ vErrors = vErrors.concat(validate3.errors);
+ errors = vErrors.length;
+ }
+ var valid2 = errors === errs_2;
+ if (!valid2)
+ break;
+ }
+ } else {
+ validate3.errors = [{
+ keyword: "type",
+ dataPath: (dataPath || "") + ".properties",
+ schemaPath: "#/properties/properties/type",
+ params: {
+ type: "object"
+ },
+ message: "should be object"
+ }];
+ return false;
+ }
+ var valid1 = errors === errs_1;
+ }
+ if (valid1) {
+ var data1 = data.patternProperties;
+ if (data1 === void 0) {
+ valid1 = true;
+ } else {
+ var errs_1 = errors;
+ if (data1 && typeof data1 === "object" && !Array.isArray(data1)) {
+ var errs__1 = errors;
+ for (var key1 in data1) {
+ var startErrs1 = errors;
+ var data2 = key1;
+ var errs_2 = errors;
+ if (errors === errs_2) {
+ if (typeof data2 === "string") {
+ if (!formats.regex(data2)) {
+ var err = {
+ keyword: "format",
+ dataPath: (dataPath || "") + ".patternProperties",
+ schemaPath: "#/properties/patternProperties/propertyNames/format",
+ params: {
+ format: "regex"
+ },
+ message: 'should match format "regex"'
+ };
+ if (vErrors === null)
+ vErrors = [err];
+ else
+ vErrors.push(err);
+ errors++;
+ }
+ }
+ }
+ var valid2 = errors === errs_2;
+ if (!valid2) {
+ for (var i1 = startErrs1; i1 < errors; i1++) {
+ vErrors[i1].propertyName = key1;
+ }
+ var err = {
+ keyword: "propertyNames",
+ dataPath: (dataPath || "") + ".patternProperties",
+ schemaPath: "#/properties/patternProperties/propertyNames",
+ params: {
+ propertyName: "" + key1
+ },
+ message: "property name '" + key1 + "' is invalid"
+ };
+ if (vErrors === null)
+ vErrors = [err];
+ else
+ vErrors.push(err);
+ errors++;
+ validate3.errors = vErrors;
+ return false;
+ break;
+ }
+ }
+ if (errs__1 == errors) {
+ var errs__1 = errors;
+ var valid2 = true;
+ for (var key1 in data1) {
+ var errs_2 = errors;
+ if (!validate3(data1[key1], (dataPath || "") + ".patternProperties['" + key1 + "']", data1, key1, rootData)) {
+ if (vErrors === null)
+ vErrors = validate3.errors;
+ else
+ vErrors = vErrors.concat(validate3.errors);
+ errors = vErrors.length;
+ }
+ var valid2 = errors === errs_2;
+ if (!valid2)
+ break;
+ }
+ }
+ } else {
+ validate3.errors = [{
+ keyword: "type",
+ dataPath: (dataPath || "") + ".patternProperties",
+ schemaPath: "#/properties/patternProperties/type",
+ params: {
+ type: "object"
+ },
+ message: "should be object"
+ }];
+ return false;
+ }
+ var valid1 = errors === errs_1;
+ }
+ if (valid1) {
+ var data1 = data.dependencies;
+ if (data1 === void 0) {
+ valid1 = true;
+ } else {
+ var errs_1 = errors;
+ if (data1 && typeof data1 === "object" && !Array.isArray(data1)) {
+ var errs__1 = errors;
+ var valid2 = true;
+ for (var key1 in data1) {
+ var data2 = data1[key1];
+ var errs_2 = errors;
+ var errs__2 = errors;
+ var valid2 = false;
+ var errs_3 = errors;
+ if (!validate3(data2, (dataPath || "") + ".dependencies['" + key1 + "']", data1, key1, rootData)) {
+ if (vErrors === null)
+ vErrors = validate3.errors;
+ else
+ vErrors = vErrors.concat(validate3.errors);
+ errors = vErrors.length;
+ }
+ var valid3 = errors === errs_3;
+ valid2 = valid2 || valid3;
+ if (!valid2) {
+ var errs_3 = errors;
+ var errs_4 = errors;
+ if (Array.isArray(data2)) {
+ var errs__4 = errors;
+ var valid4;
+ for (var i4 = 0; i4 < data2.length; i4++) {
+ var errs_5 = errors;
+ if (typeof data2[i4] !== "string") {
+ var err = {
+ keyword: "type",
+ dataPath: (dataPath || "") + ".dependencies['" + key1 + "'][" + i4 + "]",
+ schemaPath: "#/definitions/stringArray/items/type",
+ params: {
+ type: "string"
+ },
+ message: "should be string"
+ };
+ if (vErrors === null)
+ vErrors = [err];
+ else
+ vErrors.push(err);
+ errors++;
+ }
+ var valid5 = errors === errs_5;
+ if (!valid5)
+ break;
+ }
+ if (errs__4 == errors) {
+ var i = data2.length, valid4 = true, j;
+ if (i > 1) {
+ var itemIndices = {}, item;
+ for (; i--; ) {
+ var item = data2[i];
+ if (typeof item !== "string")
+ continue;
+ if (typeof itemIndices[item] == "number") {
+ valid4 = false;
+ j = itemIndices[item];
+ break;
+ }
+ itemIndices[item] = i;
+ }
+ }
+ if (!valid4) {
+ var err = {
+ keyword: "uniqueItems",
+ dataPath: (dataPath || "") + ".dependencies['" + key1 + "']",
+ schemaPath: "#/definitions/stringArray/uniqueItems",
+ params: {
+ i,
+ j
+ },
+ message: "should NOT have duplicate items (items ## " + j + " and " + i + " are identical)"
+ };
+ if (vErrors === null)
+ vErrors = [err];
+ else
+ vErrors.push(err);
+ errors++;
+ }
+ }
+ } else {
+ var err = {
+ keyword: "type",
+ dataPath: (dataPath || "") + ".dependencies['" + key1 + "']",
+ schemaPath: "#/definitions/stringArray/type",
+ params: {
+ type: "array"
+ },
+ message: "should be array"
+ };
+ if (vErrors === null)
+ vErrors = [err];
+ else
+ vErrors.push(err);
+ errors++;
+ }
+ var valid4 = errors === errs_4;
+ var valid3 = errors === errs_3;
+ valid2 = valid2 || valid3;
+ }
+ if (!valid2) {
+ var err = {
+ keyword: "anyOf",
+ dataPath: (dataPath || "") + ".dependencies['" + key1 + "']",
+ schemaPath: "#/properties/dependencies/additionalProperties/anyOf",
+ params: {},
+ message: "should match some schema in anyOf"
+ };
+ if (vErrors === null)
+ vErrors = [err];
+ else
+ vErrors.push(err);
+ errors++;
+ validate3.errors = vErrors;
+ return false;
+ } else {
+ errors = errs__2;
+ if (vErrors !== null) {
+ if (errs__2)
+ vErrors.length = errs__2;
+ else
+ vErrors = null;
+ }
+ }
+ var valid2 = errors === errs_2;
+ if (!valid2)
+ break;
+ }
+ } else {
+ validate3.errors = [{
+ keyword: "type",
+ dataPath: (dataPath || "") + ".dependencies",
+ schemaPath: "#/properties/dependencies/type",
+ params: {
+ type: "object"
+ },
+ message: "should be object"
+ }];
+ return false;
+ }
+ var valid1 = errors === errs_1;
+ }
+ if (valid1) {
+ if (data.propertyNames === void 0) {
+ valid1 = true;
+ } else {
+ var errs_1 = errors;
+ if (!validate3(data.propertyNames, (dataPath || "") + ".propertyNames", data, "propertyNames", rootData)) {
+ if (vErrors === null)
+ vErrors = validate3.errors;
+ else
+ vErrors = vErrors.concat(validate3.errors);
+ errors = vErrors.length;
+ }
+ var valid1 = errors === errs_1;
+ }
+ if (valid1) {
+ if (valid1) {
+ var data1 = data.enum;
+ if (data1 === void 0) {
+ valid1 = true;
+ } else {
+ var errs_1 = errors;
+ if (Array.isArray(data1)) {
+ if (data1.length < 1) {
+ validate3.errors = [{
+ keyword: "minItems",
+ dataPath: (dataPath || "") + ".enum",
+ schemaPath: "#/properties/enum/minItems",
+ params: {
+ limit: 1
+ },
+ message: "should NOT have fewer than 1 items"
+ }];
+ return false;
+ } else {
+ var errs__1 = errors;
+ var valid1;
+ if (errs__1 == errors) {
+ var i = data1.length, valid1 = true, j;
+ if (i > 1) {
+ outer:
+ for (; i--; ) {
+ for (j = i; j--; ) {
+ if (equal(data1[i], data1[j])) {
+ valid1 = false;
+ break outer;
+ }
+ }
+ }
+ }
+ if (!valid1) {
+ validate3.errors = [{
+ keyword: "uniqueItems",
+ dataPath: (dataPath || "") + ".enum",
+ schemaPath: "#/properties/enum/uniqueItems",
+ params: {
+ i,
+ j
+ },
+ message: "should NOT have duplicate items (items ## " + j + " and " + i + " are identical)"
+ }];
+ return false;
+ }
+ }
+ }
+ } else {
+ validate3.errors = [{
+ keyword: "type",
+ dataPath: (dataPath || "") + ".enum",
+ schemaPath: "#/properties/enum/type",
+ params: {
+ type: "array"
+ },
+ message: "should be array"
+ }];
+ return false;
+ }
+ var valid1 = errors === errs_1;
+ }
+ if (valid1) {
+ var data1 = data.type;
+ if (data1 === void 0) {
+ valid1 = true;
+ } else {
+ var errs_1 = errors;
+ var errs__1 = errors;
+ var valid1 = false;
+ var errs_2 = errors;
+ var errs_3 = errors;
+ var schema3 = refVal5.enum;
+ var valid3;
+ valid3 = false;
+ for (var i3 = 0; i3 < schema3.length; i3++)
+ if (equal(data1, schema3[i3])) {
+ valid3 = true;
+ break;
+ }
+ if (!valid3) {
+ var err = {
+ keyword: "enum",
+ dataPath: (dataPath || "") + ".type",
+ schemaPath: "#/definitions/simpleTypes/enum",
+ params: {
+ allowedValues: schema3
+ },
+ message: "should be equal to one of the allowed values"
+ };
+ if (vErrors === null)
+ vErrors = [err];
+ else
+ vErrors.push(err);
+ errors++;
+ }
+ var valid3 = errors === errs_3;
+ var valid2 = errors === errs_2;
+ valid1 = valid1 || valid2;
+ if (!valid1) {
+ var errs_2 = errors;
+ if (Array.isArray(data1)) {
+ if (data1.length < 1) {
+ var err = {
+ keyword: "minItems",
+ dataPath: (dataPath || "") + ".type",
+ schemaPath: "#/properties/type/anyOf/1/minItems",
+ params: {
+ limit: 1
+ },
+ message: "should NOT have fewer than 1 items"
+ };
+ if (vErrors === null)
+ vErrors = [err];
+ else
+ vErrors.push(err);
+ errors++;
+ } else {
+ var errs__2 = errors;
+ var valid2;
+ for (var i2 = 0; i2 < data1.length; i2++) {
+ var errs_3 = errors;
+ var errs_4 = errors;
+ var schema4 = refVal[5].enum;
+ var valid4;
+ valid4 = false;
+ for (var i4 = 0; i4 < schema4.length; i4++)
+ if (equal(data1[i2], schema4[i4])) {
+ valid4 = true;
+ break;
+ }
+ if (!valid4) {
+ var err = {
+ keyword: "enum",
+ dataPath: (dataPath || "") + ".type[" + i2 + "]",
+ schemaPath: "#/definitions/simpleTypes/enum",
+ params: {
+ allowedValues: schema4
+ },
+ message: "should be equal to one of the allowed values"
+ };
+ if (vErrors === null)
+ vErrors = [err];
+ else
+ vErrors.push(err);
+ errors++;
+ }
+ var valid4 = errors === errs_4;
+ var valid3 = errors === errs_3;
+ if (!valid3)
+ break;
+ }
+ if (errs__2 == errors) {
+ var i = data1.length, valid2 = true, j;
+ if (i > 1) {
+ outer:
+ for (; i--; ) {
+ for (j = i; j--; ) {
+ if (equal(data1[i], data1[j])) {
+ valid2 = false;
+ break outer;
+ }
+ }
+ }
+ }
+ if (!valid2) {
+ var err = {
+ keyword: "uniqueItems",
+ dataPath: (dataPath || "") + ".type",
+ schemaPath: "#/properties/type/anyOf/1/uniqueItems",
+ params: {
+ i,
+ j
+ },
+ message: "should NOT have duplicate items (items ## " + j + " and " + i + " are identical)"
+ };
+ if (vErrors === null)
+ vErrors = [err];
+ else
+ vErrors.push(err);
+ errors++;
+ }
+ }
+ }
+ } else {
+ var err = {
+ keyword: "type",
+ dataPath: (dataPath || "") + ".type",
+ schemaPath: "#/properties/type/anyOf/1/type",
+ params: {
+ type: "array"
+ },
+ message: "should be array"
+ };
+ if (vErrors === null)
+ vErrors = [err];
+ else
+ vErrors.push(err);
+ errors++;
+ }
+ var valid2 = errors === errs_2;
+ valid1 = valid1 || valid2;
+ }
+ if (!valid1) {
+ var err = {
+ keyword: "anyOf",
+ dataPath: (dataPath || "") + ".type",
+ schemaPath: "#/properties/type/anyOf",
+ params: {},
+ message: "should match some schema in anyOf"
+ };
+ if (vErrors === null)
+ vErrors = [err];
+ else
+ vErrors.push(err);
+ errors++;
+ validate3.errors = vErrors;
+ return false;
+ } else {
+ errors = errs__1;
+ if (vErrors !== null) {
+ if (errs__1)
+ vErrors.length = errs__1;
+ else
+ vErrors = null;
+ }
+ }
+ var valid1 = errors === errs_1;
+ }
+ if (valid1) {
+ if (data.format === void 0) {
+ valid1 = true;
+ } else {
+ var errs_1 = errors;
+ if (typeof data.format !== "string") {
+ validate3.errors = [{
+ keyword: "type",
+ dataPath: (dataPath || "") + ".format",
+ schemaPath: "#/properties/format/type",
+ params: {
+ type: "string"
+ },
+ message: "should be string"
+ }];
+ return false;
+ }
+ var valid1 = errors === errs_1;
+ }
+ if (valid1) {
+ if (data.contentMediaType === void 0) {
+ valid1 = true;
+ } else {
+ var errs_1 = errors;
+ if (typeof data.contentMediaType !== "string") {
+ validate3.errors = [{
+ keyword: "type",
+ dataPath: (dataPath || "") + ".contentMediaType",
+ schemaPath: "#/properties/contentMediaType/type",
+ params: {
+ type: "string"
+ },
+ message: "should be string"
+ }];
+ return false;
+ }
+ var valid1 = errors === errs_1;
+ }
+ if (valid1) {
+ if (data.contentEncoding === void 0) {
+ valid1 = true;
+ } else {
+ var errs_1 = errors;
+ if (typeof data.contentEncoding !== "string") {
+ validate3.errors = [{
+ keyword: "type",
+ dataPath: (dataPath || "") + ".contentEncoding",
+ schemaPath: "#/properties/contentEncoding/type",
+ params: {
+ type: "string"
+ },
+ message: "should be string"
+ }];
+ return false;
+ }
+ var valid1 = errors === errs_1;
+ }
+ if (valid1) {
+ if (data.if === void 0) {
+ valid1 = true;
+ } else {
+ var errs_1 = errors;
+ if (!validate3(data.if, (dataPath || "") + ".if", data, "if", rootData)) {
+ if (vErrors === null)
+ vErrors = validate3.errors;
+ else
+ vErrors = vErrors.concat(validate3.errors);
+ errors = vErrors.length;
+ }
+ var valid1 = errors === errs_1;
+ }
+ if (valid1) {
+ if (data.then === void 0) {
+ valid1 = true;
+ } else {
+ var errs_1 = errors;
+ if (!validate3(data.then, (dataPath || "") + ".then", data, "then", rootData)) {
+ if (vErrors === null)
+ vErrors = validate3.errors;
+ else
+ vErrors = vErrors.concat(validate3.errors);
+ errors = vErrors.length;
+ }
+ var valid1 = errors === errs_1;
+ }
+ if (valid1) {
+ if (data.else === void 0) {
+ valid1 = true;
+ } else {
+ var errs_1 = errors;
+ if (!validate3(data.else, (dataPath || "") + ".else", data, "else", rootData)) {
+ if (vErrors === null)
+ vErrors = validate3.errors;
+ else
+ vErrors = vErrors.concat(validate3.errors);
+ errors = vErrors.length;
+ }
+ var valid1 = errors === errs_1;
+ }
+ if (valid1) {
+ if (data.allOf === void 0) {
+ valid1 = true;
+ } else {
+ var errs_1 = errors;
+ if (!refVal[3](data.allOf, (dataPath || "") + ".allOf", data, "allOf", rootData)) {
+ if (vErrors === null)
+ vErrors = refVal[3].errors;
+ else
+ vErrors = vErrors.concat(refVal[3].errors);
+ errors = vErrors.length;
+ }
+ var valid1 = errors === errs_1;
+ }
+ if (valid1) {
+ if (data.anyOf === void 0) {
+ valid1 = true;
+ } else {
+ var errs_1 = errors;
+ if (!refVal[3](data.anyOf, (dataPath || "") + ".anyOf", data, "anyOf", rootData)) {
+ if (vErrors === null)
+ vErrors = refVal[3].errors;
+ else
+ vErrors = vErrors.concat(refVal[3].errors);
+ errors = vErrors.length;
+ }
+ var valid1 = errors === errs_1;
+ }
+ if (valid1) {
+ if (data.oneOf === void 0) {
+ valid1 = true;
+ } else {
+ var errs_1 = errors;
+ if (!refVal[3](data.oneOf, (dataPath || "") + ".oneOf", data, "oneOf", rootData)) {
+ if (vErrors === null)
+ vErrors = refVal[3].errors;
+ else
+ vErrors = vErrors.concat(refVal[3].errors);
+ errors = vErrors.length;
+ }
+ var valid1 = errors === errs_1;
+ }
+ if (valid1) {
+ if (data.not === void 0) {
+ valid1 = true;
+ } else {
+ var errs_1 = errors;
+ if (!validate3(data.not, (dataPath || "") + ".not", data, "not", rootData)) {
+ if (vErrors === null)
+ vErrors = validate3.errors;
+ else
+ vErrors = vErrors.concat(validate3.errors);
+ errors = vErrors.length;
+ }
+ var valid1 = errors === errs_1;
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ validate3.errors = vErrors;
+ return errors === 0;
+ }, "validate");
+ }();
+ validate2.schema = {
+ "$schema": "http://json-schema.org/draft-07/schema#",
+ "$id": "http://json-schema.org/draft-07/schema#",
+ "title": "Core schema meta-schema",
+ "definitions": {
+ "schemaArray": {
+ "type": "array",
+ "minItems": 1,
+ "items": {
+ "$ref": "#"
+ }
+ },
+ "nonNegativeInteger": {
+ "type": "integer",
+ "minimum": 0
+ },
+ "nonNegativeIntegerDefault0": {
+ "allOf": [{
+ "$ref": "#/definitions/nonNegativeInteger"
+ }, {
+ "default": 0
+ }]
+ },
+ "simpleTypes": {
+ "enum": ["array", "boolean", "integer", "null", "number", "object", "string"]
+ },
+ "stringArray": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "uniqueItems": true,
+ "default": []
+ }
+ },
+ "type": ["object", "boolean"],
+ "properties": {
+ "$id": {
+ "type": "string",
+ "format": "uri-reference"
+ },
+ "$schema": {
+ "type": "string",
+ "format": "uri"
+ },
+ "$ref": {
+ "type": "string",
+ "format": "uri-reference"
+ },
+ "$comment": {
+ "type": "string"
+ },
+ "title": {
+ "type": "string"
+ },
+ "description": {
+ "type": "string"
+ },
+ "default": true,
+ "readOnly": {
+ "type": "boolean",
+ "default": false
+ },
+ "examples": {
+ "type": "array",
+ "items": true
+ },
+ "multipleOf": {
+ "type": "number",
+ "exclusiveMinimum": 0
+ },
+ "maximum": {
+ "type": "number"
+ },
+ "exclusiveMaximum": {
+ "type": "number"
+ },
+ "minimum": {
+ "type": "number"
+ },
+ "exclusiveMinimum": {
+ "type": "number"
+ },
+ "maxLength": {
+ "$ref": "#/definitions/nonNegativeInteger"
+ },
+ "minLength": {
+ "$ref": "#/definitions/nonNegativeIntegerDefault0"
+ },
+ "pattern": {
+ "type": "string",
+ "format": "regex"
+ },
+ "additionalItems": {
+ "$ref": "#"
+ },
+ "items": {
+ "anyOf": [{
+ "$ref": "#"
+ }, {
+ "$ref": "#/definitions/schemaArray"
+ }],
+ "default": true
+ },
+ "maxItems": {
+ "$ref": "#/definitions/nonNegativeInteger"
+ },
+ "minItems": {
+ "$ref": "#/definitions/nonNegativeIntegerDefault0"
+ },
+ "uniqueItems": {
+ "type": "boolean",
+ "default": false
+ },
+ "contains": {
+ "$ref": "#"
+ },
+ "maxProperties": {
+ "$ref": "#/definitions/nonNegativeInteger"
+ },
+ "minProperties": {
+ "$ref": "#/definitions/nonNegativeIntegerDefault0"
+ },
+ "required": {
+ "$ref": "#/definitions/stringArray"
+ },
+ "additionalProperties": {
+ "$ref": "#"
+ },
+ "definitions": {
+ "type": "object",
+ "additionalProperties": {
+ "$ref": "#"
+ },
+ "default": {}
+ },
+ "properties": {
+ "type": "object",
+ "additionalProperties": {
+ "$ref": "#"
+ },
+ "default": {}
+ },
+ "patternProperties": {
+ "type": "object",
+ "additionalProperties": {
+ "$ref": "#"
+ },
+ "propertyNames": {
+ "format": "regex"
+ },
+ "default": {}
+ },
+ "dependencies": {
+ "type": "object",
+ "additionalProperties": {
+ "anyOf": [{
+ "$ref": "#"
+ }, {
+ "$ref": "#/definitions/stringArray"
+ }]
+ }
+ },
+ "propertyNames": {
+ "$ref": "#"
+ },
+ "const": true,
+ "enum": {
+ "type": "array",
+ "items": true,
+ "minItems": 1,
+ "uniqueItems": true
+ },
+ "type": {
+ "anyOf": [{
+ "$ref": "#/definitions/simpleTypes"
+ }, {
+ "type": "array",
+ "items": {
+ "$ref": "#/definitions/simpleTypes"
+ },
+ "minItems": 1,
+ "uniqueItems": true
+ }]
+ },
+ "format": {
+ "type": "string"
+ },
+ "contentMediaType": {
+ "type": "string"
+ },
+ "contentEncoding": {
+ "type": "string"
+ },
+ "if": {
+ "$ref": "#"
+ },
+ "then": {
+ "$ref": "#"
+ },
+ "else": {
+ "$ref": "#"
+ },
+ "allOf": {
+ "$ref": "#/definitions/schemaArray"
+ },
+ "anyOf": {
+ "$ref": "#/definitions/schemaArray"
+ },
+ "oneOf": {
+ "$ref": "#/definitions/schemaArray"
+ },
+ "not": {
+ "$ref": "#"
+ }
+ },
+ "default": true
+ };
+ validate2.errors = null;
+ module2.exports = validate2;
+ }
+});
+
+// ../../node_modules/.pnpm/string-similarity@4.0.4/node_modules/string-similarity/src/index.js
+var require_src4 = __commonJS({
+ "../../node_modules/.pnpm/string-similarity@4.0.4/node_modules/string-similarity/src/index.js"(exports2, module2) {
+ init_import_meta_url();
+ module2.exports = {
+ compareTwoStrings,
+ findBestMatch
+ };
+ function compareTwoStrings(first, second) {
+ first = first.replace(/\s+/g, "");
+ second = second.replace(/\s+/g, "");
+ if (first === second)
+ return 1;
+ if (first.length < 2 || second.length < 2)
+ return 0;
+ let firstBigrams = /* @__PURE__ */ new Map();
+ for (let i = 0; i < first.length - 1; i++) {
+ const bigram = first.substring(i, i + 2);
+ const count = firstBigrams.has(bigram) ? firstBigrams.get(bigram) + 1 : 1;
+ firstBigrams.set(bigram, count);
+ }
+ ;
+ let intersectionSize = 0;
+ for (let i = 0; i < second.length - 1; i++) {
+ const bigram = second.substring(i, i + 2);
+ const count = firstBigrams.has(bigram) ? firstBigrams.get(bigram) : 0;
+ if (count > 0) {
+ firstBigrams.set(bigram, count - 1);
+ intersectionSize++;
+ }
+ }
+ return 2 * intersectionSize / (first.length + second.length - 2);
+ }
+ __name(compareTwoStrings, "compareTwoStrings");
+ function findBestMatch(mainString, targetStrings) {
+ if (!areArgsValid(mainString, targetStrings))
+ throw new Error("Bad arguments: First argument should be a string, second should be an array of strings");
+ const ratings = [];
+ let bestMatchIndex = 0;
+ for (let i = 0; i < targetStrings.length; i++) {
+ const currentTargetString = targetStrings[i];
+ const currentRating = compareTwoStrings(mainString, currentTargetString);
+ ratings.push({ target: currentTargetString, rating: currentRating });
+ if (currentRating > ratings[bestMatchIndex].rating) {
+ bestMatchIndex = i;
+ }
+ }
+ const bestMatch = ratings[bestMatchIndex];
+ return { ratings, bestMatch, bestMatchIndex };
+ }
+ __name(findBestMatch, "findBestMatch");
+ function areArgsValid(mainString, targetStrings) {
+ if (typeof mainString !== "string")
+ return false;
+ if (!Array.isArray(targetStrings))
+ return false;
+ if (!targetStrings.length)
+ return false;
+ if (targetStrings.find(function(s) {
+ return typeof s !== "string";
+ }))
+ return false;
+ return true;
+ }
+ __name(areArgsValid, "areArgsValid");
+ }
+});
+
+// ../../node_modules/.pnpm/fast-json-stringify@2.7.13/node_modules/fast-json-stringify/index.js
+var require_fast_json_stringify = __commonJS({
+ "../../node_modules/.pnpm/fast-json-stringify@2.7.13/node_modules/fast-json-stringify/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var Ajv = require_ajv();
+ var merge = require_cjs();
+ var clone = require_rfdc()({ proto: true });
+ var fjsCloned = Symbol("fast-json-stringify.cloned");
+ var validate2 = require_schema_validator();
+ var stringSimilarity = null;
+ var isLong;
+ try {
+ isLong = require("long").isLong;
+ } catch (e2) {
+ isLong = null;
+ }
+ var addComma = `
+ if (addComma) {
+ json += ','
+ } else {
+ addComma = true
+ }
+`;
+ function isValidSchema(schema, name) {
+ if (!validate2(schema)) {
+ if (name) {
+ name = `"${name}" `;
+ } else {
+ name = "";
+ }
+ const first = validate2.errors[0];
+ const err = new Error(`${name}schema is invalid: data${first.dataPath} ${first.message}`);
+ err.errors = isValidSchema.errors;
+ throw err;
+ }
+ }
+ __name(isValidSchema, "isValidSchema");
+ function mergeLocation(source, dest) {
+ return {
+ schema: dest.schema || source.schema,
+ root: dest.root || source.root,
+ externalSchema: dest.externalSchema || source.externalSchema
+ };
+ }
+ __name(mergeLocation, "mergeLocation");
+ var arrayItemsReferenceSerializersMap = /* @__PURE__ */ new Map();
+ var objectReferenceSerializersMap = /* @__PURE__ */ new Map();
+ function build5(schema, options14) {
+ arrayItemsReferenceSerializersMap.clear();
+ objectReferenceSerializersMap.clear();
+ options14 = options14 || {};
+ isValidSchema(schema);
+ if (options14.schema) {
+ for (var key of Object.keys(options14.schema)) {
+ isValidSchema(options14.schema[key], key);
+ }
+ }
+ let intParseFunctionName = "trunc";
+ if (options14.rounding) {
+ if (["floor", "ceil", "round"].includes(options14.rounding)) {
+ intParseFunctionName = options14.rounding;
+ } else {
+ throw new Error(`Unsupported integer rounding method ${options14.rounding}`);
+ }
+ }
+ let code = `
+ 'use strict'
+ `;
+ code += `
+ ${asFunctions}
+
+ var isLong = ${isLong ? isLong.toString() : false}
+
+ function parseInteger(int) { return Math.${intParseFunctionName}(int) }
+ `;
+ let location = {
+ schema,
+ root: schema,
+ externalSchema: options14.schema
+ };
+ if (schema.$ref) {
+ location = refFinder(schema.$ref, location);
+ schema = location.schema;
+ }
+ if (schema.type === void 0) {
+ schema.type = inferTypeByKeyword(schema);
+ }
+ let main2;
+ switch (schema.type) {
+ case "object":
+ main2 = "$main";
+ code = buildObject(location, code, main2);
+ break;
+ case "string":
+ main2 = schema.nullable ? "$asStringNullable" : getStringSerializer(schema.format);
+ break;
+ case "integer":
+ main2 = schema.nullable ? "$asIntegerNullable" : "$asInteger";
+ break;
+ case "number":
+ main2 = schema.nullable ? "$asNumberNullable" : "$asNumber";
+ break;
+ case "boolean":
+ main2 = schema.nullable ? "$asBooleanNullable" : "$asBoolean";
+ break;
+ case "null":
+ main2 = "$asNull";
+ break;
+ case "array":
+ main2 = "$main";
+ code = buildArray(location, code, main2);
+ schema = location.schema;
+ break;
+ case void 0:
+ main2 = "$asAny";
+ break;
+ default:
+ throw new Error(`${schema.type} unsupported`);
+ }
+ code += `
+ ;
+ return ${main2}
+ `;
+ const dependencies = [new Ajv(options14.ajv)];
+ const dependenciesName = ["ajv"];
+ dependenciesName.push(code);
+ if (options14.debugMode) {
+ dependenciesName.toString = function() {
+ return dependenciesName.join("\n");
+ };
+ return dependenciesName;
+ }
+ arrayItemsReferenceSerializersMap.clear();
+ objectReferenceSerializersMap.clear();
+ return Function.apply(null, dependenciesName).apply(null, dependencies);
+ }
+ __name(build5, "build");
+ var objectKeywords = [
+ "maxProperties",
+ "minProperties",
+ "required",
+ "properties",
+ "patternProperties",
+ "additionalProperties",
+ "dependencies"
+ ];
+ var arrayKeywords = [
+ "items",
+ "additionalItems",
+ "maxItems",
+ "minItems",
+ "uniqueItems",
+ "contains"
+ ];
+ var stringKeywords = [
+ "maxLength",
+ "minLength",
+ "pattern"
+ ];
+ var numberKeywords = [
+ "multipleOf",
+ "maximum",
+ "exclusiveMaximum",
+ "minimum",
+ "exclusiveMinimum"
+ ];
+ function inferTypeByKeyword(schema) {
+ for (var keyword of objectKeywords) {
+ if (keyword in schema)
+ return "object";
+ }
+ for (var keyword of arrayKeywords) {
+ if (keyword in schema)
+ return "array";
+ }
+ for (var keyword of stringKeywords) {
+ if (keyword in schema)
+ return "string";
+ }
+ for (var keyword of numberKeywords) {
+ if (keyword in schema)
+ return "number";
+ }
+ return schema.type;
+ }
+ __name(inferTypeByKeyword, "inferTypeByKeyword");
+ var stringSerializerMap = {
+ "date-time": "$asDatetime",
+ date: "$asDate",
+ time: "$asTime"
+ };
+ function getStringSerializer(format8) {
+ return stringSerializerMap[format8] || "$asString";
+ }
+ __name(getStringSerializer, "getStringSerializer");
+ function getTestSerializer(format8) {
+ return stringSerializerMap[format8];
+ }
+ __name(getTestSerializer, "getTestSerializer");
+ var asFunctions = `
+function $pad2Zeros (num) {
+ const s = '00' + num
+ return s[s.length - 2] + s[s.length - 1]
+}
+
+function $asAny (i) {
+ return JSON.stringify(i)
+}
+
+function $asNull () {
+ return 'null'
+}
+
+function $asInteger (i) {
+ if (isLong && isLong(i)) {
+ return i.toString()
+ } else if (typeof i === 'bigint') {
+ return i.toString()
+ } else if (Number.isInteger(i)) {
+ return $asNumber(i)
+ } else {
+ /* eslint no-undef: "off" */
+ return $asNumber(parseInteger(i))
+ }
+}
+
+function $asIntegerNullable (i) {
+ return i === null ? null : $asInteger(i)
+}
+
+function $asNumber (i) {
+ const num = Number(i)
+ if (isNaN(num)) {
+ return 'null'
+ } else {
+ return '' + num
+ }
+}
+
+function $asNumberNullable (i) {
+ return i === null ? null : $asNumber(i)
+}
+
+function $asBoolean (bool) {
+ return bool && 'true' || 'false' // eslint-disable-line
+}
+
+function $asBooleanNullable (bool) {
+ return bool === null ? null : $asBoolean(bool)
+}
+
+function $asDatetime (date, skipQuotes) {
+ const quotes = skipQuotes === true ? '' : '"'
+ if (date instanceof Date) {
+ return quotes + date.toISOString() + quotes
+ } else if (date && typeof date.toISOString === 'function') {
+ return quotes + date.toISOString() + quotes
+ } else {
+ return $asString(date, skipQuotes)
+ }
+}
+
+function $asDate (date, skipQuotes) {
+ const quotes = skipQuotes === true ? '' : '"'
+ if (date instanceof Date) {
+ return quotes + new Date(date.getTime() - (date.getTimezoneOffset() * 60000 )).toISOString().slice(0, 10) + quotes
+ } else if (date && typeof date.format === 'function') {
+ return quotes + date.format('YYYY-MM-DD') + quotes
+ } else {
+ return $asString(date, skipQuotes)
+ }
+}
+
+function $asTime (date, skipQuotes) {
+ const quotes = skipQuotes === true ? '' : '"'
+ if (date instanceof Date) {
+ const hour = new Intl.DateTimeFormat('en', { hour: 'numeric', hour12: false }).format(date)
+ const minute = new Intl.DateTimeFormat('en', { minute: 'numeric' }).format(date)
+ const second = new Intl.DateTimeFormat('en', { second: 'numeric' }).format(date)
+ return quotes + $pad2Zeros(hour) + ':' + $pad2Zeros(minute) + ':' + $pad2Zeros(second) + quotes
+ } else if (date && typeof date.format === 'function') {
+ return quotes + date.format('HH:mm:ss') + quotes
+ } else {
+ return $asString(date, skipQuotes)
+ }
+}
+
+function $asString (str, skipQuotes) {
+ const quotes = skipQuotes === true ? '' : '"'
+ if (str instanceof Date) {
+ return quotes + str.toISOString() + quotes
+ } else if (str === null) {
+ return quotes + quotes
+ } else if (str instanceof RegExp) {
+ str = str.source
+ } else if (typeof str !== 'string') {
+ str = str.toString()
+ }
+ // If we skipQuotes it means that we are using it as test
+ // no need to test the string length for the render
+ if (skipQuotes) {
+ return str
+ }
+
+ if (str.length < 42) {
+ return $asStringSmall(str)
+ } else {
+ return JSON.stringify(str)
+ }
+}
+
+function $asStringNullable (str) {
+ return str === null ? null : $asString(str)
+}
+
+// magically escape strings for json
+// relying on their charCodeAt
+// everything below 32 needs JSON.stringify()
+// every string that contain surrogate needs JSON.stringify()
+// 34 and 92 happens all the time, so we
+// have a fast case for them
+function $asStringSmall (str) {
+ const l = str.length
+ let result = ''
+ let last = 0
+ let found = false
+ let surrogateFound = false
+ let point = 255
+ // eslint-disable-next-line
+ for (var i = 0; i < l && point >= 32; i++) {
+ point = str.charCodeAt(i)
+ if (point >= 0xD800 && point <= 0xDFFF) {
+ // The current character is a surrogate.
+ surrogateFound = true
+ }
+ if (point === 34 || point === 92) {
+ result += str.slice(last, i) + '\\\\'
+ last = i
+ found = true
+ }
+ }
+
+ if (!found) {
+ result = str
+ } else {
+ result += str.slice(last)
+ }
+ return ((point < 32) || (surrogateFound === true)) ? JSON.stringify(str) : '"' + result + '"'
+}
+`;
+ function addPatternProperties(location) {
+ const schema = location.schema;
+ const pp = schema.patternProperties;
+ let code = `
+ var properties = ${JSON.stringify(schema.properties)} || {}
+ var keys = Object.keys(obj)
+ for (var i = 0; i < keys.length; i++) {
+ if (properties[keys[i]]) continue
+ `;
+ Object.keys(pp).forEach((regex, index) => {
+ let ppLocation = mergeLocation(location, { schema: pp[regex] });
+ if (pp[regex].$ref) {
+ ppLocation = refFinder(pp[regex].$ref, location);
+ pp[regex] = ppLocation.schema;
+ }
+ const type = pp[regex].type;
+ const format8 = pp[regex].format;
+ const stringSerializer = getStringSerializer(format8);
+ try {
+ RegExp(regex);
+ } catch (err) {
+ throw new Error(`${err.message}. Found at ${regex} matching ${JSON.stringify(pp[regex])}`);
+ }
+ const ifPpKeyExists = `if (/${regex.replace(/\\*\//g, "\\/")}/.test(keys[i])) {`;
+ if (type === "object") {
+ code += `${buildObject(ppLocation, "", "buildObjectPP" + index)}
+ ${ifPpKeyExists}
+ ${addComma}
+ json += $asString(keys[i]) + ':' + buildObjectPP${index}(obj[keys[i]])
+ `;
+ } else if (type === "array") {
+ code += `${buildArray(ppLocation, "", "buildArrayPP" + index)}
+ ${ifPpKeyExists}
+ ${addComma}
+ json += $asString(keys[i]) + ':' + buildArrayPP${index}(obj[keys[i]])
+ `;
+ } else if (type === "null") {
+ code += `
+ ${ifPpKeyExists}
+ ${addComma}
+ json += $asString(keys[i]) +':null'
+ `;
+ } else if (type === "string") {
+ code += `
+ ${ifPpKeyExists}
+ ${addComma}
+ json += $asString(keys[i]) + ':' + ${stringSerializer}(obj[keys[i]])
+ `;
+ } else if (type === "integer") {
+ code += `
+ ${ifPpKeyExists}
+ ${addComma}
+ json += $asString(keys[i]) + ':' + $asInteger(obj[keys[i]])
+ `;
+ } else if (type === "number") {
+ code += `
+ ${ifPpKeyExists}
+ ${addComma}
+ json += $asString(keys[i]) + ':' + $asNumber(obj[keys[i]])
+ `;
+ } else if (type === "boolean") {
+ code += `
+ ${ifPpKeyExists}
+ ${addComma}
+ json += $asString(keys[i]) + ':' + $asBoolean(obj[keys[i]])
+ `;
+ } else if (type === void 0) {
+ code += `
+ ${ifPpKeyExists}
+ ${addComma}
+ json += $asString(keys[i]) + ':' + $asAny(obj[keys[i]])
+ `;
+ } else {
+ code += `
+ ${ifPpKeyExists}
+ throw new Error('Cannot coerce ' + obj[keys[i]] + ' to ' + ${JSON.stringify(type)})
+ `;
+ }
+ code += `
+ continue
+ }
+ `;
+ });
+ if (schema.additionalProperties) {
+ code += additionalProperty(location);
+ }
+ code += `
+ }
+ `;
+ return code;
+ }
+ __name(addPatternProperties, "addPatternProperties");
+ function additionalProperty(location) {
+ let ap = location.schema.additionalProperties;
+ let code = "";
+ if (ap === true) {
+ return `
+ if (obj[keys[i]] !== undefined && typeof obj[keys[i]] !== 'function' && typeof obj[keys[i]] !== 'symbol') {
+ ${addComma}
+ json += $asString(keys[i]) + ':' + JSON.stringify(obj[keys[i]])
+ }
+ `;
+ }
+ let apLocation = mergeLocation(location, { schema: ap });
+ if (ap.$ref) {
+ apLocation = refFinder(ap.$ref, location);
+ ap = apLocation.schema;
+ }
+ const type = ap.type;
+ const format8 = ap.format;
+ const stringSerializer = getStringSerializer(format8);
+ if (type === "object") {
+ code += `${buildObject(apLocation, "", "buildObjectAP")}
+ ${addComma}
+ json += $asString(keys[i]) + ':' + buildObjectAP(obj[keys[i]])
+ `;
+ } else if (type === "array") {
+ code += `${buildArray(apLocation, "", "buildArrayAP")}
+ ${addComma}
+ json += $asString(keys[i]) + ':' + buildArrayAP(obj[keys[i]])
+ `;
+ } else if (type === "null") {
+ code += `
+ ${addComma}
+ json += $asString(keys[i]) +':null'
+ `;
+ } else if (type === "string") {
+ code += `
+ ${addComma}
+ json += $asString(keys[i]) + ':' + ${stringSerializer}(obj[keys[i]])
+ `;
+ } else if (type === "integer") {
+ code += `
+ var t = Number(obj[keys[i]])
+ `;
+ if (isLong) {
+ code += `
+ if (isLong(obj[keys[i]]) || !isNaN(t)) {
+ ${addComma}
+ json += $asString(keys[i]) + ':' + $asInteger(obj[keys[i]])
+ }
+ `;
+ } else {
+ code += `
+ if (!isNaN(t)) {
+ ${addComma}
+ json += $asString(keys[i]) + ':' + t
+ }
+ `;
+ }
+ } else if (type === "number") {
+ code += `
+ var t = Number(obj[keys[i]])
+ if (!isNaN(t)) {
+ ${addComma}
+ json += $asString(keys[i]) + ':' + t
+ }
+ `;
+ } else if (type === "boolean") {
+ code += `
+ ${addComma}
+ json += $asString(keys[i]) + ':' + $asBoolean(obj[keys[i]])
+ `;
+ } else if (type === void 0) {
+ code += `
+ ${addComma}
+ json += $asString(keys[i]) + ':' + $asAny(obj[keys[i]])
+ `;
+ } else {
+ code += `
+ throw new Error('Cannot coerce ' + obj[keys[i]] + ' to ' + ${JSON.stringify(type)})
+ `;
+ }
+ return code;
+ }
+ __name(additionalProperty, "additionalProperty");
+ function addAdditionalProperties(location) {
+ return `
+ var properties = ${JSON.stringify(location.schema.properties)} || {}
+ var keys = Object.keys(obj)
+ for (var i = 0; i < keys.length; i++) {
+ if (properties[keys[i]]) continue
+ ${additionalProperty(location)}
+ }
+ `;
+ }
+ __name(addAdditionalProperties, "addAdditionalProperties");
+ function idFinder(schema, searchedId) {
+ let objSchema;
+ const explore = /* @__PURE__ */ __name((schema2, searchedId2) => {
+ Object.keys(schema2 || {}).forEach((key, i, a) => {
+ if (key === "$id" && schema2[key] === searchedId2) {
+ objSchema = schema2;
+ } else if (objSchema === void 0 && typeof schema2[key] === "object") {
+ explore(schema2[key], searchedId2);
+ }
+ });
+ }, "explore");
+ explore(schema, searchedId);
+ return objSchema;
+ }
+ __name(idFinder, "idFinder");
+ function refFinder(ref, location) {
+ const externalSchema = location.externalSchema;
+ let root = location.root;
+ let schema = location.schema;
+ if (externalSchema && externalSchema[ref]) {
+ return {
+ schema: externalSchema[ref],
+ root: externalSchema[ref],
+ externalSchema
+ };
+ }
+ ref = ref.split("#");
+ if (ref[0]) {
+ schema = externalSchema[ref[0]];
+ root = externalSchema[ref[0]];
+ if (schema === void 0) {
+ findBadKey(externalSchema, [ref[0]]);
+ }
+ if (schema.$ref) {
+ return refFinder(schema.$ref, {
+ schema,
+ root,
+ externalSchema
+ });
+ }
+ }
+ let code = "return schema";
+ if (ref[1]) {
+ const walk = ref[1].split("/");
+ if (walk.length === 1) {
+ const targetId = `#${ref[1]}`;
+ let dereferenced = idFinder(schema, targetId);
+ if (dereferenced === void 0 && !ref[0]) {
+ for (var key of Object.keys(externalSchema)) {
+ dereferenced = idFinder(externalSchema[key], targetId);
+ if (dereferenced !== void 0) {
+ root = externalSchema[key];
+ break;
+ }
+ }
+ }
+ return {
+ schema: dereferenced,
+ root,
+ externalSchema
+ };
+ } else {
+ for (var i = 1; i < walk.length; i++) {
+ code += `[${JSON.stringify(walk[i])}]`;
+ }
+ }
+ }
+ let result;
+ try {
+ result = new Function("schema", code)(root);
+ } catch (err) {
+ }
+ if (result === void 0 && ref[1]) {
+ const walk = ref[1].split("/");
+ findBadKey(schema, walk.slice(1));
+ }
+ if (result.$ref) {
+ return refFinder(result.$ref, {
+ schema,
+ root,
+ externalSchema
+ });
+ }
+ return {
+ schema: result,
+ root,
+ externalSchema
+ };
+ function findBadKey(obj, keys) {
+ if (keys.length === 0)
+ return null;
+ const key2 = keys.shift();
+ if (obj[key2] === void 0) {
+ stringSimilarity = stringSimilarity || require_src4();
+ const { bestMatch } = stringSimilarity.findBestMatch(key2, Object.keys(obj));
+ if (bestMatch.rating >= 0.5) {
+ throw new Error(`Cannot find reference ${JSON.stringify(key2)}, did you mean ${JSON.stringify(bestMatch.target)}?`);
+ } else {
+ throw new Error(`Cannot find reference ${JSON.stringify(key2)}`);
+ }
+ }
+ return findBadKey(obj[key2], keys);
+ }
+ __name(findBadKey, "findBadKey");
+ }
+ __name(refFinder, "refFinder");
+ function buildCode(location, code, laterCode, name) {
+ if (location.schema.$ref) {
+ location = refFinder(location.schema.$ref, location);
+ }
+ const schema = location.schema;
+ let required = schema.required;
+ Object.keys(schema.properties || {}).forEach((key, i2, a) => {
+ let propertyLocation = mergeLocation(location, { schema: schema.properties[key] });
+ if (schema.properties[key].$ref) {
+ propertyLocation = refFinder(schema.properties[key].$ref, location);
+ schema.properties[key] = propertyLocation.schema;
+ }
+ const type = schema.properties[key].type;
+ const nullable = schema.properties[key].nullable;
+ const sanitized = JSON.stringify(key);
+ const asString = JSON.stringify(sanitized);
+ if (nullable) {
+ code += `
+ if (obj[${sanitized}] === null) {
+ ${addComma}
+ json += ${asString} + ':null'
+ var rendered = true
+ } else {
+ `;
+ }
+ if (type === "number") {
+ code += `
+ var t = Number(obj[${sanitized}])
+ if (!isNaN(t)) {
+ ${addComma}
+ json += ${asString} + ':' + t
+ `;
+ } else if (type === "integer") {
+ code += `
+ var rendered = false
+ `;
+ if (isLong) {
+ code += `
+ if (isLong(obj[${sanitized}])) {
+ ${addComma}
+ json += ${asString} + ':' + obj[${sanitized}].toString()
+ rendered = true
+ } else {
+ var t = Number(obj[${sanitized}])
+ if (!isNaN(t)) {
+ ${addComma}
+ json += ${asString} + ':' + t
+ rendered = true
+ }
+ }
+ `;
+ } else {
+ code += `
+ var t = $asInteger(obj[${sanitized}])
+ if (!isNaN(t)) {
+ ${addComma}
+ json += ${asString} + ':' + t
+ rendered = true
+ }
+ `;
+ }
+ code += `
+ if (rendered) {
+ `;
+ } else {
+ code += `
+ if (obj[${sanitized}] !== undefined) {
+ ${addComma}
+ json += ${asString} + ':'
+ `;
+ const result = nested(laterCode, name, key, mergeLocation(propertyLocation, { schema: schema.properties[key] }), void 0, false);
+ code += result.code;
+ laterCode = result.laterCode;
+ }
+ const defaultValue = schema.properties[key].default;
+ if (defaultValue !== void 0) {
+ required = filterRequired(required, key);
+ code += `
+ } else {
+ ${addComma}
+ json += ${asString} + ':' + ${JSON.stringify(JSON.stringify(defaultValue))}
+ `;
+ } else if (required && required.indexOf(key) !== -1) {
+ required = filterRequired(required, key);
+ code += `
+ } else {
+ throw new Error('${sanitized} is required!')
+ `;
+ }
+ code += `
+ }
+ `;
+ if (nullable) {
+ code += `
+ }
+ `;
+ }
+ });
+ if (required && required.length > 0) {
+ code += "var required = [";
+ for (var i = 0; i < required.length; i++) {
+ if (i > 0) {
+ code += ",";
+ }
+ code += `${JSON.stringify(required[i])}`;
+ }
+ code += `]
+ for (var i = 0; i < required.length; i++) {
+ if (obj[required[i]] === undefined) throw new Error('"' + required[i] + '" is required!')
+ }
+ `;
+ }
+ if (schema.allOf) {
+ const builtCode = buildCodeWithAllOfs(location, code, laterCode, name);
+ code = builtCode.code;
+ laterCode = builtCode.laterCode;
+ }
+ return { code, laterCode };
+ }
+ __name(buildCode, "buildCode");
+ function filterRequired(required, key) {
+ if (!required) {
+ return required;
+ }
+ return required.filter((k) => k !== key);
+ }
+ __name(filterRequired, "filterRequired");
+ function buildCodeWithAllOfs(location, code, laterCode, name) {
+ if (location.schema.allOf) {
+ location.schema.allOf.forEach((ss) => {
+ const builtCode = buildCodeWithAllOfs(mergeLocation(location, { schema: ss }), code, laterCode, name);
+ code = builtCode.code;
+ laterCode = builtCode.laterCode;
+ });
+ } else {
+ const builtCode = buildCode(location, code, laterCode, name);
+ code = builtCode.code;
+ laterCode = builtCode.laterCode;
+ }
+ return { code, laterCode };
+ }
+ __name(buildCodeWithAllOfs, "buildCodeWithAllOfs");
+ function buildInnerObject(location, name) {
+ const schema = location.schema;
+ const result = buildCodeWithAllOfs(location, "", "", name);
+ if (schema.patternProperties) {
+ result.code += addPatternProperties(location);
+ } else if (schema.additionalProperties && !schema.patternProperties) {
+ result.code += addAdditionalProperties(location);
+ }
+ return result;
+ }
+ __name(buildInnerObject, "buildInnerObject");
+ function addIfThenElse(location, name) {
+ let code = "";
+ let r;
+ let laterCode = "";
+ let innerR;
+ const schema = location.schema;
+ const copy = merge({}, schema);
+ const i = copy.if;
+ const then = copy.then;
+ const e2 = copy.else ? copy.else : { additionalProperties: true };
+ delete copy.if;
+ delete copy.then;
+ delete copy.else;
+ let merged = merge(copy, then);
+ let mergedLocation = mergeLocation(location, { schema: merged });
+ code += `
+ valid = ajv.validate(${JSON.stringify(i)}, obj)
+ if (valid) {
+ `;
+ if (merged.if && merged.then) {
+ innerR = addIfThenElse(mergedLocation, name + "Then");
+ code += innerR.code;
+ laterCode = innerR.laterCode;
+ }
+ r = buildInnerObject(mergedLocation, name + "Then");
+ code += r.code;
+ laterCode += r.laterCode;
+ code += `
+ }
+ `;
+ merged = merge(copy, e2);
+ mergedLocation = mergeLocation(mergedLocation, { schema: merged });
+ code += `
+ else {
+ `;
+ if (merged.if && merged.then) {
+ innerR = addIfThenElse(mergedLocation, name + "Else");
+ code += innerR.code;
+ laterCode += innerR.laterCode;
+ }
+ r = buildInnerObject(mergedLocation, name + "Else");
+ code += r.code;
+ laterCode += r.laterCode;
+ code += `
+ }
+ `;
+ return { code, laterCode };
+ }
+ __name(addIfThenElse, "addIfThenElse");
+ function toJSON(variableName) {
+ return `(${variableName} && typeof ${variableName}.toJSON === 'function')
+ ? ${variableName}.toJSON()
+ : ${variableName}
+ `;
+ }
+ __name(toJSON, "toJSON");
+ function buildObject(location, code, name) {
+ const schema = location.schema;
+ code += `
+ function ${name} (input) {
+ `;
+ if (schema.nullable) {
+ code += `
+ if(input === null) {
+ return 'null';
+ }
+ `;
+ }
+ if (objectReferenceSerializersMap.has(schema)) {
+ code += `
+ return ${objectReferenceSerializersMap.get(schema)}(input)
+ }
+ `;
+ return code;
+ }
+ objectReferenceSerializersMap.set(schema, name);
+ code += `
+ var obj = ${toJSON("input")}
+ var json = '{'
+ var addComma = false
+ `;
+ let r;
+ if (schema.if && schema.then) {
+ code += `
+ var valid
+ `;
+ r = addIfThenElse(location, name);
+ } else {
+ r = buildInnerObject(location, name);
+ }
+ code += `${r.code}
+ json += '}'
+ return json
+ }
+ ${r.laterCode}
+ `;
+ return code;
+ }
+ __name(buildObject, "buildObject");
+ function buildArray(location, code, name, key = null) {
+ let schema = location.schema;
+ code += `
+ function ${name} (obj) {
+ `;
+ if (schema.nullable) {
+ code += `
+ if(obj === null) {
+ return 'null';
+ }
+ `;
+ }
+ const laterCode = "";
+ if (!schema.items) {
+ schema.items = {};
+ }
+ if (schema.items.$ref) {
+ if (!schema[fjsCloned]) {
+ location.schema = clone(location.schema);
+ schema = location.schema;
+ schema[fjsCloned] = true;
+ }
+ location = refFinder(schema.items.$ref, location);
+ schema.items = location.schema;
+ if (arrayItemsReferenceSerializersMap.has(schema.items)) {
+ code += `
+ return ${arrayItemsReferenceSerializersMap.get(schema.items)}(obj)
+ }
+ `;
+ return code;
+ }
+ arrayItemsReferenceSerializersMap.set(schema.items, name);
+ }
+ let result = { code: "", laterCode: "" };
+ const accessor = "[i]";
+ if (Array.isArray(schema.items)) {
+ result = schema.items.reduce((res, item, i) => {
+ const tmpRes = nested(laterCode, name, accessor, mergeLocation(location, { schema: item }), i, true);
+ const condition = `i === ${i} && ${buildArrayTypeCondition(item.type, accessor)}`;
+ return {
+ code: `${res.code}
+ ${i > 0 ? "else" : ""} if (${condition}) {
+ ${tmpRes.code}
+ }`,
+ laterCode: `${res.laterCode}
+ ${tmpRes.laterCode}`
+ };
+ }, result);
+ if (schema.additionalItems) {
+ const tmpRes = nested(laterCode, name, accessor, mergeLocation(location, { schema: schema.items }), void 0, true);
+ result.code += `
+ else if (i >= ${schema.items.length}) {
+ ${tmpRes.code}
+ }
+ `;
+ }
+ result.code += `
+ else {
+ throw new Error(\`Item at \${i} does not match schema definition.\`)
+ }
+ `;
+ } else {
+ result = nested(laterCode, name, accessor, mergeLocation(location, { schema: schema.items }), void 0, true);
+ }
+ if (key) {
+ code += `
+ if(!Array.isArray(obj)) {
+ throw new TypeError(\`Property '${key}' should be of type array, received '\${obj}' instead.\`)
+ }
+ `;
+ }
+ code += `
+ var l = obj.length
+ var jsonOutput= ''
+ for (var i = 0; i < l; i++) {
+ var json = ''
+ ${result.code}
+ jsonOutput += json
+
+ if (json.length > 0 && i < l - 1) {
+ jsonOutput += ','
+ }
+ }
+ return \`[\${jsonOutput}]\`
+ }
+ ${result.laterCode}
+ `;
+ return code;
+ }
+ __name(buildArray, "buildArray");
+ function buildArrayTypeCondition(type, accessor) {
+ let condition;
+ switch (type) {
+ case "null":
+ condition = `obj${accessor} === null`;
+ break;
+ case "string":
+ condition = `typeof obj${accessor} === 'string'`;
+ break;
+ case "integer":
+ condition = `Number.isInteger(obj${accessor})`;
+ break;
+ case "number":
+ condition = `Number.isFinite(obj${accessor})`;
+ break;
+ case "boolean":
+ condition = `typeof obj${accessor} === 'boolean'`;
+ break;
+ case "object":
+ condition = `obj${accessor} && typeof obj${accessor} === 'object' && obj${accessor}.constructor === Object`;
+ break;
+ case "array":
+ condition = `Array.isArray(obj${accessor})`;
+ break;
+ default:
+ if (Array.isArray(type)) {
+ const conditions = type.map((subType) => {
+ return buildArrayTypeCondition(subType, accessor);
+ });
+ condition = `(${conditions.join(" || ")})`;
+ } else {
+ throw new Error(`${type} unsupported`);
+ }
+ }
+ return condition;
+ }
+ __name(buildArrayTypeCondition, "buildArrayTypeCondition");
+ function dereferenceOfRefs(location, type) {
+ if (!location.schema[fjsCloned]) {
+ const schemaClone = clone(location.schema);
+ schemaClone[fjsCloned] = true;
+ location.schema = schemaClone;
+ }
+ const schema = location.schema;
+ const locations = [];
+ schema[type].forEach((s, index) => {
+ let sLocation = mergeLocation(location, { schema: s });
+ while (s.$ref) {
+ sLocation = refFinder(s.$ref, sLocation);
+ schema[type][index] = sLocation.schema;
+ s = schema[type][index];
+ }
+ locations[index] = sLocation;
+ });
+ return locations;
+ }
+ __name(dereferenceOfRefs, "dereferenceOfRefs");
+ var strNameCounter = 0;
+ function asFuncName(str) {
+ let rep = str.replace(/[^a-zA-Z0-9$_]/g, "");
+ if (rep.length === 0) {
+ return "anan" + strNameCounter++;
+ } else if (rep !== str) {
+ rep += strNameCounter++;
+ }
+ return rep;
+ }
+ __name(asFuncName, "asFuncName");
+ function nested(laterCode, name, key, location, subKey, isArray) {
+ let code = "";
+ let funcName;
+ subKey = subKey || "";
+ let schema = location.schema;
+ if (schema.$ref) {
+ schema = refFinder(schema.$ref, location);
+ }
+ if (schema.type === void 0) {
+ const inferredType = inferTypeByKeyword(schema);
+ if (inferredType) {
+ schema.type = inferredType;
+ }
+ }
+ const type = schema.type;
+ const nullable = schema.nullable === true;
+ const accessor = isArray ? key : `[${JSON.stringify(key)}]`;
+ switch (type) {
+ case "null":
+ code += `
+ json += $asNull()
+ `;
+ break;
+ case "string": {
+ const stringSerializer = getStringSerializer(schema.format);
+ code += nullable ? `json += obj${accessor} === null ? null : ${stringSerializer}(obj${accessor})` : `json += ${stringSerializer}(obj${accessor})`;
+ break;
+ }
+ case "integer":
+ code += nullable ? `json += obj${accessor} === null ? null : $asInteger(obj${accessor})` : `json += $asInteger(obj${accessor})`;
+ break;
+ case "number":
+ code += nullable ? `json += obj${accessor} === null ? null : $asNumber(obj${accessor})` : `json += $asNumber(obj${accessor})`;
+ break;
+ case "boolean":
+ code += nullable ? `json += obj${accessor} === null ? null : $asBoolean(obj${accessor})` : `json += $asBoolean(obj${accessor})`;
+ break;
+ case "object":
+ funcName = asFuncName(name + key + subKey);
+ laterCode = buildObject(location, laterCode, funcName);
+ code += `
+ json += ${funcName}(obj${accessor})
+ `;
+ break;
+ case "array":
+ funcName = asFuncName("$arr" + name + key + subKey);
+ laterCode = buildArray(location, laterCode, funcName, key);
+ code += `
+ json += ${funcName}(obj${accessor})
+ `;
+ break;
+ case void 0:
+ if ("anyOf" in schema) {
+ const anyOfLocations = dereferenceOfRefs(location, "anyOf");
+ anyOfLocations.forEach((location2, index) => {
+ const nestedResult = nested(laterCode, name, key, location2, subKey !== "" ? subKey : "i" + index, isArray);
+ const testSerializer = getTestSerializer(location2.schema.format);
+ const testValue = testSerializer !== void 0 ? `${testSerializer}(obj${accessor}, true)` : `obj${accessor}`;
+ code += `
+ ${index === 0 ? "if" : "else if"}(ajv.validate(${JSON.stringify(location2.schema)}, ${testValue}))
+ ${nestedResult.code}
+ `;
+ laterCode = nestedResult.laterCode;
+ });
+ code += `
+ else json+= null
+ `;
+ } else if ("oneOf" in schema) {
+ const oneOfLocations = dereferenceOfRefs(location, "oneOf");
+ oneOfLocations.forEach((location2, index) => {
+ const nestedResult = nested(laterCode, name, key, location2, subKey !== "" ? subKey : "i" + index, isArray);
+ const testSerializer = getTestSerializer(location2.schema.format);
+ const testValue = testSerializer !== void 0 ? `${testSerializer}(obj${accessor}, true)` : `obj${accessor}`;
+ code += `
+ ${index === 0 ? "if" : "else if"}(ajv.validate(${JSON.stringify(location2.schema)}, ${testValue}))
+ ${nestedResult.code}
+ `;
+ laterCode = nestedResult.laterCode;
+ });
+ if (!isArray) {
+ code += `
+ else json+= null
+ `;
+ }
+ } else if (isEmpty(schema)) {
+ code += `
+ json += JSON.stringify(obj${accessor})
+ `;
+ } else if ("const" in schema) {
+ code += `
+ if(ajv.validate(${JSON.stringify(schema)}, obj${accessor}))
+ json += '${JSON.stringify(schema.const)}'
+ else
+ throw new Error(\`Item \${JSON.stringify(obj${accessor})} does not match schema definition.\`)
+ `;
+ } else if (schema.type === void 0) {
+ code += `
+ json += JSON.stringify(obj${accessor})
+ `;
+ } else {
+ throw new Error(`${schema.type} unsupported`);
+ }
+ break;
+ default:
+ if (Array.isArray(type)) {
+ const nullIndex = type.indexOf("null");
+ const sortedTypes = nullIndex !== -1 ? [type[nullIndex]].concat(type.slice(0, nullIndex)).concat(type.slice(nullIndex + 1)) : type;
+ sortedTypes.forEach((type2, index) => {
+ const statement = index === 0 ? "if" : "else if";
+ const tempSchema = Object.assign({}, schema, { type: type2 });
+ const nestedResult = nested(laterCode, name, key, mergeLocation(location, { schema: tempSchema }), subKey, isArray);
+ switch (type2) {
+ case "string": {
+ code += `
+ ${statement}(obj${accessor} === null || typeof obj${accessor} === "${type2}" || obj${accessor} instanceof Date || typeof obj${accessor}.toISOString === "function" || obj${accessor} instanceof RegExp || (typeof obj${accessor} === "object" && Object.hasOwnProperty.call(obj${accessor}, "toString")))
+ ${nestedResult.code}
+ `;
+ break;
+ }
+ case "null": {
+ code += `
+ ${statement}(obj${accessor} == null)
+ ${nestedResult.code}
+ `;
+ break;
+ }
+ case "array": {
+ code += `
+ ${statement}(Array.isArray(obj${accessor}))
+ ${nestedResult.code}
+ `;
+ break;
+ }
+ case "integer": {
+ code += `
+ ${statement}(Number.isInteger(obj${accessor}) || obj${accessor} === null)
+ ${nestedResult.code}
+ `;
+ break;
+ }
+ case "number": {
+ code += `
+ ${statement}(isNaN(obj${accessor}) === false)
+ ${nestedResult.code}
+ `;
+ break;
+ }
+ default: {
+ code += `
+ ${statement}(typeof obj${accessor} === "${type2}")
+ ${nestedResult.code}
+ `;
+ break;
+ }
+ }
+ laterCode = nestedResult.laterCode;
+ });
+ code += `
+ else json+= null
+ `;
+ } else {
+ throw new Error(`${type} unsupported`);
+ }
+ }
+ return {
+ code,
+ laterCode
+ };
+ }
+ __name(nested, "nested");
+ function isEmpty(schema) {
+ for (var key in schema) {
+ if (schema.hasOwnProperty(key) && schema[key] !== void 0) {
+ return false;
+ }
+ }
+ return true;
+ }
+ __name(isEmpty, "isEmpty");
+ module2.exports = build5;
+ module2.exports.restore = function(debugModeStr, options14 = {}) {
+ const dependencies = [debugModeStr];
+ const args = [];
+ if (debugModeStr.startsWith("ajv")) {
+ dependencies.unshift("ajv");
+ args.push(new Ajv(options14.ajv));
+ }
+ return Function.apply(null, ["ajv", debugModeStr]).apply(null, args);
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/fast-safe-stringify@2.1.1/node_modules/fast-safe-stringify/index.js
+var require_fast_safe_stringify = __commonJS({
+ "../../node_modules/.pnpm/fast-safe-stringify@2.1.1/node_modules/fast-safe-stringify/index.js"(exports2, module2) {
+ init_import_meta_url();
+ module2.exports = stringify;
+ stringify.default = stringify;
+ stringify.stable = deterministicStringify;
+ stringify.stableStringify = deterministicStringify;
+ var LIMIT_REPLACE_NODE = "[...]";
+ var CIRCULAR_REPLACE_NODE = "[Circular]";
+ var arr = [];
+ var replacerStack = [];
+ function defaultOptions() {
+ return {
+ depthLimit: Number.MAX_SAFE_INTEGER,
+ edgesLimit: Number.MAX_SAFE_INTEGER
+ };
+ }
+ __name(defaultOptions, "defaultOptions");
+ function stringify(obj, replacer2, spacer, options14) {
+ if (typeof options14 === "undefined") {
+ options14 = defaultOptions();
+ }
+ decirc(obj, "", 0, [], void 0, 0, options14);
+ var res;
+ try {
+ if (replacerStack.length === 0) {
+ res = JSON.stringify(obj, replacer2, spacer);
+ } else {
+ res = JSON.stringify(obj, replaceGetterValues(replacer2), spacer);
+ }
+ } catch (_2) {
+ return JSON.stringify("[unable to serialize, circular reference is too complex to analyze]");
+ } finally {
+ while (arr.length !== 0) {
+ var part = arr.pop();
+ if (part.length === 4) {
+ Object.defineProperty(part[0], part[1], part[3]);
+ } else {
+ part[0][part[1]] = part[2];
+ }
+ }
+ }
+ return res;
+ }
+ __name(stringify, "stringify");
+ function setReplace(replace, val, k, parent) {
+ var propertyDescriptor = Object.getOwnPropertyDescriptor(parent, k);
+ if (propertyDescriptor.get !== void 0) {
+ if (propertyDescriptor.configurable) {
+ Object.defineProperty(parent, k, { value: replace });
+ arr.push([parent, k, val, propertyDescriptor]);
+ } else {
+ replacerStack.push([val, k, replace]);
+ }
+ } else {
+ parent[k] = replace;
+ arr.push([parent, k, val]);
+ }
+ }
+ __name(setReplace, "setReplace");
+ function decirc(val, k, edgeIndex, stack, parent, depth, options14) {
+ depth += 1;
+ var i;
+ if (typeof val === "object" && val !== null) {
+ for (i = 0; i < stack.length; i++) {
+ if (stack[i] === val) {
+ setReplace(CIRCULAR_REPLACE_NODE, val, k, parent);
+ return;
+ }
+ }
+ if (typeof options14.depthLimit !== "undefined" && depth > options14.depthLimit) {
+ setReplace(LIMIT_REPLACE_NODE, val, k, parent);
+ return;
+ }
+ if (typeof options14.edgesLimit !== "undefined" && edgeIndex + 1 > options14.edgesLimit) {
+ setReplace(LIMIT_REPLACE_NODE, val, k, parent);
+ return;
+ }
+ stack.push(val);
+ if (Array.isArray(val)) {
+ for (i = 0; i < val.length; i++) {
+ decirc(val[i], i, i, stack, val, depth, options14);
+ }
+ } else {
+ var keys = Object.keys(val);
+ for (i = 0; i < keys.length; i++) {
+ var key = keys[i];
+ decirc(val[key], key, i, stack, val, depth, options14);
+ }
+ }
+ stack.pop();
+ }
+ }
+ __name(decirc, "decirc");
+ function compareFunction(a, b) {
+ if (a < b) {
+ return -1;
+ }
+ if (a > b) {
+ return 1;
+ }
+ return 0;
+ }
+ __name(compareFunction, "compareFunction");
+ function deterministicStringify(obj, replacer2, spacer, options14) {
+ if (typeof options14 === "undefined") {
+ options14 = defaultOptions();
+ }
+ var tmp5 = deterministicDecirc(obj, "", 0, [], void 0, 0, options14) || obj;
+ var res;
+ try {
+ if (replacerStack.length === 0) {
+ res = JSON.stringify(tmp5, replacer2, spacer);
+ } else {
+ res = JSON.stringify(tmp5, replaceGetterValues(replacer2), spacer);
+ }
+ } catch (_2) {
+ return JSON.stringify("[unable to serialize, circular reference is too complex to analyze]");
+ } finally {
+ while (arr.length !== 0) {
+ var part = arr.pop();
+ if (part.length === 4) {
+ Object.defineProperty(part[0], part[1], part[3]);
+ } else {
+ part[0][part[1]] = part[2];
+ }
+ }
+ }
+ return res;
+ }
+ __name(deterministicStringify, "deterministicStringify");
+ function deterministicDecirc(val, k, edgeIndex, stack, parent, depth, options14) {
+ depth += 1;
+ var i;
+ if (typeof val === "object" && val !== null) {
+ for (i = 0; i < stack.length; i++) {
+ if (stack[i] === val) {
+ setReplace(CIRCULAR_REPLACE_NODE, val, k, parent);
+ return;
+ }
+ }
+ try {
+ if (typeof val.toJSON === "function") {
+ return;
+ }
+ } catch (_2) {
+ return;
+ }
+ if (typeof options14.depthLimit !== "undefined" && depth > options14.depthLimit) {
+ setReplace(LIMIT_REPLACE_NODE, val, k, parent);
+ return;
+ }
+ if (typeof options14.edgesLimit !== "undefined" && edgeIndex + 1 > options14.edgesLimit) {
+ setReplace(LIMIT_REPLACE_NODE, val, k, parent);
+ return;
+ }
+ stack.push(val);
+ if (Array.isArray(val)) {
+ for (i = 0; i < val.length; i++) {
+ deterministicDecirc(val[i], i, i, stack, val, depth, options14);
+ }
+ } else {
+ var tmp5 = {};
+ var keys = Object.keys(val).sort(compareFunction);
+ for (i = 0; i < keys.length; i++) {
+ var key = keys[i];
+ deterministicDecirc(val[key], key, i, stack, val, depth, options14);
+ tmp5[key] = val[key];
+ }
+ if (typeof parent !== "undefined") {
+ arr.push([parent, k, val]);
+ parent[k] = tmp5;
+ } else {
+ return tmp5;
+ }
+ }
+ stack.pop();
+ }
+ }
+ __name(deterministicDecirc, "deterministicDecirc");
+ function replaceGetterValues(replacer2) {
+ replacer2 = typeof replacer2 !== "undefined" ? replacer2 : function(k, v) {
+ return v;
+ };
+ return function(key, val) {
+ if (replacerStack.length > 0) {
+ for (var i = 0; i < replacerStack.length; i++) {
+ var part = replacerStack[i];
+ if (part[1] === key && part[0] === val) {
+ val = part[2];
+ replacerStack.splice(i, 1);
+ break;
+ }
+ }
+ }
+ return replacer2.call(this, key, val);
+ };
+ }
+ __name(replaceGetterValues, "replaceGetterValues");
+ }
+});
+
+// ../../node_modules/.pnpm/object-keys@1.1.1/node_modules/object-keys/isArguments.js
+var require_isArguments = __commonJS({
+ "../../node_modules/.pnpm/object-keys@1.1.1/node_modules/object-keys/isArguments.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var toStr = Object.prototype.toString;
+ module2.exports = /* @__PURE__ */ __name(function isArguments(value) {
+ var str = toStr.call(value);
+ var isArgs = str === "[object Arguments]";
+ if (!isArgs) {
+ isArgs = str !== "[object Array]" && value !== null && typeof value === "object" && typeof value.length === "number" && value.length >= 0 && toStr.call(value.callee) === "[object Function]";
+ }
+ return isArgs;
+ }, "isArguments");
+ }
+});
+
+// ../../node_modules/.pnpm/object-keys@1.1.1/node_modules/object-keys/implementation.js
+var require_implementation2 = __commonJS({
+ "../../node_modules/.pnpm/object-keys@1.1.1/node_modules/object-keys/implementation.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var keysShim;
+ if (!Object.keys) {
+ has = Object.prototype.hasOwnProperty;
+ toStr = Object.prototype.toString;
+ isArgs = require_isArguments();
+ isEnumerable = Object.prototype.propertyIsEnumerable;
+ hasDontEnumBug = !isEnumerable.call({ toString: null }, "toString");
+ hasProtoEnumBug = isEnumerable.call(function() {
+ }, "prototype");
+ dontEnums = [
+ "toString",
+ "toLocaleString",
+ "valueOf",
+ "hasOwnProperty",
+ "isPrototypeOf",
+ "propertyIsEnumerable",
+ "constructor"
+ ];
+ equalsConstructorPrototype = /* @__PURE__ */ __name(function(o) {
+ var ctor = o.constructor;
+ return ctor && ctor.prototype === o;
+ }, "equalsConstructorPrototype");
+ excludedKeys = {
+ $applicationCache: true,
+ $console: true,
+ $external: true,
+ $frame: true,
+ $frameElement: true,
+ $frames: true,
+ $innerHeight: true,
+ $innerWidth: true,
+ $onmozfullscreenchange: true,
+ $onmozfullscreenerror: true,
+ $outerHeight: true,
+ $outerWidth: true,
+ $pageXOffset: true,
+ $pageYOffset: true,
+ $parent: true,
+ $scrollLeft: true,
+ $scrollTop: true,
+ $scrollX: true,
+ $scrollY: true,
+ $self: true,
+ $webkitIndexedDB: true,
+ $webkitStorageInfo: true,
+ $window: true
+ };
+ hasAutomationEqualityBug = function() {
+ if (typeof window === "undefined") {
+ return false;
+ }
+ for (var k in window) {
+ try {
+ if (!excludedKeys["$" + k] && has.call(window, k) && window[k] !== null && typeof window[k] === "object") {
+ try {
+ equalsConstructorPrototype(window[k]);
+ } catch (e2) {
+ return true;
+ }
+ }
+ } catch (e2) {
+ return true;
+ }
+ }
+ return false;
+ }();
+ equalsConstructorPrototypeIfNotBuggy = /* @__PURE__ */ __name(function(o) {
+ if (typeof window === "undefined" || !hasAutomationEqualityBug) {
+ return equalsConstructorPrototype(o);
+ }
+ try {
+ return equalsConstructorPrototype(o);
+ } catch (e2) {
+ return false;
+ }
+ }, "equalsConstructorPrototypeIfNotBuggy");
+ keysShim = /* @__PURE__ */ __name(function keys(object) {
+ var isObject2 = object !== null && typeof object === "object";
+ var isFunction2 = toStr.call(object) === "[object Function]";
+ var isArguments = isArgs(object);
+ var isString2 = isObject2 && toStr.call(object) === "[object String]";
+ var theKeys = [];
+ if (!isObject2 && !isFunction2 && !isArguments) {
+ throw new TypeError("Object.keys called on a non-object");
+ }
+ var skipProto = hasProtoEnumBug && isFunction2;
+ if (isString2 && object.length > 0 && !has.call(object, 0)) {
+ for (var i = 0; i < object.length; ++i) {
+ theKeys.push(String(i));
+ }
+ }
+ if (isArguments && object.length > 0) {
+ for (var j = 0; j < object.length; ++j) {
+ theKeys.push(String(j));
+ }
+ } else {
+ for (var name in object) {
+ if (!(skipProto && name === "prototype") && has.call(object, name)) {
+ theKeys.push(String(name));
+ }
+ }
+ }
+ if (hasDontEnumBug) {
+ var skipConstructor = equalsConstructorPrototypeIfNotBuggy(object);
+ for (var k = 0; k < dontEnums.length; ++k) {
+ if (!(skipConstructor && dontEnums[k] === "constructor") && has.call(object, dontEnums[k])) {
+ theKeys.push(dontEnums[k]);
+ }
+ }
+ }
+ return theKeys;
+ }, "keys");
+ }
+ var has;
+ var toStr;
+ var isArgs;
+ var isEnumerable;
+ var hasDontEnumBug;
+ var hasProtoEnumBug;
+ var dontEnums;
+ var equalsConstructorPrototype;
+ var excludedKeys;
+ var hasAutomationEqualityBug;
+ var equalsConstructorPrototypeIfNotBuggy;
+ module2.exports = keysShim;
+ }
+});
+
+// ../../node_modules/.pnpm/object-keys@1.1.1/node_modules/object-keys/index.js
+var require_object_keys = __commonJS({
+ "../../node_modules/.pnpm/object-keys@1.1.1/node_modules/object-keys/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var slice = Array.prototype.slice;
+ var isArgs = require_isArguments();
+ var origKeys = Object.keys;
+ var keysShim = origKeys ? /* @__PURE__ */ __name(function keys(o) {
+ return origKeys(o);
+ }, "keys") : require_implementation2();
+ var originalKeys = Object.keys;
+ keysShim.shim = /* @__PURE__ */ __name(function shimObjectKeys() {
+ if (Object.keys) {
+ var keysWorksWithArguments = function() {
+ var args = Object.keys(arguments);
+ return args && args.length === arguments.length;
+ }(1, 2);
+ if (!keysWorksWithArguments) {
+ Object.keys = /* @__PURE__ */ __name(function keys(object) {
+ if (isArgs(object)) {
+ return originalKeys(slice.call(object));
+ }
+ return originalKeys(object);
+ }, "keys");
+ }
+ } else {
+ Object.keys = keysShim;
+ }
+ return Object.keys || keysShim;
+ }, "shimObjectKeys");
+ module2.exports = keysShim;
+ }
+});
+
+// ../../node_modules/.pnpm/has-property-descriptors@1.0.0/node_modules/has-property-descriptors/index.js
+var require_has_property_descriptors = __commonJS({
+ "../../node_modules/.pnpm/has-property-descriptors@1.0.0/node_modules/has-property-descriptors/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var GetIntrinsic = require_get_intrinsic();
+ var $defineProperty = GetIntrinsic("%Object.defineProperty%", true);
+ var hasPropertyDescriptors = /* @__PURE__ */ __name(function hasPropertyDescriptors2() {
+ if ($defineProperty) {
+ try {
+ $defineProperty({}, "a", { value: 1 });
+ return true;
+ } catch (e2) {
+ return false;
+ }
+ }
+ return false;
+ }, "hasPropertyDescriptors");
+ hasPropertyDescriptors.hasArrayLengthDefineBug = /* @__PURE__ */ __name(function hasArrayLengthDefineBug() {
+ if (!hasPropertyDescriptors()) {
+ return null;
+ }
+ try {
+ return $defineProperty([], "length", { value: 1 }).length !== 1;
+ } catch (e2) {
+ return true;
+ }
+ }, "hasArrayLengthDefineBug");
+ module2.exports = hasPropertyDescriptors;
+ }
+});
+
+// ../../node_modules/.pnpm/define-properties@1.2.0/node_modules/define-properties/index.js
+var require_define_properties = __commonJS({
+ "../../node_modules/.pnpm/define-properties@1.2.0/node_modules/define-properties/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var keys = require_object_keys();
+ var hasSymbols = typeof Symbol === "function" && typeof Symbol("foo") === "symbol";
+ var toStr = Object.prototype.toString;
+ var concat = Array.prototype.concat;
+ var origDefineProperty = Object.defineProperty;
+ var isFunction2 = /* @__PURE__ */ __name(function(fn2) {
+ return typeof fn2 === "function" && toStr.call(fn2) === "[object Function]";
+ }, "isFunction");
+ var hasPropertyDescriptors = require_has_property_descriptors()();
+ var supportsDescriptors = origDefineProperty && hasPropertyDescriptors;
+ var defineProperty2 = /* @__PURE__ */ __name(function(object, name, value, predicate) {
+ if (name in object) {
+ if (predicate === true) {
+ if (object[name] === value) {
+ return;
+ }
+ } else if (!isFunction2(predicate) || !predicate()) {
+ return;
+ }
+ }
+ if (supportsDescriptors) {
+ origDefineProperty(object, name, {
+ configurable: true,
+ enumerable: false,
+ value,
+ writable: true
+ });
+ } else {
+ object[name] = value;
+ }
+ }, "defineProperty");
+ var defineProperties = /* @__PURE__ */ __name(function(object, map) {
+ var predicates = arguments.length > 2 ? arguments[2] : {};
+ var props = keys(map);
+ if (hasSymbols) {
+ props = concat.call(props, Object.getOwnPropertySymbols(map));
+ }
+ for (var i = 0; i < props.length; i += 1) {
+ defineProperty2(object, props[i], map[props[i]], predicates[props[i]]);
+ }
+ }, "defineProperties");
+ defineProperties.supportsDescriptors = !!supportsDescriptors;
+ module2.exports = defineProperties;
+ }
+});
+
+// ../../node_modules/.pnpm/globalthis@1.0.3/node_modules/globalthis/implementation.js
+var require_implementation3 = __commonJS({
+ "../../node_modules/.pnpm/globalthis@1.0.3/node_modules/globalthis/implementation.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ module2.exports = global;
+ }
+});
+
+// ../../node_modules/.pnpm/globalthis@1.0.3/node_modules/globalthis/polyfill.js
+var require_polyfill = __commonJS({
+ "../../node_modules/.pnpm/globalthis@1.0.3/node_modules/globalthis/polyfill.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var implementation = require_implementation3();
+ module2.exports = /* @__PURE__ */ __name(function getPolyfill() {
+ if (typeof global !== "object" || !global || global.Math !== Math || global.Array !== Array) {
+ return implementation;
+ }
+ return global;
+ }, "getPolyfill");
+ }
+});
+
+// ../../node_modules/.pnpm/globalthis@1.0.3/node_modules/globalthis/shim.js
+var require_shim = __commonJS({
+ "../../node_modules/.pnpm/globalthis@1.0.3/node_modules/globalthis/shim.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var define2 = require_define_properties();
+ var getPolyfill = require_polyfill();
+ module2.exports = /* @__PURE__ */ __name(function shimGlobal() {
+ var polyfill2 = getPolyfill();
+ if (define2.supportsDescriptors) {
+ var descriptor2 = Object.getOwnPropertyDescriptor(polyfill2, "globalThis");
+ if (!descriptor2 || descriptor2.configurable && (descriptor2.enumerable || !descriptor2.writable || globalThis !== polyfill2)) {
+ Object.defineProperty(polyfill2, "globalThis", {
+ configurable: true,
+ enumerable: false,
+ value: polyfill2,
+ writable: true
+ });
+ }
+ } else if (typeof globalThis !== "object" || globalThis !== polyfill2) {
+ polyfill2.globalThis = polyfill2;
+ }
+ return polyfill2;
+ }, "shimGlobal");
+ }
+});
+
+// ../../node_modules/.pnpm/globalthis@1.0.3/node_modules/globalthis/index.js
+var require_globalthis = __commonJS({
+ "../../node_modules/.pnpm/globalthis@1.0.3/node_modules/globalthis/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var defineProperties = require_define_properties();
+ var implementation = require_implementation3();
+ var getPolyfill = require_polyfill();
+ var shim3 = require_shim();
+ var polyfill2 = getPolyfill();
+ var getGlobal = /* @__PURE__ */ __name(function() {
+ return polyfill2;
+ }, "getGlobal");
+ defineProperties(getGlobal, {
+ getPolyfill,
+ implementation,
+ shim: shim3
+ });
+ module2.exports = getGlobal;
+ }
+});
+
+// ../../node_modules/.pnpm/roarr@7.11.0/node_modules/roarr/dist/src/constants.js
+var require_constants6 = __commonJS({
+ "../../node_modules/.pnpm/roarr@7.11.0/node_modules/roarr/dist/src/constants.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ Object.defineProperty(exports2, "__esModule", { value: true });
+ exports2.logLevels = void 0;
+ exports2.logLevels = {
+ debug: 20,
+ error: 50,
+ fatal: 60,
+ info: 30,
+ trace: 10,
+ warn: 40
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/fast-printf@1.6.9/node_modules/fast-printf/dist/src/tokenize.js
+var require_tokenize = __commonJS({
+ "../../node_modules/.pnpm/fast-printf@1.6.9/node_modules/fast-printf/dist/src/tokenize.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ Object.defineProperty(exports2, "__esModule", { value: true });
+ exports2.tokenize = void 0;
+ var TokenRule = /(?:%(?([+0-]|-\+))?(?\d+)?(?\d+\$)?(?\.\d+)?(?[%BCESb-iosux]))|(\\%)/g;
+ var tokenize = /* @__PURE__ */ __name((subject) => {
+ let matchResult;
+ const tokens = [];
+ let argumentIndex = 0;
+ let lastIndex = 0;
+ let lastToken = null;
+ while ((matchResult = TokenRule.exec(subject)) !== null) {
+ if (matchResult.index > lastIndex) {
+ lastToken = {
+ literal: subject.slice(lastIndex, matchResult.index),
+ type: "literal"
+ };
+ tokens.push(lastToken);
+ }
+ const match = matchResult[0];
+ lastIndex = matchResult.index + match.length;
+ if (match === "\\%" || match === "%%") {
+ if (lastToken && lastToken.type === "literal") {
+ lastToken.literal += "%";
+ } else {
+ lastToken = {
+ literal: "%",
+ type: "literal"
+ };
+ tokens.push(lastToken);
+ }
+ } else if (matchResult.groups) {
+ lastToken = {
+ conversion: matchResult.groups.conversion,
+ flag: matchResult.groups.flag || null,
+ placeholder: match,
+ position: matchResult.groups.position ? Number.parseInt(matchResult.groups.position, 10) - 1 : argumentIndex++,
+ precision: matchResult.groups.precision ? Number.parseInt(matchResult.groups.precision.slice(1), 10) : null,
+ type: "placeholder",
+ width: matchResult.groups.width ? Number.parseInt(matchResult.groups.width, 10) : null
+ };
+ tokens.push(lastToken);
+ }
+ }
+ if (lastIndex <= subject.length - 1) {
+ if (lastToken && lastToken.type === "literal") {
+ lastToken.literal += subject.slice(lastIndex);
+ } else {
+ tokens.push({
+ literal: subject.slice(lastIndex),
+ type: "literal"
+ });
+ }
+ }
+ return tokens;
+ }, "tokenize");
+ exports2.tokenize = tokenize;
+ }
+});
+
+// ../../node_modules/.pnpm/fast-printf@1.6.9/node_modules/fast-printf/dist/src/createPrintf.js
+var require_createPrintf = __commonJS({
+ "../../node_modules/.pnpm/fast-printf@1.6.9/node_modules/fast-printf/dist/src/createPrintf.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ Object.defineProperty(exports2, "__esModule", { value: true });
+ exports2.createPrintf = void 0;
+ var boolean_1 = require_lib5();
+ var tokenize_1 = require_tokenize();
+ var formatDefaultUnboundExpression = /* @__PURE__ */ __name((subject, token) => {
+ return token.placeholder;
+ }, "formatDefaultUnboundExpression");
+ var createPrintf = /* @__PURE__ */ __name((configuration) => {
+ var _a2;
+ const padValue = /* @__PURE__ */ __name((value, width, flag) => {
+ if (flag === "-") {
+ return value.padEnd(width, " ");
+ } else if (flag === "-+") {
+ return ((Number(value) >= 0 ? "+" : "") + value).padEnd(width, " ");
+ } else if (flag === "+") {
+ return ((Number(value) >= 0 ? "+" : "") + value).padStart(width, " ");
+ } else if (flag === "0") {
+ return value.padStart(width, "0");
+ } else {
+ return value.padStart(width, " ");
+ }
+ }, "padValue");
+ const formatUnboundExpression = (_a2 = configuration === null || configuration === void 0 ? void 0 : configuration.formatUnboundExpression) !== null && _a2 !== void 0 ? _a2 : formatDefaultUnboundExpression;
+ const cache2 = {};
+ return (subject, ...boundValues) => {
+ let tokens = cache2[subject];
+ if (!tokens) {
+ tokens = cache2[subject] = tokenize_1.tokenize(subject);
+ }
+ let result = "";
+ for (const token of tokens) {
+ if (token.type === "literal") {
+ result += token.literal;
+ } else {
+ let boundValue = boundValues[token.position];
+ if (boundValue === void 0) {
+ result += formatUnboundExpression(subject, token, boundValues);
+ } else if (token.conversion === "b") {
+ result += boolean_1.boolean(boundValue) ? "true" : "false";
+ } else if (token.conversion === "B") {
+ result += boolean_1.boolean(boundValue) ? "TRUE" : "FALSE";
+ } else if (token.conversion === "c") {
+ result += boundValue;
+ } else if (token.conversion === "C") {
+ result += String(boundValue).toUpperCase();
+ } else if (token.conversion === "i" || token.conversion === "d") {
+ boundValue = String(Math.trunc(boundValue));
+ if (token.width !== null) {
+ boundValue = padValue(boundValue, token.width, token.flag);
+ }
+ result += boundValue;
+ } else if (token.conversion === "e") {
+ result += Number(boundValue).toExponential();
+ } else if (token.conversion === "E") {
+ result += Number(boundValue).toExponential().toUpperCase();
+ } else if (token.conversion === "f") {
+ if (token.precision !== null) {
+ boundValue = Number(boundValue).toFixed(token.precision);
+ }
+ if (token.width !== null) {
+ boundValue = padValue(String(boundValue), token.width, token.flag);
+ }
+ result += boundValue;
+ } else if (token.conversion === "o") {
+ result += (Number.parseInt(String(boundValue), 10) >>> 0).toString(8);
+ } else if (token.conversion === "s") {
+ if (token.width !== null) {
+ boundValue = padValue(String(boundValue), token.width, token.flag);
+ }
+ result += boundValue;
+ } else if (token.conversion === "S") {
+ if (token.width !== null) {
+ boundValue = padValue(String(boundValue), token.width, token.flag);
+ }
+ result += String(boundValue).toUpperCase();
+ } else if (token.conversion === "u") {
+ result += Number.parseInt(String(boundValue), 10) >>> 0;
+ } else if (token.conversion === "x") {
+ boundValue = (Number.parseInt(String(boundValue), 10) >>> 0).toString(16);
+ if (token.width !== null) {
+ boundValue = padValue(String(boundValue), token.width, token.flag);
+ }
+ result += boundValue;
+ } else {
+ throw new Error("Unknown format specifier.");
+ }
+ }
+ }
+ return result;
+ };
+ }, "createPrintf");
+ exports2.createPrintf = createPrintf;
+ }
+});
+
+// ../../node_modules/.pnpm/fast-printf@1.6.9/node_modules/fast-printf/dist/src/printf.js
+var require_printf = __commonJS({
+ "../../node_modules/.pnpm/fast-printf@1.6.9/node_modules/fast-printf/dist/src/printf.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ Object.defineProperty(exports2, "__esModule", { value: true });
+ exports2.printf = exports2.createPrintf = void 0;
+ var createPrintf_1 = require_createPrintf();
+ Object.defineProperty(exports2, "createPrintf", { enumerable: true, get: function() {
+ return createPrintf_1.createPrintf;
+ } });
+ exports2.printf = createPrintf_1.createPrintf();
+ }
+});
+
+// ../../node_modules/.pnpm/roarr@7.11.0/node_modules/roarr/dist/src/config.js
+var require_config = __commonJS({
+ "../../node_modules/.pnpm/roarr@7.11.0/node_modules/roarr/dist/src/config.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ Object.defineProperty(exports2, "__esModule", { value: true });
+ exports2.ROARR_LOG_FORMAT_VERSION = exports2.ROARR_VERSION = void 0;
+ exports2.ROARR_VERSION = "5.0.0";
+ exports2.ROARR_LOG_FORMAT_VERSION = "2.0.0";
+ }
+});
+
+// ../../node_modules/.pnpm/roarr@7.11.0/node_modules/roarr/dist/src/utilities/hasOwnProperty.js
+var require_hasOwnProperty = __commonJS({
+ "../../node_modules/.pnpm/roarr@7.11.0/node_modules/roarr/dist/src/utilities/hasOwnProperty.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ Object.defineProperty(exports2, "__esModule", { value: true });
+ exports2.hasOwnProperty = void 0;
+ var hasOwnProperty2 = /* @__PURE__ */ __name((object, property) => {
+ return Object.prototype.hasOwnProperty.call(object, property);
+ }, "hasOwnProperty");
+ exports2.hasOwnProperty = hasOwnProperty2;
+ }
+});
+
+// ../../node_modules/.pnpm/roarr@7.11.0/node_modules/roarr/dist/src/utilities/index.js
+var require_utilities = __commonJS({
+ "../../node_modules/.pnpm/roarr@7.11.0/node_modules/roarr/dist/src/utilities/index.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ Object.defineProperty(exports2, "__esModule", { value: true });
+ exports2.hasOwnProperty = void 0;
+ var hasOwnProperty_1 = require_hasOwnProperty();
+ Object.defineProperty(exports2, "hasOwnProperty", { enumerable: true, get: function() {
+ return hasOwnProperty_1.hasOwnProperty;
+ } });
+ }
+});
+
+// ../../node_modules/.pnpm/roarr@7.11.0/node_modules/roarr/dist/src/factories/createLogger.js
+var require_createLogger = __commonJS({
+ "../../node_modules/.pnpm/roarr@7.11.0/node_modules/roarr/dist/src/factories/createLogger.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ var __importDefault = exports2 && exports2.__importDefault || function(mod) {
+ return mod && mod.__esModule ? mod : { "default": mod };
+ };
+ Object.defineProperty(exports2, "__esModule", { value: true });
+ exports2.createLogger = void 0;
+ var fast_printf_1 = require_printf();
+ var globalthis_1 = __importDefault(require_globalthis());
+ var config_1 = require_config();
+ var constants_1 = require_constants6();
+ var utilities_1 = require_utilities();
+ var loggedWarningAsyncLocalContext = false;
+ var globalThis2 = (0, globalthis_1.default)();
+ var getGlobalRoarrContext = /* @__PURE__ */ __name(() => {
+ return globalThis2.ROARR;
+ }, "getGlobalRoarrContext");
+ var createDefaultAsyncLocalContext = /* @__PURE__ */ __name(() => {
+ return {
+ messageContext: {},
+ transforms: []
+ };
+ }, "createDefaultAsyncLocalContext");
+ var getAsyncLocalContext = /* @__PURE__ */ __name(() => {
+ const asyncLocalStorage = getGlobalRoarrContext().asyncLocalStorage;
+ if (!asyncLocalStorage) {
+ throw new Error("AsyncLocalContext is unavailable.");
+ }
+ const asyncLocalContext = asyncLocalStorage.getStore();
+ if (asyncLocalContext) {
+ return asyncLocalContext;
+ }
+ return createDefaultAsyncLocalContext();
+ }, "getAsyncLocalContext");
+ var isAsyncLocalContextAvailable = /* @__PURE__ */ __name(() => {
+ return Boolean(getGlobalRoarrContext().asyncLocalStorage);
+ }, "isAsyncLocalContextAvailable");
+ var getSequence = /* @__PURE__ */ __name(() => {
+ if (isAsyncLocalContextAvailable()) {
+ const asyncLocalContext = getAsyncLocalContext();
+ if ((0, utilities_1.hasOwnProperty)(asyncLocalContext, "sequenceRoot") && (0, utilities_1.hasOwnProperty)(asyncLocalContext, "sequence")) {
+ return String(asyncLocalContext.sequenceRoot) + "." + String(asyncLocalContext.sequence++);
+ }
+ return String(getGlobalRoarrContext().sequence++);
+ }
+ return String(getGlobalRoarrContext().sequence++);
+ }, "getSequence");
+ var createLogger = /* @__PURE__ */ __name((onMessage, parentMessageContext = {}, transforms = []) => {
+ const log = /* @__PURE__ */ __name((a, b, c, d, e2, f, g, h, i, j) => {
+ const time = Date.now();
+ const sequence = getSequence();
+ let asyncLocalContext;
+ if (isAsyncLocalContextAvailable()) {
+ asyncLocalContext = getAsyncLocalContext();
+ } else {
+ asyncLocalContext = createDefaultAsyncLocalContext();
+ }
+ let context2;
+ let message;
+ if (typeof a === "string") {
+ context2 = {
+ ...asyncLocalContext.messageContext,
+ ...parentMessageContext
+ };
+ } else {
+ context2 = {
+ ...asyncLocalContext.messageContext,
+ ...parentMessageContext,
+ ...a
+ };
+ }
+ if (typeof a === "string" && b === void 0) {
+ message = a;
+ } else if (typeof a === "string") {
+ message = (0, fast_printf_1.printf)(a, b, c, d, e2, f, g, h, i, j);
+ } else {
+ let fallbackMessage = b;
+ if (typeof b !== "string") {
+ if (b === void 0) {
+ fallbackMessage = "";
+ } else {
+ throw new TypeError("Message must be a string. Received " + typeof b + ".");
+ }
+ }
+ message = (0, fast_printf_1.printf)(fallbackMessage, c, d, e2, f, g, h, i, j);
+ }
+ let packet = {
+ context: context2,
+ message,
+ sequence,
+ time,
+ version: config_1.ROARR_LOG_FORMAT_VERSION
+ };
+ for (const transform of [...asyncLocalContext.transforms, ...transforms]) {
+ packet = transform(packet);
+ if (typeof packet !== "object" || packet === null) {
+ throw new Error("Message transform function must return a message object.");
+ }
+ }
+ onMessage(packet);
+ }, "log");
+ log.child = (context2) => {
+ let asyncLocalContext;
+ if (isAsyncLocalContextAvailable()) {
+ asyncLocalContext = getAsyncLocalContext();
+ } else {
+ asyncLocalContext = createDefaultAsyncLocalContext();
+ }
+ if (typeof context2 === "function") {
+ return (0, exports2.createLogger)(onMessage, {
+ ...asyncLocalContext.messageContext,
+ ...parentMessageContext,
+ ...context2
+ }, [
+ context2,
+ ...transforms
+ ]);
+ }
+ return (0, exports2.createLogger)(onMessage, {
+ ...asyncLocalContext.messageContext,
+ ...parentMessageContext,
+ ...context2
+ }, transforms);
+ };
+ log.getContext = () => {
+ let asyncLocalContext;
+ if (isAsyncLocalContextAvailable()) {
+ asyncLocalContext = getAsyncLocalContext();
+ } else {
+ asyncLocalContext = createDefaultAsyncLocalContext();
+ }
+ return {
+ ...asyncLocalContext.messageContext,
+ ...parentMessageContext
+ };
+ };
+ log.adopt = async (routine, context2) => {
+ if (!isAsyncLocalContextAvailable()) {
+ if (loggedWarningAsyncLocalContext === false) {
+ loggedWarningAsyncLocalContext = true;
+ onMessage({
+ context: {
+ logLevel: constants_1.logLevels.warn,
+ package: "roarr"
+ },
+ message: "async_hooks are unavailable; Roarr.adopt will not function as expected",
+ sequence: getSequence(),
+ time: Date.now(),
+ version: config_1.ROARR_LOG_FORMAT_VERSION
+ });
+ }
+ return routine();
+ }
+ const asyncLocalContext = getAsyncLocalContext();
+ let sequenceRoot;
+ if ((0, utilities_1.hasOwnProperty)(asyncLocalContext, "sequenceRoot")) {
+ sequenceRoot = asyncLocalContext.sequenceRoot + "." + String(asyncLocalContext.sequence++);
+ } else {
+ sequenceRoot = String(getGlobalRoarrContext().sequence++);
+ }
+ let nextContext = {
+ ...asyncLocalContext.messageContext
+ };
+ const nextTransforms = [
+ ...asyncLocalContext.transforms
+ ];
+ if (typeof context2 === "function") {
+ nextTransforms.push(context2);
+ } else {
+ nextContext = {
+ ...nextContext,
+ ...context2
+ };
+ }
+ const asyncLocalStorage = getGlobalRoarrContext().asyncLocalStorage;
+ if (!asyncLocalStorage) {
+ throw new Error("Async local context unavailable.");
+ }
+ return asyncLocalStorage.run({
+ messageContext: nextContext,
+ sequence: 0,
+ sequenceRoot,
+ transforms: nextTransforms
+ }, () => {
+ return routine();
+ });
+ };
+ log.trace = (a, b, c, d, e2, f, g, h, i, j) => {
+ log.child({
+ logLevel: constants_1.logLevels.trace
+ })(a, b, c, d, e2, f, g, h, i, j);
+ };
+ log.debug = (a, b, c, d, e2, f, g, h, i, j) => {
+ log.child({
+ logLevel: constants_1.logLevels.debug
+ })(a, b, c, d, e2, f, g, h, i, j);
+ };
+ log.info = (a, b, c, d, e2, f, g, h, i, j) => {
+ log.child({
+ logLevel: constants_1.logLevels.info
+ })(a, b, c, d, e2, f, g, h, i, j);
+ };
+ log.warn = (a, b, c, d, e2, f, g, h, i, j) => {
+ log.child({
+ logLevel: constants_1.logLevels.warn
+ })(a, b, c, d, e2, f, g, h, i, j);
+ };
+ log.error = (a, b, c, d, e2, f, g, h, i, j) => {
+ log.child({
+ logLevel: constants_1.logLevels.error
+ })(a, b, c, d, e2, f, g, h, i, j);
+ };
+ log.fatal = (a, b, c, d, e2, f, g, h, i, j) => {
+ log.child({
+ logLevel: constants_1.logLevels.fatal
+ })(a, b, c, d, e2, f, g, h, i, j);
+ };
+ return log;
+ }, "createLogger");
+ exports2.createLogger = createLogger;
+ }
+});
+
+// ../../node_modules/.pnpm/roarr@7.11.0/node_modules/roarr/dist/src/factories/createMockLogger.js
+var require_createMockLogger = __commonJS({
+ "../../node_modules/.pnpm/roarr@7.11.0/node_modules/roarr/dist/src/factories/createMockLogger.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ Object.defineProperty(exports2, "__esModule", { value: true });
+ exports2.createMockLogger = void 0;
+ var constants_1 = require_constants6();
+ var createMockLogger = /* @__PURE__ */ __name((onMessage, parentContext) => {
+ const log = /* @__PURE__ */ __name(() => {
+ return void 0;
+ }, "log");
+ log.adopt = async (routine) => {
+ return routine();
+ };
+ log.child = (context2) => {
+ return (0, exports2.createMockLogger)(onMessage, parentContext);
+ };
+ log.getContext = () => {
+ return {};
+ };
+ log.trace = (a, b, c, d, e2, f, g, h, i, j) => {
+ log.child({
+ logLevel: constants_1.logLevels.trace
+ })(a, b, c, d, e2, f, g, h, i, j);
+ };
+ log.debug = (a, b, c, d, e2, f, g, h, i, j) => {
+ log.child({
+ logLevel: constants_1.logLevels.debug
+ })(a, b, c, d, e2, f, g, h, i, j);
+ };
+ log.info = (a, b, c, d, e2, f, g, h, i, j) => {
+ log.child({
+ logLevel: constants_1.logLevels.info
+ })(a, b, c, d, e2, f, g, h, i, j);
+ };
+ log.warn = (a, b, c, d, e2, f, g, h, i, j) => {
+ log.child({
+ logLevel: constants_1.logLevels.warn
+ })(a, b, c, d, e2, f, g, h, i, j);
+ };
+ log.error = (a, b, c, d, e2, f, g, h, i, j) => {
+ log.child({
+ logLevel: constants_1.logLevels.error
+ })(a, b, c, d, e2, f, g, h, i, j);
+ };
+ log.fatal = (a, b, c, d, e2, f, g, h, i, j) => {
+ log.child({
+ logLevel: constants_1.logLevels.fatal
+ })(a, b, c, d, e2, f, g, h, i, j);
+ };
+ return log;
+ }, "createMockLogger");
+ exports2.createMockLogger = createMockLogger;
+ }
+});
+
+// ../../node_modules/.pnpm/semver-compare@1.0.0/node_modules/semver-compare/index.js
+var require_semver_compare = __commonJS({
+ "../../node_modules/.pnpm/semver-compare@1.0.0/node_modules/semver-compare/index.js"(exports2, module2) {
+ init_import_meta_url();
+ module2.exports = /* @__PURE__ */ __name(function cmp(a, b) {
+ var pa2 = a.split(".");
+ var pb = b.split(".");
+ for (var i = 0; i < 3; i++) {
+ var na = Number(pa2[i]);
+ var nb = Number(pb[i]);
+ if (na > nb)
+ return 1;
+ if (nb > na)
+ return -1;
+ if (!isNaN(na) && isNaN(nb))
+ return 1;
+ if (isNaN(na) && !isNaN(nb))
+ return -1;
+ }
+ return 0;
+ }, "cmp");
+ }
+});
+
+// ../../node_modules/.pnpm/roarr@7.11.0/node_modules/roarr/dist/src/factories/createNodeWriter.js
+var require_createNodeWriter = __commonJS({
+ "../../node_modules/.pnpm/roarr@7.11.0/node_modules/roarr/dist/src/factories/createNodeWriter.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ Object.defineProperty(exports2, "__esModule", { value: true });
+ exports2.createNodeWriter = void 0;
+ var createBlockingWriter = /* @__PURE__ */ __name((stream2) => {
+ return (message) => {
+ stream2.write(message + "\n");
+ };
+ }, "createBlockingWriter");
+ var createNodeWriter = /* @__PURE__ */ __name(() => {
+ var _a2;
+ const targetStream = ((_a2 = process.env.ROARR_STREAM) !== null && _a2 !== void 0 ? _a2 : "STDOUT").toUpperCase();
+ const stream2 = targetStream.toUpperCase() === "STDOUT" ? process.stdout : process.stderr;
+ return createBlockingWriter(stream2);
+ }, "createNodeWriter");
+ exports2.createNodeWriter = createNodeWriter;
+ }
+});
+
+// ../../node_modules/.pnpm/roarr@7.11.0/node_modules/roarr/dist/src/factories/createRoarrInitialGlobalState.js
+var require_createRoarrInitialGlobalState = __commonJS({
+ "../../node_modules/.pnpm/roarr@7.11.0/node_modules/roarr/dist/src/factories/createRoarrInitialGlobalState.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ var __importDefault = exports2 && exports2.__importDefault || function(mod) {
+ return mod && mod.__esModule ? mod : { "default": mod };
+ };
+ Object.defineProperty(exports2, "__esModule", { value: true });
+ exports2.createRoarrInitialGlobalState = void 0;
+ var semver_compare_1 = __importDefault(require_semver_compare());
+ var config_1 = require_config();
+ var createNodeWriter_1 = require_createNodeWriter();
+ var createRoarrInitialGlobalState = /* @__PURE__ */ __name((currentState) => {
+ const versions = (currentState.versions || []).concat();
+ if (versions.length > 1) {
+ versions.sort(semver_compare_1.default);
+ }
+ const currentIsLatestVersion = !versions.length || (0, semver_compare_1.default)(config_1.ROARR_VERSION, versions[versions.length - 1]) === 1;
+ if (!versions.includes(config_1.ROARR_VERSION)) {
+ versions.push(config_1.ROARR_VERSION);
+ }
+ versions.sort(semver_compare_1.default);
+ let newState = {
+ sequence: 0,
+ ...currentState,
+ versions
+ };
+ if (currentIsLatestVersion || !newState.write) {
+ try {
+ const AsyncLocalStorage = require("async_hooks").AsyncLocalStorage;
+ const asyncLocalStorage = new AsyncLocalStorage();
+ newState = {
+ ...newState,
+ ...{
+ write: (0, createNodeWriter_1.createNodeWriter)()
+ },
+ asyncLocalStorage
+ };
+ } catch (_a2) {
+ }
+ }
+ return newState;
+ }, "createRoarrInitialGlobalState");
+ exports2.createRoarrInitialGlobalState = createRoarrInitialGlobalState;
+ }
+});
+
+// ../../node_modules/.pnpm/roarr@7.11.0/node_modules/roarr/dist/src/getLogLevelName.js
+var require_getLogLevelName = __commonJS({
+ "../../node_modules/.pnpm/roarr@7.11.0/node_modules/roarr/dist/src/getLogLevelName.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ Object.defineProperty(exports2, "__esModule", { value: true });
+ exports2.getLogLevelName = void 0;
+ var getLogLevelName = /* @__PURE__ */ __name((numericLogLevel) => {
+ if (numericLogLevel <= 10) {
+ return "trace";
+ }
+ if (numericLogLevel <= 20) {
+ return "debug";
+ }
+ if (numericLogLevel <= 30) {
+ return "info";
+ }
+ if (numericLogLevel <= 40) {
+ return "warn";
+ }
+ if (numericLogLevel <= 50) {
+ return "error";
+ }
+ return "fatal";
+ }, "getLogLevelName");
+ exports2.getLogLevelName = getLogLevelName;
+ }
+});
+
+// ../../node_modules/.pnpm/roarr@7.11.0/node_modules/roarr/dist/src/Roarr.js
+var require_Roarr = __commonJS({
+ "../../node_modules/.pnpm/roarr@7.11.0/node_modules/roarr/dist/src/Roarr.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ var __importDefault = exports2 && exports2.__importDefault || function(mod) {
+ return mod && mod.__esModule ? mod : { "default": mod };
+ };
+ var _a2;
+ Object.defineProperty(exports2, "__esModule", { value: true });
+ exports2.ROARR = exports2.Roarr = exports2.logLevels = exports2.getLogLevelName = void 0;
+ var boolean_1 = require_lib5();
+ var fast_json_stringify_1 = __importDefault(require_fast_json_stringify());
+ var fast_safe_stringify_1 = __importDefault(require_fast_safe_stringify());
+ var globalthis_1 = __importDefault(require_globalthis());
+ var constants_1 = require_constants6();
+ Object.defineProperty(exports2, "logLevels", { enumerable: true, get: function() {
+ return constants_1.logLevels;
+ } });
+ var createLogger_1 = require_createLogger();
+ var createMockLogger_1 = require_createMockLogger();
+ var createRoarrInitialGlobalState_1 = require_createRoarrInitialGlobalState();
+ var getLogLevelName_1 = require_getLogLevelName();
+ Object.defineProperty(exports2, "getLogLevelName", { enumerable: true, get: function() {
+ return getLogLevelName_1.getLogLevelName;
+ } });
+ var fastStringify = (0, fast_json_stringify_1.default)({
+ properties: {
+ message: {
+ type: "string"
+ },
+ sequence: {
+ type: "string"
+ },
+ time: {
+ type: "integer"
+ },
+ version: {
+ type: "string"
+ }
+ },
+ type: "object"
+ });
+ var globalThis2 = (0, globalthis_1.default)();
+ var ROARR = globalThis2.ROARR = (0, createRoarrInitialGlobalState_1.createRoarrInitialGlobalState)(globalThis2.ROARR || {});
+ exports2.ROARR = ROARR;
+ var logFactory = createLogger_1.createLogger;
+ var enabled = (0, boolean_1.boolean)((_a2 = process.env.ROARR_LOG) !== null && _a2 !== void 0 ? _a2 : "");
+ if (!enabled) {
+ logFactory = createMockLogger_1.createMockLogger;
+ }
+ var serializeMessage = /* @__PURE__ */ __name((message) => {
+ return '{"context":' + (0, fast_safe_stringify_1.default)(message.context) + "," + fastStringify(message).slice(1);
+ }, "serializeMessage");
+ var Roarr = logFactory((message) => {
+ var _a3;
+ if (ROARR.write) {
+ ROARR.write(((_a3 = ROARR.serializeMessage) !== null && _a3 !== void 0 ? _a3 : serializeMessage)(message));
+ }
+ });
+ exports2.Roarr = Roarr;
+ }
+});
+
+// ../../node_modules/.pnpm/http-terminator@3.2.0/node_modules/http-terminator/dist/src/Logger.js
+var require_Logger = __commonJS({
+ "../../node_modules/.pnpm/http-terminator@3.2.0/node_modules/http-terminator/dist/src/Logger.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ Object.defineProperty(exports2, "__esModule", { value: true });
+ exports2.Logger = void 0;
+ var roarr_1 = require_Roarr();
+ exports2.Logger = roarr_1.Roarr.child({
+ package: "http-terminator"
+ });
+ }
+});
+
+// ../../node_modules/.pnpm/http-terminator@3.2.0/node_modules/http-terminator/dist/src/factories/createInternalHttpTerminator.js
+var require_createInternalHttpTerminator = __commonJS({
+ "../../node_modules/.pnpm/http-terminator@3.2.0/node_modules/http-terminator/dist/src/factories/createInternalHttpTerminator.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ var __importDefault = exports2 && exports2.__importDefault || function(mod) {
+ return mod && mod.__esModule ? mod : { "default": mod };
+ };
+ Object.defineProperty(exports2, "__esModule", { value: true });
+ exports2.createInternalHttpTerminator = void 0;
+ var http_1 = __importDefault(require("http"));
+ var p_wait_for_1 = __importDefault(require_p_wait_for());
+ var Logger_1 = require_Logger();
+ var log = Logger_1.Logger.child({
+ namespace: "createHttpTerminator"
+ });
+ var configurationDefaults = {
+ gracefulTerminationTimeout: 1e3
+ };
+ var createInternalHttpTerminator = /* @__PURE__ */ __name((configurationInput) => {
+ const configuration = {
+ ...configurationDefaults,
+ ...configurationInput
+ };
+ const server2 = configuration.server;
+ const sockets = /* @__PURE__ */ new Set();
+ const secureSockets = /* @__PURE__ */ new Set();
+ let terminating;
+ server2.on("connection", (socket) => {
+ if (terminating) {
+ socket.destroy();
+ } else {
+ sockets.add(socket);
+ socket.once("close", () => {
+ sockets.delete(socket);
+ });
+ }
+ });
+ server2.on("secureConnection", (socket) => {
+ if (terminating) {
+ socket.destroy();
+ } else {
+ secureSockets.add(socket);
+ socket.once("close", () => {
+ secureSockets.delete(socket);
+ });
+ }
+ });
+ const destroySocket = /* @__PURE__ */ __name((socket) => {
+ socket.destroy();
+ if (socket.server instanceof http_1.default.Server) {
+ sockets.delete(socket);
+ } else {
+ secureSockets.delete(socket);
+ }
+ }, "destroySocket");
+ const terminate = /* @__PURE__ */ __name(async () => {
+ if (terminating) {
+ log.warn("already terminating HTTP server");
+ return terminating;
+ }
+ let resolveTerminating;
+ let rejectTerminating;
+ terminating = new Promise((resolve18, reject) => {
+ resolveTerminating = resolve18;
+ rejectTerminating = reject;
+ });
+ server2.on("request", (incomingMessage, outgoingMessage) => {
+ if (!outgoingMessage.headersSent) {
+ outgoingMessage.setHeader("connection", "close");
+ }
+ });
+ for (const socket of sockets) {
+ if (!(socket.server instanceof http_1.default.Server)) {
+ continue;
+ }
+ const serverResponse = socket._httpMessage;
+ if (serverResponse) {
+ if (!serverResponse.headersSent) {
+ serverResponse.setHeader("connection", "close");
+ }
+ continue;
+ }
+ destroySocket(socket);
+ }
+ for (const socket of secureSockets) {
+ const serverResponse = socket._httpMessage;
+ if (serverResponse) {
+ if (!serverResponse.headersSent) {
+ serverResponse.setHeader("connection", "close");
+ }
+ continue;
+ }
+ destroySocket(socket);
+ }
+ try {
+ await (0, p_wait_for_1.default)(() => {
+ return sockets.size === 0 && secureSockets.size === 0;
+ }, {
+ interval: 10,
+ timeout: configuration.gracefulTerminationTimeout
+ });
+ } catch (_a2) {
+ } finally {
+ for (const socket of sockets) {
+ destroySocket(socket);
+ }
+ for (const socket of secureSockets) {
+ destroySocket(socket);
+ }
+ }
+ server2.close((error) => {
+ if (error) {
+ rejectTerminating(error);
+ } else {
+ resolveTerminating();
+ }
+ });
+ return terminating;
+ }, "terminate");
+ return {
+ secureSockets,
+ sockets,
+ terminate
+ };
+ }, "createInternalHttpTerminator");
+ exports2.createInternalHttpTerminator = createInternalHttpTerminator;
+ }
+});
+
+// ../../node_modules/.pnpm/http-terminator@3.2.0/node_modules/http-terminator/dist/src/factories/createHttpTerminator.js
+var require_createHttpTerminator = __commonJS({
+ "../../node_modules/.pnpm/http-terminator@3.2.0/node_modules/http-terminator/dist/src/factories/createHttpTerminator.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ Object.defineProperty(exports2, "__esModule", { value: true });
+ exports2.createHttpTerminator = void 0;
+ var createInternalHttpTerminator_1 = require_createInternalHttpTerminator();
+ var createHttpTerminator3 = /* @__PURE__ */ __name((configurationInput) => {
+ const httpTerminator = (0, createInternalHttpTerminator_1.createInternalHttpTerminator)(configurationInput);
+ return {
+ terminate: httpTerminator.terminate
+ };
+ }, "createHttpTerminator");
+ exports2.createHttpTerminator = createHttpTerminator3;
+ }
+});
+
+// ../../node_modules/.pnpm/http-terminator@3.2.0/node_modules/http-terminator/dist/src/index.js
+var require_src5 = __commonJS({
+ "../../node_modules/.pnpm/http-terminator@3.2.0/node_modules/http-terminator/dist/src/index.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ Object.defineProperty(exports2, "__esModule", { value: true });
+ exports2.createHttpTerminator = void 0;
+ var createHttpTerminator_1 = require_createHttpTerminator();
+ Object.defineProperty(exports2, "createHttpTerminator", { enumerable: true, get: function() {
+ return createHttpTerminator_1.createHttpTerminator;
+ } });
+ }
+});
+
+// ../../node_modules/.pnpm/ws@8.11.0/node_modules/ws/lib/stream.js
+var require_stream3 = __commonJS({
+ "../../node_modules/.pnpm/ws@8.11.0/node_modules/ws/lib/stream.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var { Duplex } = require("stream");
+ function emitClose(stream2) {
+ stream2.emit("close");
+ }
+ __name(emitClose, "emitClose");
+ function duplexOnEnd() {
+ if (!this.destroyed && this._writableState.finished) {
+ this.destroy();
+ }
+ }
+ __name(duplexOnEnd, "duplexOnEnd");
+ function duplexOnError(err) {
+ this.removeListener("error", duplexOnError);
+ this.destroy();
+ if (this.listenerCount("error") === 0) {
+ this.emit("error", err);
+ }
+ }
+ __name(duplexOnError, "duplexOnError");
+ function createWebSocketStream2(ws, options14) {
+ let terminateOnDestroy = true;
+ const duplex = new Duplex({
+ ...options14,
+ autoDestroy: false,
+ emitClose: false,
+ objectMode: false,
+ writableObjectMode: false
+ });
+ ws.on("message", /* @__PURE__ */ __name(function message(msg, isBinary) {
+ const data = !isBinary && duplex._readableState.objectMode ? msg.toString() : msg;
+ if (!duplex.push(data))
+ ws.pause();
+ }, "message"));
+ ws.once("error", /* @__PURE__ */ __name(function error(err) {
+ if (duplex.destroyed)
+ return;
+ terminateOnDestroy = false;
+ duplex.destroy(err);
+ }, "error"));
+ ws.once("close", /* @__PURE__ */ __name(function close() {
+ if (duplex.destroyed)
+ return;
+ duplex.push(null);
+ }, "close"));
+ duplex._destroy = function(err, callback) {
+ if (ws.readyState === ws.CLOSED) {
+ callback(err);
+ process.nextTick(emitClose, duplex);
+ return;
+ }
+ let called = false;
+ ws.once("error", /* @__PURE__ */ __name(function error(err2) {
+ called = true;
+ callback(err2);
+ }, "error"));
+ ws.once("close", /* @__PURE__ */ __name(function close() {
+ if (!called)
+ callback(err);
+ process.nextTick(emitClose, duplex);
+ }, "close"));
+ if (terminateOnDestroy)
+ ws.terminate();
+ };
+ duplex._final = function(callback) {
+ if (ws.readyState === ws.CONNECTING) {
+ ws.once("open", /* @__PURE__ */ __name(function open3() {
+ duplex._final(callback);
+ }, "open"));
+ return;
+ }
+ if (ws._socket === null)
+ return;
+ if (ws._socket._writableState.finished) {
+ callback();
+ if (duplex._readableState.endEmitted)
+ duplex.destroy();
+ } else {
+ ws._socket.once("finish", /* @__PURE__ */ __name(function finish() {
+ callback();
+ }, "finish"));
+ ws.close();
+ }
+ };
+ duplex._read = function() {
+ if (ws.isPaused)
+ ws.resume();
+ };
+ duplex._write = function(chunk, encoding, callback) {
+ if (ws.readyState === ws.CONNECTING) {
+ ws.once("open", /* @__PURE__ */ __name(function open3() {
+ duplex._write(chunk, encoding, callback);
+ }, "open"));
+ return;
+ }
+ ws.send(chunk, callback);
+ };
+ duplex.on("end", duplexOnEnd);
+ duplex.on("error", duplexOnError);
+ return duplex;
+ }
+ __name(createWebSocketStream2, "createWebSocketStream");
+ module2.exports = createWebSocketStream2;
+ }
+});
+
+// ../../node_modules/.pnpm/ws@8.11.0/node_modules/ws/lib/constants.js
+var require_constants7 = __commonJS({
+ "../../node_modules/.pnpm/ws@8.11.0/node_modules/ws/lib/constants.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ module2.exports = {
+ BINARY_TYPES: ["nodebuffer", "arraybuffer", "fragments"],
+ EMPTY_BUFFER: Buffer.alloc(0),
+ GUID: "258EAFA5-E914-47DA-95CA-C5AB0DC85B11",
+ kForOnEventAttribute: Symbol("kIsForOnEventAttribute"),
+ kListener: Symbol("kListener"),
+ kStatusCode: Symbol("status-code"),
+ kWebSocket: Symbol("websocket"),
+ NOOP: () => {
+ }
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/ws@8.11.0/node_modules/ws/lib/buffer-util.js
+var require_buffer_util2 = __commonJS({
+ "../../node_modules/.pnpm/ws@8.11.0/node_modules/ws/lib/buffer-util.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var { EMPTY_BUFFER } = require_constants7();
+ function concat(list, totalLength) {
+ if (list.length === 0)
+ return EMPTY_BUFFER;
+ if (list.length === 1)
+ return list[0];
+ const target = Buffer.allocUnsafe(totalLength);
+ let offset = 0;
+ for (let i = 0; i < list.length; i++) {
+ const buf = list[i];
+ target.set(buf, offset);
+ offset += buf.length;
+ }
+ if (offset < totalLength)
+ return target.slice(0, offset);
+ return target;
+ }
+ __name(concat, "concat");
+ function _mask(source, mask, output, offset, length) {
+ for (let i = 0; i < length; i++) {
+ output[offset + i] = source[i] ^ mask[i & 3];
+ }
+ }
+ __name(_mask, "_mask");
+ function _unmask(buffer, mask) {
+ for (let i = 0; i < buffer.length; i++) {
+ buffer[i] ^= mask[i & 3];
+ }
+ }
+ __name(_unmask, "_unmask");
+ function toArrayBuffer(buf) {
+ if (buf.byteLength === buf.buffer.byteLength) {
+ return buf.buffer;
+ }
+ return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
+ }
+ __name(toArrayBuffer, "toArrayBuffer");
+ function toBuffer(data) {
+ toBuffer.readOnly = true;
+ if (Buffer.isBuffer(data))
+ return data;
+ let buf;
+ if (data instanceof ArrayBuffer) {
+ buf = Buffer.from(data);
+ } else if (ArrayBuffer.isView(data)) {
+ buf = Buffer.from(data.buffer, data.byteOffset, data.byteLength);
+ } else {
+ buf = Buffer.from(data);
+ toBuffer.readOnly = false;
+ }
+ return buf;
+ }
+ __name(toBuffer, "toBuffer");
+ module2.exports = {
+ concat,
+ mask: _mask,
+ toArrayBuffer,
+ toBuffer,
+ unmask: _unmask
+ };
+ if (!process.env.WS_NO_BUFFER_UTIL) {
+ try {
+ const bufferUtil = require("bufferutil");
+ module2.exports.mask = function(source, mask, output, offset, length) {
+ if (length < 48)
+ _mask(source, mask, output, offset, length);
+ else
+ bufferUtil.mask(source, mask, output, offset, length);
+ };
+ module2.exports.unmask = function(buffer, mask) {
+ if (buffer.length < 32)
+ _unmask(buffer, mask);
+ else
+ bufferUtil.unmask(buffer, mask);
+ };
+ } catch (e2) {
+ }
+ }
+ }
+});
+
+// ../../node_modules/.pnpm/ws@8.11.0/node_modules/ws/lib/limiter.js
+var require_limiter2 = __commonJS({
+ "../../node_modules/.pnpm/ws@8.11.0/node_modules/ws/lib/limiter.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var kDone = Symbol("kDone");
+ var kRun = Symbol("kRun");
+ var Limiter = class {
+ /**
+ * Creates a new `Limiter`.
+ *
+ * @param {Number} [concurrency=Infinity] The maximum number of jobs allowed
+ * to run concurrently
+ */
+ constructor(concurrency) {
+ this[kDone] = () => {
+ this.pending--;
+ this[kRun]();
+ };
+ this.concurrency = concurrency || Infinity;
+ this.jobs = [];
+ this.pending = 0;
+ }
+ /**
+ * Adds a job to the queue.
+ *
+ * @param {Function} job The job to run
+ * @public
+ */
+ add(job) {
+ this.jobs.push(job);
+ this[kRun]();
+ }
+ /**
+ * Removes a job from the queue and runs it if possible.
+ *
+ * @private
+ */
+ [kRun]() {
+ if (this.pending === this.concurrency)
+ return;
+ if (this.jobs.length) {
+ const job = this.jobs.shift();
+ this.pending++;
+ job(this[kDone]);
+ }
+ }
+ };
+ __name(Limiter, "Limiter");
+ module2.exports = Limiter;
+ }
+});
+
+// ../../node_modules/.pnpm/ws@8.11.0/node_modules/ws/lib/permessage-deflate.js
+var require_permessage_deflate2 = __commonJS({
+ "../../node_modules/.pnpm/ws@8.11.0/node_modules/ws/lib/permessage-deflate.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var zlib = require("zlib");
+ var bufferUtil = require_buffer_util2();
+ var Limiter = require_limiter2();
+ var { kStatusCode } = require_constants7();
+ var TRAILER = Buffer.from([0, 0, 255, 255]);
+ var kPerMessageDeflate = Symbol("permessage-deflate");
+ var kTotalLength = Symbol("total-length");
+ var kCallback = Symbol("callback");
+ var kBuffers = Symbol("buffers");
+ var kError = Symbol("error");
+ var zlibLimiter;
+ var PerMessageDeflate = class {
+ /**
+ * Creates a PerMessageDeflate instance.
+ *
+ * @param {Object} [options] Configuration options
+ * @param {(Boolean|Number)} [options.clientMaxWindowBits] Advertise support
+ * for, or request, a custom client window size
+ * @param {Boolean} [options.clientNoContextTakeover=false] Advertise/
+ * acknowledge disabling of client context takeover
+ * @param {Number} [options.concurrencyLimit=10] The number of concurrent
+ * calls to zlib
+ * @param {(Boolean|Number)} [options.serverMaxWindowBits] Request/confirm the
+ * use of a custom server window size
+ * @param {Boolean} [options.serverNoContextTakeover=false] Request/accept
+ * disabling of server context takeover
+ * @param {Number} [options.threshold=1024] Size (in bytes) below which
+ * messages should not be compressed if context takeover is disabled
+ * @param {Object} [options.zlibDeflateOptions] Options to pass to zlib on
+ * deflate
+ * @param {Object} [options.zlibInflateOptions] Options to pass to zlib on
+ * inflate
+ * @param {Boolean} [isServer=false] Create the instance in either server or
+ * client mode
+ * @param {Number} [maxPayload=0] The maximum allowed message length
+ */
+ constructor(options14, isServer, maxPayload) {
+ this._maxPayload = maxPayload | 0;
+ this._options = options14 || {};
+ this._threshold = this._options.threshold !== void 0 ? this._options.threshold : 1024;
+ this._isServer = !!isServer;
+ this._deflate = null;
+ this._inflate = null;
+ this.params = null;
+ if (!zlibLimiter) {
+ const concurrency = this._options.concurrencyLimit !== void 0 ? this._options.concurrencyLimit : 10;
+ zlibLimiter = new Limiter(concurrency);
+ }
+ }
+ /**
+ * @type {String}
+ */
+ static get extensionName() {
+ return "permessage-deflate";
+ }
+ /**
+ * Create an extension negotiation offer.
+ *
+ * @return {Object} Extension parameters
+ * @public
+ */
+ offer() {
+ const params = {};
+ if (this._options.serverNoContextTakeover) {
+ params.server_no_context_takeover = true;
+ }
+ if (this._options.clientNoContextTakeover) {
+ params.client_no_context_takeover = true;
+ }
+ if (this._options.serverMaxWindowBits) {
+ params.server_max_window_bits = this._options.serverMaxWindowBits;
+ }
+ if (this._options.clientMaxWindowBits) {
+ params.client_max_window_bits = this._options.clientMaxWindowBits;
+ } else if (this._options.clientMaxWindowBits == null) {
+ params.client_max_window_bits = true;
+ }
+ return params;
+ }
+ /**
+ * Accept an extension negotiation offer/response.
+ *
+ * @param {Array} configurations The extension negotiation offers/reponse
+ * @return {Object} Accepted configuration
+ * @public
+ */
+ accept(configurations) {
+ configurations = this.normalizeParams(configurations);
+ this.params = this._isServer ? this.acceptAsServer(configurations) : this.acceptAsClient(configurations);
+ return this.params;
+ }
+ /**
+ * Releases all resources used by the extension.
+ *
+ * @public
+ */
+ cleanup() {
+ if (this._inflate) {
+ this._inflate.close();
+ this._inflate = null;
+ }
+ if (this._deflate) {
+ const callback = this._deflate[kCallback];
+ this._deflate.close();
+ this._deflate = null;
+ if (callback) {
+ callback(
+ new Error(
+ "The deflate stream was closed while data was being processed"
+ )
+ );
+ }
+ }
+ }
+ /**
+ * Accept an extension negotiation offer.
+ *
+ * @param {Array} offers The extension negotiation offers
+ * @return {Object} Accepted configuration
+ * @private
+ */
+ acceptAsServer(offers) {
+ const opts = this._options;
+ const accepted = offers.find((params) => {
+ if (opts.serverNoContextTakeover === false && params.server_no_context_takeover || params.server_max_window_bits && (opts.serverMaxWindowBits === false || typeof opts.serverMaxWindowBits === "number" && opts.serverMaxWindowBits > params.server_max_window_bits) || typeof opts.clientMaxWindowBits === "number" && !params.client_max_window_bits) {
+ return false;
+ }
+ return true;
+ });
+ if (!accepted) {
+ throw new Error("None of the extension offers can be accepted");
+ }
+ if (opts.serverNoContextTakeover) {
+ accepted.server_no_context_takeover = true;
+ }
+ if (opts.clientNoContextTakeover) {
+ accepted.client_no_context_takeover = true;
+ }
+ if (typeof opts.serverMaxWindowBits === "number") {
+ accepted.server_max_window_bits = opts.serverMaxWindowBits;
+ }
+ if (typeof opts.clientMaxWindowBits === "number") {
+ accepted.client_max_window_bits = opts.clientMaxWindowBits;
+ } else if (accepted.client_max_window_bits === true || opts.clientMaxWindowBits === false) {
+ delete accepted.client_max_window_bits;
+ }
+ return accepted;
+ }
+ /**
+ * Accept the extension negotiation response.
+ *
+ * @param {Array} response The extension negotiation response
+ * @return {Object} Accepted configuration
+ * @private
+ */
+ acceptAsClient(response) {
+ const params = response[0];
+ if (this._options.clientNoContextTakeover === false && params.client_no_context_takeover) {
+ throw new Error('Unexpected parameter "client_no_context_takeover"');
+ }
+ if (!params.client_max_window_bits) {
+ if (typeof this._options.clientMaxWindowBits === "number") {
+ params.client_max_window_bits = this._options.clientMaxWindowBits;
+ }
+ } else if (this._options.clientMaxWindowBits === false || typeof this._options.clientMaxWindowBits === "number" && params.client_max_window_bits > this._options.clientMaxWindowBits) {
+ throw new Error(
+ 'Unexpected or invalid parameter "client_max_window_bits"'
+ );
+ }
+ return params;
+ }
+ /**
+ * Normalize parameters.
+ *
+ * @param {Array} configurations The extension negotiation offers/reponse
+ * @return {Array} The offers/response with normalized parameters
+ * @private
+ */
+ normalizeParams(configurations) {
+ configurations.forEach((params) => {
+ Object.keys(params).forEach((key) => {
+ let value = params[key];
+ if (value.length > 1) {
+ throw new Error(`Parameter "${key}" must have only a single value`);
+ }
+ value = value[0];
+ if (key === "client_max_window_bits") {
+ if (value !== true) {
+ const num = +value;
+ if (!Number.isInteger(num) || num < 8 || num > 15) {
+ throw new TypeError(
+ `Invalid value for parameter "${key}": ${value}`
+ );
+ }
+ value = num;
+ } else if (!this._isServer) {
+ throw new TypeError(
+ `Invalid value for parameter "${key}": ${value}`
+ );
+ }
+ } else if (key === "server_max_window_bits") {
+ const num = +value;
+ if (!Number.isInteger(num) || num < 8 || num > 15) {
+ throw new TypeError(
+ `Invalid value for parameter "${key}": ${value}`
+ );
+ }
+ value = num;
+ } else if (key === "client_no_context_takeover" || key === "server_no_context_takeover") {
+ if (value !== true) {
+ throw new TypeError(
+ `Invalid value for parameter "${key}": ${value}`
+ );
+ }
+ } else {
+ throw new Error(`Unknown parameter "${key}"`);
+ }
+ params[key] = value;
+ });
+ });
+ return configurations;
+ }
+ /**
+ * Decompress data. Concurrency limited.
+ *
+ * @param {Buffer} data Compressed data
+ * @param {Boolean} fin Specifies whether or not this is the last fragment
+ * @param {Function} callback Callback
+ * @public
+ */
+ decompress(data, fin, callback) {
+ zlibLimiter.add((done) => {
+ this._decompress(data, fin, (err, result) => {
+ done();
+ callback(err, result);
+ });
+ });
+ }
+ /**
+ * Compress data. Concurrency limited.
+ *
+ * @param {(Buffer|String)} data Data to compress
+ * @param {Boolean} fin Specifies whether or not this is the last fragment
+ * @param {Function} callback Callback
+ * @public
+ */
+ compress(data, fin, callback) {
+ zlibLimiter.add((done) => {
+ this._compress(data, fin, (err, result) => {
+ done();
+ callback(err, result);
+ });
+ });
+ }
+ /**
+ * Decompress data.
+ *
+ * @param {Buffer} data Compressed data
+ * @param {Boolean} fin Specifies whether or not this is the last fragment
+ * @param {Function} callback Callback
+ * @private
+ */
+ _decompress(data, fin, callback) {
+ const endpoint = this._isServer ? "client" : "server";
+ if (!this._inflate) {
+ const key = `${endpoint}_max_window_bits`;
+ const windowBits = typeof this.params[key] !== "number" ? zlib.Z_DEFAULT_WINDOWBITS : this.params[key];
+ this._inflate = zlib.createInflateRaw({
+ ...this._options.zlibInflateOptions,
+ windowBits
+ });
+ this._inflate[kPerMessageDeflate] = this;
+ this._inflate[kTotalLength] = 0;
+ this._inflate[kBuffers] = [];
+ this._inflate.on("error", inflateOnError);
+ this._inflate.on("data", inflateOnData);
+ }
+ this._inflate[kCallback] = callback;
+ this._inflate.write(data);
+ if (fin)
+ this._inflate.write(TRAILER);
+ this._inflate.flush(() => {
+ const err = this._inflate[kError];
+ if (err) {
+ this._inflate.close();
+ this._inflate = null;
+ callback(err);
+ return;
+ }
+ const data2 = bufferUtil.concat(
+ this._inflate[kBuffers],
+ this._inflate[kTotalLength]
+ );
+ if (this._inflate._readableState.endEmitted) {
+ this._inflate.close();
+ this._inflate = null;
+ } else {
+ this._inflate[kTotalLength] = 0;
+ this._inflate[kBuffers] = [];
+ if (fin && this.params[`${endpoint}_no_context_takeover`]) {
+ this._inflate.reset();
+ }
+ }
+ callback(null, data2);
+ });
+ }
+ /**
+ * Compress data.
+ *
+ * @param {(Buffer|String)} data Data to compress
+ * @param {Boolean} fin Specifies whether or not this is the last fragment
+ * @param {Function} callback Callback
+ * @private
+ */
+ _compress(data, fin, callback) {
+ const endpoint = this._isServer ? "server" : "client";
+ if (!this._deflate) {
+ const key = `${endpoint}_max_window_bits`;
+ const windowBits = typeof this.params[key] !== "number" ? zlib.Z_DEFAULT_WINDOWBITS : this.params[key];
+ this._deflate = zlib.createDeflateRaw({
+ ...this._options.zlibDeflateOptions,
+ windowBits
+ });
+ this._deflate[kTotalLength] = 0;
+ this._deflate[kBuffers] = [];
+ this._deflate.on("data", deflateOnData);
+ }
+ this._deflate[kCallback] = callback;
+ this._deflate.write(data);
+ this._deflate.flush(zlib.Z_SYNC_FLUSH, () => {
+ if (!this._deflate) {
+ return;
+ }
+ let data2 = bufferUtil.concat(
+ this._deflate[kBuffers],
+ this._deflate[kTotalLength]
+ );
+ if (fin)
+ data2 = data2.slice(0, data2.length - 4);
+ this._deflate[kCallback] = null;
+ this._deflate[kTotalLength] = 0;
+ this._deflate[kBuffers] = [];
+ if (fin && this.params[`${endpoint}_no_context_takeover`]) {
+ this._deflate.reset();
+ }
+ callback(null, data2);
+ });
+ }
+ };
+ __name(PerMessageDeflate, "PerMessageDeflate");
+ module2.exports = PerMessageDeflate;
+ function deflateOnData(chunk) {
+ this[kBuffers].push(chunk);
+ this[kTotalLength] += chunk.length;
+ }
+ __name(deflateOnData, "deflateOnData");
+ function inflateOnData(chunk) {
+ this[kTotalLength] += chunk.length;
+ if (this[kPerMessageDeflate]._maxPayload < 1 || this[kTotalLength] <= this[kPerMessageDeflate]._maxPayload) {
+ this[kBuffers].push(chunk);
+ return;
+ }
+ this[kError] = new RangeError("Max payload size exceeded");
+ this[kError].code = "WS_ERR_UNSUPPORTED_MESSAGE_LENGTH";
+ this[kError][kStatusCode] = 1009;
+ this.removeListener("data", inflateOnData);
+ this.reset();
+ }
+ __name(inflateOnData, "inflateOnData");
+ function inflateOnError(err) {
+ this[kPerMessageDeflate]._inflate = null;
+ err[kStatusCode] = 1007;
+ this[kCallback](err);
+ }
+ __name(inflateOnError, "inflateOnError");
+ }
+});
+
+// ../../node_modules/.pnpm/ws@8.11.0/node_modules/ws/lib/validation.js
+var require_validation2 = __commonJS({
+ "../../node_modules/.pnpm/ws@8.11.0/node_modules/ws/lib/validation.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var tokenChars = [
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ // 0 - 15
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ // 16 - 31
+ 0,
+ 1,
+ 0,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 0,
+ 0,
+ 1,
+ 1,
+ 0,
+ 1,
+ 1,
+ 0,
+ // 32 - 47
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ // 48 - 63
+ 0,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ // 64 - 79
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 0,
+ 0,
+ 0,
+ 1,
+ 1,
+ // 80 - 95
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ // 96 - 111
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 0,
+ 1,
+ 0,
+ 1,
+ 0
+ // 112 - 127
+ ];
+ function isValidStatusCode(code) {
+ return code >= 1e3 && code <= 1014 && code !== 1004 && code !== 1005 && code !== 1006 || code >= 3e3 && code <= 4999;
+ }
+ __name(isValidStatusCode, "isValidStatusCode");
+ function _isValidUTF8(buf) {
+ const len = buf.length;
+ let i = 0;
+ while (i < len) {
+ if ((buf[i] & 128) === 0) {
+ i++;
+ } else if ((buf[i] & 224) === 192) {
+ if (i + 1 === len || (buf[i + 1] & 192) !== 128 || (buf[i] & 254) === 192) {
+ return false;
+ }
+ i += 2;
+ } else if ((buf[i] & 240) === 224) {
+ if (i + 2 >= len || (buf[i + 1] & 192) !== 128 || (buf[i + 2] & 192) !== 128 || buf[i] === 224 && (buf[i + 1] & 224) === 128 || // Overlong
+ buf[i] === 237 && (buf[i + 1] & 224) === 160) {
+ return false;
+ }
+ i += 3;
+ } else if ((buf[i] & 248) === 240) {
+ if (i + 3 >= len || (buf[i + 1] & 192) !== 128 || (buf[i + 2] & 192) !== 128 || (buf[i + 3] & 192) !== 128 || buf[i] === 240 && (buf[i + 1] & 240) === 128 || // Overlong
+ buf[i] === 244 && buf[i + 1] > 143 || buf[i] > 244) {
+ return false;
+ }
+ i += 4;
+ } else {
+ return false;
+ }
+ }
+ return true;
+ }
+ __name(_isValidUTF8, "_isValidUTF8");
+ module2.exports = {
+ isValidStatusCode,
+ isValidUTF8: _isValidUTF8,
+ tokenChars
+ };
+ if (!process.env.WS_NO_UTF_8_VALIDATE) {
+ try {
+ const isValidUTF8 = require("utf-8-validate");
+ module2.exports.isValidUTF8 = function(buf) {
+ return buf.length < 150 ? _isValidUTF8(buf) : isValidUTF8(buf);
+ };
+ } catch (e2) {
+ }
+ }
+ }
+});
+
+// ../../node_modules/.pnpm/ws@8.11.0/node_modules/ws/lib/receiver.js
+var require_receiver3 = __commonJS({
+ "../../node_modules/.pnpm/ws@8.11.0/node_modules/ws/lib/receiver.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var { Writable } = require("stream");
+ var PerMessageDeflate = require_permessage_deflate2();
+ var {
+ BINARY_TYPES,
+ EMPTY_BUFFER,
+ kStatusCode,
+ kWebSocket
+ } = require_constants7();
+ var { concat, toArrayBuffer, unmask } = require_buffer_util2();
+ var { isValidStatusCode, isValidUTF8 } = require_validation2();
+ var GET_INFO = 0;
+ var GET_PAYLOAD_LENGTH_16 = 1;
+ var GET_PAYLOAD_LENGTH_64 = 2;
+ var GET_MASK = 3;
+ var GET_DATA = 4;
+ var INFLATING = 5;
+ var Receiver2 = class extends Writable {
+ /**
+ * Creates a Receiver instance.
+ *
+ * @param {Object} [options] Options object
+ * @param {String} [options.binaryType=nodebuffer] The type for binary data
+ * @param {Object} [options.extensions] An object containing the negotiated
+ * extensions
+ * @param {Boolean} [options.isServer=false] Specifies whether to operate in
+ * client or server mode
+ * @param {Number} [options.maxPayload=0] The maximum allowed message length
+ * @param {Boolean} [options.skipUTF8Validation=false] Specifies whether or
+ * not to skip UTF-8 validation for text and close messages
+ */
+ constructor(options14 = {}) {
+ super();
+ this._binaryType = options14.binaryType || BINARY_TYPES[0];
+ this._extensions = options14.extensions || {};
+ this._isServer = !!options14.isServer;
+ this._maxPayload = options14.maxPayload | 0;
+ this._skipUTF8Validation = !!options14.skipUTF8Validation;
+ this[kWebSocket] = void 0;
+ this._bufferedBytes = 0;
+ this._buffers = [];
+ this._compressed = false;
+ this._payloadLength = 0;
+ this._mask = void 0;
+ this._fragmented = 0;
+ this._masked = false;
+ this._fin = false;
+ this._opcode = 0;
+ this._totalPayloadLength = 0;
+ this._messageLength = 0;
+ this._fragments = [];
+ this._state = GET_INFO;
+ this._loop = false;
+ }
+ /**
+ * Implements `Writable.prototype._write()`.
+ *
+ * @param {Buffer} chunk The chunk of data to write
+ * @param {String} encoding The character encoding of `chunk`
+ * @param {Function} cb Callback
+ * @private
+ */
+ _write(chunk, encoding, cb) {
+ if (this._opcode === 8 && this._state == GET_INFO)
+ return cb();
+ this._bufferedBytes += chunk.length;
+ this._buffers.push(chunk);
+ this.startLoop(cb);
+ }
+ /**
+ * Consumes `n` bytes from the buffered data.
+ *
+ * @param {Number} n The number of bytes to consume
+ * @return {Buffer} The consumed bytes
+ * @private
+ */
+ consume(n) {
+ this._bufferedBytes -= n;
+ if (n === this._buffers[0].length)
+ return this._buffers.shift();
+ if (n < this._buffers[0].length) {
+ const buf = this._buffers[0];
+ this._buffers[0] = buf.slice(n);
+ return buf.slice(0, n);
+ }
+ const dst = Buffer.allocUnsafe(n);
+ do {
+ const buf = this._buffers[0];
+ const offset = dst.length - n;
+ if (n >= buf.length) {
+ dst.set(this._buffers.shift(), offset);
+ } else {
+ dst.set(new Uint8Array(buf.buffer, buf.byteOffset, n), offset);
+ this._buffers[0] = buf.slice(n);
+ }
+ n -= buf.length;
+ } while (n > 0);
+ return dst;
+ }
+ /**
+ * Starts the parsing loop.
+ *
+ * @param {Function} cb Callback
+ * @private
+ */
+ startLoop(cb) {
+ let err;
+ this._loop = true;
+ do {
+ switch (this._state) {
+ case GET_INFO:
+ err = this.getInfo();
+ break;
+ case GET_PAYLOAD_LENGTH_16:
+ err = this.getPayloadLength16();
+ break;
+ case GET_PAYLOAD_LENGTH_64:
+ err = this.getPayloadLength64();
+ break;
+ case GET_MASK:
+ this.getMask();
+ break;
+ case GET_DATA:
+ err = this.getData(cb);
+ break;
+ default:
+ this._loop = false;
+ return;
+ }
+ } while (this._loop);
+ cb(err);
+ }
+ /**
+ * Reads the first two bytes of a frame.
+ *
+ * @return {(RangeError|undefined)} A possible error
+ * @private
+ */
+ getInfo() {
+ if (this._bufferedBytes < 2) {
+ this._loop = false;
+ return;
+ }
+ const buf = this.consume(2);
+ if ((buf[0] & 48) !== 0) {
+ this._loop = false;
+ return error(
+ RangeError,
+ "RSV2 and RSV3 must be clear",
+ true,
+ 1002,
+ "WS_ERR_UNEXPECTED_RSV_2_3"
+ );
+ }
+ const compressed = (buf[0] & 64) === 64;
+ if (compressed && !this._extensions[PerMessageDeflate.extensionName]) {
+ this._loop = false;
+ return error(
+ RangeError,
+ "RSV1 must be clear",
+ true,
+ 1002,
+ "WS_ERR_UNEXPECTED_RSV_1"
+ );
+ }
+ this._fin = (buf[0] & 128) === 128;
+ this._opcode = buf[0] & 15;
+ this._payloadLength = buf[1] & 127;
+ if (this._opcode === 0) {
+ if (compressed) {
+ this._loop = false;
+ return error(
+ RangeError,
+ "RSV1 must be clear",
+ true,
+ 1002,
+ "WS_ERR_UNEXPECTED_RSV_1"
+ );
+ }
+ if (!this._fragmented) {
+ this._loop = false;
+ return error(
+ RangeError,
+ "invalid opcode 0",
+ true,
+ 1002,
+ "WS_ERR_INVALID_OPCODE"
+ );
+ }
+ this._opcode = this._fragmented;
+ } else if (this._opcode === 1 || this._opcode === 2) {
+ if (this._fragmented) {
+ this._loop = false;
+ return error(
+ RangeError,
+ `invalid opcode ${this._opcode}`,
+ true,
+ 1002,
+ "WS_ERR_INVALID_OPCODE"
+ );
+ }
+ this._compressed = compressed;
+ } else if (this._opcode > 7 && this._opcode < 11) {
+ if (!this._fin) {
+ this._loop = false;
+ return error(
+ RangeError,
+ "FIN must be set",
+ true,
+ 1002,
+ "WS_ERR_EXPECTED_FIN"
+ );
+ }
+ if (compressed) {
+ this._loop = false;
+ return error(
+ RangeError,
+ "RSV1 must be clear",
+ true,
+ 1002,
+ "WS_ERR_UNEXPECTED_RSV_1"
+ );
+ }
+ if (this._payloadLength > 125) {
+ this._loop = false;
+ return error(
+ RangeError,
+ `invalid payload length ${this._payloadLength}`,
+ true,
+ 1002,
+ "WS_ERR_INVALID_CONTROL_PAYLOAD_LENGTH"
+ );
+ }
+ } else {
+ this._loop = false;
+ return error(
+ RangeError,
+ `invalid opcode ${this._opcode}`,
+ true,
+ 1002,
+ "WS_ERR_INVALID_OPCODE"
+ );
+ }
+ if (!this._fin && !this._fragmented)
+ this._fragmented = this._opcode;
+ this._masked = (buf[1] & 128) === 128;
+ if (this._isServer) {
+ if (!this._masked) {
+ this._loop = false;
+ return error(
+ RangeError,
+ "MASK must be set",
+ true,
+ 1002,
+ "WS_ERR_EXPECTED_MASK"
+ );
+ }
+ } else if (this._masked) {
+ this._loop = false;
+ return error(
+ RangeError,
+ "MASK must be clear",
+ true,
+ 1002,
+ "WS_ERR_UNEXPECTED_MASK"
+ );
+ }
+ if (this._payloadLength === 126)
+ this._state = GET_PAYLOAD_LENGTH_16;
+ else if (this._payloadLength === 127)
+ this._state = GET_PAYLOAD_LENGTH_64;
+ else
+ return this.haveLength();
+ }
+ /**
+ * Gets extended payload length (7+16).
+ *
+ * @return {(RangeError|undefined)} A possible error
+ * @private
+ */
+ getPayloadLength16() {
+ if (this._bufferedBytes < 2) {
+ this._loop = false;
+ return;
+ }
+ this._payloadLength = this.consume(2).readUInt16BE(0);
+ return this.haveLength();
+ }
+ /**
+ * Gets extended payload length (7+64).
+ *
+ * @return {(RangeError|undefined)} A possible error
+ * @private
+ */
+ getPayloadLength64() {
+ if (this._bufferedBytes < 8) {
+ this._loop = false;
+ return;
+ }
+ const buf = this.consume(8);
+ const num = buf.readUInt32BE(0);
+ if (num > Math.pow(2, 53 - 32) - 1) {
+ this._loop = false;
+ return error(
+ RangeError,
+ "Unsupported WebSocket frame: payload length > 2^53 - 1",
+ false,
+ 1009,
+ "WS_ERR_UNSUPPORTED_DATA_PAYLOAD_LENGTH"
+ );
+ }
+ this._payloadLength = num * Math.pow(2, 32) + buf.readUInt32BE(4);
+ return this.haveLength();
+ }
+ /**
+ * Payload length has been read.
+ *
+ * @return {(RangeError|undefined)} A possible error
+ * @private
+ */
+ haveLength() {
+ if (this._payloadLength && this._opcode < 8) {
+ this._totalPayloadLength += this._payloadLength;
+ if (this._totalPayloadLength > this._maxPayload && this._maxPayload > 0) {
+ this._loop = false;
+ return error(
+ RangeError,
+ "Max payload size exceeded",
+ false,
+ 1009,
+ "WS_ERR_UNSUPPORTED_MESSAGE_LENGTH"
+ );
+ }
+ }
+ if (this._masked)
+ this._state = GET_MASK;
+ else
+ this._state = GET_DATA;
+ }
+ /**
+ * Reads mask bytes.
+ *
+ * @private
+ */
+ getMask() {
+ if (this._bufferedBytes < 4) {
+ this._loop = false;
+ return;
+ }
+ this._mask = this.consume(4);
+ this._state = GET_DATA;
+ }
+ /**
+ * Reads data bytes.
+ *
+ * @param {Function} cb Callback
+ * @return {(Error|RangeError|undefined)} A possible error
+ * @private
+ */
+ getData(cb) {
+ let data = EMPTY_BUFFER;
+ if (this._payloadLength) {
+ if (this._bufferedBytes < this._payloadLength) {
+ this._loop = false;
+ return;
+ }
+ data = this.consume(this._payloadLength);
+ if (this._masked && (this._mask[0] | this._mask[1] | this._mask[2] | this._mask[3]) !== 0) {
+ unmask(data, this._mask);
+ }
+ }
+ if (this._opcode > 7)
+ return this.controlMessage(data);
+ if (this._compressed) {
+ this._state = INFLATING;
+ this.decompress(data, cb);
+ return;
+ }
+ if (data.length) {
+ this._messageLength = this._totalPayloadLength;
+ this._fragments.push(data);
+ }
+ return this.dataMessage();
+ }
+ /**
+ * Decompresses data.
+ *
+ * @param {Buffer} data Compressed data
+ * @param {Function} cb Callback
+ * @private
+ */
+ decompress(data, cb) {
+ const perMessageDeflate = this._extensions[PerMessageDeflate.extensionName];
+ perMessageDeflate.decompress(data, this._fin, (err, buf) => {
+ if (err)
+ return cb(err);
+ if (buf.length) {
+ this._messageLength += buf.length;
+ if (this._messageLength > this._maxPayload && this._maxPayload > 0) {
+ return cb(
+ error(
+ RangeError,
+ "Max payload size exceeded",
+ false,
+ 1009,
+ "WS_ERR_UNSUPPORTED_MESSAGE_LENGTH"
+ )
+ );
+ }
+ this._fragments.push(buf);
+ }
+ const er = this.dataMessage();
+ if (er)
+ return cb(er);
+ this.startLoop(cb);
+ });
+ }
+ /**
+ * Handles a data message.
+ *
+ * @return {(Error|undefined)} A possible error
+ * @private
+ */
+ dataMessage() {
+ if (this._fin) {
+ const messageLength = this._messageLength;
+ const fragments = this._fragments;
+ this._totalPayloadLength = 0;
+ this._messageLength = 0;
+ this._fragmented = 0;
+ this._fragments = [];
+ if (this._opcode === 2) {
+ let data;
+ if (this._binaryType === "nodebuffer") {
+ data = concat(fragments, messageLength);
+ } else if (this._binaryType === "arraybuffer") {
+ data = toArrayBuffer(concat(fragments, messageLength));
+ } else {
+ data = fragments;
+ }
+ this.emit("message", data, true);
+ } else {
+ const buf = concat(fragments, messageLength);
+ if (!this._skipUTF8Validation && !isValidUTF8(buf)) {
+ this._loop = false;
+ return error(
+ Error,
+ "invalid UTF-8 sequence",
+ true,
+ 1007,
+ "WS_ERR_INVALID_UTF8"
+ );
+ }
+ this.emit("message", buf, false);
+ }
+ }
+ this._state = GET_INFO;
+ }
+ /**
+ * Handles a control message.
+ *
+ * @param {Buffer} data Data to handle
+ * @return {(Error|RangeError|undefined)} A possible error
+ * @private
+ */
+ controlMessage(data) {
+ if (this._opcode === 8) {
+ this._loop = false;
+ if (data.length === 0) {
+ this.emit("conclude", 1005, EMPTY_BUFFER);
+ this.end();
+ } else if (data.length === 1) {
+ return error(
+ RangeError,
+ "invalid payload length 1",
+ true,
+ 1002,
+ "WS_ERR_INVALID_CONTROL_PAYLOAD_LENGTH"
+ );
+ } else {
+ const code = data.readUInt16BE(0);
+ if (!isValidStatusCode(code)) {
+ return error(
+ RangeError,
+ `invalid status code ${code}`,
+ true,
+ 1002,
+ "WS_ERR_INVALID_CLOSE_CODE"
+ );
+ }
+ const buf = data.slice(2);
+ if (!this._skipUTF8Validation && !isValidUTF8(buf)) {
+ return error(
+ Error,
+ "invalid UTF-8 sequence",
+ true,
+ 1007,
+ "WS_ERR_INVALID_UTF8"
+ );
+ }
+ this.emit("conclude", code, buf);
+ this.end();
+ }
+ } else if (this._opcode === 9) {
+ this.emit("ping", data);
+ } else {
+ this.emit("pong", data);
+ }
+ this._state = GET_INFO;
+ }
+ };
+ __name(Receiver2, "Receiver");
+ module2.exports = Receiver2;
+ function error(ErrorCtor, message, prefix, statusCode, errorCode) {
+ const err = new ErrorCtor(
+ prefix ? `Invalid WebSocket frame: ${message}` : message
+ );
+ Error.captureStackTrace(err, error);
+ err.code = errorCode;
+ err[kStatusCode] = statusCode;
+ return err;
+ }
+ __name(error, "error");
+ }
+});
+
+// ../../node_modules/.pnpm/ws@8.11.0/node_modules/ws/lib/sender.js
+var require_sender2 = __commonJS({
+ "../../node_modules/.pnpm/ws@8.11.0/node_modules/ws/lib/sender.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var net3 = require("net");
+ var tls = require("tls");
+ var { randomFillSync } = require("crypto");
+ var PerMessageDeflate = require_permessage_deflate2();
+ var { EMPTY_BUFFER } = require_constants7();
+ var { isValidStatusCode } = require_validation2();
+ var { mask: applyMask, toBuffer } = require_buffer_util2();
+ var kByteLength = Symbol("kByteLength");
+ var maskBuffer = Buffer.alloc(4);
+ var Sender2 = class {
+ /**
+ * Creates a Sender instance.
+ *
+ * @param {(net.Socket|tls.Socket)} socket The connection socket
+ * @param {Object} [extensions] An object containing the negotiated extensions
+ * @param {Function} [generateMask] The function used to generate the masking
+ * key
+ */
+ constructor(socket, extensions, generateMask) {
+ this._extensions = extensions || {};
+ if (generateMask) {
+ this._generateMask = generateMask;
+ this._maskBuffer = Buffer.alloc(4);
+ }
+ this._socket = socket;
+ this._firstFragment = true;
+ this._compress = false;
+ this._bufferedBytes = 0;
+ this._deflating = false;
+ this._queue = [];
+ }
+ /**
+ * Frames a piece of data according to the HyBi WebSocket protocol.
+ *
+ * @param {(Buffer|String)} data The data to frame
+ * @param {Object} options Options object
+ * @param {Boolean} [options.fin=false] Specifies whether or not to set the
+ * FIN bit
+ * @param {Function} [options.generateMask] The function used to generate the
+ * masking key
+ * @param {Boolean} [options.mask=false] Specifies whether or not to mask
+ * `data`
+ * @param {Buffer} [options.maskBuffer] The buffer used to store the masking
+ * key
+ * @param {Number} options.opcode The opcode
+ * @param {Boolean} [options.readOnly=false] Specifies whether `data` can be
+ * modified
+ * @param {Boolean} [options.rsv1=false] Specifies whether or not to set the
+ * RSV1 bit
+ * @return {(Buffer|String)[]} The framed data
+ * @public
+ */
+ static frame(data, options14) {
+ let mask;
+ let merge = false;
+ let offset = 2;
+ let skipMasking = false;
+ if (options14.mask) {
+ mask = options14.maskBuffer || maskBuffer;
+ if (options14.generateMask) {
+ options14.generateMask(mask);
+ } else {
+ randomFillSync(mask, 0, 4);
+ }
+ skipMasking = (mask[0] | mask[1] | mask[2] | mask[3]) === 0;
+ offset = 6;
+ }
+ let dataLength;
+ if (typeof data === "string") {
+ if ((!options14.mask || skipMasking) && options14[kByteLength] !== void 0) {
+ dataLength = options14[kByteLength];
+ } else {
+ data = Buffer.from(data);
+ dataLength = data.length;
+ }
+ } else {
+ dataLength = data.length;
+ merge = options14.mask && options14.readOnly && !skipMasking;
+ }
+ let payloadLength = dataLength;
+ if (dataLength >= 65536) {
+ offset += 8;
+ payloadLength = 127;
+ } else if (dataLength > 125) {
+ offset += 2;
+ payloadLength = 126;
+ }
+ const target = Buffer.allocUnsafe(merge ? dataLength + offset : offset);
+ target[0] = options14.fin ? options14.opcode | 128 : options14.opcode;
+ if (options14.rsv1)
+ target[0] |= 64;
+ target[1] = payloadLength;
+ if (payloadLength === 126) {
+ target.writeUInt16BE(dataLength, 2);
+ } else if (payloadLength === 127) {
+ target[2] = target[3] = 0;
+ target.writeUIntBE(dataLength, 4, 6);
+ }
+ if (!options14.mask)
+ return [target, data];
+ target[1] |= 128;
+ target[offset - 4] = mask[0];
+ target[offset - 3] = mask[1];
+ target[offset - 2] = mask[2];
+ target[offset - 1] = mask[3];
+ if (skipMasking)
+ return [target, data];
+ if (merge) {
+ applyMask(data, mask, target, offset, dataLength);
+ return [target];
+ }
+ applyMask(data, mask, data, 0, dataLength);
+ return [target, data];
+ }
+ /**
+ * Sends a close message to the other peer.
+ *
+ * @param {Number} [code] The status code component of the body
+ * @param {(String|Buffer)} [data] The message component of the body
+ * @param {Boolean} [mask=false] Specifies whether or not to mask the message
+ * @param {Function} [cb] Callback
+ * @public
+ */
+ close(code, data, mask, cb) {
+ let buf;
+ if (code === void 0) {
+ buf = EMPTY_BUFFER;
+ } else if (typeof code !== "number" || !isValidStatusCode(code)) {
+ throw new TypeError("First argument must be a valid error code number");
+ } else if (data === void 0 || !data.length) {
+ buf = Buffer.allocUnsafe(2);
+ buf.writeUInt16BE(code, 0);
+ } else {
+ const length = Buffer.byteLength(data);
+ if (length > 123) {
+ throw new RangeError("The message must not be greater than 123 bytes");
+ }
+ buf = Buffer.allocUnsafe(2 + length);
+ buf.writeUInt16BE(code, 0);
+ if (typeof data === "string") {
+ buf.write(data, 2);
+ } else {
+ buf.set(data, 2);
+ }
+ }
+ const options14 = {
+ [kByteLength]: buf.length,
+ fin: true,
+ generateMask: this._generateMask,
+ mask,
+ maskBuffer: this._maskBuffer,
+ opcode: 8,
+ readOnly: false,
+ rsv1: false
+ };
+ if (this._deflating) {
+ this.enqueue([this.dispatch, buf, false, options14, cb]);
+ } else {
+ this.sendFrame(Sender2.frame(buf, options14), cb);
+ }
+ }
+ /**
+ * Sends a ping message to the other peer.
+ *
+ * @param {*} data The message to send
+ * @param {Boolean} [mask=false] Specifies whether or not to mask `data`
+ * @param {Function} [cb] Callback
+ * @public
+ */
+ ping(data, mask, cb) {
+ let byteLength;
+ let readOnly;
+ if (typeof data === "string") {
+ byteLength = Buffer.byteLength(data);
+ readOnly = false;
+ } else {
+ data = toBuffer(data);
+ byteLength = data.length;
+ readOnly = toBuffer.readOnly;
+ }
+ if (byteLength > 125) {
+ throw new RangeError("The data size must not be greater than 125 bytes");
+ }
+ const options14 = {
+ [kByteLength]: byteLength,
+ fin: true,
+ generateMask: this._generateMask,
+ mask,
+ maskBuffer: this._maskBuffer,
+ opcode: 9,
+ readOnly,
+ rsv1: false
+ };
+ if (this._deflating) {
+ this.enqueue([this.dispatch, data, false, options14, cb]);
+ } else {
+ this.sendFrame(Sender2.frame(data, options14), cb);
+ }
+ }
+ /**
+ * Sends a pong message to the other peer.
+ *
+ * @param {*} data The message to send
+ * @param {Boolean} [mask=false] Specifies whether or not to mask `data`
+ * @param {Function} [cb] Callback
+ * @public
+ */
+ pong(data, mask, cb) {
+ let byteLength;
+ let readOnly;
+ if (typeof data === "string") {
+ byteLength = Buffer.byteLength(data);
+ readOnly = false;
+ } else {
+ data = toBuffer(data);
+ byteLength = data.length;
+ readOnly = toBuffer.readOnly;
+ }
+ if (byteLength > 125) {
+ throw new RangeError("The data size must not be greater than 125 bytes");
+ }
+ const options14 = {
+ [kByteLength]: byteLength,
+ fin: true,
+ generateMask: this._generateMask,
+ mask,
+ maskBuffer: this._maskBuffer,
+ opcode: 10,
+ readOnly,
+ rsv1: false
+ };
+ if (this._deflating) {
+ this.enqueue([this.dispatch, data, false, options14, cb]);
+ } else {
+ this.sendFrame(Sender2.frame(data, options14), cb);
+ }
+ }
+ /**
+ * Sends a data message to the other peer.
+ *
+ * @param {*} data The message to send
+ * @param {Object} options Options object
+ * @param {Boolean} [options.binary=false] Specifies whether `data` is binary
+ * or text
+ * @param {Boolean} [options.compress=false] Specifies whether or not to
+ * compress `data`
+ * @param {Boolean} [options.fin=false] Specifies whether the fragment is the
+ * last one
+ * @param {Boolean} [options.mask=false] Specifies whether or not to mask
+ * `data`
+ * @param {Function} [cb] Callback
+ * @public
+ */
+ send(data, options14, cb) {
+ const perMessageDeflate = this._extensions[PerMessageDeflate.extensionName];
+ let opcode = options14.binary ? 2 : 1;
+ let rsv1 = options14.compress;
+ let byteLength;
+ let readOnly;
+ if (typeof data === "string") {
+ byteLength = Buffer.byteLength(data);
+ readOnly = false;
+ } else {
+ data = toBuffer(data);
+ byteLength = data.length;
+ readOnly = toBuffer.readOnly;
+ }
+ if (this._firstFragment) {
+ this._firstFragment = false;
+ if (rsv1 && perMessageDeflate && perMessageDeflate.params[perMessageDeflate._isServer ? "server_no_context_takeover" : "client_no_context_takeover"]) {
+ rsv1 = byteLength >= perMessageDeflate._threshold;
+ }
+ this._compress = rsv1;
+ } else {
+ rsv1 = false;
+ opcode = 0;
+ }
+ if (options14.fin)
+ this._firstFragment = true;
+ if (perMessageDeflate) {
+ const opts = {
+ [kByteLength]: byteLength,
+ fin: options14.fin,
+ generateMask: this._generateMask,
+ mask: options14.mask,
+ maskBuffer: this._maskBuffer,
+ opcode,
+ readOnly,
+ rsv1
+ };
+ if (this._deflating) {
+ this.enqueue([this.dispatch, data, this._compress, opts, cb]);
+ } else {
+ this.dispatch(data, this._compress, opts, cb);
+ }
+ } else {
+ this.sendFrame(
+ Sender2.frame(data, {
+ [kByteLength]: byteLength,
+ fin: options14.fin,
+ generateMask: this._generateMask,
+ mask: options14.mask,
+ maskBuffer: this._maskBuffer,
+ opcode,
+ readOnly,
+ rsv1: false
+ }),
+ cb
+ );
+ }
+ }
+ /**
+ * Dispatches a message.
+ *
+ * @param {(Buffer|String)} data The message to send
+ * @param {Boolean} [compress=false] Specifies whether or not to compress
+ * `data`
+ * @param {Object} options Options object
+ * @param {Boolean} [options.fin=false] Specifies whether or not to set the
+ * FIN bit
+ * @param {Function} [options.generateMask] The function used to generate the
+ * masking key
+ * @param {Boolean} [options.mask=false] Specifies whether or not to mask
+ * `data`
+ * @param {Buffer} [options.maskBuffer] The buffer used to store the masking
+ * key
+ * @param {Number} options.opcode The opcode
+ * @param {Boolean} [options.readOnly=false] Specifies whether `data` can be
+ * modified
+ * @param {Boolean} [options.rsv1=false] Specifies whether or not to set the
+ * RSV1 bit
+ * @param {Function} [cb] Callback
+ * @private
+ */
+ dispatch(data, compress, options14, cb) {
+ if (!compress) {
+ this.sendFrame(Sender2.frame(data, options14), cb);
+ return;
+ }
+ const perMessageDeflate = this._extensions[PerMessageDeflate.extensionName];
+ this._bufferedBytes += options14[kByteLength];
+ this._deflating = true;
+ perMessageDeflate.compress(data, options14.fin, (_2, buf) => {
+ if (this._socket.destroyed) {
+ const err = new Error(
+ "The socket was closed while data was being compressed"
+ );
+ if (typeof cb === "function")
+ cb(err);
+ for (let i = 0; i < this._queue.length; i++) {
+ const params = this._queue[i];
+ const callback = params[params.length - 1];
+ if (typeof callback === "function")
+ callback(err);
+ }
+ return;
+ }
+ this._bufferedBytes -= options14[kByteLength];
+ this._deflating = false;
+ options14.readOnly = false;
+ this.sendFrame(Sender2.frame(buf, options14), cb);
+ this.dequeue();
+ });
+ }
+ /**
+ * Executes queued send operations.
+ *
+ * @private
+ */
+ dequeue() {
+ while (!this._deflating && this._queue.length) {
+ const params = this._queue.shift();
+ this._bufferedBytes -= params[3][kByteLength];
+ Reflect.apply(params[0], this, params.slice(1));
+ }
+ }
+ /**
+ * Enqueues a send operation.
+ *
+ * @param {Array} params Send operation parameters.
+ * @private
+ */
+ enqueue(params) {
+ this._bufferedBytes += params[3][kByteLength];
+ this._queue.push(params);
+ }
+ /**
+ * Sends a frame.
+ *
+ * @param {Buffer[]} list The frame to send
+ * @param {Function} [cb] Callback
+ * @private
+ */
+ sendFrame(list, cb) {
+ if (list.length === 2) {
+ this._socket.cork();
+ this._socket.write(list[0]);
+ this._socket.write(list[1], cb);
+ this._socket.uncork();
+ } else {
+ this._socket.write(list[0], cb);
+ }
+ }
+ };
+ __name(Sender2, "Sender");
+ module2.exports = Sender2;
+ }
+});
+
+// ../../node_modules/.pnpm/ws@8.11.0/node_modules/ws/lib/event-target.js
+var require_event_target2 = __commonJS({
+ "../../node_modules/.pnpm/ws@8.11.0/node_modules/ws/lib/event-target.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var { kForOnEventAttribute, kListener } = require_constants7();
+ var kCode = Symbol("kCode");
+ var kData = Symbol("kData");
+ var kError = Symbol("kError");
+ var kMessage = Symbol("kMessage");
+ var kReason = Symbol("kReason");
+ var kTarget = Symbol("kTarget");
+ var kType = Symbol("kType");
+ var kWasClean = Symbol("kWasClean");
+ var Event2 = class {
+ /**
+ * Create a new `Event`.
+ *
+ * @param {String} type The name of the event
+ * @throws {TypeError} If the `type` argument is not specified
+ */
+ constructor(type) {
+ this[kTarget] = null;
+ this[kType] = type;
+ }
+ /**
+ * @type {*}
+ */
+ get target() {
+ return this[kTarget];
+ }
+ /**
+ * @type {String}
+ */
+ get type() {
+ return this[kType];
+ }
+ };
+ __name(Event2, "Event");
+ Object.defineProperty(Event2.prototype, "target", { enumerable: true });
+ Object.defineProperty(Event2.prototype, "type", { enumerable: true });
+ var CloseEvent = class extends Event2 {
+ /**
+ * Create a new `CloseEvent`.
+ *
+ * @param {String} type The name of the event
+ * @param {Object} [options] A dictionary object that allows for setting
+ * attributes via object members of the same name
+ * @param {Number} [options.code=0] The status code explaining why the
+ * connection was closed
+ * @param {String} [options.reason=''] A human-readable string explaining why
+ * the connection was closed
+ * @param {Boolean} [options.wasClean=false] Indicates whether or not the
+ * connection was cleanly closed
+ */
+ constructor(type, options14 = {}) {
+ super(type);
+ this[kCode] = options14.code === void 0 ? 0 : options14.code;
+ this[kReason] = options14.reason === void 0 ? "" : options14.reason;
+ this[kWasClean] = options14.wasClean === void 0 ? false : options14.wasClean;
+ }
+ /**
+ * @type {Number}
+ */
+ get code() {
+ return this[kCode];
+ }
+ /**
+ * @type {String}
+ */
+ get reason() {
+ return this[kReason];
+ }
+ /**
+ * @type {Boolean}
+ */
+ get wasClean() {
+ return this[kWasClean];
+ }
+ };
+ __name(CloseEvent, "CloseEvent");
+ Object.defineProperty(CloseEvent.prototype, "code", { enumerable: true });
+ Object.defineProperty(CloseEvent.prototype, "reason", { enumerable: true });
+ Object.defineProperty(CloseEvent.prototype, "wasClean", { enumerable: true });
+ var ErrorEvent2 = class extends Event2 {
+ /**
+ * Create a new `ErrorEvent`.
+ *
+ * @param {String} type The name of the event
+ * @param {Object} [options] A dictionary object that allows for setting
+ * attributes via object members of the same name
+ * @param {*} [options.error=null] The error that generated this event
+ * @param {String} [options.message=''] The error message
+ */
+ constructor(type, options14 = {}) {
+ super(type);
+ this[kError] = options14.error === void 0 ? null : options14.error;
+ this[kMessage] = options14.message === void 0 ? "" : options14.message;
+ }
+ /**
+ * @type {*}
+ */
+ get error() {
+ return this[kError];
+ }
+ /**
+ * @type {String}
+ */
+ get message() {
+ return this[kMessage];
+ }
+ };
+ __name(ErrorEvent2, "ErrorEvent");
+ Object.defineProperty(ErrorEvent2.prototype, "error", { enumerable: true });
+ Object.defineProperty(ErrorEvent2.prototype, "message", { enumerable: true });
+ var MessageEvent = class extends Event2 {
+ /**
+ * Create a new `MessageEvent`.
+ *
+ * @param {String} type The name of the event
+ * @param {Object} [options] A dictionary object that allows for setting
+ * attributes via object members of the same name
+ * @param {*} [options.data=null] The message content
+ */
+ constructor(type, options14 = {}) {
+ super(type);
+ this[kData] = options14.data === void 0 ? null : options14.data;
+ }
+ /**
+ * @type {*}
+ */
+ get data() {
+ return this[kData];
+ }
+ };
+ __name(MessageEvent, "MessageEvent");
+ Object.defineProperty(MessageEvent.prototype, "data", { enumerable: true });
+ var EventTarget2 = {
+ /**
+ * Register an event listener.
+ *
+ * @param {String} type A string representing the event type to listen for
+ * @param {(Function|Object)} handler The listener to add
+ * @param {Object} [options] An options object specifies characteristics about
+ * the event listener
+ * @param {Boolean} [options.once=false] A `Boolean` indicating that the
+ * listener should be invoked at most once after being added. If `true`,
+ * the listener would be automatically removed when invoked.
+ * @public
+ */
+ addEventListener(type, handler15, options14 = {}) {
+ for (const listener of this.listeners(type)) {
+ if (!options14[kForOnEventAttribute] && listener[kListener] === handler15 && !listener[kForOnEventAttribute]) {
+ return;
+ }
+ }
+ let wrapper;
+ if (type === "message") {
+ wrapper = /* @__PURE__ */ __name(function onMessage(data, isBinary) {
+ const event = new MessageEvent("message", {
+ data: isBinary ? data : data.toString()
+ });
+ event[kTarget] = this;
+ callListener(handler15, this, event);
+ }, "onMessage");
+ } else if (type === "close") {
+ wrapper = /* @__PURE__ */ __name(function onClose(code, message) {
+ const event = new CloseEvent("close", {
+ code,
+ reason: message.toString(),
+ wasClean: this._closeFrameReceived && this._closeFrameSent
+ });
+ event[kTarget] = this;
+ callListener(handler15, this, event);
+ }, "onClose");
+ } else if (type === "error") {
+ wrapper = /* @__PURE__ */ __name(function onError(error) {
+ const event = new ErrorEvent2("error", {
+ error,
+ message: error.message
+ });
+ event[kTarget] = this;
+ callListener(handler15, this, event);
+ }, "onError");
+ } else if (type === "open") {
+ wrapper = /* @__PURE__ */ __name(function onOpen() {
+ const event = new Event2("open");
+ event[kTarget] = this;
+ callListener(handler15, this, event);
+ }, "onOpen");
+ } else {
+ return;
+ }
+ wrapper[kForOnEventAttribute] = !!options14[kForOnEventAttribute];
+ wrapper[kListener] = handler15;
+ if (options14.once) {
+ this.once(type, wrapper);
+ } else {
+ this.on(type, wrapper);
+ }
+ },
+ /**
+ * Remove an event listener.
+ *
+ * @param {String} type A string representing the event type to remove
+ * @param {(Function|Object)} handler The listener to remove
+ * @public
+ */
+ removeEventListener(type, handler15) {
+ for (const listener of this.listeners(type)) {
+ if (listener[kListener] === handler15 && !listener[kForOnEventAttribute]) {
+ this.removeListener(type, listener);
+ break;
+ }
+ }
+ }
+ };
+ module2.exports = {
+ CloseEvent,
+ ErrorEvent: ErrorEvent2,
+ Event: Event2,
+ EventTarget: EventTarget2,
+ MessageEvent
+ };
+ function callListener(listener, thisArg, event) {
+ if (typeof listener === "object" && listener.handleEvent) {
+ listener.handleEvent.call(listener, event);
+ } else {
+ listener.call(thisArg, event);
+ }
+ }
+ __name(callListener, "callListener");
+ }
+});
+
+// ../../node_modules/.pnpm/ws@8.11.0/node_modules/ws/lib/extension.js
+var require_extension2 = __commonJS({
+ "../../node_modules/.pnpm/ws@8.11.0/node_modules/ws/lib/extension.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var { tokenChars } = require_validation2();
+ function push(dest, name, elem) {
+ if (dest[name] === void 0)
+ dest[name] = [elem];
+ else
+ dest[name].push(elem);
+ }
+ __name(push, "push");
+ function parse4(header) {
+ const offers = /* @__PURE__ */ Object.create(null);
+ let params = /* @__PURE__ */ Object.create(null);
+ let mustUnescape = false;
+ let isEscaping = false;
+ let inQuotes = false;
+ let extensionName;
+ let paramName;
+ let start = -1;
+ let code = -1;
+ let end = -1;
+ let i = 0;
+ for (; i < header.length; i++) {
+ code = header.charCodeAt(i);
+ if (extensionName === void 0) {
+ if (end === -1 && tokenChars[code] === 1) {
+ if (start === -1)
+ start = i;
+ } else if (i !== 0 && (code === 32 || code === 9)) {
+ if (end === -1 && start !== -1)
+ end = i;
+ } else if (code === 59 || code === 44) {
+ if (start === -1) {
+ throw new SyntaxError(`Unexpected character at index ${i}`);
+ }
+ if (end === -1)
+ end = i;
+ const name = header.slice(start, end);
+ if (code === 44) {
+ push(offers, name, params);
+ params = /* @__PURE__ */ Object.create(null);
+ } else {
+ extensionName = name;
+ }
+ start = end = -1;
+ } else {
+ throw new SyntaxError(`Unexpected character at index ${i}`);
+ }
+ } else if (paramName === void 0) {
+ if (end === -1 && tokenChars[code] === 1) {
+ if (start === -1)
+ start = i;
+ } else if (code === 32 || code === 9) {
+ if (end === -1 && start !== -1)
+ end = i;
+ } else if (code === 59 || code === 44) {
+ if (start === -1) {
+ throw new SyntaxError(`Unexpected character at index ${i}`);
+ }
+ if (end === -1)
+ end = i;
+ push(params, header.slice(start, end), true);
+ if (code === 44) {
+ push(offers, extensionName, params);
+ params = /* @__PURE__ */ Object.create(null);
+ extensionName = void 0;
+ }
+ start = end = -1;
+ } else if (code === 61 && start !== -1 && end === -1) {
+ paramName = header.slice(start, i);
+ start = end = -1;
+ } else {
+ throw new SyntaxError(`Unexpected character at index ${i}`);
+ }
+ } else {
+ if (isEscaping) {
+ if (tokenChars[code] !== 1) {
+ throw new SyntaxError(`Unexpected character at index ${i}`);
+ }
+ if (start === -1)
+ start = i;
+ else if (!mustUnescape)
+ mustUnescape = true;
+ isEscaping = false;
+ } else if (inQuotes) {
+ if (tokenChars[code] === 1) {
+ if (start === -1)
+ start = i;
+ } else if (code === 34 && start !== -1) {
+ inQuotes = false;
+ end = i;
+ } else if (code === 92) {
+ isEscaping = true;
+ } else {
+ throw new SyntaxError(`Unexpected character at index ${i}`);
+ }
+ } else if (code === 34 && header.charCodeAt(i - 1) === 61) {
+ inQuotes = true;
+ } else if (end === -1 && tokenChars[code] === 1) {
+ if (start === -1)
+ start = i;
+ } else if (start !== -1 && (code === 32 || code === 9)) {
+ if (end === -1)
+ end = i;
+ } else if (code === 59 || code === 44) {
+ if (start === -1) {
+ throw new SyntaxError(`Unexpected character at index ${i}`);
+ }
+ if (end === -1)
+ end = i;
+ let value = header.slice(start, end);
+ if (mustUnescape) {
+ value = value.replace(/\\/g, "");
+ mustUnescape = false;
+ }
+ push(params, paramName, value);
+ if (code === 44) {
+ push(offers, extensionName, params);
+ params = /* @__PURE__ */ Object.create(null);
+ extensionName = void 0;
+ }
+ paramName = void 0;
+ start = end = -1;
+ } else {
+ throw new SyntaxError(`Unexpected character at index ${i}`);
+ }
+ }
+ }
+ if (start === -1 || inQuotes || code === 32 || code === 9) {
+ throw new SyntaxError("Unexpected end of input");
+ }
+ if (end === -1)
+ end = i;
+ const token = header.slice(start, end);
+ if (extensionName === void 0) {
+ push(offers, token, params);
+ } else {
+ if (paramName === void 0) {
+ push(params, token, true);
+ } else if (mustUnescape) {
+ push(params, paramName, token.replace(/\\/g, ""));
+ } else {
+ push(params, paramName, token);
+ }
+ push(offers, extensionName, params);
+ }
+ return offers;
+ }
+ __name(parse4, "parse");
+ function format8(extensions) {
+ return Object.keys(extensions).map((extension) => {
+ let configurations = extensions[extension];
+ if (!Array.isArray(configurations))
+ configurations = [configurations];
+ return configurations.map((params) => {
+ return [extension].concat(
+ Object.keys(params).map((k) => {
+ let values = params[k];
+ if (!Array.isArray(values))
+ values = [values];
+ return values.map((v) => v === true ? k : `${k}=${v}`).join("; ");
+ })
+ ).join("; ");
+ }).join(", ");
+ }).join(", ");
+ }
+ __name(format8, "format");
+ module2.exports = { format: format8, parse: parse4 };
+ }
+});
+
+// ../../node_modules/.pnpm/ws@8.11.0/node_modules/ws/lib/websocket.js
+var require_websocket3 = __commonJS({
+ "../../node_modules/.pnpm/ws@8.11.0/node_modules/ws/lib/websocket.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var EventEmitter3 = require("events");
+ var https2 = require("https");
+ var http3 = require("http");
+ var net3 = require("net");
+ var tls = require("tls");
+ var { randomBytes, createHash } = require("crypto");
+ var { Readable } = require("stream");
+ var { URL: URL4 } = require("url");
+ var PerMessageDeflate = require_permessage_deflate2();
+ var Receiver2 = require_receiver3();
+ var Sender2 = require_sender2();
+ var {
+ BINARY_TYPES,
+ EMPTY_BUFFER,
+ GUID,
+ kForOnEventAttribute,
+ kListener,
+ kStatusCode,
+ kWebSocket,
+ NOOP
+ } = require_constants7();
+ var {
+ EventTarget: { addEventListener, removeEventListener }
+ } = require_event_target2();
+ var { format: format8, parse: parse4 } = require_extension2();
+ var { toBuffer } = require_buffer_util2();
+ var closeTimeout = 30 * 1e3;
+ var kAborted = Symbol("kAborted");
+ var protocolVersions = [8, 13];
+ var readyStates = ["CONNECTING", "OPEN", "CLOSING", "CLOSED"];
+ var subprotocolRegex = /^[!#$%&'*+\-.0-9A-Z^_`|a-z~]+$/;
+ var WebSocket2 = class extends EventEmitter3 {
+ /**
+ * Create a new `WebSocket`.
+ *
+ * @param {(String|URL)} address The URL to which to connect
+ * @param {(String|String[])} [protocols] The subprotocols
+ * @param {Object} [options] Connection options
+ */
+ constructor(address, protocols, options14) {
+ super();
+ this._binaryType = BINARY_TYPES[0];
+ this._closeCode = 1006;
+ this._closeFrameReceived = false;
+ this._closeFrameSent = false;
+ this._closeMessage = EMPTY_BUFFER;
+ this._closeTimer = null;
+ this._extensions = {};
+ this._paused = false;
+ this._protocol = "";
+ this._readyState = WebSocket2.CONNECTING;
+ this._receiver = null;
+ this._sender = null;
+ this._socket = null;
+ if (address !== null) {
+ this._bufferedAmount = 0;
+ this._isServer = false;
+ this._redirects = 0;
+ if (protocols === void 0) {
+ protocols = [];
+ } else if (!Array.isArray(protocols)) {
+ if (typeof protocols === "object" && protocols !== null) {
+ options14 = protocols;
+ protocols = [];
+ } else {
+ protocols = [protocols];
+ }
+ }
+ initAsClient(this, address, protocols, options14);
+ } else {
+ this._isServer = true;
+ }
+ }
+ /**
+ * This deviates from the WHATWG interface since ws doesn't support the
+ * required default "blob" type (instead we define a custom "nodebuffer"
+ * type).
+ *
+ * @type {String}
+ */
+ get binaryType() {
+ return this._binaryType;
+ }
+ set binaryType(type) {
+ if (!BINARY_TYPES.includes(type))
+ return;
+ this._binaryType = type;
+ if (this._receiver)
+ this._receiver._binaryType = type;
+ }
+ /**
+ * @type {Number}
+ */
+ get bufferedAmount() {
+ if (!this._socket)
+ return this._bufferedAmount;
+ return this._socket._writableState.length + this._sender._bufferedBytes;
+ }
+ /**
+ * @type {String}
+ */
+ get extensions() {
+ return Object.keys(this._extensions).join();
+ }
+ /**
+ * @type {Boolean}
+ */
+ get isPaused() {
+ return this._paused;
+ }
+ /**
+ * @type {Function}
+ */
+ /* istanbul ignore next */
+ get onclose() {
+ return null;
+ }
+ /**
+ * @type {Function}
+ */
+ /* istanbul ignore next */
+ get onerror() {
+ return null;
+ }
+ /**
+ * @type {Function}
+ */
+ /* istanbul ignore next */
+ get onopen() {
+ return null;
+ }
+ /**
+ * @type {Function}
+ */
+ /* istanbul ignore next */
+ get onmessage() {
+ return null;
+ }
+ /**
+ * @type {String}
+ */
+ get protocol() {
+ return this._protocol;
+ }
+ /**
+ * @type {Number}
+ */
+ get readyState() {
+ return this._readyState;
+ }
+ /**
+ * @type {String}
+ */
+ get url() {
+ return this._url;
+ }
+ /**
+ * Set up the socket and the internal resources.
+ *
+ * @param {(net.Socket|tls.Socket)} socket The network socket between the
+ * server and client
+ * @param {Buffer} head The first packet of the upgraded stream
+ * @param {Object} options Options object
+ * @param {Function} [options.generateMask] The function used to generate the
+ * masking key
+ * @param {Number} [options.maxPayload=0] The maximum allowed message size
+ * @param {Boolean} [options.skipUTF8Validation=false] Specifies whether or
+ * not to skip UTF-8 validation for text and close messages
+ * @private
+ */
+ setSocket(socket, head, options14) {
+ const receiver = new Receiver2({
+ binaryType: this.binaryType,
+ extensions: this._extensions,
+ isServer: this._isServer,
+ maxPayload: options14.maxPayload,
+ skipUTF8Validation: options14.skipUTF8Validation
+ });
+ this._sender = new Sender2(socket, this._extensions, options14.generateMask);
+ this._receiver = receiver;
+ this._socket = socket;
+ receiver[kWebSocket] = this;
+ socket[kWebSocket] = this;
+ receiver.on("conclude", receiverOnConclude);
+ receiver.on("drain", receiverOnDrain);
+ receiver.on("error", receiverOnError);
+ receiver.on("message", receiverOnMessage);
+ receiver.on("ping", receiverOnPing);
+ receiver.on("pong", receiverOnPong);
+ socket.setTimeout(0);
+ socket.setNoDelay();
+ if (head.length > 0)
+ socket.unshift(head);
+ socket.on("close", socketOnClose);
+ socket.on("data", socketOnData);
+ socket.on("end", socketOnEnd);
+ socket.on("error", socketOnError);
+ this._readyState = WebSocket2.OPEN;
+ this.emit("open");
+ }
+ /**
+ * Emit the `'close'` event.
+ *
+ * @private
+ */
+ emitClose() {
+ if (!this._socket) {
+ this._readyState = WebSocket2.CLOSED;
+ this.emit("close", this._closeCode, this._closeMessage);
+ return;
+ }
+ if (this._extensions[PerMessageDeflate.extensionName]) {
+ this._extensions[PerMessageDeflate.extensionName].cleanup();
+ }
+ this._receiver.removeAllListeners();
+ this._readyState = WebSocket2.CLOSED;
+ this.emit("close", this._closeCode, this._closeMessage);
+ }
+ /**
+ * Start a closing handshake.
+ *
+ * +----------+ +-----------+ +----------+
+ * - - -|ws.close()|-->|close frame|-->|ws.close()|- - -
+ * | +----------+ +-----------+ +----------+ |
+ * +----------+ +-----------+ |
+ * CLOSING |ws.close()|<--|close frame|<--+-----+ CLOSING
+ * +----------+ +-----------+ |
+ * | | | +---+ |
+ * +------------------------+-->|fin| - - - -
+ * | +---+ | +---+
+ * - - - - -|fin|<---------------------+
+ * +---+
+ *
+ * @param {Number} [code] Status code explaining why the connection is closing
+ * @param {(String|Buffer)} [data] The reason why the connection is
+ * closing
+ * @public
+ */
+ close(code, data) {
+ if (this.readyState === WebSocket2.CLOSED)
+ return;
+ if (this.readyState === WebSocket2.CONNECTING) {
+ const msg = "WebSocket was closed before the connection was established";
+ return abortHandshake(this, this._req, msg);
+ }
+ if (this.readyState === WebSocket2.CLOSING) {
+ if (this._closeFrameSent && (this._closeFrameReceived || this._receiver._writableState.errorEmitted)) {
+ this._socket.end();
+ }
+ return;
+ }
+ this._readyState = WebSocket2.CLOSING;
+ this._sender.close(code, data, !this._isServer, (err) => {
+ if (err)
+ return;
+ this._closeFrameSent = true;
+ if (this._closeFrameReceived || this._receiver._writableState.errorEmitted) {
+ this._socket.end();
+ }
+ });
+ this._closeTimer = setTimeout(
+ this._socket.destroy.bind(this._socket),
+ closeTimeout
+ );
+ }
+ /**
+ * Pause the socket.
+ *
+ * @public
+ */
+ pause() {
+ if (this.readyState === WebSocket2.CONNECTING || this.readyState === WebSocket2.CLOSED) {
+ return;
+ }
+ this._paused = true;
+ this._socket.pause();
+ }
+ /**
+ * Send a ping.
+ *
+ * @param {*} [data] The data to send
+ * @param {Boolean} [mask] Indicates whether or not to mask `data`
+ * @param {Function} [cb] Callback which is executed when the ping is sent
+ * @public
+ */
+ ping(data, mask, cb) {
+ if (this.readyState === WebSocket2.CONNECTING) {
+ throw new Error("WebSocket is not open: readyState 0 (CONNECTING)");
+ }
+ if (typeof data === "function") {
+ cb = data;
+ data = mask = void 0;
+ } else if (typeof mask === "function") {
+ cb = mask;
+ mask = void 0;
+ }
+ if (typeof data === "number")
+ data = data.toString();
+ if (this.readyState !== WebSocket2.OPEN) {
+ sendAfterClose(this, data, cb);
+ return;
+ }
+ if (mask === void 0)
+ mask = !this._isServer;
+ this._sender.ping(data || EMPTY_BUFFER, mask, cb);
+ }
+ /**
+ * Send a pong.
+ *
+ * @param {*} [data] The data to send
+ * @param {Boolean} [mask] Indicates whether or not to mask `data`
+ * @param {Function} [cb] Callback which is executed when the pong is sent
+ * @public
+ */
+ pong(data, mask, cb) {
+ if (this.readyState === WebSocket2.CONNECTING) {
+ throw new Error("WebSocket is not open: readyState 0 (CONNECTING)");
+ }
+ if (typeof data === "function") {
+ cb = data;
+ data = mask = void 0;
+ } else if (typeof mask === "function") {
+ cb = mask;
+ mask = void 0;
+ }
+ if (typeof data === "number")
+ data = data.toString();
+ if (this.readyState !== WebSocket2.OPEN) {
+ sendAfterClose(this, data, cb);
+ return;
+ }
+ if (mask === void 0)
+ mask = !this._isServer;
+ this._sender.pong(data || EMPTY_BUFFER, mask, cb);
+ }
+ /**
+ * Resume the socket.
+ *
+ * @public
+ */
+ resume() {
+ if (this.readyState === WebSocket2.CONNECTING || this.readyState === WebSocket2.CLOSED) {
+ return;
+ }
+ this._paused = false;
+ if (!this._receiver._writableState.needDrain)
+ this._socket.resume();
+ }
+ /**
+ * Send a data message.
+ *
+ * @param {*} data The message to send
+ * @param {Object} [options] Options object
+ * @param {Boolean} [options.binary] Specifies whether `data` is binary or
+ * text
+ * @param {Boolean} [options.compress] Specifies whether or not to compress
+ * `data`
+ * @param {Boolean} [options.fin=true] Specifies whether the fragment is the
+ * last one
+ * @param {Boolean} [options.mask] Specifies whether or not to mask `data`
+ * @param {Function} [cb] Callback which is executed when data is written out
+ * @public
+ */
+ send(data, options14, cb) {
+ if (this.readyState === WebSocket2.CONNECTING) {
+ throw new Error("WebSocket is not open: readyState 0 (CONNECTING)");
+ }
+ if (typeof options14 === "function") {
+ cb = options14;
+ options14 = {};
+ }
+ if (typeof data === "number")
+ data = data.toString();
+ if (this.readyState !== WebSocket2.OPEN) {
+ sendAfterClose(this, data, cb);
+ return;
+ }
+ const opts = {
+ binary: typeof data !== "string",
+ mask: !this._isServer,
+ compress: true,
+ fin: true,
+ ...options14
+ };
+ if (!this._extensions[PerMessageDeflate.extensionName]) {
+ opts.compress = false;
+ }
+ this._sender.send(data || EMPTY_BUFFER, opts, cb);
+ }
+ /**
+ * Forcibly close the connection.
+ *
+ * @public
+ */
+ terminate() {
+ if (this.readyState === WebSocket2.CLOSED)
+ return;
+ if (this.readyState === WebSocket2.CONNECTING) {
+ const msg = "WebSocket was closed before the connection was established";
+ return abortHandshake(this, this._req, msg);
+ }
+ if (this._socket) {
+ this._readyState = WebSocket2.CLOSING;
+ this._socket.destroy();
+ }
+ }
+ };
+ __name(WebSocket2, "WebSocket");
+ Object.defineProperty(WebSocket2, "CONNECTING", {
+ enumerable: true,
+ value: readyStates.indexOf("CONNECTING")
+ });
+ Object.defineProperty(WebSocket2.prototype, "CONNECTING", {
+ enumerable: true,
+ value: readyStates.indexOf("CONNECTING")
+ });
+ Object.defineProperty(WebSocket2, "OPEN", {
+ enumerable: true,
+ value: readyStates.indexOf("OPEN")
+ });
+ Object.defineProperty(WebSocket2.prototype, "OPEN", {
+ enumerable: true,
+ value: readyStates.indexOf("OPEN")
+ });
+ Object.defineProperty(WebSocket2, "CLOSING", {
+ enumerable: true,
+ value: readyStates.indexOf("CLOSING")
+ });
+ Object.defineProperty(WebSocket2.prototype, "CLOSING", {
+ enumerable: true,
+ value: readyStates.indexOf("CLOSING")
+ });
+ Object.defineProperty(WebSocket2, "CLOSED", {
+ enumerable: true,
+ value: readyStates.indexOf("CLOSED")
+ });
+ Object.defineProperty(WebSocket2.prototype, "CLOSED", {
+ enumerable: true,
+ value: readyStates.indexOf("CLOSED")
+ });
+ [
+ "binaryType",
+ "bufferedAmount",
+ "extensions",
+ "isPaused",
+ "protocol",
+ "readyState",
+ "url"
+ ].forEach((property) => {
+ Object.defineProperty(WebSocket2.prototype, property, { enumerable: true });
+ });
+ ["open", "error", "close", "message"].forEach((method) => {
+ Object.defineProperty(WebSocket2.prototype, `on${method}`, {
+ enumerable: true,
+ get() {
+ for (const listener of this.listeners(method)) {
+ if (listener[kForOnEventAttribute])
+ return listener[kListener];
+ }
+ return null;
+ },
+ set(handler15) {
+ for (const listener of this.listeners(method)) {
+ if (listener[kForOnEventAttribute]) {
+ this.removeListener(method, listener);
+ break;
+ }
+ }
+ if (typeof handler15 !== "function")
+ return;
+ this.addEventListener(method, handler15, {
+ [kForOnEventAttribute]: true
+ });
+ }
+ });
+ });
+ WebSocket2.prototype.addEventListener = addEventListener;
+ WebSocket2.prototype.removeEventListener = removeEventListener;
+ module2.exports = WebSocket2;
+ function initAsClient(websocket, address, protocols, options14) {
+ const opts = {
+ protocolVersion: protocolVersions[1],
+ maxPayload: 100 * 1024 * 1024,
+ skipUTF8Validation: false,
+ perMessageDeflate: true,
+ followRedirects: false,
+ maxRedirects: 10,
+ ...options14,
+ createConnection: void 0,
+ socketPath: void 0,
+ hostname: void 0,
+ protocol: void 0,
+ timeout: void 0,
+ method: "GET",
+ host: void 0,
+ path: void 0,
+ port: void 0
+ };
+ if (!protocolVersions.includes(opts.protocolVersion)) {
+ throw new RangeError(
+ `Unsupported protocol version: ${opts.protocolVersion} (supported versions: ${protocolVersions.join(", ")})`
+ );
+ }
+ let parsedUrl;
+ if (address instanceof URL4) {
+ parsedUrl = address;
+ websocket._url = address.href;
+ } else {
+ try {
+ parsedUrl = new URL4(address);
+ } catch (e2) {
+ throw new SyntaxError(`Invalid URL: ${address}`);
+ }
+ websocket._url = address;
+ }
+ const isSecure = parsedUrl.protocol === "wss:";
+ const isIpcUrl = parsedUrl.protocol === "ws+unix:";
+ let invalidUrlMessage;
+ if (parsedUrl.protocol !== "ws:" && !isSecure && !isIpcUrl) {
+ invalidUrlMessage = `The URL's protocol must be one of "ws:", "wss:", or "ws+unix:"`;
+ } else if (isIpcUrl && !parsedUrl.pathname) {
+ invalidUrlMessage = "The URL's pathname is empty";
+ } else if (parsedUrl.hash) {
+ invalidUrlMessage = "The URL contains a fragment identifier";
+ }
+ if (invalidUrlMessage) {
+ const err = new SyntaxError(invalidUrlMessage);
+ if (websocket._redirects === 0) {
+ throw err;
+ } else {
+ emitErrorAndClose(websocket, err);
+ return;
+ }
+ }
+ const defaultPort = isSecure ? 443 : 80;
+ const key = randomBytes(16).toString("base64");
+ const request = isSecure ? https2.request : http3.request;
+ const protocolSet = /* @__PURE__ */ new Set();
+ let perMessageDeflate;
+ opts.createConnection = isSecure ? tlsConnect : netConnect;
+ opts.defaultPort = opts.defaultPort || defaultPort;
+ opts.port = parsedUrl.port || defaultPort;
+ opts.host = parsedUrl.hostname.startsWith("[") ? parsedUrl.hostname.slice(1, -1) : parsedUrl.hostname;
+ opts.headers = {
+ ...opts.headers,
+ "Sec-WebSocket-Version": opts.protocolVersion,
+ "Sec-WebSocket-Key": key,
+ Connection: "Upgrade",
+ Upgrade: "websocket"
+ };
+ opts.path = parsedUrl.pathname + parsedUrl.search;
+ opts.timeout = opts.handshakeTimeout;
+ if (opts.perMessageDeflate) {
+ perMessageDeflate = new PerMessageDeflate(
+ opts.perMessageDeflate !== true ? opts.perMessageDeflate : {},
+ false,
+ opts.maxPayload
+ );
+ opts.headers["Sec-WebSocket-Extensions"] = format8({
+ [PerMessageDeflate.extensionName]: perMessageDeflate.offer()
+ });
+ }
+ if (protocols.length) {
+ for (const protocol of protocols) {
+ if (typeof protocol !== "string" || !subprotocolRegex.test(protocol) || protocolSet.has(protocol)) {
+ throw new SyntaxError(
+ "An invalid or duplicated subprotocol was specified"
+ );
+ }
+ protocolSet.add(protocol);
+ }
+ opts.headers["Sec-WebSocket-Protocol"] = protocols.join(",");
+ }
+ if (opts.origin) {
+ if (opts.protocolVersion < 13) {
+ opts.headers["Sec-WebSocket-Origin"] = opts.origin;
+ } else {
+ opts.headers.Origin = opts.origin;
+ }
+ }
+ if (parsedUrl.username || parsedUrl.password) {
+ opts.auth = `${parsedUrl.username}:${parsedUrl.password}`;
+ }
+ if (isIpcUrl) {
+ const parts = opts.path.split(":");
+ opts.socketPath = parts[0];
+ opts.path = parts[1];
+ }
+ let req;
+ if (opts.followRedirects) {
+ if (websocket._redirects === 0) {
+ websocket._originalIpc = isIpcUrl;
+ websocket._originalSecure = isSecure;
+ websocket._originalHostOrSocketPath = isIpcUrl ? opts.socketPath : parsedUrl.host;
+ const headers = options14 && options14.headers;
+ options14 = { ...options14, headers: {} };
+ if (headers) {
+ for (const [key2, value] of Object.entries(headers)) {
+ options14.headers[key2.toLowerCase()] = value;
+ }
+ }
+ } else if (websocket.listenerCount("redirect") === 0) {
+ const isSameHost = isIpcUrl ? websocket._originalIpc ? opts.socketPath === websocket._originalHostOrSocketPath : false : websocket._originalIpc ? false : parsedUrl.host === websocket._originalHostOrSocketPath;
+ if (!isSameHost || websocket._originalSecure && !isSecure) {
+ delete opts.headers.authorization;
+ delete opts.headers.cookie;
+ if (!isSameHost)
+ delete opts.headers.host;
+ opts.auth = void 0;
+ }
+ }
+ if (opts.auth && !options14.headers.authorization) {
+ options14.headers.authorization = "Basic " + Buffer.from(opts.auth).toString("base64");
+ }
+ req = websocket._req = request(opts);
+ if (websocket._redirects) {
+ websocket.emit("redirect", websocket.url, req);
+ }
+ } else {
+ req = websocket._req = request(opts);
+ }
+ if (opts.timeout) {
+ req.on("timeout", () => {
+ abortHandshake(websocket, req, "Opening handshake has timed out");
+ });
+ }
+ req.on("error", (err) => {
+ if (req === null || req[kAborted])
+ return;
+ req = websocket._req = null;
+ emitErrorAndClose(websocket, err);
+ });
+ req.on("response", (res) => {
+ const location = res.headers.location;
+ const statusCode = res.statusCode;
+ if (location && opts.followRedirects && statusCode >= 300 && statusCode < 400) {
+ if (++websocket._redirects > opts.maxRedirects) {
+ abortHandshake(websocket, req, "Maximum redirects exceeded");
+ return;
+ }
+ req.abort();
+ let addr;
+ try {
+ addr = new URL4(location, address);
+ } catch (e2) {
+ const err = new SyntaxError(`Invalid URL: ${location}`);
+ emitErrorAndClose(websocket, err);
+ return;
+ }
+ initAsClient(websocket, addr, protocols, options14);
+ } else if (!websocket.emit("unexpected-response", req, res)) {
+ abortHandshake(
+ websocket,
+ req,
+ `Unexpected server response: ${res.statusCode}`
+ );
+ }
+ });
+ req.on("upgrade", (res, socket, head) => {
+ websocket.emit("upgrade", res);
+ if (websocket.readyState !== WebSocket2.CONNECTING)
+ return;
+ req = websocket._req = null;
+ if (res.headers.upgrade.toLowerCase() !== "websocket") {
+ abortHandshake(websocket, socket, "Invalid Upgrade header");
+ return;
+ }
+ const digest = createHash("sha1").update(key + GUID).digest("base64");
+ if (res.headers["sec-websocket-accept"] !== digest) {
+ abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header");
+ return;
+ }
+ const serverProt = res.headers["sec-websocket-protocol"];
+ let protError;
+ if (serverProt !== void 0) {
+ if (!protocolSet.size) {
+ protError = "Server sent a subprotocol but none was requested";
+ } else if (!protocolSet.has(serverProt)) {
+ protError = "Server sent an invalid subprotocol";
+ }
+ } else if (protocolSet.size) {
+ protError = "Server sent no subprotocol";
+ }
+ if (protError) {
+ abortHandshake(websocket, socket, protError);
+ return;
+ }
+ if (serverProt)
+ websocket._protocol = serverProt;
+ const secWebSocketExtensions = res.headers["sec-websocket-extensions"];
+ if (secWebSocketExtensions !== void 0) {
+ if (!perMessageDeflate) {
+ const message = "Server sent a Sec-WebSocket-Extensions header but no extension was requested";
+ abortHandshake(websocket, socket, message);
+ return;
+ }
+ let extensions;
+ try {
+ extensions = parse4(secWebSocketExtensions);
+ } catch (err) {
+ const message = "Invalid Sec-WebSocket-Extensions header";
+ abortHandshake(websocket, socket, message);
+ return;
+ }
+ const extensionNames = Object.keys(extensions);
+ if (extensionNames.length !== 1 || extensionNames[0] !== PerMessageDeflate.extensionName) {
+ const message = "Server indicated an extension that was not requested";
+ abortHandshake(websocket, socket, message);
+ return;
+ }
+ try {
+ perMessageDeflate.accept(extensions[PerMessageDeflate.extensionName]);
+ } catch (err) {
+ const message = "Invalid Sec-WebSocket-Extensions header";
+ abortHandshake(websocket, socket, message);
+ return;
+ }
+ websocket._extensions[PerMessageDeflate.extensionName] = perMessageDeflate;
+ }
+ websocket.setSocket(socket, head, {
+ generateMask: opts.generateMask,
+ maxPayload: opts.maxPayload,
+ skipUTF8Validation: opts.skipUTF8Validation
+ });
+ });
+ req.end();
+ }
+ __name(initAsClient, "initAsClient");
+ function emitErrorAndClose(websocket, err) {
+ websocket._readyState = WebSocket2.CLOSING;
+ websocket.emit("error", err);
+ websocket.emitClose();
+ }
+ __name(emitErrorAndClose, "emitErrorAndClose");
+ function netConnect(options14) {
+ options14.path = options14.socketPath;
+ return net3.connect(options14);
+ }
+ __name(netConnect, "netConnect");
+ function tlsConnect(options14) {
+ options14.path = void 0;
+ if (!options14.servername && options14.servername !== "") {
+ options14.servername = net3.isIP(options14.host) ? "" : options14.host;
+ }
+ return tls.connect(options14);
+ }
+ __name(tlsConnect, "tlsConnect");
+ function abortHandshake(websocket, stream2, message) {
+ websocket._readyState = WebSocket2.CLOSING;
+ const err = new Error(message);
+ Error.captureStackTrace(err, abortHandshake);
+ if (stream2.setHeader) {
+ stream2[kAborted] = true;
+ stream2.abort();
+ if (stream2.socket && !stream2.socket.destroyed) {
+ stream2.socket.destroy();
+ }
+ process.nextTick(emitErrorAndClose, websocket, err);
+ } else {
+ stream2.destroy(err);
+ stream2.once("error", websocket.emit.bind(websocket, "error"));
+ stream2.once("close", websocket.emitClose.bind(websocket));
+ }
+ }
+ __name(abortHandshake, "abortHandshake");
+ function sendAfterClose(websocket, data, cb) {
+ if (data) {
+ const length = toBuffer(data).length;
+ if (websocket._socket)
+ websocket._sender._bufferedBytes += length;
+ else
+ websocket._bufferedAmount += length;
+ }
+ if (cb) {
+ const err = new Error(
+ `WebSocket is not open: readyState ${websocket.readyState} (${readyStates[websocket.readyState]})`
+ );
+ cb(err);
+ }
+ }
+ __name(sendAfterClose, "sendAfterClose");
+ function receiverOnConclude(code, reason) {
+ const websocket = this[kWebSocket];
+ websocket._closeFrameReceived = true;
+ websocket._closeMessage = reason;
+ websocket._closeCode = code;
+ if (websocket._socket[kWebSocket] === void 0)
+ return;
+ websocket._socket.removeListener("data", socketOnData);
+ process.nextTick(resume, websocket._socket);
+ if (code === 1005)
+ websocket.close();
+ else
+ websocket.close(code, reason);
+ }
+ __name(receiverOnConclude, "receiverOnConclude");
+ function receiverOnDrain() {
+ const websocket = this[kWebSocket];
+ if (!websocket.isPaused)
+ websocket._socket.resume();
+ }
+ __name(receiverOnDrain, "receiverOnDrain");
+ function receiverOnError(err) {
+ const websocket = this[kWebSocket];
+ if (websocket._socket[kWebSocket] !== void 0) {
+ websocket._socket.removeListener("data", socketOnData);
+ process.nextTick(resume, websocket._socket);
+ websocket.close(err[kStatusCode]);
+ }
+ websocket.emit("error", err);
+ }
+ __name(receiverOnError, "receiverOnError");
+ function receiverOnFinish() {
+ this[kWebSocket].emitClose();
+ }
+ __name(receiverOnFinish, "receiverOnFinish");
+ function receiverOnMessage(data, isBinary) {
+ this[kWebSocket].emit("message", data, isBinary);
+ }
+ __name(receiverOnMessage, "receiverOnMessage");
+ function receiverOnPing(data) {
+ const websocket = this[kWebSocket];
+ websocket.pong(data, !websocket._isServer, NOOP);
+ websocket.emit("ping", data);
+ }
+ __name(receiverOnPing, "receiverOnPing");
+ function receiverOnPong(data) {
+ this[kWebSocket].emit("pong", data);
+ }
+ __name(receiverOnPong, "receiverOnPong");
+ function resume(stream2) {
+ stream2.resume();
+ }
+ __name(resume, "resume");
+ function socketOnClose() {
+ const websocket = this[kWebSocket];
+ this.removeListener("close", socketOnClose);
+ this.removeListener("data", socketOnData);
+ this.removeListener("end", socketOnEnd);
+ websocket._readyState = WebSocket2.CLOSING;
+ let chunk;
+ if (!this._readableState.endEmitted && !websocket._closeFrameReceived && !websocket._receiver._writableState.errorEmitted && (chunk = websocket._socket.read()) !== null) {
+ websocket._receiver.write(chunk);
+ }
+ websocket._receiver.end();
+ this[kWebSocket] = void 0;
+ clearTimeout(websocket._closeTimer);
+ if (websocket._receiver._writableState.finished || websocket._receiver._writableState.errorEmitted) {
+ websocket.emitClose();
+ } else {
+ websocket._receiver.on("error", receiverOnFinish);
+ websocket._receiver.on("finish", receiverOnFinish);
+ }
+ }
+ __name(socketOnClose, "socketOnClose");
+ function socketOnData(chunk) {
+ if (!this[kWebSocket]._receiver.write(chunk)) {
+ this.pause();
+ }
+ }
+ __name(socketOnData, "socketOnData");
+ function socketOnEnd() {
+ const websocket = this[kWebSocket];
+ websocket._readyState = WebSocket2.CLOSING;
+ websocket._receiver.end();
+ this.end();
+ }
+ __name(socketOnEnd, "socketOnEnd");
+ function socketOnError() {
+ const websocket = this[kWebSocket];
+ this.removeListener("error", socketOnError);
+ this.on("error", NOOP);
+ if (websocket) {
+ websocket._readyState = WebSocket2.CLOSING;
+ this.destroy();
+ }
+ }
+ __name(socketOnError, "socketOnError");
+ }
+});
+
+// ../../node_modules/.pnpm/ws@8.11.0/node_modules/ws/lib/subprotocol.js
+var require_subprotocol = __commonJS({
+ "../../node_modules/.pnpm/ws@8.11.0/node_modules/ws/lib/subprotocol.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var { tokenChars } = require_validation2();
+ function parse4(header) {
+ const protocols = /* @__PURE__ */ new Set();
+ let start = -1;
+ let end = -1;
+ let i = 0;
+ for (i; i < header.length; i++) {
+ const code = header.charCodeAt(i);
+ if (end === -1 && tokenChars[code] === 1) {
+ if (start === -1)
+ start = i;
+ } else if (i !== 0 && (code === 32 || code === 9)) {
+ if (end === -1 && start !== -1)
+ end = i;
+ } else if (code === 44) {
+ if (start === -1) {
+ throw new SyntaxError(`Unexpected character at index ${i}`);
+ }
+ if (end === -1)
+ end = i;
+ const protocol2 = header.slice(start, end);
+ if (protocols.has(protocol2)) {
+ throw new SyntaxError(`The "${protocol2}" subprotocol is duplicated`);
+ }
+ protocols.add(protocol2);
+ start = end = -1;
+ } else {
+ throw new SyntaxError(`Unexpected character at index ${i}`);
+ }
+ }
+ if (start === -1 || end !== -1) {
+ throw new SyntaxError("Unexpected end of input");
+ }
+ const protocol = header.slice(start, i);
+ if (protocols.has(protocol)) {
+ throw new SyntaxError(`The "${protocol}" subprotocol is duplicated`);
+ }
+ protocols.add(protocol);
+ return protocols;
+ }
+ __name(parse4, "parse");
+ module2.exports = { parse: parse4 };
+ }
+});
+
+// ../../node_modules/.pnpm/ws@8.11.0/node_modules/ws/lib/websocket-server.js
+var require_websocket_server2 = __commonJS({
+ "../../node_modules/.pnpm/ws@8.11.0/node_modules/ws/lib/websocket-server.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var EventEmitter3 = require("events");
+ var http3 = require("http");
+ var https2 = require("https");
+ var net3 = require("net");
+ var tls = require("tls");
+ var { createHash } = require("crypto");
+ var extension = require_extension2();
+ var PerMessageDeflate = require_permessage_deflate2();
+ var subprotocol = require_subprotocol();
+ var WebSocket2 = require_websocket3();
+ var { GUID, kWebSocket } = require_constants7();
+ var keyRegex = /^[+/0-9A-Za-z]{22}==$/;
+ var RUNNING = 0;
+ var CLOSING = 1;
+ var CLOSED = 2;
+ var WebSocketServer2 = class extends EventEmitter3 {
+ /**
+ * Create a `WebSocketServer` instance.
+ *
+ * @param {Object} options Configuration options
+ * @param {Number} [options.backlog=511] The maximum length of the queue of
+ * pending connections
+ * @param {Boolean} [options.clientTracking=true] Specifies whether or not to
+ * track clients
+ * @param {Function} [options.handleProtocols] A hook to handle protocols
+ * @param {String} [options.host] The hostname where to bind the server
+ * @param {Number} [options.maxPayload=104857600] The maximum allowed message
+ * size
+ * @param {Boolean} [options.noServer=false] Enable no server mode
+ * @param {String} [options.path] Accept only connections matching this path
+ * @param {(Boolean|Object)} [options.perMessageDeflate=false] Enable/disable
+ * permessage-deflate
+ * @param {Number} [options.port] The port where to bind the server
+ * @param {(http.Server|https.Server)} [options.server] A pre-created HTTP/S
+ * server to use
+ * @param {Boolean} [options.skipUTF8Validation=false] Specifies whether or
+ * not to skip UTF-8 validation for text and close messages
+ * @param {Function} [options.verifyClient] A hook to reject connections
+ * @param {Function} [options.WebSocket=WebSocket] Specifies the `WebSocket`
+ * class to use. It must be the `WebSocket` class or class that extends it
+ * @param {Function} [callback] A listener for the `listening` event
+ */
+ constructor(options14, callback) {
+ super();
+ options14 = {
+ maxPayload: 100 * 1024 * 1024,
+ skipUTF8Validation: false,
+ perMessageDeflate: false,
+ handleProtocols: null,
+ clientTracking: true,
+ verifyClient: null,
+ noServer: false,
+ backlog: null,
+ // use default (511 as implemented in net.js)
+ server: null,
+ host: null,
+ path: null,
+ port: null,
+ WebSocket: WebSocket2,
+ ...options14
+ };
+ if (options14.port == null && !options14.server && !options14.noServer || options14.port != null && (options14.server || options14.noServer) || options14.server && options14.noServer) {
+ throw new TypeError(
+ 'One and only one of the "port", "server", or "noServer" options must be specified'
+ );
+ }
+ if (options14.port != null) {
+ this._server = http3.createServer((req, res) => {
+ const body = http3.STATUS_CODES[426];
+ res.writeHead(426, {
+ "Content-Length": body.length,
+ "Content-Type": "text/plain"
+ });
+ res.end(body);
+ });
+ this._server.listen(
+ options14.port,
+ options14.host,
+ options14.backlog,
+ callback
+ );
+ } else if (options14.server) {
+ this._server = options14.server;
+ }
+ if (this._server) {
+ const emitConnection = this.emit.bind(this, "connection");
+ this._removeListeners = addListeners(this._server, {
+ listening: this.emit.bind(this, "listening"),
+ error: this.emit.bind(this, "error"),
+ upgrade: (req, socket, head) => {
+ this.handleUpgrade(req, socket, head, emitConnection);
+ }
+ });
+ }
+ if (options14.perMessageDeflate === true)
+ options14.perMessageDeflate = {};
+ if (options14.clientTracking) {
+ this.clients = /* @__PURE__ */ new Set();
+ this._shouldEmitClose = false;
+ }
+ this.options = options14;
+ this._state = RUNNING;
+ }
+ /**
+ * Returns the bound address, the address family name, and port of the server
+ * as reported by the operating system if listening on an IP socket.
+ * If the server is listening on a pipe or UNIX domain socket, the name is
+ * returned as a string.
+ *
+ * @return {(Object|String|null)} The address of the server
+ * @public
+ */
+ address() {
+ if (this.options.noServer) {
+ throw new Error('The server is operating in "noServer" mode');
+ }
+ if (!this._server)
+ return null;
+ return this._server.address();
+ }
+ /**
+ * Stop the server from accepting new connections and emit the `'close'` event
+ * when all existing connections are closed.
+ *
+ * @param {Function} [cb] A one-time listener for the `'close'` event
+ * @public
+ */
+ close(cb) {
+ if (this._state === CLOSED) {
+ if (cb) {
+ this.once("close", () => {
+ cb(new Error("The server is not running"));
+ });
+ }
+ process.nextTick(emitClose, this);
+ return;
+ }
+ if (cb)
+ this.once("close", cb);
+ if (this._state === CLOSING)
+ return;
+ this._state = CLOSING;
+ if (this.options.noServer || this.options.server) {
+ if (this._server) {
+ this._removeListeners();
+ this._removeListeners = this._server = null;
+ }
+ if (this.clients) {
+ if (!this.clients.size) {
+ process.nextTick(emitClose, this);
+ } else {
+ this._shouldEmitClose = true;
+ }
+ } else {
+ process.nextTick(emitClose, this);
+ }
+ } else {
+ const server2 = this._server;
+ this._removeListeners();
+ this._removeListeners = this._server = null;
+ server2.close(() => {
+ emitClose(this);
+ });
+ }
+ }
+ /**
+ * See if a given request should be handled by this server instance.
+ *
+ * @param {http.IncomingMessage} req Request object to inspect
+ * @return {Boolean} `true` if the request is valid, else `false`
+ * @public
+ */
+ shouldHandle(req) {
+ if (this.options.path) {
+ const index = req.url.indexOf("?");
+ const pathname = index !== -1 ? req.url.slice(0, index) : req.url;
+ if (pathname !== this.options.path)
+ return false;
+ }
+ return true;
+ }
+ /**
+ * Handle a HTTP Upgrade request.
+ *
+ * @param {http.IncomingMessage} req The request object
+ * @param {(net.Socket|tls.Socket)} socket The network socket between the
+ * server and client
+ * @param {Buffer} head The first packet of the upgraded stream
+ * @param {Function} cb Callback
+ * @public
+ */
+ handleUpgrade(req, socket, head, cb) {
+ socket.on("error", socketOnError);
+ const key = req.headers["sec-websocket-key"];
+ const version2 = +req.headers["sec-websocket-version"];
+ if (req.method !== "GET") {
+ const message = "Invalid HTTP method";
+ abortHandshakeOrEmitwsClientError(this, req, socket, 405, message);
+ return;
+ }
+ if (req.headers.upgrade.toLowerCase() !== "websocket") {
+ const message = "Invalid Upgrade header";
+ abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
+ return;
+ }
+ if (!key || !keyRegex.test(key)) {
+ const message = "Missing or invalid Sec-WebSocket-Key header";
+ abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
+ return;
+ }
+ if (version2 !== 8 && version2 !== 13) {
+ const message = "Missing or invalid Sec-WebSocket-Version header";
+ abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
+ return;
+ }
+ if (!this.shouldHandle(req)) {
+ abortHandshake(socket, 400);
+ return;
+ }
+ const secWebSocketProtocol = req.headers["sec-websocket-protocol"];
+ let protocols = /* @__PURE__ */ new Set();
+ if (secWebSocketProtocol !== void 0) {
+ try {
+ protocols = subprotocol.parse(secWebSocketProtocol);
+ } catch (err) {
+ const message = "Invalid Sec-WebSocket-Protocol header";
+ abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
+ return;
+ }
+ }
+ const secWebSocketExtensions = req.headers["sec-websocket-extensions"];
+ const extensions = {};
+ if (this.options.perMessageDeflate && secWebSocketExtensions !== void 0) {
+ const perMessageDeflate = new PerMessageDeflate(
+ this.options.perMessageDeflate,
+ true,
+ this.options.maxPayload
+ );
+ try {
+ const offers = extension.parse(secWebSocketExtensions);
+ if (offers[PerMessageDeflate.extensionName]) {
+ perMessageDeflate.accept(offers[PerMessageDeflate.extensionName]);
+ extensions[PerMessageDeflate.extensionName] = perMessageDeflate;
+ }
+ } catch (err) {
+ const message = "Invalid or unacceptable Sec-WebSocket-Extensions header";
+ abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
+ return;
+ }
+ }
+ if (this.options.verifyClient) {
+ const info = {
+ origin: req.headers[`${version2 === 8 ? "sec-websocket-origin" : "origin"}`],
+ secure: !!(req.socket.authorized || req.socket.encrypted),
+ req
+ };
+ if (this.options.verifyClient.length === 2) {
+ this.options.verifyClient(info, (verified, code, message, headers) => {
+ if (!verified) {
+ return abortHandshake(socket, code || 401, message, headers);
+ }
+ this.completeUpgrade(
+ extensions,
+ key,
+ protocols,
+ req,
+ socket,
+ head,
+ cb
+ );
+ });
+ return;
+ }
+ if (!this.options.verifyClient(info))
+ return abortHandshake(socket, 401);
+ }
+ this.completeUpgrade(extensions, key, protocols, req, socket, head, cb);
+ }
+ /**
+ * Upgrade the connection to WebSocket.
+ *
+ * @param {Object} extensions The accepted extensions
+ * @param {String} key The value of the `Sec-WebSocket-Key` header
+ * @param {Set} protocols The subprotocols
+ * @param {http.IncomingMessage} req The request object
+ * @param {(net.Socket|tls.Socket)} socket The network socket between the
+ * server and client
+ * @param {Buffer} head The first packet of the upgraded stream
+ * @param {Function} cb Callback
+ * @throws {Error} If called more than once with the same socket
+ * @private
+ */
+ completeUpgrade(extensions, key, protocols, req, socket, head, cb) {
+ if (!socket.readable || !socket.writable)
+ return socket.destroy();
+ if (socket[kWebSocket]) {
+ throw new Error(
+ "server.handleUpgrade() was called more than once with the same socket, possibly due to a misconfiguration"
+ );
+ }
+ if (this._state > RUNNING)
+ return abortHandshake(socket, 503);
+ const digest = createHash("sha1").update(key + GUID).digest("base64");
+ const headers = [
+ "HTTP/1.1 101 Switching Protocols",
+ "Upgrade: websocket",
+ "Connection: Upgrade",
+ `Sec-WebSocket-Accept: ${digest}`
+ ];
+ const ws = new this.options.WebSocket(null);
+ if (protocols.size) {
+ const protocol = this.options.handleProtocols ? this.options.handleProtocols(protocols, req) : protocols.values().next().value;
+ if (protocol) {
+ headers.push(`Sec-WebSocket-Protocol: ${protocol}`);
+ ws._protocol = protocol;
+ }
+ }
+ if (extensions[PerMessageDeflate.extensionName]) {
+ const params = extensions[PerMessageDeflate.extensionName].params;
+ const value = extension.format({
+ [PerMessageDeflate.extensionName]: [params]
+ });
+ headers.push(`Sec-WebSocket-Extensions: ${value}`);
+ ws._extensions = extensions;
+ }
+ this.emit("headers", headers, req);
+ socket.write(headers.concat("\r\n").join("\r\n"));
+ socket.removeListener("error", socketOnError);
+ ws.setSocket(socket, head, {
+ maxPayload: this.options.maxPayload,
+ skipUTF8Validation: this.options.skipUTF8Validation
+ });
+ if (this.clients) {
+ this.clients.add(ws);
+ ws.on("close", () => {
+ this.clients.delete(ws);
+ if (this._shouldEmitClose && !this.clients.size) {
+ process.nextTick(emitClose, this);
+ }
+ });
+ }
+ cb(ws, req);
+ }
+ };
+ __name(WebSocketServer2, "WebSocketServer");
+ module2.exports = WebSocketServer2;
+ function addListeners(server2, map) {
+ for (const event of Object.keys(map))
+ server2.on(event, map[event]);
+ return /* @__PURE__ */ __name(function removeListeners() {
+ for (const event of Object.keys(map)) {
+ server2.removeListener(event, map[event]);
+ }
+ }, "removeListeners");
+ }
+ __name(addListeners, "addListeners");
+ function emitClose(server2) {
+ server2._state = CLOSED;
+ server2.emit("close");
+ }
+ __name(emitClose, "emitClose");
+ function socketOnError() {
+ this.destroy();
+ }
+ __name(socketOnError, "socketOnError");
+ function abortHandshake(socket, code, message, headers) {
+ message = message || http3.STATUS_CODES[code];
+ headers = {
+ Connection: "close",
+ "Content-Type": "text/html",
+ "Content-Length": Buffer.byteLength(message),
+ ...headers
+ };
+ socket.once("finish", socket.destroy);
+ socket.end(
+ `HTTP/1.1 ${code} ${http3.STATUS_CODES[code]}\r
+` + Object.keys(headers).map((h) => `${h}: ${headers[h]}`).join("\r\n") + "\r\n\r\n" + message
+ );
+ }
+ __name(abortHandshake, "abortHandshake");
+ function abortHandshakeOrEmitwsClientError(server2, req, socket, code, message) {
+ if (server2.listenerCount("wsClientError")) {
+ const err = new Error(message);
+ Error.captureStackTrace(err, abortHandshakeOrEmitwsClientError);
+ server2.emit("wsClientError", err, socket, req);
+ } else {
+ abortHandshake(socket, code, message);
+ }
+ }
+ __name(abortHandshakeOrEmitwsClientError, "abortHandshakeOrEmitwsClientError");
+ }
+});
+
+// ../../node_modules/.pnpm/buffer-from@1.1.2/node_modules/buffer-from/index.js
+var require_buffer_from = __commonJS({
+ "../../node_modules/.pnpm/buffer-from@1.1.2/node_modules/buffer-from/index.js"(exports2, module2) {
+ init_import_meta_url();
+ var toString = Object.prototype.toString;
+ var isModern = typeof Buffer !== "undefined" && typeof Buffer.alloc === "function" && typeof Buffer.allocUnsafe === "function" && typeof Buffer.from === "function";
+ function isArrayBuffer(input) {
+ return toString.call(input).slice(8, -1) === "ArrayBuffer";
+ }
+ __name(isArrayBuffer, "isArrayBuffer");
+ function fromArrayBuffer(obj, byteOffset, length) {
+ byteOffset >>>= 0;
+ var maxLength = obj.byteLength - byteOffset;
+ if (maxLength < 0) {
+ throw new RangeError("'offset' is out of bounds");
+ }
+ if (length === void 0) {
+ length = maxLength;
+ } else {
+ length >>>= 0;
+ if (length > maxLength) {
+ throw new RangeError("'length' is out of bounds");
+ }
+ }
+ return isModern ? Buffer.from(obj.slice(byteOffset, byteOffset + length)) : new Buffer(new Uint8Array(obj.slice(byteOffset, byteOffset + length)));
+ }
+ __name(fromArrayBuffer, "fromArrayBuffer");
+ function fromString(string, encoding) {
+ if (typeof encoding !== "string" || encoding === "") {
+ encoding = "utf8";
+ }
+ if (!Buffer.isEncoding(encoding)) {
+ throw new TypeError('"encoding" must be a valid string encoding');
+ }
+ return isModern ? Buffer.from(string, encoding) : new Buffer(string, encoding);
+ }
+ __name(fromString, "fromString");
+ function bufferFrom(value, encodingOrOffset, length) {
+ if (typeof value === "number") {
+ throw new TypeError('"value" argument must not be a number');
+ }
+ if (isArrayBuffer(value)) {
+ return fromArrayBuffer(value, encodingOrOffset, length);
+ }
+ if (typeof value === "string") {
+ return fromString(value, encodingOrOffset);
+ }
+ return isModern ? Buffer.from(value) : new Buffer(value);
+ }
+ __name(bufferFrom, "bufferFrom");
+ module2.exports = bufferFrom;
+ }
+});
+
+// ../../node_modules/.pnpm/source-map-support@0.5.21/node_modules/source-map-support/source-map-support.js
+var require_source_map_support = __commonJS({
+ "../../node_modules/.pnpm/source-map-support@0.5.21/node_modules/source-map-support/source-map-support.js"(exports2, module2) {
+ init_import_meta_url();
+ var SourceMapConsumer = require("source-map").SourceMapConsumer;
+ var path45 = require("path");
+ var fs20;
+ try {
+ fs20 = require("fs");
+ if (!fs20.existsSync || !fs20.readFileSync) {
+ fs20 = null;
+ }
+ } catch (err) {
+ }
+ var bufferFrom = require_buffer_from();
+ function dynamicRequire(mod, request) {
+ return mod.require(request);
+ }
+ __name(dynamicRequire, "dynamicRequire");
+ var errorFormatterInstalled = false;
+ var uncaughtShimInstalled = false;
+ var emptyCacheBetweenOperations = false;
+ var environment = "auto";
+ var fileContentsCache = {};
+ var sourceMapCache = {};
+ var reSourceMap = /^data:application\/json[^,]+base64,/;
+ var retrieveFileHandlers = [];
+ var retrieveMapHandlers = [];
+ function isInBrowser() {
+ if (environment === "browser")
+ return true;
+ if (environment === "node")
+ return false;
+ return typeof window !== "undefined" && typeof XMLHttpRequest === "function" && !(window.require && window.module && window.process && window.process.type === "renderer");
+ }
+ __name(isInBrowser, "isInBrowser");
+ function hasGlobalProcessEventEmitter() {
+ return typeof process === "object" && process !== null && typeof process.on === "function";
+ }
+ __name(hasGlobalProcessEventEmitter, "hasGlobalProcessEventEmitter");
+ function globalProcessVersion() {
+ if (typeof process === "object" && process !== null) {
+ return process.version;
+ } else {
+ return "";
+ }
+ }
+ __name(globalProcessVersion, "globalProcessVersion");
+ function globalProcessStderr() {
+ if (typeof process === "object" && process !== null) {
+ return process.stderr;
+ }
+ }
+ __name(globalProcessStderr, "globalProcessStderr");
+ function globalProcessExit(code) {
+ if (typeof process === "object" && process !== null && typeof process.exit === "function") {
+ return process.exit(code);
+ }
+ }
+ __name(globalProcessExit, "globalProcessExit");
+ function handlerExec(list) {
+ return function(arg) {
+ for (var i = 0; i < list.length; i++) {
+ var ret = list[i](arg);
+ if (ret) {
+ return ret;
+ }
+ }
+ return null;
+ };
+ }
+ __name(handlerExec, "handlerExec");
+ var retrieveFile = handlerExec(retrieveFileHandlers);
+ retrieveFileHandlers.push(function(path46) {
+ path46 = path46.trim();
+ if (/^file:/.test(path46)) {
+ path46 = path46.replace(/file:\/\/\/(\w:)?/, function(protocol, drive) {
+ return drive ? "" : (
+ // file:///C:/dir/file -> C:/dir/file
+ "/"
+ );
+ });
+ }
+ if (path46 in fileContentsCache) {
+ return fileContentsCache[path46];
+ }
+ var contents = "";
+ try {
+ if (!fs20) {
+ var xhr = new XMLHttpRequest();
+ xhr.open(
+ "GET",
+ path46,
+ /** async */
+ false
+ );
+ xhr.send(null);
+ if (xhr.readyState === 4 && xhr.status === 200) {
+ contents = xhr.responseText;
+ }
+ } else if (fs20.existsSync(path46)) {
+ contents = fs20.readFileSync(path46, "utf8");
+ }
+ } catch (er) {
+ }
+ return fileContentsCache[path46] = contents;
+ });
+ function supportRelativeURL(file, url3) {
+ if (!file)
+ return url3;
+ var dir = path45.dirname(file);
+ var match = /^\w+:\/\/[^\/]*/.exec(dir);
+ var protocol = match ? match[0] : "";
+ var startPath = dir.slice(protocol.length);
+ if (protocol && /^\/\w\:/.test(startPath)) {
+ protocol += "/";
+ return protocol + path45.resolve(dir.slice(protocol.length), url3).replace(/\\/g, "/");
+ }
+ return protocol + path45.resolve(dir.slice(protocol.length), url3);
+ }
+ __name(supportRelativeURL, "supportRelativeURL");
+ function retrieveSourceMapURL(source) {
+ var fileData;
+ if (isInBrowser()) {
+ try {
+ var xhr = new XMLHttpRequest();
+ xhr.open("GET", source, false);
+ xhr.send(null);
+ fileData = xhr.readyState === 4 ? xhr.responseText : null;
+ var sourceMapHeader = xhr.getResponseHeader("SourceMap") || xhr.getResponseHeader("X-SourceMap");
+ if (sourceMapHeader) {
+ return sourceMapHeader;
+ }
+ } catch (e2) {
+ }
+ }
+ fileData = retrieveFile(source);
+ var re = /(?:\/\/[@#][\s]*sourceMappingURL=([^\s'"]+)[\s]*$)|(?:\/\*[@#][\s]*sourceMappingURL=([^\s*'"]+)[\s]*(?:\*\/)[\s]*$)/mg;
+ var lastMatch, match;
+ while (match = re.exec(fileData))
+ lastMatch = match;
+ if (!lastMatch)
+ return null;
+ return lastMatch[1];
+ }
+ __name(retrieveSourceMapURL, "retrieveSourceMapURL");
+ var retrieveSourceMap = handlerExec(retrieveMapHandlers);
+ retrieveMapHandlers.push(function(source) {
+ var sourceMappingURL = retrieveSourceMapURL(source);
+ if (!sourceMappingURL)
+ return null;
+ var sourceMapData;
+ if (reSourceMap.test(sourceMappingURL)) {
+ var rawData = sourceMappingURL.slice(sourceMappingURL.indexOf(",") + 1);
+ sourceMapData = bufferFrom(rawData, "base64").toString();
+ sourceMappingURL = source;
+ } else {
+ sourceMappingURL = supportRelativeURL(source, sourceMappingURL);
+ sourceMapData = retrieveFile(sourceMappingURL);
+ }
+ if (!sourceMapData) {
+ return null;
+ }
+ return {
+ url: sourceMappingURL,
+ map: sourceMapData
+ };
+ });
+ function mapSourcePosition(position) {
+ var sourceMap = sourceMapCache[position.source];
+ if (!sourceMap) {
+ var urlAndMap = retrieveSourceMap(position.source);
+ if (urlAndMap) {
+ sourceMap = sourceMapCache[position.source] = {
+ url: urlAndMap.url,
+ map: new SourceMapConsumer(urlAndMap.map)
+ };
+ if (sourceMap.map.sourcesContent) {
+ sourceMap.map.sources.forEach(function(source, i) {
+ var contents = sourceMap.map.sourcesContent[i];
+ if (contents) {
+ var url3 = supportRelativeURL(sourceMap.url, source);
+ fileContentsCache[url3] = contents;
+ }
+ });
+ }
+ } else {
+ sourceMap = sourceMapCache[position.source] = {
+ url: null,
+ map: null
+ };
+ }
+ }
+ if (sourceMap && sourceMap.map && typeof sourceMap.map.originalPositionFor === "function") {
+ var originalPosition = sourceMap.map.originalPositionFor(position);
+ if (originalPosition.source !== null) {
+ originalPosition.source = supportRelativeURL(
+ sourceMap.url,
+ originalPosition.source
+ );
+ return originalPosition;
+ }
+ }
+ return position;
+ }
+ __name(mapSourcePosition, "mapSourcePosition");
+ function mapEvalOrigin(origin) {
+ var match = /^eval at ([^(]+) \((.+):(\d+):(\d+)\)$/.exec(origin);
+ if (match) {
+ var position = mapSourcePosition({
+ source: match[2],
+ line: +match[3],
+ column: match[4] - 1
+ });
+ return "eval at " + match[1] + " (" + position.source + ":" + position.line + ":" + (position.column + 1) + ")";
+ }
+ match = /^eval at ([^(]+) \((.+)\)$/.exec(origin);
+ if (match) {
+ return "eval at " + match[1] + " (" + mapEvalOrigin(match[2]) + ")";
+ }
+ return origin;
+ }
+ __name(mapEvalOrigin, "mapEvalOrigin");
+ function CallSiteToString() {
+ var fileName;
+ var fileLocation = "";
+ if (this.isNative()) {
+ fileLocation = "native";
+ } else {
+ fileName = this.getScriptNameOrSourceURL();
+ if (!fileName && this.isEval()) {
+ fileLocation = this.getEvalOrigin();
+ fileLocation += ", ";
+ }
+ if (fileName) {
+ fileLocation += fileName;
+ } else {
+ fileLocation += "";
+ }
+ var lineNumber = this.getLineNumber();
+ if (lineNumber != null) {
+ fileLocation += ":" + lineNumber;
+ var columnNumber = this.getColumnNumber();
+ if (columnNumber) {
+ fileLocation += ":" + columnNumber;
+ }
+ }
+ }
+ var line = "";
+ var functionName = this.getFunctionName();
+ var addSuffix = true;
+ var isConstructor = this.isConstructor();
+ var isMethodCall = !(this.isToplevel() || isConstructor);
+ if (isMethodCall) {
+ var typeName = this.getTypeName();
+ if (typeName === "[object Object]") {
+ typeName = "null";
+ }
+ var methodName = this.getMethodName();
+ if (functionName) {
+ if (typeName && functionName.indexOf(typeName) != 0) {
+ line += typeName + ".";
+ }
+ line += functionName;
+ if (methodName && functionName.indexOf("." + methodName) != functionName.length - methodName.length - 1) {
+ line += " [as " + methodName + "]";
+ }
+ } else {
+ line += typeName + "." + (methodName || "");
+ }
+ } else if (isConstructor) {
+ line += "new " + (functionName || "");
+ } else if (functionName) {
+ line += functionName;
+ } else {
+ line += fileLocation;
+ addSuffix = false;
+ }
+ if (addSuffix) {
+ line += " (" + fileLocation + ")";
+ }
+ return line;
+ }
+ __name(CallSiteToString, "CallSiteToString");
+ function cloneCallSite(frame) {
+ var object = {};
+ Object.getOwnPropertyNames(Object.getPrototypeOf(frame)).forEach(function(name) {
+ object[name] = /^(?:is|get)/.test(name) ? function() {
+ return frame[name].call(frame);
+ } : frame[name];
+ });
+ object.toString = CallSiteToString;
+ return object;
+ }
+ __name(cloneCallSite, "cloneCallSite");
+ function wrapCallSite(frame, state) {
+ if (state === void 0) {
+ state = { nextPosition: null, curPosition: null };
+ }
+ if (frame.isNative()) {
+ state.curPosition = null;
+ return frame;
+ }
+ var source = frame.getFileName() || frame.getScriptNameOrSourceURL();
+ if (source) {
+ var line = frame.getLineNumber();
+ var column = frame.getColumnNumber() - 1;
+ var noHeader = /^v(10\.1[6-9]|10\.[2-9][0-9]|10\.[0-9]{3,}|1[2-9]\d*|[2-9]\d|\d{3,}|11\.11)/;
+ var headerLength = noHeader.test(globalProcessVersion()) ? 0 : 62;
+ if (line === 1 && column > headerLength && !isInBrowser() && !frame.isEval()) {
+ column -= headerLength;
+ }
+ var position = mapSourcePosition({
+ source,
+ line,
+ column
+ });
+ state.curPosition = position;
+ frame = cloneCallSite(frame);
+ var originalFunctionName = frame.getFunctionName;
+ frame.getFunctionName = function() {
+ if (state.nextPosition == null) {
+ return originalFunctionName();
+ }
+ return state.nextPosition.name || originalFunctionName();
+ };
+ frame.getFileName = function() {
+ return position.source;
+ };
+ frame.getLineNumber = function() {
+ return position.line;
+ };
+ frame.getColumnNumber = function() {
+ return position.column + 1;
+ };
+ frame.getScriptNameOrSourceURL = function() {
+ return position.source;
+ };
+ return frame;
+ }
+ var origin = frame.isEval() && frame.getEvalOrigin();
+ if (origin) {
+ origin = mapEvalOrigin(origin);
+ frame = cloneCallSite(frame);
+ frame.getEvalOrigin = function() {
+ return origin;
+ };
+ return frame;
+ }
+ return frame;
+ }
+ __name(wrapCallSite, "wrapCallSite");
+ function prepareStackTrace(error, stack) {
+ if (emptyCacheBetweenOperations) {
+ fileContentsCache = {};
+ sourceMapCache = {};
+ }
+ var name = error.name || "Error";
+ var message = error.message || "";
+ var errorString = name + ": " + message;
+ var state = { nextPosition: null, curPosition: null };
+ var processedStack = [];
+ for (var i = stack.length - 1; i >= 0; i--) {
+ processedStack.push("\n at " + wrapCallSite(stack[i], state));
+ state.nextPosition = state.curPosition;
+ }
+ state.curPosition = state.nextPosition = null;
+ return errorString + processedStack.reverse().join("");
+ }
+ __name(prepareStackTrace, "prepareStackTrace");
+ function getErrorSource(error) {
+ var match = /\n at [^(]+ \((.*):(\d+):(\d+)\)/.exec(error.stack);
+ if (match) {
+ var source = match[1];
+ var line = +match[2];
+ var column = +match[3];
+ var contents = fileContentsCache[source];
+ if (!contents && fs20 && fs20.existsSync(source)) {
+ try {
+ contents = fs20.readFileSync(source, "utf8");
+ } catch (er) {
+ contents = "";
+ }
+ }
+ if (contents) {
+ var code = contents.split(/(?:\r\n|\r|\n)/)[line - 1];
+ if (code) {
+ return source + ":" + line + "\n" + code + "\n" + new Array(column).join(" ") + "^";
+ }
+ }
+ }
+ return null;
+ }
+ __name(getErrorSource, "getErrorSource");
+ function printErrorAndExit(error) {
+ var source = getErrorSource(error);
+ var stderr = globalProcessStderr();
+ if (stderr && stderr._handle && stderr._handle.setBlocking) {
+ stderr._handle.setBlocking(true);
+ }
+ if (source) {
+ console.error();
+ console.error(source);
+ }
+ console.error(error.stack);
+ globalProcessExit(1);
+ }
+ __name(printErrorAndExit, "printErrorAndExit");
+ function shimEmitUncaughtException() {
+ var origEmit = process.emit;
+ process.emit = function(type) {
+ if (type === "uncaughtException") {
+ var hasStack = arguments[1] && arguments[1].stack;
+ var hasListeners = this.listeners(type).length > 0;
+ if (hasStack && !hasListeners) {
+ return printErrorAndExit(arguments[1]);
+ }
+ }
+ return origEmit.apply(this, arguments);
+ };
+ }
+ __name(shimEmitUncaughtException, "shimEmitUncaughtException");
+ var originalRetrieveFileHandlers = retrieveFileHandlers.slice(0);
+ var originalRetrieveMapHandlers = retrieveMapHandlers.slice(0);
+ exports2.wrapCallSite = wrapCallSite;
+ exports2.getErrorSource = getErrorSource;
+ exports2.mapSourcePosition = mapSourcePosition;
+ exports2.retrieveSourceMap = retrieveSourceMap;
+ exports2.install = function(options14) {
+ options14 = options14 || {};
+ if (options14.environment) {
+ environment = options14.environment;
+ if (["node", "browser", "auto"].indexOf(environment) === -1) {
+ throw new Error("environment " + environment + " was unknown. Available options are {auto, browser, node}");
+ }
+ }
+ if (options14.retrieveFile) {
+ if (options14.overrideRetrieveFile) {
+ retrieveFileHandlers.length = 0;
+ }
+ retrieveFileHandlers.unshift(options14.retrieveFile);
+ }
+ if (options14.retrieveSourceMap) {
+ if (options14.overrideRetrieveSourceMap) {
+ retrieveMapHandlers.length = 0;
+ }
+ retrieveMapHandlers.unshift(options14.retrieveSourceMap);
+ }
+ if (options14.hookRequire && !isInBrowser()) {
+ var Module = dynamicRequire(module2, "module");
+ var $compile = Module.prototype._compile;
+ if (!$compile.__sourceMapSupport) {
+ Module.prototype._compile = function(content, filename) {
+ fileContentsCache[filename] = content;
+ sourceMapCache[filename] = void 0;
+ return $compile.call(this, content, filename);
+ };
+ Module.prototype._compile.__sourceMapSupport = true;
+ }
+ }
+ if (!emptyCacheBetweenOperations) {
+ emptyCacheBetweenOperations = "emptyCacheBetweenOperations" in options14 ? options14.emptyCacheBetweenOperations : false;
+ }
+ if (!errorFormatterInstalled) {
+ errorFormatterInstalled = true;
+ Error.prepareStackTrace = prepareStackTrace;
+ }
+ if (!uncaughtShimInstalled) {
+ var installHandler = "handleUncaughtExceptions" in options14 ? options14.handleUncaughtExceptions : true;
+ try {
+ var worker_threads = dynamicRequire(module2, "worker_threads");
+ if (worker_threads.isMainThread === false) {
+ installHandler = false;
+ }
+ } catch (e2) {
+ }
+ if (installHandler && hasGlobalProcessEventEmitter()) {
+ uncaughtShimInstalled = true;
+ shimEmitUncaughtException();
+ }
+ }
+ };
+ exports2.resetRetrieveHandlers = function() {
+ retrieveFileHandlers.length = 0;
+ retrieveMapHandlers.length = 0;
+ retrieveFileHandlers = originalRetrieveFileHandlers.slice(0);
+ retrieveMapHandlers = originalRetrieveMapHandlers.slice(0);
+ retrieveSourceMap = handlerExec(retrieveMapHandlers);
+ retrieveFile = handlerExec(retrieveFileHandlers);
+ };
+ }
+});
+
+// ../pages-shared/metadata-generator/constants.ts
+var REDIRECTS_VERSION, HEADERS_VERSION, ANALYTICS_VERSION, PERMITTED_STATUS_CODES, HEADER_SEPARATOR, MAX_LINE_LENGTH, MAX_HEADER_RULES, MAX_DYNAMIC_REDIRECT_RULES, MAX_STATIC_REDIRECT_RULES, UNSET_OPERATOR, SPLAT_REGEX, PLACEHOLDER_REGEX;
+var init_constants = __esm({
+ "../pages-shared/metadata-generator/constants.ts"() {
+ init_import_meta_url();
+ REDIRECTS_VERSION = 1;
+ HEADERS_VERSION = 2;
+ ANALYTICS_VERSION = 1;
+ PERMITTED_STATUS_CODES = /* @__PURE__ */ new Set([200, 301, 302, 303, 307, 308]);
+ HEADER_SEPARATOR = ":";
+ MAX_LINE_LENGTH = 2e3;
+ MAX_HEADER_RULES = 100;
+ MAX_DYNAMIC_REDIRECT_RULES = 100;
+ MAX_STATIC_REDIRECT_RULES = 2e3;
+ UNSET_OPERATOR = "! ";
+ SPLAT_REGEX = /\*/g;
+ PLACEHOLDER_REGEX = /:[A-Za-z]\w*/g;
+ }
+});
+
+// ../pages-shared/metadata-generator/createMetadataObject.ts
+function createMetadataObject({
+ redirects,
+ headers,
+ webAnalyticsToken,
+ deploymentId,
+ failOpen,
+ logger: logger2 = /* @__PURE__ */ __name((_message) => {
+ }, "logger")
+}) {
+ return {
+ ...constructRedirects({ redirects, logger: logger2 }),
+ ...constructHeaders({ headers, logger: logger2 }),
+ ...constructWebAnalytics({ webAnalyticsToken, logger: logger2 }),
+ deploymentId,
+ failOpen
+ };
+}
+function constructRedirects({
+ redirects,
+ logger: logger2
+}) {
+ if (!redirects)
+ return {};
+ const num_valid = redirects.rules.length;
+ const num_invalid = redirects.invalid.length;
+ logger2(
+ `Parsed ${num_valid} valid redirect rule${num_valid === 1 ? "" : "s"}.`
+ );
+ if (num_invalid > 0) {
+ logger2(`Found invalid redirect lines:`);
+ for (const { line, lineNumber, message } of redirects.invalid) {
+ if (line)
+ logger2(` - ${lineNumber ? `#${lineNumber}: ` : ""}${line}`);
+ logger2(` ${message}`);
+ }
+ }
+ if (num_valid === 0) {
+ return {};
+ }
+ const staticRedirects = {};
+ const dynamicRedirects = {};
+ let canCreateStaticRule = true;
+ for (const rule of redirects.rules) {
+ if (!rule.from.match(SPLAT_REGEX) && !rule.from.match(PLACEHOLDER_REGEX)) {
+ if (canCreateStaticRule) {
+ staticRedirects[rule.from] = {
+ status: rule.status,
+ to: rule.to,
+ lineNumber: rule.lineNumber
+ };
+ continue;
+ } else {
+ logger2(
+ `Info: the redirect rule ${rule.from} \u2192 ${rule.status} ${rule.to} could be made more performant by bringing it above any lines with splats or placeholders.`
+ );
+ }
+ }
+ dynamicRedirects[rule.from] = { status: rule.status, to: rule.to };
+ canCreateStaticRule = false;
+ }
+ return {
+ redirects: {
+ version: REDIRECTS_VERSION,
+ staticRules: staticRedirects,
+ rules: dynamicRedirects
+ }
+ };
+}
+function constructHeaders({
+ headers,
+ logger: logger2
+}) {
+ if (!headers)
+ return {};
+ const num_valid = headers.rules.length;
+ const num_invalid = headers.invalid.length;
+ logger2(`Parsed ${num_valid} valid header rule${num_valid === 1 ? "" : "s"}.`);
+ if (num_invalid > 0) {
+ logger2(`Found invalid header lines:`);
+ for (const { line, lineNumber, message } of headers.invalid) {
+ if (line)
+ logger2(` - ${lineNumber ? `#${lineNumber}: ` : ""} ${line}`);
+ logger2(` ${message}`);
+ }
+ }
+ if (num_valid === 0) {
+ return {};
+ }
+ const rules = {};
+ for (const rule of headers.rules) {
+ rules[rule.path] = {};
+ if (Object.keys(rule.headers).length) {
+ rules[rule.path].set = rule.headers;
+ }
+ if (rule.unsetHeaders.length) {
+ rules[rule.path].unset = rule.unsetHeaders;
+ }
+ }
+ return {
+ headers: {
+ version: HEADERS_VERSION,
+ rules
+ }
+ };
+}
+function constructWebAnalytics({
+ webAnalyticsToken
+}) {
+ if (!webAnalyticsToken)
+ return {};
+ return {
+ analytics: {
+ version: ANALYTICS_VERSION,
+ token: webAnalyticsToken
+ }
+ };
+}
+var init_createMetadataObject = __esm({
+ "../pages-shared/metadata-generator/createMetadataObject.ts"() {
+ init_import_meta_url();
+ init_constants();
+ __name(createMetadataObject, "createMetadataObject");
+ __name(constructRedirects, "constructRedirects");
+ __name(constructHeaders, "constructHeaders");
+ __name(constructWebAnalytics, "constructWebAnalytics");
+ }
+});
+
+// ../pages-shared/metadata-generator/validateURL.ts
+function urlHasHost(token) {
+ const host = URL_REGEX.exec(token);
+ return Boolean(host && host.groups && host.groups.host);
+}
+var extractPathname, URL_REGEX, HOST_WITH_PORT_REGEX, PATH_REGEX, validateUrl;
+var init_validateURL = __esm({
+ "../pages-shared/metadata-generator/validateURL.ts"() {
+ init_import_meta_url();
+ extractPathname = /* @__PURE__ */ __name((path45 = "/", includeSearch, includeHash) => {
+ if (!path45.startsWith("/"))
+ path45 = `/${path45}`;
+ const url3 = new URL(`//${path45}`, "relative://");
+ return `${url3.pathname}${includeSearch ? url3.search : ""}${includeHash ? url3.hash : ""}`;
+ }, "extractPathname");
+ URL_REGEX = /^https:\/\/+(?[^/]+)\/?(?.*)/;
+ HOST_WITH_PORT_REGEX = /.*:\d+$/;
+ PATH_REGEX = /^\//;
+ validateUrl = /* @__PURE__ */ __name((token, onlyRelative = false, disallowPorts = false, includeSearch = false, includeHash = false) => {
+ const host = URL_REGEX.exec(token);
+ if (host && host.groups && host.groups.host) {
+ if (onlyRelative)
+ return [
+ void 0,
+ `Only relative URLs are allowed. Skipping absolute URL ${token}.`
+ ];
+ if (disallowPorts && host.groups.host.match(HOST_WITH_PORT_REGEX)) {
+ return [
+ void 0,
+ `Specifying ports is not supported. Skipping absolute URL ${token}.`
+ ];
+ }
+ return [
+ `https://${host.groups.host}${extractPathname(
+ host.groups.path,
+ includeSearch,
+ includeHash
+ )}`,
+ void 0
+ ];
+ } else {
+ if (!token.startsWith("/") && onlyRelative)
+ token = `/${token}`;
+ const path45 = PATH_REGEX.exec(token);
+ if (path45) {
+ try {
+ return [extractPathname(token, includeSearch, includeHash), void 0];
+ } catch {
+ return [void 0, `Error parsing URL segment ${token}. Skipping.`];
+ }
+ }
+ }
+ return [
+ void 0,
+ onlyRelative ? "URLs should begin with a forward-slash." : 'URLs should either be relative (e.g. begin with a forward-slash), or use HTTPS (e.g. begin with "https://").'
+ ];
+ }, "validateUrl");
+ __name(urlHasHost, "urlHasHost");
+ }
+});
+
+// ../pages-shared/metadata-generator/parseHeaders.ts
+function parseHeaders(input) {
+ const lines = input.split("\n");
+ const rules = [];
+ const invalid = [];
+ let rule = void 0;
+ for (let i = 0; i < lines.length; i++) {
+ const line = lines[i].trim();
+ if (line.length === 0 || line.startsWith("#"))
+ continue;
+ if (line.length > MAX_LINE_LENGTH) {
+ invalid.push({
+ message: `Ignoring line ${i + 1} as it exceeds the maximum allowed length of ${MAX_LINE_LENGTH}.`
+ });
+ continue;
+ }
+ if (LINE_IS_PROBABLY_A_PATH.test(line)) {
+ if (rules.length >= MAX_HEADER_RULES) {
+ invalid.push({
+ message: `Maximum number of rules supported is ${MAX_HEADER_RULES}. Skipping remaining ${lines.length - i} lines of file.`
+ });
+ break;
+ }
+ if (rule) {
+ if (isValidRule(rule)) {
+ rules.push({
+ path: rule.path,
+ headers: rule.headers,
+ unsetHeaders: rule.unsetHeaders
+ });
+ } else {
+ invalid.push({
+ line: rule.line,
+ lineNumber: i + 1,
+ message: "No headers specified"
+ });
+ }
+ }
+ const [path45, pathError] = validateUrl(line, false, true);
+ if (pathError) {
+ invalid.push({
+ line,
+ lineNumber: i + 1,
+ message: pathError
+ });
+ rule = void 0;
+ continue;
+ }
+ rule = {
+ path: path45,
+ line,
+ headers: {},
+ unsetHeaders: []
+ };
+ continue;
+ }
+ if (!line.includes(HEADER_SEPARATOR)) {
+ if (!rule) {
+ invalid.push({
+ line,
+ lineNumber: i + 1,
+ message: "Expected a path beginning with at least one forward-slash"
+ });
+ } else {
+ if (line.trim().startsWith(UNSET_OPERATOR)) {
+ rule.unsetHeaders.push(line.trim().replace(UNSET_OPERATOR, ""));
+ } else {
+ invalid.push({
+ line,
+ lineNumber: i + 1,
+ message: "Expected a colon-separated header pair (e.g. name: value)"
+ });
+ }
+ }
+ continue;
+ }
+ const [rawName, ...rawValue] = line.split(HEADER_SEPARATOR);
+ const name = rawName.trim().toLowerCase();
+ if (name.includes(" ")) {
+ invalid.push({
+ line,
+ lineNumber: i + 1,
+ message: "Header name cannot include spaces"
+ });
+ continue;
+ }
+ const value = rawValue.join(HEADER_SEPARATOR).trim();
+ if (name === "") {
+ invalid.push({
+ line,
+ lineNumber: i + 1,
+ message: "No header name specified"
+ });
+ continue;
+ }
+ if (value === "") {
+ invalid.push({
+ line,
+ lineNumber: i + 1,
+ message: "No header value specified"
+ });
+ continue;
+ }
+ if (!rule) {
+ invalid.push({
+ line,
+ lineNumber: i + 1,
+ message: `Path should come before header (${name}: ${value})`
+ });
+ continue;
+ }
+ const existingValues = rule.headers[name];
+ rule.headers[name] = existingValues ? `${existingValues}, ${value}` : value;
+ }
+ if (rule) {
+ if (isValidRule(rule)) {
+ rules.push({
+ path: rule.path,
+ headers: rule.headers,
+ unsetHeaders: rule.unsetHeaders
+ });
+ } else {
+ invalid.push({ line: rule.line, message: "No headers specified" });
+ }
+ }
+ return {
+ rules,
+ invalid
+ };
+}
+function isValidRule(rule) {
+ return Object.keys(rule.headers).length > 0 || rule.unsetHeaders.length > 0;
+}
+var LINE_IS_PROBABLY_A_PATH;
+var init_parseHeaders = __esm({
+ "../pages-shared/metadata-generator/parseHeaders.ts"() {
+ init_import_meta_url();
+ init_constants();
+ init_validateURL();
+ LINE_IS_PROBABLY_A_PATH = new RegExp(/^([^\s]+:\/\/|^\/)/);
+ __name(parseHeaders, "parseHeaders");
+ __name(isValidRule, "isValidRule");
+ }
+});
+
+// ../pages-shared/metadata-generator/parseRedirects.ts
+function parseRedirects(input) {
+ const lines = input.split("\n");
+ const rules = [];
+ const seen_paths = /* @__PURE__ */ new Set();
+ const invalid = [];
+ let staticRules = 0;
+ let dynamicRules = 0;
+ let canCreateStaticRule = true;
+ for (let i = 0; i < lines.length; i++) {
+ const line = lines[i].trim();
+ if (line.length === 0 || line.startsWith("#"))
+ continue;
+ if (line.length > MAX_LINE_LENGTH) {
+ invalid.push({
+ message: `Ignoring line ${i + 1} as it exceeds the maximum allowed length of ${MAX_LINE_LENGTH}.`
+ });
+ continue;
+ }
+ const tokens = line.split(/\s+/);
+ if (tokens.length < 2 || tokens.length > 3) {
+ invalid.push({
+ line,
+ lineNumber: i + 1,
+ message: `Expected exactly 2 or 3 whitespace-separated tokens. Got ${tokens.length}.`
+ });
+ continue;
+ }
+ const [str_from, str_to, str_status = "302"] = tokens;
+ const fromResult = validateUrl(str_from, true, true, false, false);
+ if (fromResult[0] === void 0) {
+ invalid.push({
+ line,
+ lineNumber: i + 1,
+ message: fromResult[1]
+ });
+ continue;
+ }
+ const from = fromResult[0];
+ if (canCreateStaticRule && !from.match(SPLAT_REGEX) && !from.match(PLACEHOLDER_REGEX)) {
+ staticRules += 1;
+ if (staticRules > MAX_STATIC_REDIRECT_RULES) {
+ invalid.push({
+ message: `Maximum number of static rules supported is ${MAX_STATIC_REDIRECT_RULES}. Skipping line.`
+ });
+ continue;
+ }
+ } else {
+ dynamicRules += 1;
+ canCreateStaticRule = false;
+ if (dynamicRules > MAX_DYNAMIC_REDIRECT_RULES) {
+ invalid.push({
+ message: `Maximum number of dynamic rules supported is ${MAX_DYNAMIC_REDIRECT_RULES}. Skipping remaining ${lines.length - i} lines of file.`
+ });
+ break;
+ }
+ }
+ const toResult = validateUrl(str_to, false, false, true, true);
+ if (toResult[0] === void 0) {
+ invalid.push({
+ line,
+ lineNumber: i + 1,
+ message: toResult[1]
+ });
+ continue;
+ }
+ const to = toResult[0];
+ const status = Number(str_status);
+ if (isNaN(status) || !PERMITTED_STATUS_CODES.has(status)) {
+ invalid.push({
+ line,
+ lineNumber: i + 1,
+ message: `Valid status codes are 200, 301, 302 (default), 303, 307, or 308. Got ${str_status}.`
+ });
+ continue;
+ }
+ if (/\/\*?$/.test(from) && /\/index(.html)?$/.test(to) && !urlHasHost(to)) {
+ invalid.push({
+ line,
+ lineNumber: i + 1,
+ message: "Infinite loop detected in this rule and has been ignored. This will cause a redirect to strip `.html` or `/index` and end up triggering this rule again. Please fix or remove this rule to silence this warning."
+ });
+ continue;
+ }
+ if (seen_paths.has(from)) {
+ invalid.push({
+ line,
+ lineNumber: i + 1,
+ message: `Ignoring duplicate rule for path ${from}.`
+ });
+ continue;
+ }
+ seen_paths.add(from);
+ if (status === 200) {
+ if (urlHasHost(to)) {
+ invalid.push({
+ line,
+ lineNumber: i + 1,
+ message: `Proxy (200) redirects can only point to relative paths. Got ${to}`
+ });
+ continue;
+ }
+ }
+ rules.push({ from, to, status, lineNumber: i + 1 });
+ }
+ return {
+ rules,
+ invalid
+ };
+}
+var init_parseRedirects = __esm({
+ "../pages-shared/metadata-generator/parseRedirects.ts"() {
+ init_import_meta_url();
+ init_constants();
+ init_validateURL();
+ __name(parseRedirects, "parseRedirects");
+ }
+});
+
+// ../../node_modules/.pnpm/mime@3.0.0/node_modules/mime/Mime.js
+var require_Mime = __commonJS({
+ "../../node_modules/.pnpm/mime@3.0.0/node_modules/mime/Mime.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ function Mime() {
+ this._types = /* @__PURE__ */ Object.create(null);
+ this._extensions = /* @__PURE__ */ Object.create(null);
+ for (let i = 0; i < arguments.length; i++) {
+ this.define(arguments[i]);
+ }
+ this.define = this.define.bind(this);
+ this.getType = this.getType.bind(this);
+ this.getExtension = this.getExtension.bind(this);
+ }
+ __name(Mime, "Mime");
+ Mime.prototype.define = function(typeMap, force) {
+ for (let type in typeMap) {
+ let extensions = typeMap[type].map(function(t2) {
+ return t2.toLowerCase();
+ });
+ type = type.toLowerCase();
+ for (let i = 0; i < extensions.length; i++) {
+ const ext = extensions[i];
+ if (ext[0] === "*") {
+ continue;
+ }
+ if (!force && ext in this._types) {
+ throw new Error(
+ 'Attempt to change mapping for "' + ext + '" extension from "' + this._types[ext] + '" to "' + type + '". Pass `force=true` to allow this, otherwise remove "' + ext + '" from the list of extensions for "' + type + '".'
+ );
+ }
+ this._types[ext] = type;
+ }
+ if (force || !this._extensions[type]) {
+ const ext = extensions[0];
+ this._extensions[type] = ext[0] !== "*" ? ext : ext.substr(1);
+ }
+ }
+ };
+ Mime.prototype.getType = function(path45) {
+ path45 = String(path45);
+ let last = path45.replace(/^.*[/\\]/, "").toLowerCase();
+ let ext = last.replace(/^.*\./, "").toLowerCase();
+ let hasPath = last.length < path45.length;
+ let hasDot = ext.length < last.length - 1;
+ return (hasDot || !hasPath) && this._types[ext] || null;
+ };
+ Mime.prototype.getExtension = function(type) {
+ type = /^\s*([^;\s]*)/.test(type) && RegExp.$1;
+ return type && this._extensions[type.toLowerCase()] || null;
+ };
+ module2.exports = Mime;
+ }
+});
+
+// ../../node_modules/.pnpm/mime@3.0.0/node_modules/mime/types/standard.js
+var require_standard = __commonJS({
+ "../../node_modules/.pnpm/mime@3.0.0/node_modules/mime/types/standard.js"(exports2, module2) {
+ init_import_meta_url();
+ module2.exports = { "application/andrew-inset": ["ez"], "application/applixware": ["aw"], "application/atom+xml": ["atom"], "application/atomcat+xml": ["atomcat"], "application/atomdeleted+xml": ["atomdeleted"], "application/atomsvc+xml": ["atomsvc"], "application/atsc-dwd+xml": ["dwd"], "application/atsc-held+xml": ["held"], "application/atsc-rsat+xml": ["rsat"], "application/bdoc": ["bdoc"], "application/calendar+xml": ["xcs"], "application/ccxml+xml": ["ccxml"], "application/cdfx+xml": ["cdfx"], "application/cdmi-capability": ["cdmia"], "application/cdmi-container": ["cdmic"], "application/cdmi-domain": ["cdmid"], "application/cdmi-object": ["cdmio"], "application/cdmi-queue": ["cdmiq"], "application/cu-seeme": ["cu"], "application/dash+xml": ["mpd"], "application/davmount+xml": ["davmount"], "application/docbook+xml": ["dbk"], "application/dssc+der": ["dssc"], "application/dssc+xml": ["xdssc"], "application/ecmascript": ["es", "ecma"], "application/emma+xml": ["emma"], "application/emotionml+xml": ["emotionml"], "application/epub+zip": ["epub"], "application/exi": ["exi"], "application/express": ["exp"], "application/fdt+xml": ["fdt"], "application/font-tdpfr": ["pfr"], "application/geo+json": ["geojson"], "application/gml+xml": ["gml"], "application/gpx+xml": ["gpx"], "application/gxf": ["gxf"], "application/gzip": ["gz"], "application/hjson": ["hjson"], "application/hyperstudio": ["stk"], "application/inkml+xml": ["ink", "inkml"], "application/ipfix": ["ipfix"], "application/its+xml": ["its"], "application/java-archive": ["jar", "war", "ear"], "application/java-serialized-object": ["ser"], "application/java-vm": ["class"], "application/javascript": ["js", "mjs"], "application/json": ["json", "map"], "application/json5": ["json5"], "application/jsonml+json": ["jsonml"], "application/ld+json": ["jsonld"], "application/lgr+xml": ["lgr"], "application/lost+xml": ["lostxml"], "application/mac-binhex40": ["hqx"], "application/mac-compactpro": ["cpt"], "application/mads+xml": ["mads"], "application/manifest+json": ["webmanifest"], "application/marc": ["mrc"], "application/marcxml+xml": ["mrcx"], "application/mathematica": ["ma", "nb", "mb"], "application/mathml+xml": ["mathml"], "application/mbox": ["mbox"], "application/mediaservercontrol+xml": ["mscml"], "application/metalink+xml": ["metalink"], "application/metalink4+xml": ["meta4"], "application/mets+xml": ["mets"], "application/mmt-aei+xml": ["maei"], "application/mmt-usd+xml": ["musd"], "application/mods+xml": ["mods"], "application/mp21": ["m21", "mp21"], "application/mp4": ["mp4s", "m4p"], "application/msword": ["doc", "dot"], "application/mxf": ["mxf"], "application/n-quads": ["nq"], "application/n-triples": ["nt"], "application/node": ["cjs"], "application/octet-stream": ["bin", "dms", "lrf", "mar", "so", "dist", "distz", "pkg", "bpk", "dump", "elc", "deploy", "exe", "dll", "deb", "dmg", "iso", "img", "msi", "msp", "msm", "buffer"], "application/oda": ["oda"], "application/oebps-package+xml": ["opf"], "application/ogg": ["ogx"], "application/omdoc+xml": ["omdoc"], "application/onenote": ["onetoc", "onetoc2", "onetmp", "onepkg"], "application/oxps": ["oxps"], "application/p2p-overlay+xml": ["relo"], "application/patch-ops-error+xml": ["xer"], "application/pdf": ["pdf"], "application/pgp-encrypted": ["pgp"], "application/pgp-signature": ["asc", "sig"], "application/pics-rules": ["prf"], "application/pkcs10": ["p10"], "application/pkcs7-mime": ["p7m", "p7c"], "application/pkcs7-signature": ["p7s"], "application/pkcs8": ["p8"], "application/pkix-attr-cert": ["ac"], "application/pkix-cert": ["cer"], "application/pkix-crl": ["crl"], "application/pkix-pkipath": ["pkipath"], "application/pkixcmp": ["pki"], "application/pls+xml": ["pls"], "application/postscript": ["ai", "eps", "ps"], "application/provenance+xml": ["provx"], "application/pskc+xml": ["pskcxml"], "application/raml+yaml": ["raml"], "application/rdf+xml": ["rdf", "owl"], "application/reginfo+xml": ["rif"], "application/relax-ng-compact-syntax": ["rnc"], "application/resource-lists+xml": ["rl"], "application/resource-lists-diff+xml": ["rld"], "application/rls-services+xml": ["rs"], "application/route-apd+xml": ["rapd"], "application/route-s-tsid+xml": ["sls"], "application/route-usd+xml": ["rusd"], "application/rpki-ghostbusters": ["gbr"], "application/rpki-manifest": ["mft"], "application/rpki-roa": ["roa"], "application/rsd+xml": ["rsd"], "application/rss+xml": ["rss"], "application/rtf": ["rtf"], "application/sbml+xml": ["sbml"], "application/scvp-cv-request": ["scq"], "application/scvp-cv-response": ["scs"], "application/scvp-vp-request": ["spq"], "application/scvp-vp-response": ["spp"], "application/sdp": ["sdp"], "application/senml+xml": ["senmlx"], "application/sensml+xml": ["sensmlx"], "application/set-payment-initiation": ["setpay"], "application/set-registration-initiation": ["setreg"], "application/shf+xml": ["shf"], "application/sieve": ["siv", "sieve"], "application/smil+xml": ["smi", "smil"], "application/sparql-query": ["rq"], "application/sparql-results+xml": ["srx"], "application/srgs": ["gram"], "application/srgs+xml": ["grxml"], "application/sru+xml": ["sru"], "application/ssdl+xml": ["ssdl"], "application/ssml+xml": ["ssml"], "application/swid+xml": ["swidtag"], "application/tei+xml": ["tei", "teicorpus"], "application/thraud+xml": ["tfi"], "application/timestamped-data": ["tsd"], "application/toml": ["toml"], "application/trig": ["trig"], "application/ttml+xml": ["ttml"], "application/ubjson": ["ubj"], "application/urc-ressheet+xml": ["rsheet"], "application/urc-targetdesc+xml": ["td"], "application/voicexml+xml": ["vxml"], "application/wasm": ["wasm"], "application/widget": ["wgt"], "application/winhlp": ["hlp"], "application/wsdl+xml": ["wsdl"], "application/wspolicy+xml": ["wspolicy"], "application/xaml+xml": ["xaml"], "application/xcap-att+xml": ["xav"], "application/xcap-caps+xml": ["xca"], "application/xcap-diff+xml": ["xdf"], "application/xcap-el+xml": ["xel"], "application/xcap-ns+xml": ["xns"], "application/xenc+xml": ["xenc"], "application/xhtml+xml": ["xhtml", "xht"], "application/xliff+xml": ["xlf"], "application/xml": ["xml", "xsl", "xsd", "rng"], "application/xml-dtd": ["dtd"], "application/xop+xml": ["xop"], "application/xproc+xml": ["xpl"], "application/xslt+xml": ["*xsl", "xslt"], "application/xspf+xml": ["xspf"], "application/xv+xml": ["mxml", "xhvml", "xvml", "xvm"], "application/yang": ["yang"], "application/yin+xml": ["yin"], "application/zip": ["zip"], "audio/3gpp": ["*3gpp"], "audio/adpcm": ["adp"], "audio/amr": ["amr"], "audio/basic": ["au", "snd"], "audio/midi": ["mid", "midi", "kar", "rmi"], "audio/mobile-xmf": ["mxmf"], "audio/mp3": ["*mp3"], "audio/mp4": ["m4a", "mp4a"], "audio/mpeg": ["mpga", "mp2", "mp2a", "mp3", "m2a", "m3a"], "audio/ogg": ["oga", "ogg", "spx", "opus"], "audio/s3m": ["s3m"], "audio/silk": ["sil"], "audio/wav": ["wav"], "audio/wave": ["*wav"], "audio/webm": ["weba"], "audio/xm": ["xm"], "font/collection": ["ttc"], "font/otf": ["otf"], "font/ttf": ["ttf"], "font/woff": ["woff"], "font/woff2": ["woff2"], "image/aces": ["exr"], "image/apng": ["apng"], "image/avif": ["avif"], "image/bmp": ["bmp"], "image/cgm": ["cgm"], "image/dicom-rle": ["drle"], "image/emf": ["emf"], "image/fits": ["fits"], "image/g3fax": ["g3"], "image/gif": ["gif"], "image/heic": ["heic"], "image/heic-sequence": ["heics"], "image/heif": ["heif"], "image/heif-sequence": ["heifs"], "image/hej2k": ["hej2"], "image/hsj2": ["hsj2"], "image/ief": ["ief"], "image/jls": ["jls"], "image/jp2": ["jp2", "jpg2"], "image/jpeg": ["jpeg", "jpg", "jpe"], "image/jph": ["jph"], "image/jphc": ["jhc"], "image/jpm": ["jpm"], "image/jpx": ["jpx", "jpf"], "image/jxr": ["jxr"], "image/jxra": ["jxra"], "image/jxrs": ["jxrs"], "image/jxs": ["jxs"], "image/jxsc": ["jxsc"], "image/jxsi": ["jxsi"], "image/jxss": ["jxss"], "image/ktx": ["ktx"], "image/ktx2": ["ktx2"], "image/png": ["png"], "image/sgi": ["sgi"], "image/svg+xml": ["svg", "svgz"], "image/t38": ["t38"], "image/tiff": ["tif", "tiff"], "image/tiff-fx": ["tfx"], "image/webp": ["webp"], "image/wmf": ["wmf"], "message/disposition-notification": ["disposition-notification"], "message/global": ["u8msg"], "message/global-delivery-status": ["u8dsn"], "message/global-disposition-notification": ["u8mdn"], "message/global-headers": ["u8hdr"], "message/rfc822": ["eml", "mime"], "model/3mf": ["3mf"], "model/gltf+json": ["gltf"], "model/gltf-binary": ["glb"], "model/iges": ["igs", "iges"], "model/mesh": ["msh", "mesh", "silo"], "model/mtl": ["mtl"], "model/obj": ["obj"], "model/step+xml": ["stpx"], "model/step+zip": ["stpz"], "model/step-xml+zip": ["stpxz"], "model/stl": ["stl"], "model/vrml": ["wrl", "vrml"], "model/x3d+binary": ["*x3db", "x3dbz"], "model/x3d+fastinfoset": ["x3db"], "model/x3d+vrml": ["*x3dv", "x3dvz"], "model/x3d+xml": ["x3d", "x3dz"], "model/x3d-vrml": ["x3dv"], "text/cache-manifest": ["appcache", "manifest"], "text/calendar": ["ics", "ifb"], "text/coffeescript": ["coffee", "litcoffee"], "text/css": ["css"], "text/csv": ["csv"], "text/html": ["html", "htm", "shtml"], "text/jade": ["jade"], "text/jsx": ["jsx"], "text/less": ["less"], "text/markdown": ["markdown", "md"], "text/mathml": ["mml"], "text/mdx": ["mdx"], "text/n3": ["n3"], "text/plain": ["txt", "text", "conf", "def", "list", "log", "in", "ini"], "text/richtext": ["rtx"], "text/rtf": ["*rtf"], "text/sgml": ["sgml", "sgm"], "text/shex": ["shex"], "text/slim": ["slim", "slm"], "text/spdx": ["spdx"], "text/stylus": ["stylus", "styl"], "text/tab-separated-values": ["tsv"], "text/troff": ["t", "tr", "roff", "man", "me", "ms"], "text/turtle": ["ttl"], "text/uri-list": ["uri", "uris", "urls"], "text/vcard": ["vcard"], "text/vtt": ["vtt"], "text/xml": ["*xml"], "text/yaml": ["yaml", "yml"], "video/3gpp": ["3gp", "3gpp"], "video/3gpp2": ["3g2"], "video/h261": ["h261"], "video/h263": ["h263"], "video/h264": ["h264"], "video/iso.segment": ["m4s"], "video/jpeg": ["jpgv"], "video/jpm": ["*jpm", "jpgm"], "video/mj2": ["mj2", "mjp2"], "video/mp2t": ["ts"], "video/mp4": ["mp4", "mp4v", "mpg4"], "video/mpeg": ["mpeg", "mpg", "mpe", "m1v", "m2v"], "video/ogg": ["ogv"], "video/quicktime": ["qt", "mov"], "video/webm": ["webm"] };
+ }
+});
+
+// ../../node_modules/.pnpm/mime@3.0.0/node_modules/mime/types/other.js
+var require_other = __commonJS({
+ "../../node_modules/.pnpm/mime@3.0.0/node_modules/mime/types/other.js"(exports2, module2) {
+ init_import_meta_url();
+ module2.exports = { "application/prs.cww": ["cww"], "application/vnd.1000minds.decision-model+xml": ["1km"], "application/vnd.3gpp.pic-bw-large": ["plb"], "application/vnd.3gpp.pic-bw-small": ["psb"], "application/vnd.3gpp.pic-bw-var": ["pvb"], "application/vnd.3gpp2.tcap": ["tcap"], "application/vnd.3m.post-it-notes": ["pwn"], "application/vnd.accpac.simply.aso": ["aso"], "application/vnd.accpac.simply.imp": ["imp"], "application/vnd.acucobol": ["acu"], "application/vnd.acucorp": ["atc", "acutc"], "application/vnd.adobe.air-application-installer-package+zip": ["air"], "application/vnd.adobe.formscentral.fcdt": ["fcdt"], "application/vnd.adobe.fxp": ["fxp", "fxpl"], "application/vnd.adobe.xdp+xml": ["xdp"], "application/vnd.adobe.xfdf": ["xfdf"], "application/vnd.ahead.space": ["ahead"], "application/vnd.airzip.filesecure.azf": ["azf"], "application/vnd.airzip.filesecure.azs": ["azs"], "application/vnd.amazon.ebook": ["azw"], "application/vnd.americandynamics.acc": ["acc"], "application/vnd.amiga.ami": ["ami"], "application/vnd.android.package-archive": ["apk"], "application/vnd.anser-web-certificate-issue-initiation": ["cii"], "application/vnd.anser-web-funds-transfer-initiation": ["fti"], "application/vnd.antix.game-component": ["atx"], "application/vnd.apple.installer+xml": ["mpkg"], "application/vnd.apple.keynote": ["key"], "application/vnd.apple.mpegurl": ["m3u8"], "application/vnd.apple.numbers": ["numbers"], "application/vnd.apple.pages": ["pages"], "application/vnd.apple.pkpass": ["pkpass"], "application/vnd.aristanetworks.swi": ["swi"], "application/vnd.astraea-software.iota": ["iota"], "application/vnd.audiograph": ["aep"], "application/vnd.balsamiq.bmml+xml": ["bmml"], "application/vnd.blueice.multipass": ["mpm"], "application/vnd.bmi": ["bmi"], "application/vnd.businessobjects": ["rep"], "application/vnd.chemdraw+xml": ["cdxml"], "application/vnd.chipnuts.karaoke-mmd": ["mmd"], "application/vnd.cinderella": ["cdy"], "application/vnd.citationstyles.style+xml": ["csl"], "application/vnd.claymore": ["cla"], "application/vnd.cloanto.rp9": ["rp9"], "application/vnd.clonk.c4group": ["c4g", "c4d", "c4f", "c4p", "c4u"], "application/vnd.cluetrust.cartomobile-config": ["c11amc"], "application/vnd.cluetrust.cartomobile-config-pkg": ["c11amz"], "application/vnd.commonspace": ["csp"], "application/vnd.contact.cmsg": ["cdbcmsg"], "application/vnd.cosmocaller": ["cmc"], "application/vnd.crick.clicker": ["clkx"], "application/vnd.crick.clicker.keyboard": ["clkk"], "application/vnd.crick.clicker.palette": ["clkp"], "application/vnd.crick.clicker.template": ["clkt"], "application/vnd.crick.clicker.wordbank": ["clkw"], "application/vnd.criticaltools.wbs+xml": ["wbs"], "application/vnd.ctc-posml": ["pml"], "application/vnd.cups-ppd": ["ppd"], "application/vnd.curl.car": ["car"], "application/vnd.curl.pcurl": ["pcurl"], "application/vnd.dart": ["dart"], "application/vnd.data-vision.rdz": ["rdz"], "application/vnd.dbf": ["dbf"], "application/vnd.dece.data": ["uvf", "uvvf", "uvd", "uvvd"], "application/vnd.dece.ttml+xml": ["uvt", "uvvt"], "application/vnd.dece.unspecified": ["uvx", "uvvx"], "application/vnd.dece.zip": ["uvz", "uvvz"], "application/vnd.denovo.fcselayout-link": ["fe_launch"], "application/vnd.dna": ["dna"], "application/vnd.dolby.mlp": ["mlp"], "application/vnd.dpgraph": ["dpg"], "application/vnd.dreamfactory": ["dfac"], "application/vnd.ds-keypoint": ["kpxx"], "application/vnd.dvb.ait": ["ait"], "application/vnd.dvb.service": ["svc"], "application/vnd.dynageo": ["geo"], "application/vnd.ecowin.chart": ["mag"], "application/vnd.enliven": ["nml"], "application/vnd.epson.esf": ["esf"], "application/vnd.epson.msf": ["msf"], "application/vnd.epson.quickanime": ["qam"], "application/vnd.epson.salt": ["slt"], "application/vnd.epson.ssf": ["ssf"], "application/vnd.eszigno3+xml": ["es3", "et3"], "application/vnd.ezpix-album": ["ez2"], "application/vnd.ezpix-package": ["ez3"], "application/vnd.fdf": ["fdf"], "application/vnd.fdsn.mseed": ["mseed"], "application/vnd.fdsn.seed": ["seed", "dataless"], "application/vnd.flographit": ["gph"], "application/vnd.fluxtime.clip": ["ftc"], "application/vnd.framemaker": ["fm", "frame", "maker", "book"], "application/vnd.frogans.fnc": ["fnc"], "application/vnd.frogans.ltf": ["ltf"], "application/vnd.fsc.weblaunch": ["fsc"], "application/vnd.fujitsu.oasys": ["oas"], "application/vnd.fujitsu.oasys2": ["oa2"], "application/vnd.fujitsu.oasys3": ["oa3"], "application/vnd.fujitsu.oasysgp": ["fg5"], "application/vnd.fujitsu.oasysprs": ["bh2"], "application/vnd.fujixerox.ddd": ["ddd"], "application/vnd.fujixerox.docuworks": ["xdw"], "application/vnd.fujixerox.docuworks.binder": ["xbd"], "application/vnd.fuzzysheet": ["fzs"], "application/vnd.genomatix.tuxedo": ["txd"], "application/vnd.geogebra.file": ["ggb"], "application/vnd.geogebra.tool": ["ggt"], "application/vnd.geometry-explorer": ["gex", "gre"], "application/vnd.geonext": ["gxt"], "application/vnd.geoplan": ["g2w"], "application/vnd.geospace": ["g3w"], "application/vnd.gmx": ["gmx"], "application/vnd.google-apps.document": ["gdoc"], "application/vnd.google-apps.presentation": ["gslides"], "application/vnd.google-apps.spreadsheet": ["gsheet"], "application/vnd.google-earth.kml+xml": ["kml"], "application/vnd.google-earth.kmz": ["kmz"], "application/vnd.grafeq": ["gqf", "gqs"], "application/vnd.groove-account": ["gac"], "application/vnd.groove-help": ["ghf"], "application/vnd.groove-identity-message": ["gim"], "application/vnd.groove-injector": ["grv"], "application/vnd.groove-tool-message": ["gtm"], "application/vnd.groove-tool-template": ["tpl"], "application/vnd.groove-vcard": ["vcg"], "application/vnd.hal+xml": ["hal"], "application/vnd.handheld-entertainment+xml": ["zmm"], "application/vnd.hbci": ["hbci"], "application/vnd.hhe.lesson-player": ["les"], "application/vnd.hp-hpgl": ["hpgl"], "application/vnd.hp-hpid": ["hpid"], "application/vnd.hp-hps": ["hps"], "application/vnd.hp-jlyt": ["jlt"], "application/vnd.hp-pcl": ["pcl"], "application/vnd.hp-pclxl": ["pclxl"], "application/vnd.hydrostatix.sof-data": ["sfd-hdstx"], "application/vnd.ibm.minipay": ["mpy"], "application/vnd.ibm.modcap": ["afp", "listafp", "list3820"], "application/vnd.ibm.rights-management": ["irm"], "application/vnd.ibm.secure-container": ["sc"], "application/vnd.iccprofile": ["icc", "icm"], "application/vnd.igloader": ["igl"], "application/vnd.immervision-ivp": ["ivp"], "application/vnd.immervision-ivu": ["ivu"], "application/vnd.insors.igm": ["igm"], "application/vnd.intercon.formnet": ["xpw", "xpx"], "application/vnd.intergeo": ["i2g"], "application/vnd.intu.qbo": ["qbo"], "application/vnd.intu.qfx": ["qfx"], "application/vnd.ipunplugged.rcprofile": ["rcprofile"], "application/vnd.irepository.package+xml": ["irp"], "application/vnd.is-xpr": ["xpr"], "application/vnd.isac.fcs": ["fcs"], "application/vnd.jam": ["jam"], "application/vnd.jcp.javame.midlet-rms": ["rms"], "application/vnd.jisp": ["jisp"], "application/vnd.joost.joda-archive": ["joda"], "application/vnd.kahootz": ["ktz", "ktr"], "application/vnd.kde.karbon": ["karbon"], "application/vnd.kde.kchart": ["chrt"], "application/vnd.kde.kformula": ["kfo"], "application/vnd.kde.kivio": ["flw"], "application/vnd.kde.kontour": ["kon"], "application/vnd.kde.kpresenter": ["kpr", "kpt"], "application/vnd.kde.kspread": ["ksp"], "application/vnd.kde.kword": ["kwd", "kwt"], "application/vnd.kenameaapp": ["htke"], "application/vnd.kidspiration": ["kia"], "application/vnd.kinar": ["kne", "knp"], "application/vnd.koan": ["skp", "skd", "skt", "skm"], "application/vnd.kodak-descriptor": ["sse"], "application/vnd.las.las+xml": ["lasxml"], "application/vnd.llamagraphics.life-balance.desktop": ["lbd"], "application/vnd.llamagraphics.life-balance.exchange+xml": ["lbe"], "application/vnd.lotus-1-2-3": ["123"], "application/vnd.lotus-approach": ["apr"], "application/vnd.lotus-freelance": ["pre"], "application/vnd.lotus-notes": ["nsf"], "application/vnd.lotus-organizer": ["org"], "application/vnd.lotus-screencam": ["scm"], "application/vnd.lotus-wordpro": ["lwp"], "application/vnd.macports.portpkg": ["portpkg"], "application/vnd.mapbox-vector-tile": ["mvt"], "application/vnd.mcd": ["mcd"], "application/vnd.medcalcdata": ["mc1"], "application/vnd.mediastation.cdkey": ["cdkey"], "application/vnd.mfer": ["mwf"], "application/vnd.mfmp": ["mfm"], "application/vnd.micrografx.flo": ["flo"], "application/vnd.micrografx.igx": ["igx"], "application/vnd.mif": ["mif"], "application/vnd.mobius.daf": ["daf"], "application/vnd.mobius.dis": ["dis"], "application/vnd.mobius.mbk": ["mbk"], "application/vnd.mobius.mqy": ["mqy"], "application/vnd.mobius.msl": ["msl"], "application/vnd.mobius.plc": ["plc"], "application/vnd.mobius.txf": ["txf"], "application/vnd.mophun.application": ["mpn"], "application/vnd.mophun.certificate": ["mpc"], "application/vnd.mozilla.xul+xml": ["xul"], "application/vnd.ms-artgalry": ["cil"], "application/vnd.ms-cab-compressed": ["cab"], "application/vnd.ms-excel": ["xls", "xlm", "xla", "xlc", "xlt", "xlw"], "application/vnd.ms-excel.addin.macroenabled.12": ["xlam"], "application/vnd.ms-excel.sheet.binary.macroenabled.12": ["xlsb"], "application/vnd.ms-excel.sheet.macroenabled.12": ["xlsm"], "application/vnd.ms-excel.template.macroenabled.12": ["xltm"], "application/vnd.ms-fontobject": ["eot"], "application/vnd.ms-htmlhelp": ["chm"], "application/vnd.ms-ims": ["ims"], "application/vnd.ms-lrm": ["lrm"], "application/vnd.ms-officetheme": ["thmx"], "application/vnd.ms-outlook": ["msg"], "application/vnd.ms-pki.seccat": ["cat"], "application/vnd.ms-pki.stl": ["*stl"], "application/vnd.ms-powerpoint": ["ppt", "pps", "pot"], "application/vnd.ms-powerpoint.addin.macroenabled.12": ["ppam"], "application/vnd.ms-powerpoint.presentation.macroenabled.12": ["pptm"], "application/vnd.ms-powerpoint.slide.macroenabled.12": ["sldm"], "application/vnd.ms-powerpoint.slideshow.macroenabled.12": ["ppsm"], "application/vnd.ms-powerpoint.template.macroenabled.12": ["potm"], "application/vnd.ms-project": ["mpp", "mpt"], "application/vnd.ms-word.document.macroenabled.12": ["docm"], "application/vnd.ms-word.template.macroenabled.12": ["dotm"], "application/vnd.ms-works": ["wps", "wks", "wcm", "wdb"], "application/vnd.ms-wpl": ["wpl"], "application/vnd.ms-xpsdocument": ["xps"], "application/vnd.mseq": ["mseq"], "application/vnd.musician": ["mus"], "application/vnd.muvee.style": ["msty"], "application/vnd.mynfc": ["taglet"], "application/vnd.neurolanguage.nlu": ["nlu"], "application/vnd.nitf": ["ntf", "nitf"], "application/vnd.noblenet-directory": ["nnd"], "application/vnd.noblenet-sealer": ["nns"], "application/vnd.noblenet-web": ["nnw"], "application/vnd.nokia.n-gage.ac+xml": ["*ac"], "application/vnd.nokia.n-gage.data": ["ngdat"], "application/vnd.nokia.n-gage.symbian.install": ["n-gage"], "application/vnd.nokia.radio-preset": ["rpst"], "application/vnd.nokia.radio-presets": ["rpss"], "application/vnd.novadigm.edm": ["edm"], "application/vnd.novadigm.edx": ["edx"], "application/vnd.novadigm.ext": ["ext"], "application/vnd.oasis.opendocument.chart": ["odc"], "application/vnd.oasis.opendocument.chart-template": ["otc"], "application/vnd.oasis.opendocument.database": ["odb"], "application/vnd.oasis.opendocument.formula": ["odf"], "application/vnd.oasis.opendocument.formula-template": ["odft"], "application/vnd.oasis.opendocument.graphics": ["odg"], "application/vnd.oasis.opendocument.graphics-template": ["otg"], "application/vnd.oasis.opendocument.image": ["odi"], "application/vnd.oasis.opendocument.image-template": ["oti"], "application/vnd.oasis.opendocument.presentation": ["odp"], "application/vnd.oasis.opendocument.presentation-template": ["otp"], "application/vnd.oasis.opendocument.spreadsheet": ["ods"], "application/vnd.oasis.opendocument.spreadsheet-template": ["ots"], "application/vnd.oasis.opendocument.text": ["odt"], "application/vnd.oasis.opendocument.text-master": ["odm"], "application/vnd.oasis.opendocument.text-template": ["ott"], "application/vnd.oasis.opendocument.text-web": ["oth"], "application/vnd.olpc-sugar": ["xo"], "application/vnd.oma.dd2+xml": ["dd2"], "application/vnd.openblox.game+xml": ["obgx"], "application/vnd.openofficeorg.extension": ["oxt"], "application/vnd.openstreetmap.data+xml": ["osm"], "application/vnd.openxmlformats-officedocument.presentationml.presentation": ["pptx"], "application/vnd.openxmlformats-officedocument.presentationml.slide": ["sldx"], "application/vnd.openxmlformats-officedocument.presentationml.slideshow": ["ppsx"], "application/vnd.openxmlformats-officedocument.presentationml.template": ["potx"], "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": ["xlsx"], "application/vnd.openxmlformats-officedocument.spreadsheetml.template": ["xltx"], "application/vnd.openxmlformats-officedocument.wordprocessingml.document": ["docx"], "application/vnd.openxmlformats-officedocument.wordprocessingml.template": ["dotx"], "application/vnd.osgeo.mapguide.package": ["mgp"], "application/vnd.osgi.dp": ["dp"], "application/vnd.osgi.subsystem": ["esa"], "application/vnd.palm": ["pdb", "pqa", "oprc"], "application/vnd.pawaafile": ["paw"], "application/vnd.pg.format": ["str"], "application/vnd.pg.osasli": ["ei6"], "application/vnd.picsel": ["efif"], "application/vnd.pmi.widget": ["wg"], "application/vnd.pocketlearn": ["plf"], "application/vnd.powerbuilder6": ["pbd"], "application/vnd.previewsystems.box": ["box"], "application/vnd.proteus.magazine": ["mgz"], "application/vnd.publishare-delta-tree": ["qps"], "application/vnd.pvi.ptid1": ["ptid"], "application/vnd.quark.quarkxpress": ["qxd", "qxt", "qwd", "qwt", "qxl", "qxb"], "application/vnd.rar": ["rar"], "application/vnd.realvnc.bed": ["bed"], "application/vnd.recordare.musicxml": ["mxl"], "application/vnd.recordare.musicxml+xml": ["musicxml"], "application/vnd.rig.cryptonote": ["cryptonote"], "application/vnd.rim.cod": ["cod"], "application/vnd.rn-realmedia": ["rm"], "application/vnd.rn-realmedia-vbr": ["rmvb"], "application/vnd.route66.link66+xml": ["link66"], "application/vnd.sailingtracker.track": ["st"], "application/vnd.seemail": ["see"], "application/vnd.sema": ["sema"], "application/vnd.semd": ["semd"], "application/vnd.semf": ["semf"], "application/vnd.shana.informed.formdata": ["ifm"], "application/vnd.shana.informed.formtemplate": ["itp"], "application/vnd.shana.informed.interchange": ["iif"], "application/vnd.shana.informed.package": ["ipk"], "application/vnd.simtech-mindmapper": ["twd", "twds"], "application/vnd.smaf": ["mmf"], "application/vnd.smart.teacher": ["teacher"], "application/vnd.software602.filler.form+xml": ["fo"], "application/vnd.solent.sdkm+xml": ["sdkm", "sdkd"], "application/vnd.spotfire.dxp": ["dxp"], "application/vnd.spotfire.sfs": ["sfs"], "application/vnd.stardivision.calc": ["sdc"], "application/vnd.stardivision.draw": ["sda"], "application/vnd.stardivision.impress": ["sdd"], "application/vnd.stardivision.math": ["smf"], "application/vnd.stardivision.writer": ["sdw", "vor"], "application/vnd.stardivision.writer-global": ["sgl"], "application/vnd.stepmania.package": ["smzip"], "application/vnd.stepmania.stepchart": ["sm"], "application/vnd.sun.wadl+xml": ["wadl"], "application/vnd.sun.xml.calc": ["sxc"], "application/vnd.sun.xml.calc.template": ["stc"], "application/vnd.sun.xml.draw": ["sxd"], "application/vnd.sun.xml.draw.template": ["std"], "application/vnd.sun.xml.impress": ["sxi"], "application/vnd.sun.xml.impress.template": ["sti"], "application/vnd.sun.xml.math": ["sxm"], "application/vnd.sun.xml.writer": ["sxw"], "application/vnd.sun.xml.writer.global": ["sxg"], "application/vnd.sun.xml.writer.template": ["stw"], "application/vnd.sus-calendar": ["sus", "susp"], "application/vnd.svd": ["svd"], "application/vnd.symbian.install": ["sis", "sisx"], "application/vnd.syncml+xml": ["xsm"], "application/vnd.syncml.dm+wbxml": ["bdm"], "application/vnd.syncml.dm+xml": ["xdm"], "application/vnd.syncml.dmddf+xml": ["ddf"], "application/vnd.tao.intent-module-archive": ["tao"], "application/vnd.tcpdump.pcap": ["pcap", "cap", "dmp"], "application/vnd.tmobile-livetv": ["tmo"], "application/vnd.trid.tpt": ["tpt"], "application/vnd.triscape.mxs": ["mxs"], "application/vnd.trueapp": ["tra"], "application/vnd.ufdl": ["ufd", "ufdl"], "application/vnd.uiq.theme": ["utz"], "application/vnd.umajin": ["umj"], "application/vnd.unity": ["unityweb"], "application/vnd.uoml+xml": ["uoml"], "application/vnd.vcx": ["vcx"], "application/vnd.visio": ["vsd", "vst", "vss", "vsw"], "application/vnd.visionary": ["vis"], "application/vnd.vsf": ["vsf"], "application/vnd.wap.wbxml": ["wbxml"], "application/vnd.wap.wmlc": ["wmlc"], "application/vnd.wap.wmlscriptc": ["wmlsc"], "application/vnd.webturbo": ["wtb"], "application/vnd.wolfram.player": ["nbp"], "application/vnd.wordperfect": ["wpd"], "application/vnd.wqd": ["wqd"], "application/vnd.wt.stf": ["stf"], "application/vnd.xara": ["xar"], "application/vnd.xfdl": ["xfdl"], "application/vnd.yamaha.hv-dic": ["hvd"], "application/vnd.yamaha.hv-script": ["hvs"], "application/vnd.yamaha.hv-voice": ["hvp"], "application/vnd.yamaha.openscoreformat": ["osf"], "application/vnd.yamaha.openscoreformat.osfpvg+xml": ["osfpvg"], "application/vnd.yamaha.smaf-audio": ["saf"], "application/vnd.yamaha.smaf-phrase": ["spf"], "application/vnd.yellowriver-custom-menu": ["cmp"], "application/vnd.zul": ["zir", "zirz"], "application/vnd.zzazz.deck+xml": ["zaz"], "application/x-7z-compressed": ["7z"], "application/x-abiword": ["abw"], "application/x-ace-compressed": ["ace"], "application/x-apple-diskimage": ["*dmg"], "application/x-arj": ["arj"], "application/x-authorware-bin": ["aab", "x32", "u32", "vox"], "application/x-authorware-map": ["aam"], "application/x-authorware-seg": ["aas"], "application/x-bcpio": ["bcpio"], "application/x-bdoc": ["*bdoc"], "application/x-bittorrent": ["torrent"], "application/x-blorb": ["blb", "blorb"], "application/x-bzip": ["bz"], "application/x-bzip2": ["bz2", "boz"], "application/x-cbr": ["cbr", "cba", "cbt", "cbz", "cb7"], "application/x-cdlink": ["vcd"], "application/x-cfs-compressed": ["cfs"], "application/x-chat": ["chat"], "application/x-chess-pgn": ["pgn"], "application/x-chrome-extension": ["crx"], "application/x-cocoa": ["cco"], "application/x-conference": ["nsc"], "application/x-cpio": ["cpio"], "application/x-csh": ["csh"], "application/x-debian-package": ["*deb", "udeb"], "application/x-dgc-compressed": ["dgc"], "application/x-director": ["dir", "dcr", "dxr", "cst", "cct", "cxt", "w3d", "fgd", "swa"], "application/x-doom": ["wad"], "application/x-dtbncx+xml": ["ncx"], "application/x-dtbook+xml": ["dtb"], "application/x-dtbresource+xml": ["res"], "application/x-dvi": ["dvi"], "application/x-envoy": ["evy"], "application/x-eva": ["eva"], "application/x-font-bdf": ["bdf"], "application/x-font-ghostscript": ["gsf"], "application/x-font-linux-psf": ["psf"], "application/x-font-pcf": ["pcf"], "application/x-font-snf": ["snf"], "application/x-font-type1": ["pfa", "pfb", "pfm", "afm"], "application/x-freearc": ["arc"], "application/x-futuresplash": ["spl"], "application/x-gca-compressed": ["gca"], "application/x-glulx": ["ulx"], "application/x-gnumeric": ["gnumeric"], "application/x-gramps-xml": ["gramps"], "application/x-gtar": ["gtar"], "application/x-hdf": ["hdf"], "application/x-httpd-php": ["php"], "application/x-install-instructions": ["install"], "application/x-iso9660-image": ["*iso"], "application/x-iwork-keynote-sffkey": ["*key"], "application/x-iwork-numbers-sffnumbers": ["*numbers"], "application/x-iwork-pages-sffpages": ["*pages"], "application/x-java-archive-diff": ["jardiff"], "application/x-java-jnlp-file": ["jnlp"], "application/x-keepass2": ["kdbx"], "application/x-latex": ["latex"], "application/x-lua-bytecode": ["luac"], "application/x-lzh-compressed": ["lzh", "lha"], "application/x-makeself": ["run"], "application/x-mie": ["mie"], "application/x-mobipocket-ebook": ["prc", "mobi"], "application/x-ms-application": ["application"], "application/x-ms-shortcut": ["lnk"], "application/x-ms-wmd": ["wmd"], "application/x-ms-wmz": ["wmz"], "application/x-ms-xbap": ["xbap"], "application/x-msaccess": ["mdb"], "application/x-msbinder": ["obd"], "application/x-mscardfile": ["crd"], "application/x-msclip": ["clp"], "application/x-msdos-program": ["*exe"], "application/x-msdownload": ["*exe", "*dll", "com", "bat", "*msi"], "application/x-msmediaview": ["mvb", "m13", "m14"], "application/x-msmetafile": ["*wmf", "*wmz", "*emf", "emz"], "application/x-msmoney": ["mny"], "application/x-mspublisher": ["pub"], "application/x-msschedule": ["scd"], "application/x-msterminal": ["trm"], "application/x-mswrite": ["wri"], "application/x-netcdf": ["nc", "cdf"], "application/x-ns-proxy-autoconfig": ["pac"], "application/x-nzb": ["nzb"], "application/x-perl": ["pl", "pm"], "application/x-pilot": ["*prc", "*pdb"], "application/x-pkcs12": ["p12", "pfx"], "application/x-pkcs7-certificates": ["p7b", "spc"], "application/x-pkcs7-certreqresp": ["p7r"], "application/x-rar-compressed": ["*rar"], "application/x-redhat-package-manager": ["rpm"], "application/x-research-info-systems": ["ris"], "application/x-sea": ["sea"], "application/x-sh": ["sh"], "application/x-shar": ["shar"], "application/x-shockwave-flash": ["swf"], "application/x-silverlight-app": ["xap"], "application/x-sql": ["sql"], "application/x-stuffit": ["sit"], "application/x-stuffitx": ["sitx"], "application/x-subrip": ["srt"], "application/x-sv4cpio": ["sv4cpio"], "application/x-sv4crc": ["sv4crc"], "application/x-t3vm-image": ["t3"], "application/x-tads": ["gam"], "application/x-tar": ["tar"], "application/x-tcl": ["tcl", "tk"], "application/x-tex": ["tex"], "application/x-tex-tfm": ["tfm"], "application/x-texinfo": ["texinfo", "texi"], "application/x-tgif": ["*obj"], "application/x-ustar": ["ustar"], "application/x-virtualbox-hdd": ["hdd"], "application/x-virtualbox-ova": ["ova"], "application/x-virtualbox-ovf": ["ovf"], "application/x-virtualbox-vbox": ["vbox"], "application/x-virtualbox-vbox-extpack": ["vbox-extpack"], "application/x-virtualbox-vdi": ["vdi"], "application/x-virtualbox-vhd": ["vhd"], "application/x-virtualbox-vmdk": ["vmdk"], "application/x-wais-source": ["src"], "application/x-web-app-manifest+json": ["webapp"], "application/x-x509-ca-cert": ["der", "crt", "pem"], "application/x-xfig": ["fig"], "application/x-xliff+xml": ["*xlf"], "application/x-xpinstall": ["xpi"], "application/x-xz": ["xz"], "application/x-zmachine": ["z1", "z2", "z3", "z4", "z5", "z6", "z7", "z8"], "audio/vnd.dece.audio": ["uva", "uvva"], "audio/vnd.digital-winds": ["eol"], "audio/vnd.dra": ["dra"], "audio/vnd.dts": ["dts"], "audio/vnd.dts.hd": ["dtshd"], "audio/vnd.lucent.voice": ["lvp"], "audio/vnd.ms-playready.media.pya": ["pya"], "audio/vnd.nuera.ecelp4800": ["ecelp4800"], "audio/vnd.nuera.ecelp7470": ["ecelp7470"], "audio/vnd.nuera.ecelp9600": ["ecelp9600"], "audio/vnd.rip": ["rip"], "audio/x-aac": ["aac"], "audio/x-aiff": ["aif", "aiff", "aifc"], "audio/x-caf": ["caf"], "audio/x-flac": ["flac"], "audio/x-m4a": ["*m4a"], "audio/x-matroska": ["mka"], "audio/x-mpegurl": ["m3u"], "audio/x-ms-wax": ["wax"], "audio/x-ms-wma": ["wma"], "audio/x-pn-realaudio": ["ram", "ra"], "audio/x-pn-realaudio-plugin": ["rmp"], "audio/x-realaudio": ["*ra"], "audio/x-wav": ["*wav"], "chemical/x-cdx": ["cdx"], "chemical/x-cif": ["cif"], "chemical/x-cmdf": ["cmdf"], "chemical/x-cml": ["cml"], "chemical/x-csml": ["csml"], "chemical/x-xyz": ["xyz"], "image/prs.btif": ["btif"], "image/prs.pti": ["pti"], "image/vnd.adobe.photoshop": ["psd"], "image/vnd.airzip.accelerator.azv": ["azv"], "image/vnd.dece.graphic": ["uvi", "uvvi", "uvg", "uvvg"], "image/vnd.djvu": ["djvu", "djv"], "image/vnd.dvb.subtitle": ["*sub"], "image/vnd.dwg": ["dwg"], "image/vnd.dxf": ["dxf"], "image/vnd.fastbidsheet": ["fbs"], "image/vnd.fpx": ["fpx"], "image/vnd.fst": ["fst"], "image/vnd.fujixerox.edmics-mmr": ["mmr"], "image/vnd.fujixerox.edmics-rlc": ["rlc"], "image/vnd.microsoft.icon": ["ico"], "image/vnd.ms-dds": ["dds"], "image/vnd.ms-modi": ["mdi"], "image/vnd.ms-photo": ["wdp"], "image/vnd.net-fpx": ["npx"], "image/vnd.pco.b16": ["b16"], "image/vnd.tencent.tap": ["tap"], "image/vnd.valve.source.texture": ["vtf"], "image/vnd.wap.wbmp": ["wbmp"], "image/vnd.xiff": ["xif"], "image/vnd.zbrush.pcx": ["pcx"], "image/x-3ds": ["3ds"], "image/x-cmu-raster": ["ras"], "image/x-cmx": ["cmx"], "image/x-freehand": ["fh", "fhc", "fh4", "fh5", "fh7"], "image/x-icon": ["*ico"], "image/x-jng": ["jng"], "image/x-mrsid-image": ["sid"], "image/x-ms-bmp": ["*bmp"], "image/x-pcx": ["*pcx"], "image/x-pict": ["pic", "pct"], "image/x-portable-anymap": ["pnm"], "image/x-portable-bitmap": ["pbm"], "image/x-portable-graymap": ["pgm"], "image/x-portable-pixmap": ["ppm"], "image/x-rgb": ["rgb"], "image/x-tga": ["tga"], "image/x-xbitmap": ["xbm"], "image/x-xpixmap": ["xpm"], "image/x-xwindowdump": ["xwd"], "message/vnd.wfa.wsc": ["wsc"], "model/vnd.collada+xml": ["dae"], "model/vnd.dwf": ["dwf"], "model/vnd.gdl": ["gdl"], "model/vnd.gtw": ["gtw"], "model/vnd.mts": ["mts"], "model/vnd.opengex": ["ogex"], "model/vnd.parasolid.transmit.binary": ["x_b"], "model/vnd.parasolid.transmit.text": ["x_t"], "model/vnd.sap.vds": ["vds"], "model/vnd.usdz+zip": ["usdz"], "model/vnd.valve.source.compiled-map": ["bsp"], "model/vnd.vtu": ["vtu"], "text/prs.lines.tag": ["dsc"], "text/vnd.curl": ["curl"], "text/vnd.curl.dcurl": ["dcurl"], "text/vnd.curl.mcurl": ["mcurl"], "text/vnd.curl.scurl": ["scurl"], "text/vnd.dvb.subtitle": ["sub"], "text/vnd.fly": ["fly"], "text/vnd.fmi.flexstor": ["flx"], "text/vnd.graphviz": ["gv"], "text/vnd.in3d.3dml": ["3dml"], "text/vnd.in3d.spot": ["spot"], "text/vnd.sun.j2me.app-descriptor": ["jad"], "text/vnd.wap.wml": ["wml"], "text/vnd.wap.wmlscript": ["wmls"], "text/x-asm": ["s", "asm"], "text/x-c": ["c", "cc", "cxx", "cpp", "h", "hh", "dic"], "text/x-component": ["htc"], "text/x-fortran": ["f", "for", "f77", "f90"], "text/x-handlebars-template": ["hbs"], "text/x-java-source": ["java"], "text/x-lua": ["lua"], "text/x-markdown": ["mkd"], "text/x-nfo": ["nfo"], "text/x-opml": ["opml"], "text/x-org": ["*org"], "text/x-pascal": ["p", "pas"], "text/x-processing": ["pde"], "text/x-sass": ["sass"], "text/x-scss": ["scss"], "text/x-setext": ["etx"], "text/x-sfv": ["sfv"], "text/x-suse-ymp": ["ymp"], "text/x-uuencode": ["uu"], "text/x-vcalendar": ["vcs"], "text/x-vcard": ["vcf"], "video/vnd.dece.hd": ["uvh", "uvvh"], "video/vnd.dece.mobile": ["uvm", "uvvm"], "video/vnd.dece.pd": ["uvp", "uvvp"], "video/vnd.dece.sd": ["uvs", "uvvs"], "video/vnd.dece.video": ["uvv", "uvvv"], "video/vnd.dvb.file": ["dvb"], "video/vnd.fvt": ["fvt"], "video/vnd.mpegurl": ["mxu", "m4u"], "video/vnd.ms-playready.media.pyv": ["pyv"], "video/vnd.uvvu.mp4": ["uvu", "uvvu"], "video/vnd.vivo": ["viv"], "video/x-f4v": ["f4v"], "video/x-fli": ["fli"], "video/x-flv": ["flv"], "video/x-m4v": ["m4v"], "video/x-matroska": ["mkv", "mk3d", "mks"], "video/x-mng": ["mng"], "video/x-ms-asf": ["asf", "asx"], "video/x-ms-vob": ["vob"], "video/x-ms-wm": ["wm"], "video/x-ms-wmv": ["wmv"], "video/x-ms-wmx": ["wmx"], "video/x-ms-wvx": ["wvx"], "video/x-msvideo": ["avi"], "video/x-sgi-movie": ["movie"], "video/x-smv": ["smv"], "x-conference/x-cooltalk": ["ice"] };
+ }
+});
+
+// ../../node_modules/.pnpm/mime@3.0.0/node_modules/mime/index.js
+var require_mime2 = __commonJS({
+ "../../node_modules/.pnpm/mime@3.0.0/node_modules/mime/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var Mime = require_Mime();
+ module2.exports = new Mime(require_standard(), require_other());
+ }
+});
+
+// src/pages/hash.ts
+var import_node_fs7, import_node_path18, import_blake3_wasm, hashFile;
+var init_hash = __esm({
+ "src/pages/hash.ts"() {
+ init_import_meta_url();
+ import_node_fs7 = require("node:fs");
+ import_node_path18 = require("node:path");
+ import_blake3_wasm = require("blake3-wasm");
+ hashFile = /* @__PURE__ */ __name((filepath) => {
+ const contents = (0, import_node_fs7.readFileSync)(filepath);
+ const base64Contents = contents.toString("base64");
+ const extension = (0, import_node_path18.extname)(filepath).substring(1);
+ return (0, import_blake3_wasm.hash)(base64Contents + extension).toString("hex").slice(0, 32);
+ }, "hashFile");
+ }
+});
+
+// ../pages-shared/environment-polyfills/index.ts
+var polyfill;
+var init_environment_polyfills = __esm({
+ "../pages-shared/environment-polyfills/index.ts"() {
+ init_import_meta_url();
+ polyfill = /* @__PURE__ */ __name((environment) => {
+ Object.entries(environment).map(([name, value]) => {
+ Object.defineProperty(globalThis, name, {
+ value,
+ configurable: true,
+ enumerable: true,
+ writable: true
+ });
+ });
+ }, "polyfill");
+ }
+});
+
+// ../pages-shared/environment-polyfills/miniflare.ts
+var miniflare_exports = {};
+__export(miniflare_exports, {
+ default: () => miniflare_default
+});
+var miniflare_default;
+var init_miniflare = __esm({
+ "../pages-shared/environment-polyfills/miniflare.ts"() {
+ init_import_meta_url();
+ init_environment_polyfills();
+ miniflare_default = /* @__PURE__ */ __name(async () => {
+ const mf = await import("miniflare");
+ polyfill({
+ fetch: mf.fetch,
+ Headers: mf.Headers,
+ Request: mf.Request,
+ Response: mf.Response
+ });
+ }, "default");
+ }
+});
+
+// ../pages-shared/asset-server/responses.ts
+function mergeHeaders(base, extra) {
+ const baseHeaders = new Headers(base ?? {});
+ const extraHeaders = new Headers(extra ?? {});
+ return new Headers({
+ ...Object.fromEntries(baseHeaders.entries()),
+ ...Object.fromEntries(extraHeaders.entries())
+ });
+}
+function stripLeadingDoubleSlashes(location) {
+ return location.replace(/^(\/|%2F|%2f|%5C|%5c|%09|\s|\\)+(.*)/, "/$2");
+}
+var OkResponse, MovedPermanentlyResponse, FoundResponse, NotModifiedResponse, PermanentRedirectResponse, NotFoundResponse, MethodNotAllowedResponse, NotAcceptableResponse, InternalServerErrorResponse, SeeOtherResponse, TemporaryRedirectResponse;
+var init_responses = __esm({
+ "../pages-shared/asset-server/responses.ts"() {
+ init_import_meta_url();
+ __name(mergeHeaders, "mergeHeaders");
+ __name(stripLeadingDoubleSlashes, "stripLeadingDoubleSlashes");
+ OkResponse = class extends Response {
+ constructor(...[body, init]) {
+ super(body, {
+ ...init,
+ status: 200,
+ statusText: "OK"
+ });
+ }
+ };
+ __name(OkResponse, "OkResponse");
+ MovedPermanentlyResponse = class extends Response {
+ constructor(location, init, {
+ preventLeadingDoubleSlash = true
+ } = {
+ preventLeadingDoubleSlash: true
+ }) {
+ location = preventLeadingDoubleSlash ? stripLeadingDoubleSlashes(location) : location;
+ super(`Redirecting to ${location}`, {
+ ...init,
+ status: 301,
+ statusText: "Moved Permanently",
+ headers: mergeHeaders(init?.headers, {
+ location
+ })
+ });
+ }
+ };
+ __name(MovedPermanentlyResponse, "MovedPermanentlyResponse");
+ FoundResponse = class extends Response {
+ constructor(location, init, {
+ preventLeadingDoubleSlash = true
+ } = {
+ preventLeadingDoubleSlash: true
+ }) {
+ location = preventLeadingDoubleSlash ? stripLeadingDoubleSlashes(location) : location;
+ super(`Redirecting to ${location}`, {
+ ...init,
+ status: 302,
+ statusText: "Found",
+ headers: mergeHeaders(init?.headers, {
+ location
+ })
+ });
+ }
+ };
+ __name(FoundResponse, "FoundResponse");
+ NotModifiedResponse = class extends Response {
+ constructor(...[_body, _init]) {
+ super(void 0, {
+ status: 304,
+ statusText: "Not Modified"
+ });
+ }
+ };
+ __name(NotModifiedResponse, "NotModifiedResponse");
+ PermanentRedirectResponse = class extends Response {
+ constructor(location, init, {
+ preventLeadingDoubleSlash = true
+ } = {
+ preventLeadingDoubleSlash: true
+ }) {
+ location = preventLeadingDoubleSlash ? stripLeadingDoubleSlashes(location) : location;
+ super(void 0, {
+ ...init,
+ status: 308,
+ statusText: "Permanent Redirect",
+ headers: mergeHeaders(init?.headers, {
+ location
+ })
+ });
+ }
+ };
+ __name(PermanentRedirectResponse, "PermanentRedirectResponse");
+ NotFoundResponse = class extends Response {
+ constructor(...[body, init]) {
+ super(body, {
+ ...init,
+ status: 404,
+ statusText: "Not Found"
+ });
+ }
+ };
+ __name(NotFoundResponse, "NotFoundResponse");
+ MethodNotAllowedResponse = class extends Response {
+ constructor(...[body, init]) {
+ super(body, {
+ ...init,
+ status: 405,
+ statusText: "Method Not Allowed"
+ });
+ }
+ };
+ __name(MethodNotAllowedResponse, "MethodNotAllowedResponse");
+ NotAcceptableResponse = class extends Response {
+ constructor(...[body, init]) {
+ super(body, {
+ ...init,
+ status: 406,
+ statusText: "Not Acceptable"
+ });
+ }
+ };
+ __name(NotAcceptableResponse, "NotAcceptableResponse");
+ InternalServerErrorResponse = class extends Response {
+ constructor(err, init) {
+ let body = void 0;
+ if (globalThis.DEBUG) {
+ body = `${err.message}
+
+${err.stack}`;
+ }
+ super(body, {
+ ...init,
+ status: 500,
+ statusText: "Internal Server Error"
+ });
+ }
+ };
+ __name(InternalServerErrorResponse, "InternalServerErrorResponse");
+ SeeOtherResponse = class extends Response {
+ constructor(location, init, {
+ preventLeadingDoubleSlash = true
+ } = {
+ preventLeadingDoubleSlash: true
+ }) {
+ location = preventLeadingDoubleSlash ? stripLeadingDoubleSlashes(location) : location;
+ super(`Redirecting to ${location}`, {
+ ...init,
+ status: 303,
+ statusText: "See Other",
+ headers: mergeHeaders(init?.headers, { location })
+ });
+ }
+ };
+ __name(SeeOtherResponse, "SeeOtherResponse");
+ TemporaryRedirectResponse = class extends Response {
+ constructor(location, init, {
+ preventLeadingDoubleSlash = true
+ } = {
+ preventLeadingDoubleSlash: true
+ }) {
+ location = preventLeadingDoubleSlash ? stripLeadingDoubleSlashes(location) : location;
+ super(`Redirecting to ${location}`, {
+ ...init,
+ status: 307,
+ statusText: "Temporary Redirect",
+ headers: mergeHeaders(init?.headers, { location })
+ });
+ }
+ };
+ __name(TemporaryRedirectResponse, "TemporaryRedirectResponse");
+ }
+});
+
+// ../pages-shared/asset-server/rulesEngine.ts
+var ESCAPE_REGEX_CHARACTERS, escapeRegex, HOST_PLACEHOLDER_REGEX, PLACEHOLDER_REGEX2, replacer, generateRulesMatcher;
+var init_rulesEngine = __esm({
+ "../pages-shared/asset-server/rulesEngine.ts"() {
+ init_import_meta_url();
+ ESCAPE_REGEX_CHARACTERS = /[-/\\^$*+?.()|[\]{}]/g;
+ escapeRegex = /* @__PURE__ */ __name((str) => {
+ return str.replace(ESCAPE_REGEX_CHARACTERS, "\\$&");
+ }, "escapeRegex");
+ HOST_PLACEHOLDER_REGEX = /(?<=^https:\\\/\\\/[^/]*?):([A-Za-z]\w*)(?=\\)/g;
+ PLACEHOLDER_REGEX2 = /:([A-Za-z]\w*)/g;
+ replacer = /* @__PURE__ */ __name((str, replacements) => {
+ for (const [replacement, value] of Object.entries(replacements)) {
+ str = str.replaceAll(`:${replacement}`, value);
+ }
+ return str;
+ }, "replacer");
+ generateRulesMatcher = /* @__PURE__ */ __name((rules, replacerFn = (match) => match) => {
+ if (!rules)
+ return () => [];
+ const compiledRules = Object.entries(rules).map(([rule, match]) => {
+ const crossHost = rule.startsWith("https://");
+ rule = rule.split("*").map(escapeRegex).join("(?.*)");
+ const host_matches = rule.matchAll(HOST_PLACEHOLDER_REGEX);
+ for (const host_match of host_matches) {
+ rule = rule.split(host_match[0]).join(`(?<${host_match[1]}>[^/.]+)`);
+ }
+ const path_matches = rule.matchAll(PLACEHOLDER_REGEX2);
+ for (const path_match of path_matches) {
+ rule = rule.split(path_match[0]).join(`(?<${path_match[1]}>[^/]+)`);
+ }
+ rule = "^" + rule + "$";
+ try {
+ const regExp = new RegExp(rule);
+ return [{ crossHost, regExp }, match];
+ } catch {
+ }
+ }).filter((value) => value !== void 0);
+ return ({ request }) => {
+ const { pathname, hostname } = new URL(request.url);
+ return compiledRules.map(([{ crossHost, regExp }, match]) => {
+ const test = crossHost ? `https://${hostname}${pathname}` : pathname;
+ const result = regExp.exec(test);
+ if (result) {
+ return replacerFn(match, result.groups || {});
+ }
+ }).filter((value) => value !== void 0);
+ };
+ }, "generateRulesMatcher");
+ }
+});
+
+// ../pages-shared/asset-server/handler.ts
+var handler_exports = {};
+__export(handler_exports, {
+ ANALYTICS_VERSION: () => ANALYTICS_VERSION2,
+ ASSET_PRESERVATION_CACHE: () => ASSET_PRESERVATION_CACHE,
+ CACHE_CONTROL_BROWSER: () => CACHE_CONTROL_BROWSER,
+ HEADERS_VERSION: () => HEADERS_VERSION2,
+ HEADERS_VERSION_V1: () => HEADERS_VERSION_V1,
+ REDIRECTS_VERSION: () => REDIRECTS_VERSION2,
+ generateHandler: () => generateHandler,
+ normaliseHeaders: () => normaliseHeaders,
+ parseQualityWeightedList: () => parseQualityWeightedList
+});
+function normaliseHeaders(headers) {
+ if (headers.version === HEADERS_VERSION2) {
+ return headers.rules;
+ } else if (headers.version === HEADERS_VERSION_V1) {
+ return Object.keys(headers.rules).reduce(
+ (acc, key) => {
+ acc[key] = {
+ set: headers.rules[key]
+ };
+ return acc;
+ },
+ {}
+ );
+ } else {
+ return {};
+ }
+}
+async function generateHandler({
+ request,
+ metadata,
+ xServerEnvHeader,
+ xDeploymentIdHeader,
+ logError,
+ findAssetEntryForPath,
+ getAssetKey,
+ negotiateContent,
+ fetchAsset,
+ generateNotFoundResponse = /* @__PURE__ */ __name(async (notFoundRequest, notFoundFindAssetEntryForPath, notFoundServeAsset) => {
+ let assetEntry;
+ if (assetEntry = await notFoundFindAssetEntryForPath("/index.html")) {
+ return notFoundServeAsset(assetEntry, { preserve: false });
+ }
+ return new NotFoundResponse();
+ }, "generateNotFoundResponse"),
+ attachAdditionalHeaders = /* @__PURE__ */ __name(() => {
+ }, "attachAdditionalHeaders"),
+ caches,
+ waitUntil
+}) {
+ const url3 = new URL(request.url);
+ const { protocol, host, search } = url3;
+ let { pathname } = url3;
+ const earlyHintsCache = metadata.deploymentId ? await caches?.open(`eh:${metadata.deploymentId}`) : void 0;
+ const headerRules = metadata.headers ? normaliseHeaders(metadata.headers) : {};
+ const staticRules = metadata.redirects?.version === REDIRECTS_VERSION2 ? metadata.redirects.staticRules || {} : {};
+ const staticRedirectsMatcher = /* @__PURE__ */ __name(() => {
+ const withHostMatch = staticRules[`https://${host}${pathname}`];
+ const withoutHostMatch = staticRules[pathname];
+ if (withHostMatch && withoutHostMatch) {
+ if (withHostMatch.lineNumber < withoutHostMatch.lineNumber) {
+ return withHostMatch;
+ } else {
+ return withoutHostMatch;
+ }
+ }
+ return withHostMatch || withoutHostMatch;
+ }, "staticRedirectsMatcher");
+ const generateRedirectsMatcher = /* @__PURE__ */ __name(() => generateRulesMatcher(
+ metadata.redirects?.version === REDIRECTS_VERSION2 ? metadata.redirects.rules : {},
+ ({ status, to }, replacements) => ({
+ status,
+ to: replacer(to, replacements)
+ })
+ ), "generateRedirectsMatcher");
+ let assetEntry;
+ async function generateResponse() {
+ const match = staticRedirectsMatcher() || generateRedirectsMatcher()({ request })[0];
+ if (match) {
+ if (match.status === 200) {
+ pathname = new URL(match.to, request.url).pathname;
+ } else {
+ const { status, to } = match;
+ const destination = new URL(to, request.url);
+ const location = destination.origin === new URL(request.url).origin ? `${destination.pathname}${destination.search || search}${destination.hash}` : `${destination.href}${destination.search ? "" : search}${destination.hash}`;
+ switch (status) {
+ case 301:
+ return new MovedPermanentlyResponse(location, void 0, {
+ preventLeadingDoubleSlash: false
+ });
+ case 303:
+ return new SeeOtherResponse(location, void 0, {
+ preventLeadingDoubleSlash: false
+ });
+ case 307:
+ return new TemporaryRedirectResponse(location, void 0, {
+ preventLeadingDoubleSlash: false
+ });
+ case 308:
+ return new PermanentRedirectResponse(location, void 0, {
+ preventLeadingDoubleSlash: false
+ });
+ case 302:
+ default:
+ return new FoundResponse(location, void 0, {
+ preventLeadingDoubleSlash: false
+ });
+ }
+ }
+ }
+ if (!request.method.match(/^(get|head)$/i)) {
+ return new MethodNotAllowedResponse();
+ }
+ try {
+ pathname = globalThis.decodeURIComponent(pathname);
+ } catch (err) {
+ }
+ if (pathname.endsWith("/")) {
+ if (assetEntry = await findAssetEntryForPath(`${pathname}index.html`)) {
+ return serveAsset(assetEntry);
+ } else if (pathname.endsWith("/index/")) {
+ return new PermanentRedirectResponse(
+ `/${pathname.slice(1, -"index/".length)}${search}`
+ );
+ } else if (assetEntry = await findAssetEntryForPath(
+ `${pathname.replace(/\/$/, ".html")}`
+ )) {
+ return new PermanentRedirectResponse(
+ `/${pathname.slice(1, -1)}${search}`
+ );
+ } else {
+ return notFound();
+ }
+ }
+ if (assetEntry = await findAssetEntryForPath(pathname)) {
+ if (pathname.endsWith(".html")) {
+ const extensionlessPath = pathname.slice(0, -".html".length);
+ if (extensionlessPath.endsWith("/index")) {
+ return new PermanentRedirectResponse(
+ `${extensionlessPath.replace(/\/index$/, "/")}${search}`
+ );
+ } else if (await findAssetEntryForPath(extensionlessPath) || extensionlessPath === "/") {
+ return serveAsset(assetEntry);
+ } else {
+ return new PermanentRedirectResponse(`${extensionlessPath}${search}`);
+ }
+ } else {
+ return serveAsset(assetEntry);
+ }
+ } else if (pathname.endsWith("/index")) {
+ return new PermanentRedirectResponse(
+ `/${pathname.slice(1, -"index".length)}${search}`
+ );
+ } else if (assetEntry = await findAssetEntryForPath(`${pathname}.html`)) {
+ return serveAsset(assetEntry);
+ } else if (hasFileExtension(pathname)) {
+ return notFound();
+ }
+ if (assetEntry = await findAssetEntryForPath(`${pathname}/index.html`)) {
+ return new PermanentRedirectResponse(`${pathname}/${search}`);
+ } else {
+ return notFound();
+ }
+ }
+ __name(generateResponse, "generateResponse");
+ async function attachHeaders(response) {
+ const existingHeaders = new Headers(response.headers);
+ const extraHeaders = new Headers({
+ "access-control-allow-origin": "*",
+ "referrer-policy": "strict-origin-when-cross-origin",
+ ...existingHeaders.has("content-type") ? { "x-content-type-options": "nosniff" } : {}
+ });
+ const headers = new Headers({
+ // But we intentionally override existing headers
+ ...Object.fromEntries(existingHeaders.entries()),
+ ...Object.fromEntries(extraHeaders.entries())
+ });
+ if (earlyHintsCache) {
+ const preEarlyHintsHeaders = new Headers(headers);
+ const earlyHintsCacheKey = `${protocol}//${host}${pathname}`;
+ const earlyHintsResponse = await earlyHintsCache.match(
+ earlyHintsCacheKey
+ );
+ if (earlyHintsResponse) {
+ const earlyHintsLinkHeader = earlyHintsResponse.headers.get("Link");
+ if (earlyHintsLinkHeader) {
+ headers.set("Link", earlyHintsLinkHeader);
+ }
+ }
+ const clonedResponse = response.clone();
+ if (waitUntil) {
+ waitUntil(
+ (async () => {
+ try {
+ const links = [];
+ const transformedResponse = new HTMLRewriter().on("link[rel~=preconnect],link[rel~=preload]", {
+ element(element) {
+ for (const [attributeName] of element.attributes) {
+ if (!ALLOWED_EARLY_HINT_LINK_ATTRIBUTES.includes(
+ attributeName.toLowerCase()
+ )) {
+ return;
+ }
+ }
+ const href = element.getAttribute("href") || void 0;
+ const rel = element.getAttribute("rel") || void 0;
+ const as = element.getAttribute("as") || void 0;
+ if (href && !href.startsWith("data:") && rel) {
+ links.push({ href, rel, as });
+ }
+ }
+ }).transform(clonedResponse);
+ await transformedResponse.text();
+ links.forEach(({ href, rel, as }) => {
+ let link = `<${href}>; rel="${rel}"`;
+ if (as) {
+ link += `; as=${as}`;
+ }
+ preEarlyHintsHeaders.append("Link", link);
+ });
+ const linkHeader = preEarlyHintsHeaders.get("Link");
+ if (linkHeader) {
+ await earlyHintsCache.put(
+ earlyHintsCacheKey,
+ new Response(null, { headers: { Link: linkHeader } })
+ );
+ }
+ } catch (err) {
+ }
+ })()
+ );
+ }
+ }
+ const headersMatcher = generateRulesMatcher(
+ headerRules,
+ ({ set = {}, unset = [] }, replacements) => {
+ const replacedSet = {};
+ Object.keys(set).forEach((key) => {
+ replacedSet[key] = replacer(set[key], replacements);
+ });
+ return {
+ set: replacedSet,
+ unset
+ };
+ }
+ );
+ const matches = headersMatcher({ request });
+ const setMap = /* @__PURE__ */ new Set();
+ matches.forEach(({ set = {}, unset = [] }) => {
+ unset.forEach((key) => {
+ headers.delete(key);
+ });
+ Object.keys(set).forEach((key) => {
+ if (setMap.has(key.toLowerCase())) {
+ headers.append(key, set[key]);
+ } else {
+ headers.set(key, set[key]);
+ setMap.add(key.toLowerCase());
+ }
+ });
+ });
+ return new Response(
+ [101, 204, 205, 304].includes(response.status) ? null : response.body,
+ {
+ headers,
+ status: response.status,
+ statusText: response.statusText
+ }
+ );
+ }
+ __name(attachHeaders, "attachHeaders");
+ return await attachHeaders(await generateResponse());
+ async function serveAsset(servingAssetEntry, options14 = { preserve: true }) {
+ let content;
+ try {
+ content = negotiateContent(request, servingAssetEntry);
+ } catch (err) {
+ return new NotAcceptableResponse();
+ }
+ const assetKey = getAssetKey(servingAssetEntry, content);
+ const etag = `"${assetKey}"`;
+ const weakEtag = `W/${etag}`;
+ const ifNoneMatch = request.headers.get("if-none-match");
+ if (ifNoneMatch === weakEtag || ifNoneMatch === etag) {
+ return new NotModifiedResponse();
+ }
+ try {
+ const asset = await fetchAsset(assetKey);
+ const headers = {
+ etag,
+ "content-type": asset.contentType
+ };
+ let encodeBody = "automatic";
+ if (xServerEnvHeader) {
+ headers["x-server-env"] = xServerEnvHeader;
+ }
+ if (xDeploymentIdHeader && metadata.deploymentId) {
+ headers["x-deployment-id"] = metadata.deploymentId;
+ }
+ if (content.encoding) {
+ encodeBody = "manual";
+ headers["cache-control"] = "no-transform";
+ headers["content-encoding"] = content.encoding;
+ }
+ const response = new OkResponse(
+ request.method === "HEAD" ? null : asset.body,
+ {
+ headers,
+ encodeBody
+ }
+ );
+ if (isCacheable(request)) {
+ response.headers.append("cache-control", CACHE_CONTROL_BROWSER);
+ }
+ attachAdditionalHeaders(response, content, servingAssetEntry, asset);
+ if (isPreview(new URL(request.url))) {
+ response.headers.set("x-robots-tag", "noindex");
+ }
+ if (options14.preserve) {
+ const preservedResponse = new Response(
+ [101, 204, 205, 304].includes(response.status) ? null : response.clone().body,
+ response
+ );
+ preservedResponse.headers.set(
+ "cache-control",
+ CACHE_CONTROL_PRESERVATION
+ );
+ preservedResponse.headers.set("x-robots-tag", "noindex");
+ if (waitUntil && caches) {
+ waitUntil(
+ caches.open(ASSET_PRESERVATION_CACHE).then(
+ (assetPreservationCache) => assetPreservationCache.put(request.url, preservedResponse)
+ ).catch((err) => {
+ logError(err);
+ })
+ );
+ }
+ }
+ if (asset.contentType.startsWith("text/html") && metadata.analytics?.version === ANALYTICS_VERSION2) {
+ return new HTMLRewriter().on("body", {
+ element(e2) {
+ e2.append(
+ ``,
+ { html: true }
+ );
+ }
+ }).transform(response);
+ }
+ return response;
+ } catch (err) {
+ logError(err);
+ return new InternalServerErrorResponse(err);
+ }
+ }
+ __name(serveAsset, "serveAsset");
+ async function notFound() {
+ if (caches) {
+ const assetPreservationCache = await caches.open(
+ ASSET_PRESERVATION_CACHE
+ );
+ const preservedResponse = await assetPreservationCache.match(request.url);
+ if (preservedResponse) {
+ return preservedResponse;
+ }
+ }
+ let cwd2 = pathname;
+ while (cwd2) {
+ cwd2 = cwd2.slice(0, cwd2.lastIndexOf("/"));
+ if (assetEntry = await findAssetEntryForPath(`${cwd2}/404.html`)) {
+ let content;
+ try {
+ content = negotiateContent(request, assetEntry);
+ } catch (err) {
+ return new NotAcceptableResponse();
+ }
+ const assetKey = getAssetKey(assetEntry, content);
+ try {
+ const { body, contentType } = await fetchAsset(assetKey);
+ const response = new NotFoundResponse(body);
+ response.headers.set("content-type", contentType);
+ return response;
+ } catch (err) {
+ logError(err);
+ return new InternalServerErrorResponse(err);
+ }
+ }
+ }
+ return await generateNotFoundResponse(
+ request,
+ findAssetEntryForPath,
+ serveAsset
+ );
+ }
+ __name(notFound, "notFound");
+}
+function parseQualityWeightedList(list = "") {
+ const items = {};
+ list.replace(/\s/g, "").split(",").forEach((el) => {
+ const [item, weight] = el.split(";q=");
+ items[item] = weight ? parseFloat(weight) : 1;
+ });
+ return items;
+}
+function isCacheable(request) {
+ return !request.headers.has("authorization") && !request.headers.has("range");
+}
+function hasFileExtension(path45) {
+ return /\/.+\.[a-z0-9]+$/i.test(path45);
+}
+function isPreview(url3) {
+ if (url3.hostname.endsWith(".pages.dev")) {
+ return url3.hostname.split(".").length > 3 ? true : false;
+ }
+ return false;
+}
+var ASSET_PRESERVATION_CACHE, CACHE_CONTROL_PRESERVATION, CACHE_CONTROL_BROWSER, REDIRECTS_VERSION2, HEADERS_VERSION2, HEADERS_VERSION_V1, ANALYTICS_VERSION2, ALLOWED_EARLY_HINT_LINK_ATTRIBUTES;
+var init_handler = __esm({
+ "../pages-shared/asset-server/handler.ts"() {
+ init_import_meta_url();
+ init_responses();
+ init_rulesEngine();
+ ASSET_PRESERVATION_CACHE = "assetPreservationCache";
+ CACHE_CONTROL_PRESERVATION = "public, s-maxage=604800";
+ CACHE_CONTROL_BROWSER = "public, max-age=0, must-revalidate";
+ REDIRECTS_VERSION2 = 1;
+ HEADERS_VERSION2 = 2;
+ HEADERS_VERSION_V1 = 1;
+ ANALYTICS_VERSION2 = 1;
+ ALLOWED_EARLY_HINT_LINK_ATTRIBUTES = ["rel", "as", "href"];
+ __name(normaliseHeaders, "normaliseHeaders");
+ __name(generateHandler, "generateHandler");
+ __name(parseQualityWeightedList, "parseQualityWeightedList");
+ __name(isCacheable, "isCacheable");
+ __name(hasFileExtension, "hasFileExtension");
+ __name(isPreview, "isPreview");
+ }
+});
+
+// src/miniflare-cli/assets.ts
+var assets_exports = {};
+__export(assets_exports, {
+ default: () => generateASSETSBinding
+});
+async function generateASSETSBinding(options14) {
+ const assetsFetch = options14.directory !== void 0 ? await generateAssetsFetch(options14.directory, options14.log) : invalidAssetsFetch;
+ return async function(miniflareRequest) {
+ if (options14.proxyPort) {
+ try {
+ const url3 = new URL(miniflareRequest.url);
+ url3.host = `localhost:${options14.proxyPort}`;
+ const proxyRequest = new import_miniflare2.Request(url3, miniflareRequest);
+ if (proxyRequest.headers.get("Upgrade") === "websocket") {
+ proxyRequest.headers.delete("Sec-WebSocket-Accept");
+ proxyRequest.headers.delete("Sec-WebSocket-Key");
+ }
+ return await (0, import_miniflare2.fetch)(proxyRequest);
+ } catch (thrown) {
+ options14.log.error(new Error(`Could not proxy request: ${thrown}`));
+ return new import_miniflare2.Response(`[wrangler] Could not proxy request: ${thrown}`, {
+ status: 502
+ });
+ }
+ } else {
+ try {
+ return await assetsFetch(miniflareRequest);
+ } catch (thrown) {
+ options14.log.error(new Error(`Could not serve static asset: ${thrown}`));
+ return new import_miniflare2.Response(
+ `[wrangler] Could not serve static asset: ${thrown}`,
+ { status: 502 }
+ );
+ }
+ }
+ };
+}
+async function generateAssetsFetch(directory, log) {
+ directory = (0, import_node_path19.resolve)(directory);
+ const polyfill2 = (await Promise.resolve().then(() => (init_miniflare(), miniflare_exports))).default;
+ await polyfill2();
+ const { generateHandler: generateHandler3, parseQualityWeightedList: parseQualityWeightedList2 } = await Promise.resolve().then(() => (init_handler(), handler_exports));
+ const headersFile = (0, import_node_path19.join)(directory, "_headers");
+ const redirectsFile = (0, import_node_path19.join)(directory, "_redirects");
+ const workerFile = (0, import_node_path19.join)(directory, "_worker.js");
+ const ignoredFiles = [headersFile, redirectsFile, workerFile];
+ let redirects;
+ if ((0, import_node_fs8.existsSync)(redirectsFile)) {
+ const contents = (0, import_node_fs8.readFileSync)(redirectsFile, "utf-8");
+ redirects = parseRedirects(contents);
+ }
+ let headers;
+ if ((0, import_node_fs8.existsSync)(headersFile)) {
+ const contents = (0, import_node_fs8.readFileSync)(headersFile, "utf-8");
+ headers = parseHeaders(contents);
+ }
+ let metadata = createMetadataObject({
+ redirects,
+ headers,
+ logger: log.warn.bind(log)
+ });
+ (0, import_chokidar.watch)([headersFile, redirectsFile], { persistent: true }).on(
+ "change",
+ (path45) => {
+ switch (path45) {
+ case headersFile: {
+ log.log("_headers modified. Re-evaluating...");
+ const contents = (0, import_node_fs8.readFileSync)(headersFile).toString();
+ headers = parseHeaders(contents);
+ break;
+ }
+ case redirectsFile: {
+ log.log("_redirects modified. Re-evaluating...");
+ const contents = (0, import_node_fs8.readFileSync)(redirectsFile).toString();
+ redirects = parseRedirects(contents);
+ break;
+ }
+ }
+ metadata = createMetadataObject({
+ redirects,
+ headers,
+ logger: log.warn
+ });
+ }
+ );
+ const generateResponse = /* @__PURE__ */ __name(async (request) => {
+ const assetKeyEntryMap = /* @__PURE__ */ new Map();
+ return await generateHandler3({
+ request,
+ metadata,
+ xServerEnvHeader: "dev",
+ logError: console.error,
+ findAssetEntryForPath: async (path45) => {
+ const filepath = (0, import_node_path19.resolve)((0, import_node_path19.join)(directory, path45));
+ if (!filepath.startsWith(directory)) {
+ return null;
+ }
+ if ((0, import_node_fs8.existsSync)(filepath) && (0, import_node_fs8.lstatSync)(filepath).isFile() && !ignoredFiles.includes(filepath)) {
+ const hash = hashFile(filepath);
+ assetKeyEntryMap.set(hash, filepath);
+ return hash;
+ }
+ return null;
+ },
+ getAssetKey: (assetEntry) => {
+ return assetEntry;
+ },
+ negotiateContent: (contentRequest) => {
+ let rawAcceptEncoding;
+ if (contentRequest.cf && "clientAcceptEncoding" in contentRequest.cf && contentRequest.cf.clientAcceptEncoding) {
+ rawAcceptEncoding = contentRequest.cf.clientAcceptEncoding;
+ } else {
+ rawAcceptEncoding = contentRequest.headers.get("Accept-Encoding") || void 0;
+ }
+ const acceptEncoding = parseQualityWeightedList2(rawAcceptEncoding);
+ if (acceptEncoding["identity"] === 0 || acceptEncoding["*"] === 0 && acceptEncoding["identity"] === void 0) {
+ throw new Error("No acceptable encodings available");
+ }
+ return { encoding: null };
+ },
+ fetchAsset: async (assetKey) => {
+ const filepath = assetKeyEntryMap.get(assetKey);
+ if (!filepath) {
+ throw new Error(
+ "Could not fetch asset. Please file an issue on GitHub (https://github.com/cloudflare/workers-sdk/issues/new/choose) with reproduction steps."
+ );
+ }
+ const body = (0, import_node_fs8.readFileSync)(filepath);
+ let contentType = (0, import_mime.getType)(filepath) || "application/octet-stream";
+ if (contentType.startsWith("text/") && !contentType.includes("charset")) {
+ contentType = `${contentType}; charset=utf-8`;
+ }
+ return { body, contentType };
+ }
+ });
+ }, "generateResponse");
+ return async (input, init) => {
+ const request = new import_miniflare2.Request(input, init);
+ return await generateResponse(request);
+ };
+}
+var import_node_fs8, import_node_path19, import_chokidar, import_mime, import_miniflare2, invalidAssetsFetch;
+var init_assets = __esm({
+ "src/miniflare-cli/assets.ts"() {
+ init_import_meta_url();
+ import_node_fs8 = require("node:fs");
+ import_node_path19 = require("node:path");
+ init_createMetadataObject();
+ init_parseHeaders();
+ init_parseRedirects();
+ import_chokidar = require("chokidar");
+ import_mime = __toESM(require_mime2());
+ import_miniflare2 = require("miniflare");
+ init_hash();
+ __name(generateASSETSBinding, "generateASSETSBinding");
+ __name(generateAssetsFetch, "generateAssetsFetch");
+ invalidAssetsFetch = /* @__PURE__ */ __name(() => {
+ throw new Error(
+ "Trying to fetch assets directly when there is no `directory` option specified."
+ );
+ }, "invalidAssetsFetch");
+ }
+});
+
+// ../../node_modules/.pnpm/lodash.isequal@4.5.0/node_modules/lodash.isequal/index.js
+var require_lodash2 = __commonJS({
+ "../../node_modules/.pnpm/lodash.isequal@4.5.0/node_modules/lodash.isequal/index.js"(exports2, module2) {
+ init_import_meta_url();
+ var LARGE_ARRAY_SIZE = 200;
+ var HASH_UNDEFINED = "__lodash_hash_undefined__";
+ var COMPARE_PARTIAL_FLAG = 1;
+ var COMPARE_UNORDERED_FLAG = 2;
+ var MAX_SAFE_INTEGER = 9007199254740991;
+ var argsTag = "[object Arguments]";
+ var arrayTag = "[object Array]";
+ var asyncTag = "[object AsyncFunction]";
+ var boolTag = "[object Boolean]";
+ var dateTag = "[object Date]";
+ var errorTag = "[object Error]";
+ var funcTag = "[object Function]";
+ var genTag = "[object GeneratorFunction]";
+ var mapTag = "[object Map]";
+ var numberTag = "[object Number]";
+ var nullTag = "[object Null]";
+ var objectTag = "[object Object]";
+ var promiseTag = "[object Promise]";
+ var proxyTag = "[object Proxy]";
+ var regexpTag = "[object RegExp]";
+ var setTag = "[object Set]";
+ var stringTag = "[object String]";
+ var symbolTag = "[object Symbol]";
+ var undefinedTag = "[object Undefined]";
+ var weakMapTag = "[object WeakMap]";
+ var arrayBufferTag = "[object ArrayBuffer]";
+ var dataViewTag = "[object DataView]";
+ var float32Tag = "[object Float32Array]";
+ var float64Tag = "[object Float64Array]";
+ var int8Tag = "[object Int8Array]";
+ var int16Tag = "[object Int16Array]";
+ var int32Tag = "[object Int32Array]";
+ var uint8Tag = "[object Uint8Array]";
+ var uint8ClampedTag = "[object Uint8ClampedArray]";
+ var uint16Tag = "[object Uint16Array]";
+ var uint32Tag = "[object Uint32Array]";
+ var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
+ var reIsHostCtor = /^\[object .+?Constructor\]$/;
+ var reIsUint = /^(?:0|[1-9]\d*)$/;
+ 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 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 {
+ return freeProcess && freeProcess.binding && freeProcess.binding("util");
+ } catch (e2) {
+ }
+ }();
+ var nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;
+ 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;
+ }
+ __name(arrayFilter, "arrayFilter");
+ function arrayPush(array, values) {
+ var index = -1, length = values.length, offset = array.length;
+ while (++index < length) {
+ array[offset + index] = values[index];
+ }
+ return array;
+ }
+ __name(arrayPush, "arrayPush");
+ 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;
+ }
+ __name(arraySome, "arraySome");
+ function baseTimes(n, iteratee) {
+ var index = -1, result = Array(n);
+ while (++index < n) {
+ result[index] = iteratee(index);
+ }
+ return result;
+ }
+ __name(baseTimes, "baseTimes");
+ function baseUnary(func) {
+ return function(value) {
+ return func(value);
+ };
+ }
+ __name(baseUnary, "baseUnary");
+ function cacheHas(cache2, key) {
+ return cache2.has(key);
+ }
+ __name(cacheHas, "cacheHas");
+ function getValue(object, key) {
+ return object == null ? void 0 : object[key];
+ }
+ __name(getValue, "getValue");
+ function mapToArray(map) {
+ var index = -1, result = Array(map.size);
+ map.forEach(function(value, key) {
+ result[++index] = [key, value];
+ });
+ return result;
+ }
+ __name(mapToArray, "mapToArray");
+ function overArg(func, transform) {
+ return function(arg) {
+ return func(transform(arg));
+ };
+ }
+ __name(overArg, "overArg");
+ function setToArray(set) {
+ var index = -1, result = Array(set.size);
+ set.forEach(function(value) {
+ result[++index] = value;
+ });
+ return result;
+ }
+ __name(setToArray, "setToArray");
+ var arrayProto = Array.prototype;
+ var funcProto = Function.prototype;
+ var objectProto = Object.prototype;
+ var coreJsData = root["__core-js_shared__"];
+ var funcToString = funcProto.toString;
+ var hasOwnProperty2 = objectProto.hasOwnProperty;
+ var maskSrcKey = function() {
+ var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || "");
+ return uid ? "Symbol(src)_1." + uid : "";
+ }();
+ var nativeObjectToString = objectProto.toString;
+ var reIsNative = RegExp(
+ "^" + funcToString.call(hasOwnProperty2).replace(reRegExpChar, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$"
+ );
+ var Buffer3 = moduleExports ? root.Buffer : void 0;
+ var Symbol2 = root.Symbol;
+ var Uint8Array2 = root.Uint8Array;
+ var propertyIsEnumerable = objectProto.propertyIsEnumerable;
+ var splice = arrayProto.splice;
+ var symToStringTag = Symbol2 ? Symbol2.toStringTag : void 0;
+ var nativeGetSymbols = Object.getOwnPropertySymbols;
+ var nativeIsBuffer = Buffer3 ? Buffer3.isBuffer : void 0;
+ var nativeKeys = overArg(Object.keys, Object);
+ var DataView2 = getNative(root, "DataView");
+ var Map2 = getNative(root, "Map");
+ var Promise2 = getNative(root, "Promise");
+ var Set2 = getNative(root, "Set");
+ var WeakMap2 = getNative(root, "WeakMap");
+ var nativeCreate = getNative(Object, "create");
+ var dataViewCtorString = toSource(DataView2);
+ var mapCtorString = toSource(Map2);
+ var promiseCtorString = toSource(Promise2);
+ var setCtorString = toSource(Set2);
+ var weakMapCtorString = toSource(WeakMap2);
+ var symbolProto = Symbol2 ? Symbol2.prototype : void 0;
+ var symbolValueOf = symbolProto ? symbolProto.valueOf : void 0;
+ function Hash(entries) {
+ var index = -1, length = entries == null ? 0 : entries.length;
+ this.clear();
+ while (++index < length) {
+ var entry = entries[index];
+ this.set(entry[0], entry[1]);
+ }
+ }
+ __name(Hash, "Hash");
+ function hashClear() {
+ this.__data__ = nativeCreate ? nativeCreate(null) : {};
+ this.size = 0;
+ }
+ __name(hashClear, "hashClear");
+ function hashDelete(key) {
+ var result = this.has(key) && delete this.__data__[key];
+ this.size -= result ? 1 : 0;
+ return result;
+ }
+ __name(hashDelete, "hashDelete");
+ function hashGet(key) {
+ var data = this.__data__;
+ if (nativeCreate) {
+ var result = data[key];
+ return result === HASH_UNDEFINED ? void 0 : result;
+ }
+ return hasOwnProperty2.call(data, key) ? data[key] : void 0;
+ }
+ __name(hashGet, "hashGet");
+ function hashHas(key) {
+ var data = this.__data__;
+ return nativeCreate ? data[key] !== void 0 : hasOwnProperty2.call(data, key);
+ }
+ __name(hashHas, "hashHas");
+ function hashSet(key, value) {
+ var data = this.__data__;
+ this.size += this.has(key) ? 0 : 1;
+ data[key] = nativeCreate && value === void 0 ? HASH_UNDEFINED : value;
+ return this;
+ }
+ __name(hashSet, "hashSet");
+ 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 entry = entries[index];
+ this.set(entry[0], entry[1]);
+ }
+ }
+ __name(ListCache, "ListCache");
+ function listCacheClear() {
+ this.__data__ = [];
+ this.size = 0;
+ }
+ __name(listCacheClear, "listCacheClear");
+ 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;
+ }
+ __name(listCacheDelete, "listCacheDelete");
+ function listCacheGet(key) {
+ var data = this.__data__, index = assocIndexOf(data, key);
+ return index < 0 ? void 0 : data[index][1];
+ }
+ __name(listCacheGet, "listCacheGet");
+ function listCacheHas(key) {
+ return assocIndexOf(this.__data__, key) > -1;
+ }
+ __name(listCacheHas, "listCacheHas");
+ 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;
+ }
+ __name(listCacheSet, "listCacheSet");
+ 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 entry = entries[index];
+ this.set(entry[0], entry[1]);
+ }
+ }
+ __name(MapCache, "MapCache");
+ function mapCacheClear() {
+ this.size = 0;
+ this.__data__ = {
+ "hash": new Hash(),
+ "map": new (Map2 || ListCache)(),
+ "string": new Hash()
+ };
+ }
+ __name(mapCacheClear, "mapCacheClear");
+ function mapCacheDelete(key) {
+ var result = getMapData(this, key)["delete"](key);
+ this.size -= result ? 1 : 0;
+ return result;
+ }
+ __name(mapCacheDelete, "mapCacheDelete");
+ function mapCacheGet(key) {
+ return getMapData(this, key).get(key);
+ }
+ __name(mapCacheGet, "mapCacheGet");
+ function mapCacheHas(key) {
+ return getMapData(this, key).has(key);
+ }
+ __name(mapCacheHas, "mapCacheHas");
+ function mapCacheSet(key, value) {
+ var data = getMapData(this, key), size = data.size;
+ data.set(key, value);
+ this.size += data.size == size ? 0 : 1;
+ return this;
+ }
+ __name(mapCacheSet, "mapCacheSet");
+ MapCache.prototype.clear = mapCacheClear;
+ MapCache.prototype["delete"] = mapCacheDelete;
+ MapCache.prototype.get = mapCacheGet;
+ MapCache.prototype.has = mapCacheHas;
+ MapCache.prototype.set = mapCacheSet;
+ function SetCache(values) {
+ var index = -1, length = values == null ? 0 : values.length;
+ this.__data__ = new MapCache();
+ while (++index < length) {
+ this.add(values[index]);
+ }
+ }
+ __name(SetCache, "SetCache");
+ function setCacheAdd(value) {
+ this.__data__.set(value, HASH_UNDEFINED);
+ return this;
+ }
+ __name(setCacheAdd, "setCacheAdd");
+ function setCacheHas(value) {
+ return this.__data__.has(value);
+ }
+ __name(setCacheHas, "setCacheHas");
+ 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;
+ }
+ __name(Stack, "Stack");
+ function stackClear() {
+ this.__data__ = new ListCache();
+ this.size = 0;
+ }
+ __name(stackClear, "stackClear");
+ function stackDelete(key) {
+ var data = this.__data__, result = data["delete"](key);
+ this.size = data.size;
+ return result;
+ }
+ __name(stackDelete, "stackDelete");
+ function stackGet(key) {
+ return this.__data__.get(key);
+ }
+ __name(stackGet, "stackGet");
+ function stackHas(key) {
+ return this.__data__.has(key);
+ }
+ __name(stackHas, "stackHas");
+ 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;
+ }
+ __name(stackSet, "stackSet");
+ 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, result = skipIndexes ? baseTimes(value.length, String) : [], length = result.length;
+ for (var key in value) {
+ if ((inherited || hasOwnProperty2.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)))) {
+ result.push(key);
+ }
+ }
+ return result;
+ }
+ __name(arrayLikeKeys, "arrayLikeKeys");
+ function assocIndexOf(array, key) {
+ var length = array.length;
+ while (length--) {
+ if (eq(array[length][0], key)) {
+ return length;
+ }
+ }
+ return -1;
+ }
+ __name(assocIndexOf, "assocIndexOf");
+ function baseGetAllKeys(object, keysFunc, symbolsFunc) {
+ var result = keysFunc(object);
+ return isArray(object) ? result : arrayPush(result, symbolsFunc(object));
+ }
+ __name(baseGetAllKeys, "baseGetAllKeys");
+ function baseGetTag(value) {
+ if (value == null) {
+ return value === void 0 ? undefinedTag : nullTag;
+ }
+ return symToStringTag && symToStringTag in Object(value) ? getRawTag(value) : objectToString(value);
+ }
+ __name(baseGetTag, "baseGetTag");
+ function baseIsArguments(value) {
+ return isObjectLike(value) && baseGetTag(value) == argsTag;
+ }
+ __name(baseIsArguments, "baseIsArguments");
+ 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);
+ }
+ __name(baseIsEqual, "baseIsEqual");
+ 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 && hasOwnProperty2.call(object, "__wrapped__"), othIsWrapped = othIsObj && hasOwnProperty2.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);
+ }
+ __name(baseIsEqualDeep, "baseIsEqualDeep");
+ function baseIsNative(value) {
+ if (!isObject2(value) || isMasked(value)) {
+ return false;
+ }
+ var pattern = isFunction2(value) ? reIsNative : reIsHostCtor;
+ return pattern.test(toSource(value));
+ }
+ __name(baseIsNative, "baseIsNative");
+ function baseIsTypedArray(value) {
+ return isObjectLike(value) && isLength(value.length) && !!typedArrayTags[baseGetTag(value)];
+ }
+ __name(baseIsTypedArray, "baseIsTypedArray");
+ function baseKeys(object) {
+ if (!isPrototype(object)) {
+ return nativeKeys(object);
+ }
+ var result = [];
+ for (var key in Object(object)) {
+ if (hasOwnProperty2.call(object, key) && key != "constructor") {
+ result.push(key);
+ }
+ }
+ return result;
+ }
+ __name(baseKeys, "baseKeys");
+ 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 stacked = stack.get(array);
+ if (stacked && stack.get(other)) {
+ return stacked == other;
+ }
+ var index = -1, result = true, seen = bitmask & COMPARE_UNORDERED_FLAG ? new SetCache() : void 0;
+ 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 !== void 0) {
+ if (compared) {
+ continue;
+ }
+ result = 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);
+ }
+ })) {
+ result = false;
+ break;
+ }
+ } else if (!(arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {
+ result = false;
+ break;
+ }
+ }
+ stack["delete"](array);
+ stack["delete"](other);
+ return result;
+ }
+ __name(equalArrays, "equalArrays");
+ 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 result = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack);
+ stack["delete"](object);
+ return result;
+ case symbolTag:
+ if (symbolValueOf) {
+ return symbolValueOf.call(object) == symbolValueOf.call(other);
+ }
+ }
+ return false;
+ }
+ __name(equalByTag, "equalByTag");
+ 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 : hasOwnProperty2.call(other, key))) {
+ return false;
+ }
+ }
+ var stacked = stack.get(object);
+ if (stacked && stack.get(other)) {
+ return stacked == other;
+ }
+ var result = 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 === void 0 ? objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack) : compared)) {
+ result = false;
+ break;
+ }
+ skipCtor || (skipCtor = key == "constructor");
+ }
+ if (result && !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)) {
+ result = false;
+ }
+ }
+ stack["delete"](object);
+ stack["delete"](other);
+ return result;
+ }
+ __name(equalObjects, "equalObjects");
+ function getAllKeys(object) {
+ return baseGetAllKeys(object, keys, getSymbols);
+ }
+ __name(getAllKeys, "getAllKeys");
+ function getMapData(map, key) {
+ var data = map.__data__;
+ return isKeyable(key) ? data[typeof key == "string" ? "string" : "hash"] : data.map;
+ }
+ __name(getMapData, "getMapData");
+ function getNative(object, key) {
+ var value = getValue(object, key);
+ return baseIsNative(value) ? value : void 0;
+ }
+ __name(getNative, "getNative");
+ function getRawTag(value) {
+ var isOwn = hasOwnProperty2.call(value, symToStringTag), tag = value[symToStringTag];
+ try {
+ value[symToStringTag] = void 0;
+ var unmasked = true;
+ } catch (e2) {
+ }
+ var result = nativeObjectToString.call(value);
+ if (unmasked) {
+ if (isOwn) {
+ value[symToStringTag] = tag;
+ } else {
+ delete value[symToStringTag];
+ }
+ }
+ return result;
+ }
+ __name(getRawTag, "getRawTag");
+ var getSymbols = !nativeGetSymbols ? stubArray : function(object) {
+ if (object == null) {
+ return [];
+ }
+ object = Object(object);
+ return arrayFilter(nativeGetSymbols(object), function(symbol) {
+ return propertyIsEnumerable.call(object, symbol);
+ });
+ };
+ 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 = /* @__PURE__ */ __name(function(value) {
+ var result = baseGetTag(value), Ctor = result == objectTag ? value.constructor : void 0, 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 result;
+ }, "getTag");
+ }
+ function isIndex(value, length) {
+ length = length == null ? MAX_SAFE_INTEGER : length;
+ return !!length && (typeof value == "number" || reIsUint.test(value)) && (value > -1 && value % 1 == 0 && value < length);
+ }
+ __name(isIndex, "isIndex");
+ function isKeyable(value) {
+ var type = typeof value;
+ return type == "string" || type == "number" || type == "symbol" || type == "boolean" ? value !== "__proto__" : value === null;
+ }
+ __name(isKeyable, "isKeyable");
+ function isMasked(func) {
+ return !!maskSrcKey && maskSrcKey in func;
+ }
+ __name(isMasked, "isMasked");
+ function isPrototype(value) {
+ var Ctor = value && value.constructor, proto = typeof Ctor == "function" && Ctor.prototype || objectProto;
+ return value === proto;
+ }
+ __name(isPrototype, "isPrototype");
+ function objectToString(value) {
+ return nativeObjectToString.call(value);
+ }
+ __name(objectToString, "objectToString");
+ function toSource(func) {
+ if (func != null) {
+ try {
+ return funcToString.call(func);
+ } catch (e2) {
+ }
+ try {
+ return func + "";
+ } catch (e2) {
+ }
+ }
+ return "";
+ }
+ __name(toSource, "toSource");
+ function eq(value, other) {
+ return value === other || value !== value && other !== other;
+ }
+ __name(eq, "eq");
+ var isArguments = baseIsArguments(function() {
+ return arguments;
+ }()) ? baseIsArguments : function(value) {
+ return isObjectLike(value) && hasOwnProperty2.call(value, "callee") && !propertyIsEnumerable.call(value, "callee");
+ };
+ var isArray = Array.isArray;
+ function isArrayLike(value) {
+ return value != null && isLength(value.length) && !isFunction2(value);
+ }
+ __name(isArrayLike, "isArrayLike");
+ var isBuffer = nativeIsBuffer || stubFalse;
+ function isEqual(value, other) {
+ return baseIsEqual(value, other);
+ }
+ __name(isEqual, "isEqual");
+ function isFunction2(value) {
+ if (!isObject2(value)) {
+ return false;
+ }
+ var tag = baseGetTag(value);
+ return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
+ }
+ __name(isFunction2, "isFunction");
+ function isLength(value) {
+ return typeof value == "number" && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
+ }
+ __name(isLength, "isLength");
+ function isObject2(value) {
+ var type = typeof value;
+ return value != null && (type == "object" || type == "function");
+ }
+ __name(isObject2, "isObject");
+ function isObjectLike(value) {
+ return value != null && typeof value == "object";
+ }
+ __name(isObjectLike, "isObjectLike");
+ var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;
+ function keys(object) {
+ return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);
+ }
+ __name(keys, "keys");
+ function stubArray() {
+ return [];
+ }
+ __name(stubArray, "stubArray");
+ function stubFalse() {
+ return false;
+ }
+ __name(stubFalse, "stubFalse");
+ module2.exports = isEqual;
+ }
+});
+
+// ../../node_modules/.pnpm/arr-rotate@1.0.0/node_modules/arr-rotate/index.js
+var require_arr_rotate = __commonJS({
+ "../../node_modules/.pnpm/arr-rotate@1.0.0/node_modules/arr-rotate/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ module2.exports = (input, n) => {
+ if (!Array.isArray(input)) {
+ throw new TypeError(`Expected an array, got ${typeof input}`);
+ }
+ const x = input.slice();
+ const num = typeof n === "number" ? n : 0;
+ return x.splice(-num % x.length).concat(x);
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/figures@3.2.0/node_modules/figures/index.js
+var require_figures3 = __commonJS({
+ "../../node_modules/.pnpm/figures@3.2.0/node_modules/figures/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var escapeStringRegexp = require_escape_string_regexp();
+ var { platform } = process;
+ var main2 = {
+ tick: "\u2714",
+ cross: "\u2716",
+ star: "\u2605",
+ square: "\u2587",
+ squareSmall: "\u25FB",
+ squareSmallFilled: "\u25FC",
+ play: "\u25B6",
+ circle: "\u25EF",
+ circleFilled: "\u25C9",
+ circleDotted: "\u25CC",
+ circleDouble: "\u25CE",
+ circleCircle: "\u24DE",
+ circleCross: "\u24E7",
+ circlePipe: "\u24BE",
+ circleQuestionMark: "?\u20DD",
+ bullet: "\u25CF",
+ dot: "\u2024",
+ line: "\u2500",
+ ellipsis: "\u2026",
+ pointer: "\u276F",
+ pointerSmall: "\u203A",
+ info: "\u2139",
+ warning: "\u26A0",
+ hamburger: "\u2630",
+ smiley: "\u32E1",
+ mustache: "\u0DF4",
+ heart: "\u2665",
+ nodejs: "\u2B22",
+ arrowUp: "\u2191",
+ arrowDown: "\u2193",
+ arrowLeft: "\u2190",
+ arrowRight: "\u2192",
+ radioOn: "\u25C9",
+ radioOff: "\u25EF",
+ checkboxOn: "\u2612",
+ checkboxOff: "\u2610",
+ checkboxCircleOn: "\u24E7",
+ checkboxCircleOff: "\u24BE",
+ questionMarkPrefix: "?\u20DD",
+ oneHalf: "\xBD",
+ oneThird: "\u2153",
+ oneQuarter: "\xBC",
+ oneFifth: "\u2155",
+ oneSixth: "\u2159",
+ oneSeventh: "\u2150",
+ oneEighth: "\u215B",
+ oneNinth: "\u2151",
+ oneTenth: "\u2152",
+ twoThirds: "\u2154",
+ twoFifths: "\u2156",
+ threeQuarters: "\xBE",
+ threeFifths: "\u2157",
+ threeEighths: "\u215C",
+ fourFifths: "\u2158",
+ fiveSixths: "\u215A",
+ fiveEighths: "\u215D",
+ sevenEighths: "\u215E"
+ };
+ var windows = {
+ tick: "\u221A",
+ cross: "\xD7",
+ star: "*",
+ square: "\u2588",
+ squareSmall: "[ ]",
+ squareSmallFilled: "[\u2588]",
+ play: "\u25BA",
+ circle: "( )",
+ circleFilled: "(*)",
+ circleDotted: "( )",
+ circleDouble: "( )",
+ circleCircle: "(\u25CB)",
+ circleCross: "(\xD7)",
+ circlePipe: "(\u2502)",
+ circleQuestionMark: "(?)",
+ bullet: "*",
+ dot: ".",
+ line: "\u2500",
+ ellipsis: "...",
+ pointer: ">",
+ pointerSmall: "\xBB",
+ info: "i",
+ warning: "\u203C",
+ hamburger: "\u2261",
+ smiley: "\u263A",
+ mustache: "\u250C\u2500\u2510",
+ heart: main2.heart,
+ nodejs: "\u2666",
+ arrowUp: main2.arrowUp,
+ arrowDown: main2.arrowDown,
+ arrowLeft: main2.arrowLeft,
+ arrowRight: main2.arrowRight,
+ radioOn: "(*)",
+ radioOff: "( )",
+ checkboxOn: "[\xD7]",
+ checkboxOff: "[ ]",
+ checkboxCircleOn: "(\xD7)",
+ checkboxCircleOff: "( )",
+ questionMarkPrefix: "\uFF1F",
+ oneHalf: "1/2",
+ oneThird: "1/3",
+ oneQuarter: "1/4",
+ oneFifth: "1/5",
+ oneSixth: "1/6",
+ oneSeventh: "1/7",
+ oneEighth: "1/8",
+ oneNinth: "1/9",
+ oneTenth: "1/10",
+ twoThirds: "2/3",
+ twoFifths: "2/5",
+ threeQuarters: "3/4",
+ threeFifths: "3/5",
+ threeEighths: "3/8",
+ fourFifths: "4/5",
+ fiveSixths: "5/6",
+ fiveEighths: "5/8",
+ sevenEighths: "7/8"
+ };
+ if (platform === "linux") {
+ main2.questionMarkPrefix = "?";
+ }
+ var figures = platform === "win32" ? windows : main2;
+ var fn2 = /* @__PURE__ */ __name((string) => {
+ if (figures === main2) {
+ return string;
+ }
+ for (const [key, value] of Object.entries(main2)) {
+ if (value === figures[key]) {
+ continue;
+ }
+ string = string.replace(new RegExp(escapeStringRegexp(value), "g"), figures[key]);
+ }
+ return string;
+ }, "fn");
+ module2.exports = Object.assign(fn2, figures);
+ module2.exports.main = main2;
+ module2.exports.windows = windows;
+ }
+});
+
+// ../../node_modules/.pnpm/ink-select-input@4.2.1_ink@3.2.0_react@17.0.2/node_modules/ink-select-input/build/Indicator.js
+var require_Indicator = __commonJS({
+ "../../node_modules/.pnpm/ink-select-input@4.2.1_ink@3.2.0_react@17.0.2/node_modules/ink-select-input/build/Indicator.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ Object.defineProperty(exports2, "__esModule", { value: true });
+ var React18 = require_react();
+ var ink_1 = require_build2();
+ var figures = require_figures3();
+ var Indicator = /* @__PURE__ */ __name(({ isSelected = false }) => React18.createElement(ink_1.Box, { marginRight: 1 }, isSelected ? React18.createElement(ink_1.Text, { color: "blue" }, figures.pointer) : React18.createElement(ink_1.Text, null, " ")), "Indicator");
+ exports2.default = Indicator;
+ }
+});
+
+// ../../node_modules/.pnpm/ink-select-input@4.2.1_ink@3.2.0_react@17.0.2/node_modules/ink-select-input/build/Item.js
+var require_Item = __commonJS({
+ "../../node_modules/.pnpm/ink-select-input@4.2.1_ink@3.2.0_react@17.0.2/node_modules/ink-select-input/build/Item.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ Object.defineProperty(exports2, "__esModule", { value: true });
+ var React18 = require_react();
+ var ink_1 = require_build2();
+ var Item = /* @__PURE__ */ __name(({ isSelected = false, label }) => React18.createElement(ink_1.Text, { color: isSelected ? "blue" : void 0 }, label), "Item");
+ exports2.default = Item;
+ }
+});
+
+// ../../node_modules/.pnpm/ink-select-input@4.2.1_ink@3.2.0_react@17.0.2/node_modules/ink-select-input/build/SelectInput.js
+var require_SelectInput = __commonJS({
+ "../../node_modules/.pnpm/ink-select-input@4.2.1_ink@3.2.0_react@17.0.2/node_modules/ink-select-input/build/SelectInput.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ Object.defineProperty(exports2, "__esModule", { value: true });
+ var React18 = require_react();
+ var react_1 = require_react();
+ var isEqual = require_lodash2();
+ var arrayRotate = require_arr_rotate();
+ var ink_1 = require_build2();
+ var Indicator_1 = require_Indicator();
+ var Item_1 = require_Item();
+ function SelectInput4({ items = [], isFocused = true, initialIndex = 0, indicatorComponent = Indicator_1.default, itemComponent = Item_1.default, limit: customLimit, onSelect, onHighlight }) {
+ const [rotateIndex, setRotateIndex] = react_1.useState(0);
+ const [selectedIndex, setSelectedIndex] = react_1.useState(initialIndex);
+ const hasLimit = typeof customLimit === "number" && items.length > customLimit;
+ const limit = hasLimit ? Math.min(customLimit, items.length) : items.length;
+ const previousItems = react_1.useRef(items);
+ react_1.useEffect(() => {
+ if (!isEqual(previousItems.current.map((item) => item.value), items.map((item) => item.value))) {
+ setRotateIndex(0);
+ setSelectedIndex(0);
+ }
+ previousItems.current = items;
+ }, [items]);
+ ink_1.useInput(react_1.useCallback((input, key) => {
+ if (input === "k" || key.upArrow) {
+ const lastIndex = (hasLimit ? limit : items.length) - 1;
+ const atFirstIndex = selectedIndex === 0;
+ const nextIndex = hasLimit ? selectedIndex : lastIndex;
+ const nextRotateIndex = atFirstIndex ? rotateIndex + 1 : rotateIndex;
+ const nextSelectedIndex = atFirstIndex ? nextIndex : selectedIndex - 1;
+ setRotateIndex(nextRotateIndex);
+ setSelectedIndex(nextSelectedIndex);
+ const slicedItems2 = hasLimit ? arrayRotate(items, nextRotateIndex).slice(0, limit) : items;
+ if (typeof onHighlight === "function") {
+ onHighlight(slicedItems2[nextSelectedIndex]);
+ }
+ }
+ if (input === "j" || key.downArrow) {
+ const atLastIndex = selectedIndex === (hasLimit ? limit : items.length) - 1;
+ const nextIndex = hasLimit ? selectedIndex : 0;
+ const nextRotateIndex = atLastIndex ? rotateIndex - 1 : rotateIndex;
+ const nextSelectedIndex = atLastIndex ? nextIndex : selectedIndex + 1;
+ setRotateIndex(nextRotateIndex);
+ setSelectedIndex(nextSelectedIndex);
+ const slicedItems2 = hasLimit ? arrayRotate(items, nextRotateIndex).slice(0, limit) : items;
+ if (typeof onHighlight === "function") {
+ onHighlight(slicedItems2[nextSelectedIndex]);
+ }
+ }
+ if (key.return) {
+ const slicedItems2 = hasLimit ? arrayRotate(items, rotateIndex).slice(0, limit) : items;
+ if (typeof onSelect === "function") {
+ onSelect(slicedItems2[selectedIndex]);
+ }
+ }
+ }, [
+ hasLimit,
+ limit,
+ rotateIndex,
+ selectedIndex,
+ items,
+ onSelect,
+ onHighlight
+ ]), { isActive: isFocused });
+ const slicedItems = hasLimit ? arrayRotate(items, rotateIndex).slice(0, limit) : items;
+ return React18.createElement(ink_1.Box, { flexDirection: "column" }, slicedItems.map((item, index) => {
+ var _a2;
+ const isSelected = index === selectedIndex;
+ return React18.createElement(
+ ink_1.Box,
+ { key: (_a2 = item.key) !== null && _a2 !== void 0 ? _a2 : item.value },
+ React18.createElement(indicatorComponent, { isSelected }),
+ React18.createElement(itemComponent, { ...item, isSelected })
+ );
+ }));
+ }
+ __name(SelectInput4, "SelectInput");
+ exports2.default = SelectInput4;
+ }
+});
+
+// ../../node_modules/.pnpm/ink-select-input@4.2.1_ink@3.2.0_react@17.0.2/node_modules/ink-select-input/build/index.js
+var require_build3 = __commonJS({
+ "../../node_modules/.pnpm/ink-select-input@4.2.1_ink@3.2.0_react@17.0.2/node_modules/ink-select-input/build/index.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ Object.defineProperty(exports2, "__esModule", { value: true });
+ var SelectInput_1 = require_SelectInput();
+ exports2.default = SelectInput_1.default;
+ var Indicator_1 = require_Indicator();
+ Object.defineProperty(exports2, "Indicator", { enumerable: true, get: function() {
+ return Indicator_1.default;
+ } });
+ var Item_1 = require_Item();
+ Object.defineProperty(exports2, "Item", { enumerable: true, get: function() {
+ return Item_1.default;
+ } });
+ }
+});
+
+// ../../node_modules/.pnpm/object-hash@2.2.0/node_modules/object-hash/index.js
+var require_object_hash = __commonJS({
+ "../../node_modules/.pnpm/object-hash@2.2.0/node_modules/object-hash/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var crypto6 = require("crypto");
+ exports2 = module2.exports = objectHash;
+ function objectHash(object, options14) {
+ options14 = applyDefaults(object, options14);
+ return hash(object, options14);
+ }
+ __name(objectHash, "objectHash");
+ exports2.sha1 = function(object) {
+ return objectHash(object);
+ };
+ exports2.keys = function(object) {
+ return objectHash(object, { excludeValues: true, algorithm: "sha1", encoding: "hex" });
+ };
+ exports2.MD5 = function(object) {
+ return objectHash(object, { algorithm: "md5", encoding: "hex" });
+ };
+ exports2.keysMD5 = function(object) {
+ return objectHash(object, { algorithm: "md5", encoding: "hex", excludeValues: true });
+ };
+ var hashes = crypto6.getHashes ? crypto6.getHashes().slice() : ["sha1", "md5"];
+ hashes.push("passthrough");
+ var encodings = ["buffer", "hex", "binary", "base64"];
+ function applyDefaults(object, sourceOptions) {
+ sourceOptions = sourceOptions || {};
+ var options14 = {};
+ options14.algorithm = sourceOptions.algorithm || "sha1";
+ options14.encoding = sourceOptions.encoding || "hex";
+ options14.excludeValues = sourceOptions.excludeValues ? true : false;
+ options14.algorithm = options14.algorithm.toLowerCase();
+ options14.encoding = options14.encoding.toLowerCase();
+ options14.ignoreUnknown = sourceOptions.ignoreUnknown !== true ? false : true;
+ options14.respectType = sourceOptions.respectType === false ? false : true;
+ options14.respectFunctionNames = sourceOptions.respectFunctionNames === false ? false : true;
+ options14.respectFunctionProperties = sourceOptions.respectFunctionProperties === false ? false : true;
+ options14.unorderedArrays = sourceOptions.unorderedArrays !== true ? false : true;
+ options14.unorderedSets = sourceOptions.unorderedSets === false ? false : true;
+ options14.unorderedObjects = sourceOptions.unorderedObjects === false ? false : true;
+ options14.replacer = sourceOptions.replacer || void 0;
+ options14.excludeKeys = sourceOptions.excludeKeys || void 0;
+ if (typeof object === "undefined") {
+ throw new Error("Object argument required.");
+ }
+ for (var i = 0; i < hashes.length; ++i) {
+ if (hashes[i].toLowerCase() === options14.algorithm.toLowerCase()) {
+ options14.algorithm = hashes[i];
+ }
+ }
+ if (hashes.indexOf(options14.algorithm) === -1) {
+ throw new Error('Algorithm "' + options14.algorithm + '" not supported. supported values: ' + hashes.join(", "));
+ }
+ if (encodings.indexOf(options14.encoding) === -1 && options14.algorithm !== "passthrough") {
+ throw new Error('Encoding "' + options14.encoding + '" not supported. supported values: ' + encodings.join(", "));
+ }
+ return options14;
+ }
+ __name(applyDefaults, "applyDefaults");
+ function isNativeFunction(f) {
+ if (typeof f !== "function") {
+ return false;
+ }
+ var exp = /^function\s+\w*\s*\(\s*\)\s*{\s+\[native code\]\s+}$/i;
+ return exp.exec(Function.prototype.toString.call(f)) != null;
+ }
+ __name(isNativeFunction, "isNativeFunction");
+ function hash(object, options14) {
+ var hashingStream;
+ if (options14.algorithm !== "passthrough") {
+ hashingStream = crypto6.createHash(options14.algorithm);
+ } else {
+ hashingStream = new PassThrough();
+ }
+ if (typeof hashingStream.write === "undefined") {
+ hashingStream.write = hashingStream.update;
+ hashingStream.end = hashingStream.update;
+ }
+ var hasher = typeHasher(options14, hashingStream);
+ hasher.dispatch(object);
+ if (!hashingStream.update) {
+ hashingStream.end("");
+ }
+ if (hashingStream.digest) {
+ return hashingStream.digest(options14.encoding === "buffer" ? void 0 : options14.encoding);
+ }
+ var buf = hashingStream.read();
+ if (options14.encoding === "buffer") {
+ return buf;
+ }
+ return buf.toString(options14.encoding);
+ }
+ __name(hash, "hash");
+ exports2.writeToStream = function(object, options14, stream2) {
+ if (typeof stream2 === "undefined") {
+ stream2 = options14;
+ options14 = {};
+ }
+ options14 = applyDefaults(object, options14);
+ return typeHasher(options14, stream2).dispatch(object);
+ };
+ function typeHasher(options14, writeTo, context2) {
+ context2 = context2 || [];
+ var write = /* @__PURE__ */ __name(function(str) {
+ if (writeTo.update) {
+ return writeTo.update(str, "utf8");
+ } else {
+ return writeTo.write(str, "utf8");
+ }
+ }, "write");
+ return {
+ dispatch: function(value) {
+ if (options14.replacer) {
+ value = options14.replacer(value);
+ }
+ var type = typeof value;
+ if (value === null) {
+ type = "null";
+ }
+ return this["_" + type](value);
+ },
+ _object: function(object) {
+ var pattern = /\[object (.*)\]/i;
+ var objString = Object.prototype.toString.call(object);
+ var objType = pattern.exec(objString);
+ if (!objType) {
+ objType = "unknown:[" + objString + "]";
+ } else {
+ objType = objType[1];
+ }
+ objType = objType.toLowerCase();
+ var objectNumber = null;
+ if ((objectNumber = context2.indexOf(object)) >= 0) {
+ return this.dispatch("[CIRCULAR:" + objectNumber + "]");
+ } else {
+ context2.push(object);
+ }
+ if (typeof Buffer !== "undefined" && Buffer.isBuffer && Buffer.isBuffer(object)) {
+ write("buffer:");
+ return write(object);
+ }
+ if (objType !== "object" && objType !== "function" && objType !== "asyncfunction") {
+ if (this["_" + objType]) {
+ this["_" + objType](object);
+ } else if (options14.ignoreUnknown) {
+ return write("[" + objType + "]");
+ } else {
+ throw new Error('Unknown object type "' + objType + '"');
+ }
+ } else {
+ var keys = Object.keys(object);
+ if (options14.unorderedObjects) {
+ keys = keys.sort();
+ }
+ if (options14.respectType !== false && !isNativeFunction(object)) {
+ keys.splice(0, 0, "prototype", "__proto__", "constructor");
+ }
+ if (options14.excludeKeys) {
+ keys = keys.filter(function(key) {
+ return !options14.excludeKeys(key);
+ });
+ }
+ write("object:" + keys.length + ":");
+ var self2 = this;
+ return keys.forEach(function(key) {
+ self2.dispatch(key);
+ write(":");
+ if (!options14.excludeValues) {
+ self2.dispatch(object[key]);
+ }
+ write(",");
+ });
+ }
+ },
+ _array: function(arr, unordered) {
+ unordered = typeof unordered !== "undefined" ? unordered : options14.unorderedArrays !== false;
+ var self2 = this;
+ write("array:" + arr.length + ":");
+ if (!unordered || arr.length <= 1) {
+ return arr.forEach(function(entry) {
+ return self2.dispatch(entry);
+ });
+ }
+ var contextAdditions = [];
+ var entries = arr.map(function(entry) {
+ var strm = new PassThrough();
+ var localContext = context2.slice();
+ var hasher = typeHasher(options14, strm, localContext);
+ hasher.dispatch(entry);
+ contextAdditions = contextAdditions.concat(localContext.slice(context2.length));
+ return strm.read().toString();
+ });
+ context2 = context2.concat(contextAdditions);
+ entries.sort();
+ return this._array(entries, false);
+ },
+ _date: function(date) {
+ return write("date:" + date.toJSON());
+ },
+ _symbol: function(sym) {
+ return write("symbol:" + sym.toString());
+ },
+ _error: function(err) {
+ return write("error:" + err.toString());
+ },
+ _boolean: function(bool) {
+ return write("bool:" + bool.toString());
+ },
+ _string: function(string) {
+ write("string:" + string.length + ":");
+ write(string.toString());
+ },
+ _function: function(fn2) {
+ write("fn:");
+ if (isNativeFunction(fn2)) {
+ this.dispatch("[native]");
+ } else {
+ this.dispatch(fn2.toString());
+ }
+ if (options14.respectFunctionNames !== false) {
+ this.dispatch("function-name:" + String(fn2.name));
+ }
+ if (options14.respectFunctionProperties) {
+ this._object(fn2);
+ }
+ },
+ _number: function(number) {
+ return write("number:" + number.toString());
+ },
+ _xml: function(xml) {
+ return write("xml:" + xml.toString());
+ },
+ _null: function() {
+ return write("Null");
+ },
+ _undefined: function() {
+ return write("Undefined");
+ },
+ _regexp: function(regex) {
+ return write("regex:" + regex.toString());
+ },
+ _uint8array: function(arr) {
+ write("uint8array:");
+ return this.dispatch(Array.prototype.slice.call(arr));
+ },
+ _uint8clampedarray: function(arr) {
+ write("uint8clampedarray:");
+ return this.dispatch(Array.prototype.slice.call(arr));
+ },
+ _int8array: function(arr) {
+ write("uint8array:");
+ return this.dispatch(Array.prototype.slice.call(arr));
+ },
+ _uint16array: function(arr) {
+ write("uint16array:");
+ return this.dispatch(Array.prototype.slice.call(arr));
+ },
+ _int16array: function(arr) {
+ write("uint16array:");
+ return this.dispatch(Array.prototype.slice.call(arr));
+ },
+ _uint32array: function(arr) {
+ write("uint32array:");
+ return this.dispatch(Array.prototype.slice.call(arr));
+ },
+ _int32array: function(arr) {
+ write("uint32array:");
+ return this.dispatch(Array.prototype.slice.call(arr));
+ },
+ _float32array: function(arr) {
+ write("float32array:");
+ return this.dispatch(Array.prototype.slice.call(arr));
+ },
+ _float64array: function(arr) {
+ write("float64array:");
+ return this.dispatch(Array.prototype.slice.call(arr));
+ },
+ _arraybuffer: function(arr) {
+ write("arraybuffer:");
+ return this.dispatch(new Uint8Array(arr));
+ },
+ _url: function(url3) {
+ return write("url:" + url3.toString(), "utf8");
+ },
+ _map: function(map) {
+ write("map:");
+ var arr = Array.from(map);
+ return this._array(arr, options14.unorderedSets !== false);
+ },
+ _set: function(set) {
+ write("set:");
+ var arr = Array.from(set);
+ return this._array(arr, options14.unorderedSets !== false);
+ },
+ _file: function(file) {
+ write("file:");
+ return this.dispatch([file.name, file.size, file.type, file.lastModfied]);
+ },
+ _blob: function() {
+ if (options14.ignoreUnknown) {
+ return write("[blob]");
+ }
+ throw Error('Hashing Blob objects is currently not supported\n(see https://github.com/puleos/object-hash/issues/26)\nUse "options.replacer" or "options.ignoreUnknown"\n');
+ },
+ _domwindow: function() {
+ return write("domwindow");
+ },
+ _bigint: function(number) {
+ return write("bigint:" + number.toString());
+ },
+ /* Node.js standard native objects */
+ _process: function() {
+ return write("process");
+ },
+ _timer: function() {
+ return write("timer");
+ },
+ _pipe: function() {
+ return write("pipe");
+ },
+ _tcp: function() {
+ return write("tcp");
+ },
+ _udp: function() {
+ return write("udp");
+ },
+ _tty: function() {
+ return write("tty");
+ },
+ _statwatcher: function() {
+ return write("statwatcher");
+ },
+ _securecontext: function() {
+ return write("securecontext");
+ },
+ _connection: function() {
+ return write("connection");
+ },
+ _zlib: function() {
+ return write("zlib");
+ },
+ _context: function() {
+ return write("context");
+ },
+ _nodescript: function() {
+ return write("nodescript");
+ },
+ _httpparser: function() {
+ return write("httpparser");
+ },
+ _dataview: function() {
+ return write("dataview");
+ },
+ _signal: function() {
+ return write("signal");
+ },
+ _fsevent: function() {
+ return write("fsevent");
+ },
+ _tlswrap: function() {
+ return write("tlswrap");
+ }
+ };
+ }
+ __name(typeHasher, "typeHasher");
+ function PassThrough() {
+ return {
+ buf: "",
+ write: function(b) {
+ this.buf += b;
+ },
+ end: function(b) {
+ this.buf += b;
+ },
+ read: function() {
+ return this.buf;
+ }
+ };
+ }
+ __name(PassThrough, "PassThrough");
+ }
+});
+
+// ../../node_modules/.pnpm/ink-table@3.0.0_ink@3.2.0_react@17.0.2/node_modules/ink-table/dist/index.js
+var require_dist3 = __commonJS({
+ "../../node_modules/.pnpm/ink-table@3.0.0_ink@3.2.0_react@17.0.2/node_modules/ink-table/dist/index.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ var __importDefault = exports2 && exports2.__importDefault || function(mod) {
+ return mod && mod.__esModule ? mod : { "default": mod };
+ };
+ Object.defineProperty(exports2, "__esModule", { value: true });
+ exports2.Skeleton = exports2.Cell = exports2.Header = void 0;
+ var react_1 = __importDefault(require_react());
+ var ink_1 = require_build2();
+ var object_hash_1 = require_object_hash();
+ var Table10 = class extends react_1.default.Component {
+ constructor() {
+ super(...arguments);
+ this.header = row({
+ cell: this.getConfig().skeleton,
+ padding: this.getConfig().padding,
+ skeleton: {
+ component: this.getConfig().skeleton,
+ // chars
+ line: "\u2500",
+ left: "\u250C",
+ right: "\u2510",
+ cross: "\u252C"
+ }
+ });
+ this.heading = row({
+ cell: this.getConfig().header,
+ padding: this.getConfig().padding,
+ skeleton: {
+ component: this.getConfig().skeleton,
+ // chars
+ line: " ",
+ left: "\u2502",
+ right: "\u2502",
+ cross: "\u2502"
+ }
+ });
+ this.separator = row({
+ cell: this.getConfig().skeleton,
+ padding: this.getConfig().padding,
+ skeleton: {
+ component: this.getConfig().skeleton,
+ // chars
+ line: "\u2500",
+ left: "\u251C",
+ right: "\u2524",
+ cross: "\u253C"
+ }
+ });
+ this.data = row({
+ cell: this.getConfig().cell,
+ padding: this.getConfig().padding,
+ skeleton: {
+ component: this.getConfig().skeleton,
+ // chars
+ line: " ",
+ left: "\u2502",
+ right: "\u2502",
+ cross: "\u2502"
+ }
+ });
+ this.footer = row({
+ cell: this.getConfig().skeleton,
+ padding: this.getConfig().padding,
+ skeleton: {
+ component: this.getConfig().skeleton,
+ // chars
+ line: "\u2500",
+ left: "\u2514",
+ right: "\u2518",
+ cross: "\u2534"
+ }
+ });
+ }
+ /**
+ * Merges provided configuration with defaults.
+ */
+ getConfig() {
+ return {
+ data: this.props.data,
+ columns: this.props.columns || this.getDataKeys(),
+ padding: this.props.padding || 1,
+ header: this.props.header || Header,
+ cell: this.props.cell || Cell,
+ skeleton: this.props.skeleton || Skeleton
+ };
+ }
+ /**
+ * Gets all keyes used in data by traversing through the data.
+ */
+ getDataKeys() {
+ let keys = /* @__PURE__ */ new Set();
+ for (const data of this.props.data) {
+ for (const key in data) {
+ keys.add(key);
+ }
+ }
+ return Array.from(keys);
+ }
+ /**
+ * Calculates the width of each column by finding
+ * the longest value in a cell of a particular column.
+ *
+ * Returns a list of column names and their widths.
+ */
+ getColumns() {
+ const { columns, padding } = this.getConfig();
+ const widths = columns.map((key) => {
+ const header = String(key).length;
+ const data = this.props.data.map((data2) => {
+ const value = data2[key];
+ if (value == void 0 || value == null)
+ return 0;
+ return String(value).length;
+ });
+ const width = Math.max(...data, header) + padding * 2;
+ return {
+ column: key,
+ width,
+ key: String(key)
+ };
+ });
+ return widths;
+ }
+ /**
+ * Returns a (data) row representing the headings.
+ */
+ getHeadings() {
+ const { columns } = this.getConfig();
+ const headings = columns.reduce((acc, column) => ({ ...acc, [column]: column }), {});
+ return headings;
+ }
+ /* Render */
+ render() {
+ const columns = this.getColumns();
+ const headings = this.getHeadings();
+ return react_1.default.createElement(
+ ink_1.Box,
+ { flexDirection: "column" },
+ this.header({ key: "header", columns, data: {} }),
+ this.heading({ key: "heading", columns, data: headings }),
+ this.props.data.map((row2, index) => {
+ const key = `row-${object_hash_1.sha1(row2)}-${index}`;
+ return react_1.default.createElement(
+ ink_1.Box,
+ { flexDirection: "column", key },
+ this.separator({ key: `separator-${key}`, columns, data: {} }),
+ this.data({ key: `data-${key}`, columns, data: row2 })
+ );
+ }),
+ this.footer({ key: "footer", columns, data: {} })
+ );
+ }
+ };
+ __name(Table10, "Table");
+ exports2.default = Table10;
+ function row(config) {
+ const skeleton = config.skeleton;
+ return (props) => react_1.default.createElement(
+ ink_1.Box,
+ { flexDirection: "row" },
+ react_1.default.createElement(skeleton.component, null, skeleton.left),
+ intersperse(
+ (i) => {
+ const key = `${props.key}-hseparator-${i}`;
+ return react_1.default.createElement(skeleton.component, { key }, skeleton.cross);
+ },
+ // Values.
+ props.columns.map((column) => {
+ const value = props.data[column.column];
+ if (value == void 0 || value == null) {
+ const key = `${props.key}-empty-${column.key}`;
+ return react_1.default.createElement(config.cell, { key }, skeleton.line.repeat(column.width));
+ } else {
+ const key = `${props.key}-cell-${column.key}`;
+ const ml = config.padding;
+ const mr = column.width - String(value).length - config.padding;
+ return (
+ /* prettier-ignore */
+ react_1.default.createElement(config.cell, { key }, `${skeleton.line.repeat(ml)}${String(value)}${skeleton.line.repeat(mr)}`)
+ );
+ }
+ })
+ ),
+ react_1.default.createElement(skeleton.component, null, skeleton.right)
+ );
+ }
+ __name(row, "row");
+ function Header(props) {
+ return react_1.default.createElement(ink_1.Text, { bold: true, color: "blue" }, props.children);
+ }
+ __name(Header, "Header");
+ exports2.Header = Header;
+ function Cell(props) {
+ return react_1.default.createElement(ink_1.Text, null, props.children);
+ }
+ __name(Cell, "Cell");
+ exports2.Cell = Cell;
+ function Skeleton(props) {
+ return react_1.default.createElement(ink_1.Text, { bold: true }, props.children);
+ }
+ __name(Skeleton, "Skeleton");
+ exports2.Skeleton = Skeleton;
+ function intersperse(intersperser, elements) {
+ let interspersed = elements.reduce((acc, element, index) => {
+ if (acc.length === 0)
+ return [element];
+ return [...acc, intersperser(index), element];
+ }, []);
+ return interspersed;
+ }
+ __name(intersperse, "intersperse");
+ }
+});
+
+// ../../node_modules/.pnpm/ignore@5.2.0/node_modules/ignore/index.js
+var require_ignore = __commonJS({
+ "../../node_modules/.pnpm/ignore@5.2.0/node_modules/ignore/index.js"(exports2, module2) {
+ init_import_meta_url();
+ function makeArray(subject) {
+ return Array.isArray(subject) ? subject : [subject];
+ }
+ __name(makeArray, "makeArray");
+ var EMPTY = "";
+ var SPACE = " ";
+ var ESCAPE = "\\";
+ var REGEX_TEST_BLANK_LINE = /^\s+$/;
+ var REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION = /^\\!/;
+ var REGEX_REPLACE_LEADING_EXCAPED_HASH = /^\\#/;
+ var REGEX_SPLITALL_CRLF = /\r?\n/g;
+ var REGEX_TEST_INVALID_PATH = /^\.*\/|^\.+$/;
+ var SLASH = "/";
+ var KEY_IGNORE = typeof Symbol !== "undefined" ? Symbol.for("node-ignore") : "node-ignore";
+ var define2 = /* @__PURE__ */ __name((object, key, value) => Object.defineProperty(object, key, { value }), "define");
+ var REGEX_REGEXP_RANGE = /([0-z])-([0-z])/g;
+ var RETURN_FALSE = /* @__PURE__ */ __name(() => false, "RETURN_FALSE");
+ var sanitizeRange = /* @__PURE__ */ __name((range) => range.replace(
+ REGEX_REGEXP_RANGE,
+ (match, from, to) => from.charCodeAt(0) <= to.charCodeAt(0) ? match : EMPTY
+ ), "sanitizeRange");
+ var cleanRangeBackSlash = /* @__PURE__ */ __name((slashes) => {
+ const { length } = slashes;
+ return slashes.slice(0, length - length % 2);
+ }, "cleanRangeBackSlash");
+ var REPLACERS = [
+ // > Trailing spaces are ignored unless they are quoted with backslash ("\")
+ [
+ // (a\ ) -> (a )
+ // (a ) -> (a)
+ // (a \ ) -> (a )
+ /\\?\s+$/,
+ (match) => match.indexOf("\\") === 0 ? SPACE : EMPTY
+ ],
+ // replace (\ ) with ' '
+ [
+ /\\\s/g,
+ () => SPACE
+ ],
+ // Escape metacharacters
+ // which is written down by users but means special for regular expressions.
+ // > There are 12 characters with special meanings:
+ // > - the backslash \,
+ // > - the caret ^,
+ // > - the dollar sign $,
+ // > - the period or dot .,
+ // > - the vertical bar or pipe symbol |,
+ // > - the question mark ?,
+ // > - the asterisk or star *,
+ // > - the plus sign +,
+ // > - the opening parenthesis (,
+ // > - the closing parenthesis ),
+ // > - and the opening square bracket [,
+ // > - the opening curly brace {,
+ // > These special characters are often called "metacharacters".
+ [
+ /[\\$.|*+(){^]/g,
+ (match) => `\\${match}`
+ ],
+ [
+ // > a question mark (?) matches a single character
+ /(?!\\)\?/g,
+ () => "[^/]"
+ ],
+ // leading slash
+ [
+ // > A leading slash matches the beginning of the pathname.
+ // > For example, "/*.c" matches "cat-file.c" but not "mozilla-sha1/sha1.c".
+ // A leading slash matches the beginning of the pathname
+ /^\//,
+ () => "^"
+ ],
+ // replace special metacharacter slash after the leading slash
+ [
+ /\//g,
+ () => "\\/"
+ ],
+ [
+ // > A leading "**" followed by a slash means match in all directories.
+ // > For example, "**/foo" matches file or directory "foo" anywhere,
+ // > the same as pattern "foo".
+ // > "**/foo/bar" matches file or directory "bar" anywhere that is directly
+ // > under directory "foo".
+ // Notice that the '*'s have been replaced as '\\*'
+ /^\^*\\\*\\\*\\\//,
+ // '**/foo' <-> 'foo'
+ () => "^(?:.*\\/)?"
+ ],
+ // starting
+ [
+ // there will be no leading '/'
+ // (which has been replaced by section "leading slash")
+ // If starts with '**', adding a '^' to the regular expression also works
+ /^(?=[^^])/,
+ /* @__PURE__ */ __name(function startingReplacer() {
+ return !/\/(?!$)/.test(this) ? "(?:^|\\/)" : "^";
+ }, "startingReplacer")
+ ],
+ // two globstars
+ [
+ // Use lookahead assertions so that we could match more than one `'/**'`
+ /\\\/\\\*\\\*(?=\\\/|$)/g,
+ // Zero, one or several directories
+ // should not use '*', or it will be replaced by the next replacer
+ // Check if it is not the last `'/**'`
+ (_2, index, str) => index + 6 < str.length ? "(?:\\/[^\\/]+)*" : "\\/.+"
+ ],
+ // intermediate wildcards
+ [
+ // Never replace escaped '*'
+ // ignore rule '\*' will match the path '*'
+ // 'abc.*/' -> go
+ // 'abc.*' -> skip this rule
+ /(^|[^\\]+)\\\*(?=.+)/g,
+ // '*.js' matches '.js'
+ // '*.js' doesn't match 'abc'
+ (_2, p1) => `${p1}[^\\/]*`
+ ],
+ [
+ // unescape, revert step 3 except for back slash
+ // For example, if a user escape a '\\*',
+ // after step 3, the result will be '\\\\\\*'
+ /\\\\\\(?=[$.|*+(){^])/g,
+ () => ESCAPE
+ ],
+ [
+ // '\\\\' -> '\\'
+ /\\\\/g,
+ () => ESCAPE
+ ],
+ [
+ // > The range notation, e.g. [a-zA-Z],
+ // > can be used to match one of the characters in a range.
+ // `\` is escaped by step 3
+ /(\\)?\[([^\]/]*?)(\\*)($|\])/g,
+ (match, leadEscape, range, endEscape, close) => leadEscape === ESCAPE ? `\\[${range}${cleanRangeBackSlash(endEscape)}${close}` : close === "]" ? endEscape.length % 2 === 0 ? `[${sanitizeRange(range)}${endEscape}]` : "[]" : "[]"
+ ],
+ // ending
+ [
+ // 'js' will not match 'js.'
+ // 'ab' will not match 'abc'
+ /(?:[^*])$/,
+ // WTF!
+ // https://git-scm.com/docs/gitignore
+ // changes in [2.22.1](https://git-scm.com/docs/gitignore/2.22.1)
+ // which re-fixes #24, #38
+ // > If there is a separator at the end of the pattern then the pattern
+ // > will only match directories, otherwise the pattern can match both
+ // > files and directories.
+ // 'js*' will not match 'a.js'
+ // 'js/' will not match 'a.js'
+ // 'js' will match 'a.js' and 'a.js/'
+ (match) => /\/$/.test(match) ? `${match}$` : `${match}(?=$|\\/$)`
+ ],
+ // trailing wildcard
+ [
+ /(\^|\\\/)?\\\*$/,
+ (_2, p1) => {
+ const prefix = p1 ? `${p1}[^/]+` : "[^/]*";
+ return `${prefix}(?=$|\\/$)`;
+ }
+ ]
+ ];
+ var regexCache = /* @__PURE__ */ Object.create(null);
+ var makeRegex = /* @__PURE__ */ __name((pattern, ignoreCase) => {
+ let source = regexCache[pattern];
+ if (!source) {
+ source = REPLACERS.reduce(
+ (prev, current) => prev.replace(current[0], current[1].bind(pattern)),
+ pattern
+ );
+ regexCache[pattern] = source;
+ }
+ return ignoreCase ? new RegExp(source, "i") : new RegExp(source);
+ }, "makeRegex");
+ var isString2 = /* @__PURE__ */ __name((subject) => typeof subject === "string", "isString");
+ var checkPattern = /* @__PURE__ */ __name((pattern) => pattern && isString2(pattern) && !REGEX_TEST_BLANK_LINE.test(pattern) && pattern.indexOf("#") !== 0, "checkPattern");
+ var splitPattern = /* @__PURE__ */ __name((pattern) => pattern.split(REGEX_SPLITALL_CRLF), "splitPattern");
+ var IgnoreRule = class {
+ constructor(origin, pattern, negative, regex) {
+ this.origin = origin;
+ this.pattern = pattern;
+ this.negative = negative;
+ this.regex = regex;
+ }
+ };
+ __name(IgnoreRule, "IgnoreRule");
+ var createRule = /* @__PURE__ */ __name((pattern, ignoreCase) => {
+ const origin = pattern;
+ let negative = false;
+ if (pattern.indexOf("!") === 0) {
+ negative = true;
+ pattern = pattern.substr(1);
+ }
+ pattern = pattern.replace(REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION, "!").replace(REGEX_REPLACE_LEADING_EXCAPED_HASH, "#");
+ const regex = makeRegex(pattern, ignoreCase);
+ return new IgnoreRule(
+ origin,
+ pattern,
+ negative,
+ regex
+ );
+ }, "createRule");
+ var throwError = /* @__PURE__ */ __name((message, Ctor) => {
+ throw new Ctor(message);
+ }, "throwError");
+ var checkPath = /* @__PURE__ */ __name((path45, originalPath, doThrow) => {
+ if (!isString2(path45)) {
+ return doThrow(
+ `path must be a string, but got \`${originalPath}\``,
+ TypeError
+ );
+ }
+ if (!path45) {
+ return doThrow(`path must not be empty`, TypeError);
+ }
+ if (checkPath.isNotRelative(path45)) {
+ const r = "`path.relative()`d";
+ return doThrow(
+ `path should be a ${r} string, but got "${originalPath}"`,
+ RangeError
+ );
+ }
+ return true;
+ }, "checkPath");
+ var isNotRelative = /* @__PURE__ */ __name((path45) => REGEX_TEST_INVALID_PATH.test(path45), "isNotRelative");
+ checkPath.isNotRelative = isNotRelative;
+ checkPath.convert = (p) => p;
+ var Ignore = class {
+ constructor({
+ ignorecase = true,
+ ignoreCase = ignorecase,
+ allowRelativePaths = false
+ } = {}) {
+ define2(this, KEY_IGNORE, true);
+ this._rules = [];
+ this._ignoreCase = ignoreCase;
+ this._allowRelativePaths = allowRelativePaths;
+ this._initCache();
+ }
+ _initCache() {
+ this._ignoreCache = /* @__PURE__ */ Object.create(null);
+ this._testCache = /* @__PURE__ */ Object.create(null);
+ }
+ _addPattern(pattern) {
+ if (pattern && pattern[KEY_IGNORE]) {
+ this._rules = this._rules.concat(pattern._rules);
+ this._added = true;
+ return;
+ }
+ if (checkPattern(pattern)) {
+ const rule = createRule(pattern, this._ignoreCase);
+ this._added = true;
+ this._rules.push(rule);
+ }
+ }
+ // @param {Array | string | Ignore} pattern
+ add(pattern) {
+ this._added = false;
+ makeArray(
+ isString2(pattern) ? splitPattern(pattern) : pattern
+ ).forEach(this._addPattern, this);
+ if (this._added) {
+ this._initCache();
+ }
+ return this;
+ }
+ // legacy
+ addPattern(pattern) {
+ return this.add(pattern);
+ }
+ // | ignored : unignored
+ // negative | 0:0 | 0:1 | 1:0 | 1:1
+ // -------- | ------- | ------- | ------- | --------
+ // 0 | TEST | TEST | SKIP | X
+ // 1 | TESTIF | SKIP | TEST | X
+ // - SKIP: always skip
+ // - TEST: always test
+ // - TESTIF: only test if checkUnignored
+ // - X: that never happen
+ // @param {boolean} whether should check if the path is unignored,
+ // setting `checkUnignored` to `false` could reduce additional
+ // path matching.
+ // @returns {TestResult} true if a file is ignored
+ _testOne(path45, checkUnignored) {
+ let ignored = false;
+ let unignored = false;
+ this._rules.forEach((rule) => {
+ const { negative } = rule;
+ if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) {
+ return;
+ }
+ const matched = rule.regex.test(path45);
+ if (matched) {
+ ignored = !negative;
+ unignored = negative;
+ }
+ });
+ return {
+ ignored,
+ unignored
+ };
+ }
+ // @returns {TestResult}
+ _test(originalPath, cache2, checkUnignored, slices) {
+ const path45 = originalPath && checkPath.convert(originalPath);
+ checkPath(
+ path45,
+ originalPath,
+ this._allowRelativePaths ? RETURN_FALSE : throwError
+ );
+ return this._t(path45, cache2, checkUnignored, slices);
+ }
+ _t(path45, cache2, checkUnignored, slices) {
+ if (path45 in cache2) {
+ return cache2[path45];
+ }
+ if (!slices) {
+ slices = path45.split(SLASH);
+ }
+ slices.pop();
+ if (!slices.length) {
+ return cache2[path45] = this._testOne(path45, checkUnignored);
+ }
+ const parent = this._t(
+ slices.join(SLASH) + SLASH,
+ cache2,
+ checkUnignored,
+ slices
+ );
+ return cache2[path45] = parent.ignored ? parent : this._testOne(path45, checkUnignored);
+ }
+ ignores(path45) {
+ return this._test(path45, this._ignoreCache, false).ignored;
+ }
+ createFilter() {
+ return (path45) => !this.ignores(path45);
+ }
+ filter(paths) {
+ return makeArray(paths).filter(this.createFilter());
+ }
+ // @returns {TestResult}
+ test(path45) {
+ return this._test(path45, this._testCache, true);
+ }
+ };
+ __name(Ignore, "Ignore");
+ var factory = /* @__PURE__ */ __name((options14) => new Ignore(options14), "factory");
+ var isPathValid = /* @__PURE__ */ __name((path45) => checkPath(path45 && checkPath.convert(path45), path45, RETURN_FALSE), "isPathValid");
+ factory.isPathValid = isPathValid;
+ factory.default = factory;
+ module2.exports = factory;
+ if (
+ // Detect `process` so that it can run in browsers.
+ typeof process !== "undefined" && (process.env && process.env.IGNORE_TEST_WIN32 || process.platform === "win32")
+ ) {
+ const makePosix = /* @__PURE__ */ __name((str) => /^\\\\\?\\/.test(str) || /["<>|\u0000-\u001F]+/u.test(str) ? str : str.replace(/\\/g, "/"), "makePosix");
+ checkPath.convert = makePosix;
+ const REGIX_IS_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
+ checkPath.isNotRelative = (path45) => REGIX_IS_WINDOWS_PATH_ABSOLUTE.test(path45) || isNotRelative(path45);
+ }
+ }
+});
+
+// ../../node_modules/.pnpm/cli-spinners@2.6.1/node_modules/cli-spinners/spinners.json
+var require_spinners = __commonJS({
+ "../../node_modules/.pnpm/cli-spinners@2.6.1/node_modules/cli-spinners/spinners.json"(exports2, module2) {
+ module2.exports = {
+ dots: {
+ interval: 80,
+ frames: [
+ "\u280B",
+ "\u2819",
+ "\u2839",
+ "\u2838",
+ "\u283C",
+ "\u2834",
+ "\u2826",
+ "\u2827",
+ "\u2807",
+ "\u280F"
+ ]
+ },
+ dots2: {
+ interval: 80,
+ frames: [
+ "\u28FE",
+ "\u28FD",
+ "\u28FB",
+ "\u28BF",
+ "\u287F",
+ "\u28DF",
+ "\u28EF",
+ "\u28F7"
+ ]
+ },
+ dots3: {
+ interval: 80,
+ frames: [
+ "\u280B",
+ "\u2819",
+ "\u281A",
+ "\u281E",
+ "\u2816",
+ "\u2826",
+ "\u2834",
+ "\u2832",
+ "\u2833",
+ "\u2813"
+ ]
+ },
+ dots4: {
+ interval: 80,
+ frames: [
+ "\u2804",
+ "\u2806",
+ "\u2807",
+ "\u280B",
+ "\u2819",
+ "\u2838",
+ "\u2830",
+ "\u2820",
+ "\u2830",
+ "\u2838",
+ "\u2819",
+ "\u280B",
+ "\u2807",
+ "\u2806"
+ ]
+ },
+ dots5: {
+ interval: 80,
+ frames: [
+ "\u280B",
+ "\u2819",
+ "\u281A",
+ "\u2812",
+ "\u2802",
+ "\u2802",
+ "\u2812",
+ "\u2832",
+ "\u2834",
+ "\u2826",
+ "\u2816",
+ "\u2812",
+ "\u2810",
+ "\u2810",
+ "\u2812",
+ "\u2813",
+ "\u280B"
+ ]
+ },
+ dots6: {
+ interval: 80,
+ frames: [
+ "\u2801",
+ "\u2809",
+ "\u2819",
+ "\u281A",
+ "\u2812",
+ "\u2802",
+ "\u2802",
+ "\u2812",
+ "\u2832",
+ "\u2834",
+ "\u2824",
+ "\u2804",
+ "\u2804",
+ "\u2824",
+ "\u2834",
+ "\u2832",
+ "\u2812",
+ "\u2802",
+ "\u2802",
+ "\u2812",
+ "\u281A",
+ "\u2819",
+ "\u2809",
+ "\u2801"
+ ]
+ },
+ dots7: {
+ interval: 80,
+ frames: [
+ "\u2808",
+ "\u2809",
+ "\u280B",
+ "\u2813",
+ "\u2812",
+ "\u2810",
+ "\u2810",
+ "\u2812",
+ "\u2816",
+ "\u2826",
+ "\u2824",
+ "\u2820",
+ "\u2820",
+ "\u2824",
+ "\u2826",
+ "\u2816",
+ "\u2812",
+ "\u2810",
+ "\u2810",
+ "\u2812",
+ "\u2813",
+ "\u280B",
+ "\u2809",
+ "\u2808"
+ ]
+ },
+ dots8: {
+ interval: 80,
+ frames: [
+ "\u2801",
+ "\u2801",
+ "\u2809",
+ "\u2819",
+ "\u281A",
+ "\u2812",
+ "\u2802",
+ "\u2802",
+ "\u2812",
+ "\u2832",
+ "\u2834",
+ "\u2824",
+ "\u2804",
+ "\u2804",
+ "\u2824",
+ "\u2820",
+ "\u2820",
+ "\u2824",
+ "\u2826",
+ "\u2816",
+ "\u2812",
+ "\u2810",
+ "\u2810",
+ "\u2812",
+ "\u2813",
+ "\u280B",
+ "\u2809",
+ "\u2808",
+ "\u2808"
+ ]
+ },
+ dots9: {
+ interval: 80,
+ frames: [
+ "\u28B9",
+ "\u28BA",
+ "\u28BC",
+ "\u28F8",
+ "\u28C7",
+ "\u2867",
+ "\u2857",
+ "\u284F"
+ ]
+ },
+ dots10: {
+ interval: 80,
+ frames: [
+ "\u2884",
+ "\u2882",
+ "\u2881",
+ "\u2841",
+ "\u2848",
+ "\u2850",
+ "\u2860"
+ ]
+ },
+ dots11: {
+ interval: 100,
+ frames: [
+ "\u2801",
+ "\u2802",
+ "\u2804",
+ "\u2840",
+ "\u2880",
+ "\u2820",
+ "\u2810",
+ "\u2808"
+ ]
+ },
+ dots12: {
+ interval: 80,
+ frames: [
+ "\u2880\u2800",
+ "\u2840\u2800",
+ "\u2804\u2800",
+ "\u2882\u2800",
+ "\u2842\u2800",
+ "\u2805\u2800",
+ "\u2883\u2800",
+ "\u2843\u2800",
+ "\u280D\u2800",
+ "\u288B\u2800",
+ "\u284B\u2800",
+ "\u280D\u2801",
+ "\u288B\u2801",
+ "\u284B\u2801",
+ "\u280D\u2809",
+ "\u280B\u2809",
+ "\u280B\u2809",
+ "\u2809\u2819",
+ "\u2809\u2819",
+ "\u2809\u2829",
+ "\u2808\u2899",
+ "\u2808\u2859",
+ "\u2888\u2829",
+ "\u2840\u2899",
+ "\u2804\u2859",
+ "\u2882\u2829",
+ "\u2842\u2898",
+ "\u2805\u2858",
+ "\u2883\u2828",
+ "\u2843\u2890",
+ "\u280D\u2850",
+ "\u288B\u2820",
+ "\u284B\u2880",
+ "\u280D\u2841",
+ "\u288B\u2801",
+ "\u284B\u2801",
+ "\u280D\u2809",
+ "\u280B\u2809",
+ "\u280B\u2809",
+ "\u2809\u2819",
+ "\u2809\u2819",
+ "\u2809\u2829",
+ "\u2808\u2899",
+ "\u2808\u2859",
+ "\u2808\u2829",
+ "\u2800\u2899",
+ "\u2800\u2859",
+ "\u2800\u2829",
+ "\u2800\u2898",
+ "\u2800\u2858",
+ "\u2800\u2828",
+ "\u2800\u2890",
+ "\u2800\u2850",
+ "\u2800\u2820",
+ "\u2800\u2880",
+ "\u2800\u2840"
+ ]
+ },
+ dots8Bit: {
+ interval: 80,
+ frames: [
+ "\u2800",
+ "\u2801",
+ "\u2802",
+ "\u2803",
+ "\u2804",
+ "\u2805",
+ "\u2806",
+ "\u2807",
+ "\u2840",
+ "\u2841",
+ "\u2842",
+ "\u2843",
+ "\u2844",
+ "\u2845",
+ "\u2846",
+ "\u2847",
+ "\u2808",
+ "\u2809",
+ "\u280A",
+ "\u280B",
+ "\u280C",
+ "\u280D",
+ "\u280E",
+ "\u280F",
+ "\u2848",
+ "\u2849",
+ "\u284A",
+ "\u284B",
+ "\u284C",
+ "\u284D",
+ "\u284E",
+ "\u284F",
+ "\u2810",
+ "\u2811",
+ "\u2812",
+ "\u2813",
+ "\u2814",
+ "\u2815",
+ "\u2816",
+ "\u2817",
+ "\u2850",
+ "\u2851",
+ "\u2852",
+ "\u2853",
+ "\u2854",
+ "\u2855",
+ "\u2856",
+ "\u2857",
+ "\u2818",
+ "\u2819",
+ "\u281A",
+ "\u281B",
+ "\u281C",
+ "\u281D",
+ "\u281E",
+ "\u281F",
+ "\u2858",
+ "\u2859",
+ "\u285A",
+ "\u285B",
+ "\u285C",
+ "\u285D",
+ "\u285E",
+ "\u285F",
+ "\u2820",
+ "\u2821",
+ "\u2822",
+ "\u2823",
+ "\u2824",
+ "\u2825",
+ "\u2826",
+ "\u2827",
+ "\u2860",
+ "\u2861",
+ "\u2862",
+ "\u2863",
+ "\u2864",
+ "\u2865",
+ "\u2866",
+ "\u2867",
+ "\u2828",
+ "\u2829",
+ "\u282A",
+ "\u282B",
+ "\u282C",
+ "\u282D",
+ "\u282E",
+ "\u282F",
+ "\u2868",
+ "\u2869",
+ "\u286A",
+ "\u286B",
+ "\u286C",
+ "\u286D",
+ "\u286E",
+ "\u286F",
+ "\u2830",
+ "\u2831",
+ "\u2832",
+ "\u2833",
+ "\u2834",
+ "\u2835",
+ "\u2836",
+ "\u2837",
+ "\u2870",
+ "\u2871",
+ "\u2872",
+ "\u2873",
+ "\u2874",
+ "\u2875",
+ "\u2876",
+ "\u2877",
+ "\u2838",
+ "\u2839",
+ "\u283A",
+ "\u283B",
+ "\u283C",
+ "\u283D",
+ "\u283E",
+ "\u283F",
+ "\u2878",
+ "\u2879",
+ "\u287A",
+ "\u287B",
+ "\u287C",
+ "\u287D",
+ "\u287E",
+ "\u287F",
+ "\u2880",
+ "\u2881",
+ "\u2882",
+ "\u2883",
+ "\u2884",
+ "\u2885",
+ "\u2886",
+ "\u2887",
+ "\u28C0",
+ "\u28C1",
+ "\u28C2",
+ "\u28C3",
+ "\u28C4",
+ "\u28C5",
+ "\u28C6",
+ "\u28C7",
+ "\u2888",
+ "\u2889",
+ "\u288A",
+ "\u288B",
+ "\u288C",
+ "\u288D",
+ "\u288E",
+ "\u288F",
+ "\u28C8",
+ "\u28C9",
+ "\u28CA",
+ "\u28CB",
+ "\u28CC",
+ "\u28CD",
+ "\u28CE",
+ "\u28CF",
+ "\u2890",
+ "\u2891",
+ "\u2892",
+ "\u2893",
+ "\u2894",
+ "\u2895",
+ "\u2896",
+ "\u2897",
+ "\u28D0",
+ "\u28D1",
+ "\u28D2",
+ "\u28D3",
+ "\u28D4",
+ "\u28D5",
+ "\u28D6",
+ "\u28D7",
+ "\u2898",
+ "\u2899",
+ "\u289A",
+ "\u289B",
+ "\u289C",
+ "\u289D",
+ "\u289E",
+ "\u289F",
+ "\u28D8",
+ "\u28D9",
+ "\u28DA",
+ "\u28DB",
+ "\u28DC",
+ "\u28DD",
+ "\u28DE",
+ "\u28DF",
+ "\u28A0",
+ "\u28A1",
+ "\u28A2",
+ "\u28A3",
+ "\u28A4",
+ "\u28A5",
+ "\u28A6",
+ "\u28A7",
+ "\u28E0",
+ "\u28E1",
+ "\u28E2",
+ "\u28E3",
+ "\u28E4",
+ "\u28E5",
+ "\u28E6",
+ "\u28E7",
+ "\u28A8",
+ "\u28A9",
+ "\u28AA",
+ "\u28AB",
+ "\u28AC",
+ "\u28AD",
+ "\u28AE",
+ "\u28AF",
+ "\u28E8",
+ "\u28E9",
+ "\u28EA",
+ "\u28EB",
+ "\u28EC",
+ "\u28ED",
+ "\u28EE",
+ "\u28EF",
+ "\u28B0",
+ "\u28B1",
+ "\u28B2",
+ "\u28B3",
+ "\u28B4",
+ "\u28B5",
+ "\u28B6",
+ "\u28B7",
+ "\u28F0",
+ "\u28F1",
+ "\u28F2",
+ "\u28F3",
+ "\u28F4",
+ "\u28F5",
+ "\u28F6",
+ "\u28F7",
+ "\u28B8",
+ "\u28B9",
+ "\u28BA",
+ "\u28BB",
+ "\u28BC",
+ "\u28BD",
+ "\u28BE",
+ "\u28BF",
+ "\u28F8",
+ "\u28F9",
+ "\u28FA",
+ "\u28FB",
+ "\u28FC",
+ "\u28FD",
+ "\u28FE",
+ "\u28FF"
+ ]
+ },
+ line: {
+ interval: 130,
+ frames: [
+ "-",
+ "\\",
+ "|",
+ "/"
+ ]
+ },
+ line2: {
+ interval: 100,
+ frames: [
+ "\u2802",
+ "-",
+ "\u2013",
+ "\u2014",
+ "\u2013",
+ "-"
+ ]
+ },
+ pipe: {
+ interval: 100,
+ frames: [
+ "\u2524",
+ "\u2518",
+ "\u2534",
+ "\u2514",
+ "\u251C",
+ "\u250C",
+ "\u252C",
+ "\u2510"
+ ]
+ },
+ simpleDots: {
+ interval: 400,
+ frames: [
+ ". ",
+ ".. ",
+ "...",
+ " "
+ ]
+ },
+ simpleDotsScrolling: {
+ interval: 200,
+ frames: [
+ ". ",
+ ".. ",
+ "...",
+ " ..",
+ " .",
+ " "
+ ]
+ },
+ star: {
+ interval: 70,
+ frames: [
+ "\u2736",
+ "\u2738",
+ "\u2739",
+ "\u273A",
+ "\u2739",
+ "\u2737"
+ ]
+ },
+ star2: {
+ interval: 80,
+ frames: [
+ "+",
+ "x",
+ "*"
+ ]
+ },
+ flip: {
+ interval: 70,
+ frames: [
+ "_",
+ "_",
+ "_",
+ "-",
+ "`",
+ "`",
+ "'",
+ "\xB4",
+ "-",
+ "_",
+ "_",
+ "_"
+ ]
+ },
+ hamburger: {
+ interval: 100,
+ frames: [
+ "\u2631",
+ "\u2632",
+ "\u2634"
+ ]
+ },
+ growVertical: {
+ interval: 120,
+ frames: [
+ "\u2581",
+ "\u2583",
+ "\u2584",
+ "\u2585",
+ "\u2586",
+ "\u2587",
+ "\u2586",
+ "\u2585",
+ "\u2584",
+ "\u2583"
+ ]
+ },
+ growHorizontal: {
+ interval: 120,
+ frames: [
+ "\u258F",
+ "\u258E",
+ "\u258D",
+ "\u258C",
+ "\u258B",
+ "\u258A",
+ "\u2589",
+ "\u258A",
+ "\u258B",
+ "\u258C",
+ "\u258D",
+ "\u258E"
+ ]
+ },
+ balloon: {
+ interval: 140,
+ frames: [
+ " ",
+ ".",
+ "o",
+ "O",
+ "@",
+ "*",
+ " "
+ ]
+ },
+ balloon2: {
+ interval: 120,
+ frames: [
+ ".",
+ "o",
+ "O",
+ "\xB0",
+ "O",
+ "o",
+ "."
+ ]
+ },
+ noise: {
+ interval: 100,
+ frames: [
+ "\u2593",
+ "\u2592",
+ "\u2591"
+ ]
+ },
+ bounce: {
+ interval: 120,
+ frames: [
+ "\u2801",
+ "\u2802",
+ "\u2804",
+ "\u2802"
+ ]
+ },
+ boxBounce: {
+ interval: 120,
+ frames: [
+ "\u2596",
+ "\u2598",
+ "\u259D",
+ "\u2597"
+ ]
+ },
+ boxBounce2: {
+ interval: 100,
+ frames: [
+ "\u258C",
+ "\u2580",
+ "\u2590",
+ "\u2584"
+ ]
+ },
+ triangle: {
+ interval: 50,
+ frames: [
+ "\u25E2",
+ "\u25E3",
+ "\u25E4",
+ "\u25E5"
+ ]
+ },
+ arc: {
+ interval: 100,
+ frames: [
+ "\u25DC",
+ "\u25E0",
+ "\u25DD",
+ "\u25DE",
+ "\u25E1",
+ "\u25DF"
+ ]
+ },
+ circle: {
+ interval: 120,
+ frames: [
+ "\u25E1",
+ "\u2299",
+ "\u25E0"
+ ]
+ },
+ squareCorners: {
+ interval: 180,
+ frames: [
+ "\u25F0",
+ "\u25F3",
+ "\u25F2",
+ "\u25F1"
+ ]
+ },
+ circleQuarters: {
+ interval: 120,
+ frames: [
+ "\u25F4",
+ "\u25F7",
+ "\u25F6",
+ "\u25F5"
+ ]
+ },
+ circleHalves: {
+ interval: 50,
+ frames: [
+ "\u25D0",
+ "\u25D3",
+ "\u25D1",
+ "\u25D2"
+ ]
+ },
+ squish: {
+ interval: 100,
+ frames: [
+ "\u256B",
+ "\u256A"
+ ]
+ },
+ toggle: {
+ interval: 250,
+ frames: [
+ "\u22B6",
+ "\u22B7"
+ ]
+ },
+ toggle2: {
+ interval: 80,
+ frames: [
+ "\u25AB",
+ "\u25AA"
+ ]
+ },
+ toggle3: {
+ interval: 120,
+ frames: [
+ "\u25A1",
+ "\u25A0"
+ ]
+ },
+ toggle4: {
+ interval: 100,
+ frames: [
+ "\u25A0",
+ "\u25A1",
+ "\u25AA",
+ "\u25AB"
+ ]
+ },
+ toggle5: {
+ interval: 100,
+ frames: [
+ "\u25AE",
+ "\u25AF"
+ ]
+ },
+ toggle6: {
+ interval: 300,
+ frames: [
+ "\u101D",
+ "\u1040"
+ ]
+ },
+ toggle7: {
+ interval: 80,
+ frames: [
+ "\u29BE",
+ "\u29BF"
+ ]
+ },
+ toggle8: {
+ interval: 100,
+ frames: [
+ "\u25CD",
+ "\u25CC"
+ ]
+ },
+ toggle9: {
+ interval: 100,
+ frames: [
+ "\u25C9",
+ "\u25CE"
+ ]
+ },
+ toggle10: {
+ interval: 100,
+ frames: [
+ "\u3282",
+ "\u3280",
+ "\u3281"
+ ]
+ },
+ toggle11: {
+ interval: 50,
+ frames: [
+ "\u29C7",
+ "\u29C6"
+ ]
+ },
+ toggle12: {
+ interval: 120,
+ frames: [
+ "\u2617",
+ "\u2616"
+ ]
+ },
+ toggle13: {
+ interval: 80,
+ frames: [
+ "=",
+ "*",
+ "-"
+ ]
+ },
+ arrow: {
+ interval: 100,
+ frames: [
+ "\u2190",
+ "\u2196",
+ "\u2191",
+ "\u2197",
+ "\u2192",
+ "\u2198",
+ "\u2193",
+ "\u2199"
+ ]
+ },
+ arrow2: {
+ interval: 80,
+ frames: [
+ "\u2B06\uFE0F ",
+ "\u2197\uFE0F ",
+ "\u27A1\uFE0F ",
+ "\u2198\uFE0F ",
+ "\u2B07\uFE0F ",
+ "\u2199\uFE0F ",
+ "\u2B05\uFE0F ",
+ "\u2196\uFE0F "
+ ]
+ },
+ arrow3: {
+ interval: 120,
+ frames: [
+ "\u25B9\u25B9\u25B9\u25B9\u25B9",
+ "\u25B8\u25B9\u25B9\u25B9\u25B9",
+ "\u25B9\u25B8\u25B9\u25B9\u25B9",
+ "\u25B9\u25B9\u25B8\u25B9\u25B9",
+ "\u25B9\u25B9\u25B9\u25B8\u25B9",
+ "\u25B9\u25B9\u25B9\u25B9\u25B8"
+ ]
+ },
+ bouncingBar: {
+ interval: 80,
+ frames: [
+ "[ ]",
+ "[= ]",
+ "[== ]",
+ "[=== ]",
+ "[ ===]",
+ "[ ==]",
+ "[ =]",
+ "[ ]",
+ "[ =]",
+ "[ ==]",
+ "[ ===]",
+ "[====]",
+ "[=== ]",
+ "[== ]",
+ "[= ]"
+ ]
+ },
+ bouncingBall: {
+ interval: 80,
+ frames: [
+ "( \u25CF )",
+ "( \u25CF )",
+ "( \u25CF )",
+ "( \u25CF )",
+ "( \u25CF)",
+ "( \u25CF )",
+ "( \u25CF )",
+ "( \u25CF )",
+ "( \u25CF )",
+ "(\u25CF )"
+ ]
+ },
+ smiley: {
+ interval: 200,
+ frames: [
+ "\u{1F604} ",
+ "\u{1F61D} "
+ ]
+ },
+ monkey: {
+ interval: 300,
+ frames: [
+ "\u{1F648} ",
+ "\u{1F648} ",
+ "\u{1F649} ",
+ "\u{1F64A} "
+ ]
+ },
+ hearts: {
+ interval: 100,
+ frames: [
+ "\u{1F49B} ",
+ "\u{1F499} ",
+ "\u{1F49C} ",
+ "\u{1F49A} ",
+ "\u2764\uFE0F "
+ ]
+ },
+ clock: {
+ interval: 100,
+ frames: [
+ "\u{1F55B} ",
+ "\u{1F550} ",
+ "\u{1F551} ",
+ "\u{1F552} ",
+ "\u{1F553} ",
+ "\u{1F554} ",
+ "\u{1F555} ",
+ "\u{1F556} ",
+ "\u{1F557} ",
+ "\u{1F558} ",
+ "\u{1F559} ",
+ "\u{1F55A} "
+ ]
+ },
+ earth: {
+ interval: 180,
+ frames: [
+ "\u{1F30D} ",
+ "\u{1F30E} ",
+ "\u{1F30F} "
+ ]
+ },
+ material: {
+ interval: 17,
+ frames: [
+ "\u2588\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581",
+ "\u2588\u2588\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581",
+ "\u2588\u2588\u2588\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581",
+ "\u2588\u2588\u2588\u2588\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581",
+ "\u2588\u2588\u2588\u2588\u2588\u2588\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581",
+ "\u2588\u2588\u2588\u2588\u2588\u2588\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581",
+ "\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581",
+ "\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581",
+ "\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581",
+ "\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581",
+ "\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581",
+ "\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581",
+ "\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2581\u2581\u2581\u2581\u2581\u2581\u2581",
+ "\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2581\u2581\u2581\u2581\u2581\u2581",
+ "\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2581\u2581\u2581\u2581\u2581\u2581",
+ "\u2581\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2581\u2581\u2581\u2581\u2581",
+ "\u2581\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2581\u2581\u2581\u2581\u2581",
+ "\u2581\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2581\u2581\u2581\u2581\u2581",
+ "\u2581\u2581\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2581\u2581\u2581\u2581",
+ "\u2581\u2581\u2581\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2581\u2581\u2581",
+ "\u2581\u2581\u2581\u2581\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2581\u2581\u2581",
+ "\u2581\u2581\u2581\u2581\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2581\u2581",
+ "\u2581\u2581\u2581\u2581\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2581\u2581",
+ "\u2581\u2581\u2581\u2581\u2581\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2581",
+ "\u2581\u2581\u2581\u2581\u2581\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2581",
+ "\u2581\u2581\u2581\u2581\u2581\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2581",
+ "\u2581\u2581\u2581\u2581\u2581\u2581\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588",
+ "\u2581\u2581\u2581\u2581\u2581\u2581\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588",
+ "\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588",
+ "\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588",
+ "\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588",
+ "\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588",
+ "\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588",
+ "\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588",
+ "\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588",
+ "\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588",
+ "\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588",
+ "\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2588\u2588\u2588\u2588\u2588\u2588\u2588",
+ "\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2588\u2588\u2588\u2588\u2588\u2588",
+ "\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2588\u2588\u2588\u2588\u2588",
+ "\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2588\u2588\u2588\u2588\u2588",
+ "\u2588\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2588\u2588\u2588\u2588",
+ "\u2588\u2588\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2588\u2588\u2588",
+ "\u2588\u2588\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2588\u2588\u2588",
+ "\u2588\u2588\u2588\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2588\u2588\u2588",
+ "\u2588\u2588\u2588\u2588\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2588\u2588",
+ "\u2588\u2588\u2588\u2588\u2588\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2588",
+ "\u2588\u2588\u2588\u2588\u2588\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2588",
+ "\u2588\u2588\u2588\u2588\u2588\u2588\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2588",
+ "\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581",
+ "\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581",
+ "\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581",
+ "\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581",
+ "\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581",
+ "\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581",
+ "\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581",
+ "\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581",
+ "\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2581\u2581\u2581\u2581\u2581\u2581",
+ "\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2581\u2581\u2581\u2581\u2581\u2581",
+ "\u2581\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2581\u2581\u2581\u2581\u2581",
+ "\u2581\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2581\u2581\u2581\u2581\u2581",
+ "\u2581\u2581\u2581\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2581\u2581\u2581\u2581",
+ "\u2581\u2581\u2581\u2581\u2581\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2581\u2581\u2581",
+ "\u2581\u2581\u2581\u2581\u2581\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2581\u2581\u2581",
+ "\u2581\u2581\u2581\u2581\u2581\u2581\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2581\u2581\u2581",
+ "\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2581\u2581\u2581",
+ "\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2581\u2581\u2581",
+ "\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2581\u2581",
+ "\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2581\u2581",
+ "\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2581",
+ "\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2581",
+ "\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2581",
+ "\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2581",
+ "\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2581",
+ "\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2588\u2588\u2588\u2588\u2588\u2588\u2588",
+ "\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2588\u2588\u2588\u2588\u2588\u2588\u2588",
+ "\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2588\u2588\u2588\u2588\u2588",
+ "\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2588\u2588\u2588\u2588",
+ "\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2588\u2588\u2588\u2588",
+ "\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2588\u2588\u2588\u2588",
+ "\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2588\u2588\u2588",
+ "\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2588\u2588\u2588",
+ "\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2588\u2588",
+ "\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2588\u2588",
+ "\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2588\u2588",
+ "\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2588",
+ "\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2588",
+ "\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2588",
+ "\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581",
+ "\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581",
+ "\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581",
+ "\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581"
+ ]
+ },
+ moon: {
+ interval: 80,
+ frames: [
+ "\u{1F311} ",
+ "\u{1F312} ",
+ "\u{1F313} ",
+ "\u{1F314} ",
+ "\u{1F315} ",
+ "\u{1F316} ",
+ "\u{1F317} ",
+ "\u{1F318} "
+ ]
+ },
+ runner: {
+ interval: 140,
+ frames: [
+ "\u{1F6B6} ",
+ "\u{1F3C3} "
+ ]
+ },
+ pong: {
+ interval: 80,
+ frames: [
+ "\u2590\u2802 \u258C",
+ "\u2590\u2808 \u258C",
+ "\u2590 \u2802 \u258C",
+ "\u2590 \u2820 \u258C",
+ "\u2590 \u2840 \u258C",
+ "\u2590 \u2820 \u258C",
+ "\u2590 \u2802 \u258C",
+ "\u2590 \u2808 \u258C",
+ "\u2590 \u2802 \u258C",
+ "\u2590 \u2820 \u258C",
+ "\u2590 \u2840 \u258C",
+ "\u2590 \u2820 \u258C",
+ "\u2590 \u2802 \u258C",
+ "\u2590 \u2808 \u258C",
+ "\u2590 \u2802\u258C",
+ "\u2590 \u2820\u258C",
+ "\u2590 \u2840\u258C",
+ "\u2590 \u2820 \u258C",
+ "\u2590 \u2802 \u258C",
+ "\u2590 \u2808 \u258C",
+ "\u2590 \u2802 \u258C",
+ "\u2590 \u2820 \u258C",
+ "\u2590 \u2840 \u258C",
+ "\u2590 \u2820 \u258C",
+ "\u2590 \u2802 \u258C",
+ "\u2590 \u2808 \u258C",
+ "\u2590 \u2802 \u258C",
+ "\u2590 \u2820 \u258C",
+ "\u2590 \u2840 \u258C",
+ "\u2590\u2820 \u258C"
+ ]
+ },
+ shark: {
+ interval: 120,
+ frames: [
+ "\u2590|\\____________\u258C",
+ "\u2590_|\\___________\u258C",
+ "\u2590__|\\__________\u258C",
+ "\u2590___|\\_________\u258C",
+ "\u2590____|\\________\u258C",
+ "\u2590_____|\\_______\u258C",
+ "\u2590______|\\______\u258C",
+ "\u2590_______|\\_____\u258C",
+ "\u2590________|\\____\u258C",
+ "\u2590_________|\\___\u258C",
+ "\u2590__________|\\__\u258C",
+ "\u2590___________|\\_\u258C",
+ "\u2590____________|\\\u258C",
+ "\u2590____________/|\u258C",
+ "\u2590___________/|_\u258C",
+ "\u2590__________/|__\u258C",
+ "\u2590_________/|___\u258C",
+ "\u2590________/|____\u258C",
+ "\u2590_______/|_____\u258C",
+ "\u2590______/|______\u258C",
+ "\u2590_____/|_______\u258C",
+ "\u2590____/|________\u258C",
+ "\u2590___/|_________\u258C",
+ "\u2590__/|__________\u258C",
+ "\u2590_/|___________\u258C",
+ "\u2590/|____________\u258C"
+ ]
+ },
+ dqpb: {
+ interval: 100,
+ frames: [
+ "d",
+ "q",
+ "p",
+ "b"
+ ]
+ },
+ weather: {
+ interval: 100,
+ frames: [
+ "\u2600\uFE0F ",
+ "\u2600\uFE0F ",
+ "\u2600\uFE0F ",
+ "\u{1F324} ",
+ "\u26C5\uFE0F ",
+ "\u{1F325} ",
+ "\u2601\uFE0F ",
+ "\u{1F327} ",
+ "\u{1F328} ",
+ "\u{1F327} ",
+ "\u{1F328} ",
+ "\u{1F327} ",
+ "\u{1F328} ",
+ "\u26C8 ",
+ "\u{1F328} ",
+ "\u{1F327} ",
+ "\u{1F328} ",
+ "\u2601\uFE0F ",
+ "\u{1F325} ",
+ "\u26C5\uFE0F ",
+ "\u{1F324} ",
+ "\u2600\uFE0F ",
+ "\u2600\uFE0F "
+ ]
+ },
+ christmas: {
+ interval: 400,
+ frames: [
+ "\u{1F332}",
+ "\u{1F384}"
+ ]
+ },
+ grenade: {
+ interval: 80,
+ frames: [
+ "\u060C ",
+ "\u2032 ",
+ " \xB4 ",
+ " \u203E ",
+ " \u2E0C",
+ " \u2E0A",
+ " |",
+ " \u204E",
+ " \u2055",
+ " \u0DF4 ",
+ " \u2053",
+ " ",
+ " ",
+ " "
+ ]
+ },
+ point: {
+ interval: 125,
+ frames: [
+ "\u2219\u2219\u2219",
+ "\u25CF\u2219\u2219",
+ "\u2219\u25CF\u2219",
+ "\u2219\u2219\u25CF",
+ "\u2219\u2219\u2219"
+ ]
+ },
+ layer: {
+ interval: 150,
+ frames: [
+ "-",
+ "=",
+ "\u2261"
+ ]
+ },
+ betaWave: {
+ interval: 80,
+ frames: [
+ "\u03C1\u03B2\u03B2\u03B2\u03B2\u03B2\u03B2",
+ "\u03B2\u03C1\u03B2\u03B2\u03B2\u03B2\u03B2",
+ "\u03B2\u03B2\u03C1\u03B2\u03B2\u03B2\u03B2",
+ "\u03B2\u03B2\u03B2\u03C1\u03B2\u03B2\u03B2",
+ "\u03B2\u03B2\u03B2\u03B2\u03C1\u03B2\u03B2",
+ "\u03B2\u03B2\u03B2\u03B2\u03B2\u03C1\u03B2",
+ "\u03B2\u03B2\u03B2\u03B2\u03B2\u03B2\u03C1"
+ ]
+ },
+ fingerDance: {
+ interval: 160,
+ frames: [
+ "\u{1F918} ",
+ "\u{1F91F} ",
+ "\u{1F596} ",
+ "\u270B ",
+ "\u{1F91A} ",
+ "\u{1F446} "
+ ]
+ },
+ fistBump: {
+ interval: 80,
+ frames: [
+ "\u{1F91C}\u3000\u3000\u3000\u3000\u{1F91B} ",
+ "\u{1F91C}\u3000\u3000\u3000\u3000\u{1F91B} ",
+ "\u{1F91C}\u3000\u3000\u3000\u3000\u{1F91B} ",
+ "\u3000\u{1F91C}\u3000\u3000\u{1F91B}\u3000 ",
+ "\u3000\u3000\u{1F91C}\u{1F91B}\u3000\u3000 ",
+ "\u3000\u{1F91C}\u2728\u{1F91B}\u3000\u3000 ",
+ "\u{1F91C}\u3000\u2728\u3000\u{1F91B}\u3000 "
+ ]
+ },
+ soccerHeader: {
+ interval: 80,
+ frames: [
+ " \u{1F9D1}\u26BD\uFE0F \u{1F9D1} ",
+ "\u{1F9D1} \u26BD\uFE0F \u{1F9D1} ",
+ "\u{1F9D1} \u26BD\uFE0F \u{1F9D1} ",
+ "\u{1F9D1} \u26BD\uFE0F \u{1F9D1} ",
+ "\u{1F9D1} \u26BD\uFE0F \u{1F9D1} ",
+ "\u{1F9D1} \u26BD\uFE0F \u{1F9D1} ",
+ "\u{1F9D1} \u26BD\uFE0F\u{1F9D1} ",
+ "\u{1F9D1} \u26BD\uFE0F \u{1F9D1} ",
+ "\u{1F9D1} \u26BD\uFE0F \u{1F9D1} ",
+ "\u{1F9D1} \u26BD\uFE0F \u{1F9D1} ",
+ "\u{1F9D1} \u26BD\uFE0F \u{1F9D1} ",
+ "\u{1F9D1} \u26BD\uFE0F \u{1F9D1} "
+ ]
+ },
+ mindblown: {
+ interval: 160,
+ frames: [
+ "\u{1F610} ",
+ "\u{1F610} ",
+ "\u{1F62E} ",
+ "\u{1F62E} ",
+ "\u{1F626} ",
+ "\u{1F626} ",
+ "\u{1F627} ",
+ "\u{1F627} ",
+ "\u{1F92F} ",
+ "\u{1F4A5} ",
+ "\u2728 ",
+ "\u3000 ",
+ "\u3000 ",
+ "\u3000 "
+ ]
+ },
+ speaker: {
+ interval: 160,
+ frames: [
+ "\u{1F508} ",
+ "\u{1F509} ",
+ "\u{1F50A} ",
+ "\u{1F509} "
+ ]
+ },
+ orangePulse: {
+ interval: 100,
+ frames: [
+ "\u{1F538} ",
+ "\u{1F536} ",
+ "\u{1F7E0} ",
+ "\u{1F7E0} ",
+ "\u{1F536} "
+ ]
+ },
+ bluePulse: {
+ interval: 100,
+ frames: [
+ "\u{1F539} ",
+ "\u{1F537} ",
+ "\u{1F535} ",
+ "\u{1F535} ",
+ "\u{1F537} "
+ ]
+ },
+ orangeBluePulse: {
+ interval: 100,
+ frames: [
+ "\u{1F538} ",
+ "\u{1F536} ",
+ "\u{1F7E0} ",
+ "\u{1F7E0} ",
+ "\u{1F536} ",
+ "\u{1F539} ",
+ "\u{1F537} ",
+ "\u{1F535} ",
+ "\u{1F535} ",
+ "\u{1F537} "
+ ]
+ },
+ timeTravel: {
+ interval: 100,
+ frames: [
+ "\u{1F55B} ",
+ "\u{1F55A} ",
+ "\u{1F559} ",
+ "\u{1F558} ",
+ "\u{1F557} ",
+ "\u{1F556} ",
+ "\u{1F555} ",
+ "\u{1F554} ",
+ "\u{1F553} ",
+ "\u{1F552} ",
+ "\u{1F551} ",
+ "\u{1F550} "
+ ]
+ },
+ aesthetic: {
+ interval: 80,
+ frames: [
+ "\u25B0\u25B1\u25B1\u25B1\u25B1\u25B1\u25B1",
+ "\u25B0\u25B0\u25B1\u25B1\u25B1\u25B1\u25B1",
+ "\u25B0\u25B0\u25B0\u25B1\u25B1\u25B1\u25B1",
+ "\u25B0\u25B0\u25B0\u25B0\u25B1\u25B1\u25B1",
+ "\u25B0\u25B0\u25B0\u25B0\u25B0\u25B1\u25B1",
+ "\u25B0\u25B0\u25B0\u25B0\u25B0\u25B0\u25B1",
+ "\u25B0\u25B0\u25B0\u25B0\u25B0\u25B0\u25B0",
+ "\u25B0\u25B1\u25B1\u25B1\u25B1\u25B1\u25B1"
+ ]
+ }
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/cli-spinners@2.6.1/node_modules/cli-spinners/index.js
+var require_cli_spinners = __commonJS({
+ "../../node_modules/.pnpm/cli-spinners@2.6.1/node_modules/cli-spinners/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var spinners = Object.assign({}, require_spinners());
+ var spinnersList = Object.keys(spinners);
+ Object.defineProperty(spinners, "random", {
+ get() {
+ const randomIndex = Math.floor(Math.random() * spinnersList.length);
+ const spinnerName = spinnersList[randomIndex];
+ return spinners[spinnerName];
+ }
+ });
+ module2.exports = spinners;
+ }
+});
+
+// ../../node_modules/.pnpm/ink-spinner@4.0.3_ink@3.2.0_react@17.0.2/node_modules/ink-spinner/build/index.js
+var require_build4 = __commonJS({
+ "../../node_modules/.pnpm/ink-spinner@4.0.3_ink@3.2.0_react@17.0.2/node_modules/ink-spinner/build/index.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ Object.defineProperty(exports2, "__esModule", { value: true });
+ var React18 = require_react();
+ var react_1 = require_react();
+ var ink_1 = require_build2();
+ var spinners = require_cli_spinners();
+ var Spinner2 = /* @__PURE__ */ __name(({ type = "dots" }) => {
+ const [frame, setFrame] = react_1.useState(0);
+ const spinner = spinners[type];
+ react_1.useEffect(() => {
+ const timer = setInterval(() => {
+ setFrame((previousFrame) => {
+ const isLastFrame = previousFrame === spinner.frames.length - 1;
+ return isLastFrame ? 0 : previousFrame + 1;
+ });
+ }, spinner.interval);
+ return () => {
+ clearInterval(timer);
+ };
+ }, [spinner]);
+ return React18.createElement(ink_1.Text, null, spinner.frames[frame]);
+ }, "Spinner");
+ exports2.default = Spinner2;
+ }
+});
+
+// ../../node_modules/.pnpm/eventemitter3@4.0.7/node_modules/eventemitter3/index.js
+var require_eventemitter3 = __commonJS({
+ "../../node_modules/.pnpm/eventemitter3@4.0.7/node_modules/eventemitter3/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var has = Object.prototype.hasOwnProperty;
+ var prefix = "~";
+ function Events() {
+ }
+ __name(Events, "Events");
+ if (Object.create) {
+ Events.prototype = /* @__PURE__ */ Object.create(null);
+ if (!new Events().__proto__)
+ prefix = false;
+ }
+ function EE(fn2, context2, once) {
+ this.fn = fn2;
+ this.context = context2;
+ this.once = once || false;
+ }
+ __name(EE, "EE");
+ function addListener(emitter, event, fn2, context2, once) {
+ if (typeof fn2 !== "function") {
+ throw new TypeError("The listener must be a function");
+ }
+ var listener = new EE(fn2, context2 || emitter, once), evt = prefix ? prefix + event : event;
+ if (!emitter._events[evt])
+ emitter._events[evt] = listener, emitter._eventsCount++;
+ else if (!emitter._events[evt].fn)
+ emitter._events[evt].push(listener);
+ else
+ emitter._events[evt] = [emitter._events[evt], listener];
+ return emitter;
+ }
+ __name(addListener, "addListener");
+ function clearEvent(emitter, evt) {
+ if (--emitter._eventsCount === 0)
+ emitter._events = new Events();
+ else
+ delete emitter._events[evt];
+ }
+ __name(clearEvent, "clearEvent");
+ function EventEmitter3() {
+ this._events = new Events();
+ this._eventsCount = 0;
+ }
+ __name(EventEmitter3, "EventEmitter");
+ EventEmitter3.prototype.eventNames = /* @__PURE__ */ __name(function eventNames() {
+ var names = [], events, name;
+ if (this._eventsCount === 0)
+ return names;
+ for (name in events = this._events) {
+ if (has.call(events, name))
+ names.push(prefix ? name.slice(1) : name);
+ }
+ if (Object.getOwnPropertySymbols) {
+ return names.concat(Object.getOwnPropertySymbols(events));
+ }
+ return names;
+ }, "eventNames");
+ EventEmitter3.prototype.listeners = /* @__PURE__ */ __name(function listeners(event) {
+ var evt = prefix ? prefix + event : event, handlers = this._events[evt];
+ if (!handlers)
+ return [];
+ if (handlers.fn)
+ return [handlers.fn];
+ for (var i = 0, l = handlers.length, ee = new Array(l); i < l; i++) {
+ ee[i] = handlers[i].fn;
+ }
+ return ee;
+ }, "listeners");
+ EventEmitter3.prototype.listenerCount = /* @__PURE__ */ __name(function listenerCount(event) {
+ var evt = prefix ? prefix + event : event, listeners = this._events[evt];
+ if (!listeners)
+ return 0;
+ if (listeners.fn)
+ return 1;
+ return listeners.length;
+ }, "listenerCount");
+ EventEmitter3.prototype.emit = /* @__PURE__ */ __name(function emit(event, a1, a2, a3, a4, a5) {
+ var evt = prefix ? prefix + event : event;
+ if (!this._events[evt])
+ return false;
+ var listeners = this._events[evt], len = arguments.length, args, i;
+ if (listeners.fn) {
+ if (listeners.once)
+ this.removeListener(event, listeners.fn, void 0, true);
+ switch (len) {
+ case 1:
+ return listeners.fn.call(listeners.context), true;
+ case 2:
+ return listeners.fn.call(listeners.context, a1), true;
+ case 3:
+ return listeners.fn.call(listeners.context, a1, a2), true;
+ case 4:
+ return listeners.fn.call(listeners.context, a1, a2, a3), true;
+ case 5:
+ return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;
+ case 6:
+ return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;
+ }
+ for (i = 1, args = new Array(len - 1); i < len; i++) {
+ args[i - 1] = arguments[i];
+ }
+ listeners.fn.apply(listeners.context, args);
+ } else {
+ var length = listeners.length, j;
+ for (i = 0; i < length; i++) {
+ if (listeners[i].once)
+ this.removeListener(event, listeners[i].fn, void 0, true);
+ switch (len) {
+ case 1:
+ listeners[i].fn.call(listeners[i].context);
+ break;
+ case 2:
+ listeners[i].fn.call(listeners[i].context, a1);
+ break;
+ case 3:
+ listeners[i].fn.call(listeners[i].context, a1, a2);
+ break;
+ case 4:
+ listeners[i].fn.call(listeners[i].context, a1, a2, a3);
+ break;
+ default:
+ if (!args)
+ for (j = 1, args = new Array(len - 1); j < len; j++) {
+ args[j - 1] = arguments[j];
+ }
+ listeners[i].fn.apply(listeners[i].context, args);
+ }
+ }
+ }
+ return true;
+ }, "emit");
+ EventEmitter3.prototype.on = /* @__PURE__ */ __name(function on(event, fn2, context2) {
+ return addListener(this, event, fn2, context2, false);
+ }, "on");
+ EventEmitter3.prototype.once = /* @__PURE__ */ __name(function once(event, fn2, context2) {
+ return addListener(this, event, fn2, context2, true);
+ }, "once");
+ EventEmitter3.prototype.removeListener = /* @__PURE__ */ __name(function removeListener(event, fn2, context2, once) {
+ var evt = prefix ? prefix + event : event;
+ if (!this._events[evt])
+ return this;
+ if (!fn2) {
+ clearEvent(this, evt);
+ return this;
+ }
+ var listeners = this._events[evt];
+ if (listeners.fn) {
+ if (listeners.fn === fn2 && (!once || listeners.once) && (!context2 || listeners.context === context2)) {
+ clearEvent(this, evt);
+ }
+ } else {
+ for (var i = 0, events = [], length = listeners.length; i < length; i++) {
+ if (listeners[i].fn !== fn2 || once && !listeners[i].once || context2 && listeners[i].context !== context2) {
+ events.push(listeners[i]);
+ }
+ }
+ if (events.length)
+ this._events[evt] = events.length === 1 ? events[0] : events;
+ else
+ clearEvent(this, evt);
+ }
+ return this;
+ }, "removeListener");
+ EventEmitter3.prototype.removeAllListeners = /* @__PURE__ */ __name(function removeAllListeners(event) {
+ var evt;
+ if (event) {
+ evt = prefix ? prefix + event : event;
+ if (this._events[evt])
+ clearEvent(this, evt);
+ } else {
+ this._events = new Events();
+ this._eventsCount = 0;
+ }
+ return this;
+ }, "removeAllListeners");
+ EventEmitter3.prototype.off = EventEmitter3.prototype.removeListener;
+ EventEmitter3.prototype.addListener = EventEmitter3.prototype.on;
+ EventEmitter3.prefixed = prefix;
+ EventEmitter3.EventEmitter = EventEmitter3;
+ if ("undefined" !== typeof module2) {
+ module2.exports = EventEmitter3;
+ }
+ }
+});
+
+// ../../node_modules/.pnpm/minimatch@5.1.0/node_modules/minimatch/lib/path.js
+var require_path = __commonJS({
+ "../../node_modules/.pnpm/minimatch@5.1.0/node_modules/minimatch/lib/path.js"(exports2, module2) {
+ init_import_meta_url();
+ var isWindows2 = typeof process === "object" && process && process.platform === "win32";
+ module2.exports = isWindows2 ? { sep: "\\" } : { sep: "/" };
+ }
+});
+
+// ../../node_modules/.pnpm/brace-expansion@2.0.1/node_modules/brace-expansion/index.js
+var require_brace_expansion2 = __commonJS({
+ "../../node_modules/.pnpm/brace-expansion@2.0.1/node_modules/brace-expansion/index.js"(exports2, module2) {
+ init_import_meta_url();
+ var balanced = require_balanced_match();
+ module2.exports = expandTop;
+ var escSlash = "\0SLASH" + Math.random() + "\0";
+ var escOpen = "\0OPEN" + Math.random() + "\0";
+ var escClose = "\0CLOSE" + Math.random() + "\0";
+ var escComma = "\0COMMA" + Math.random() + "\0";
+ var escPeriod = "\0PERIOD" + Math.random() + "\0";
+ function numeric(str) {
+ return parseInt(str, 10) == str ? parseInt(str, 10) : str.charCodeAt(0);
+ }
+ __name(numeric, "numeric");
+ function escapeBraces(str) {
+ return str.split("\\\\").join(escSlash).split("\\{").join(escOpen).split("\\}").join(escClose).split("\\,").join(escComma).split("\\.").join(escPeriod);
+ }
+ __name(escapeBraces, "escapeBraces");
+ function unescapeBraces(str) {
+ return str.split(escSlash).join("\\").split(escOpen).join("{").split(escClose).join("}").split(escComma).join(",").split(escPeriod).join(".");
+ }
+ __name(unescapeBraces, "unescapeBraces");
+ function parseCommaParts(str) {
+ if (!str)
+ return [""];
+ var parts = [];
+ var m = balanced("{", "}", str);
+ if (!m)
+ return str.split(",");
+ var pre = m.pre;
+ var body = m.body;
+ var post = m.post;
+ var p = pre.split(",");
+ p[p.length - 1] += "{" + body + "}";
+ var postParts = parseCommaParts(post);
+ if (post.length) {
+ p[p.length - 1] += postParts.shift();
+ p.push.apply(p, postParts);
+ }
+ parts.push.apply(parts, p);
+ return parts;
+ }
+ __name(parseCommaParts, "parseCommaParts");
+ function expandTop(str) {
+ if (!str)
+ return [];
+ if (str.substr(0, 2) === "{}") {
+ str = "\\{\\}" + str.substr(2);
+ }
+ return expand(escapeBraces(str), true).map(unescapeBraces);
+ }
+ __name(expandTop, "expandTop");
+ function embrace(str) {
+ return "{" + str + "}";
+ }
+ __name(embrace, "embrace");
+ function isPadded(el) {
+ return /^-?0\d/.test(el);
+ }
+ __name(isPadded, "isPadded");
+ function lte(i, y) {
+ return i <= y;
+ }
+ __name(lte, "lte");
+ function gte(i, y) {
+ return i >= y;
+ }
+ __name(gte, "gte");
+ function expand(str, isTop) {
+ var expansions = [];
+ var m = balanced("{", "}", str);
+ if (!m)
+ return [str];
+ var pre = m.pre;
+ var post = m.post.length ? expand(m.post, false) : [""];
+ if (/\$$/.test(m.pre)) {
+ for (var k = 0; k < post.length; k++) {
+ var expansion = pre + "{" + m.body + "}" + post[k];
+ expansions.push(expansion);
+ }
+ } else {
+ var isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
+ var isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
+ var isSequence = isNumericSequence || isAlphaSequence;
+ var isOptions = m.body.indexOf(",") >= 0;
+ if (!isSequence && !isOptions) {
+ if (m.post.match(/,.*\}/)) {
+ str = m.pre + "{" + m.body + escClose + m.post;
+ return expand(str);
+ }
+ return [str];
+ }
+ var n;
+ if (isSequence) {
+ n = m.body.split(/\.\./);
+ } else {
+ n = parseCommaParts(m.body);
+ if (n.length === 1) {
+ n = expand(n[0], false).map(embrace);
+ if (n.length === 1) {
+ return post.map(function(p) {
+ return m.pre + n[0] + p;
+ });
+ }
+ }
+ }
+ var N;
+ if (isSequence) {
+ var x = numeric(n[0]);
+ var y = numeric(n[1]);
+ var width = Math.max(n[0].length, n[1].length);
+ var incr = n.length == 3 ? Math.abs(numeric(n[2])) : 1;
+ var test = lte;
+ var reverse = y < x;
+ if (reverse) {
+ incr *= -1;
+ test = gte;
+ }
+ var pad2 = n.some(isPadded);
+ N = [];
+ for (var i = x; test(i, y); i += incr) {
+ var c;
+ if (isAlphaSequence) {
+ c = String.fromCharCode(i);
+ if (c === "\\")
+ c = "";
+ } else {
+ c = String(i);
+ if (pad2) {
+ var need = width - c.length;
+ if (need > 0) {
+ var z = new Array(need + 1).join("0");
+ if (i < 0)
+ c = "-" + z + c.slice(1);
+ else
+ c = z + c;
+ }
+ }
+ }
+ N.push(c);
+ }
+ } else {
+ N = [];
+ for (var j = 0; j < n.length; j++) {
+ N.push.apply(N, expand(n[j], false));
+ }
+ }
+ for (var j = 0; j < N.length; j++) {
+ for (var k = 0; k < post.length; k++) {
+ var expansion = pre + N[j] + post[k];
+ if (!isTop || isSequence || expansion)
+ expansions.push(expansion);
+ }
+ }
+ }
+ return expansions;
+ }
+ __name(expand, "expand");
+ }
+});
+
+// ../../node_modules/.pnpm/minimatch@5.1.0/node_modules/minimatch/minimatch.js
+var require_minimatch2 = __commonJS({
+ "../../node_modules/.pnpm/minimatch@5.1.0/node_modules/minimatch/minimatch.js"(exports2, module2) {
+ init_import_meta_url();
+ var minimatch = module2.exports = (p, pattern, options14 = {}) => {
+ assertValidPattern(pattern);
+ if (!options14.nocomment && pattern.charAt(0) === "#") {
+ return false;
+ }
+ return new Minimatch2(pattern, options14).match(p);
+ };
+ module2.exports = minimatch;
+ var path45 = require_path();
+ minimatch.sep = path45.sep;
+ var GLOBSTAR = Symbol("globstar **");
+ minimatch.GLOBSTAR = GLOBSTAR;
+ var expand = require_brace_expansion2();
+ var plTypes = {
+ "!": { open: "(?:(?!(?:", close: "))[^/]*?)" },
+ "?": { open: "(?:", close: ")?" },
+ "+": { open: "(?:", close: ")+" },
+ "*": { open: "(?:", close: ")*" },
+ "@": { open: "(?:", close: ")" }
+ };
+ var qmark = "[^/]";
+ var star = qmark + "*?";
+ var twoStarDot = "(?:(?!(?:\\/|^)(?:\\.{1,2})($|\\/)).)*?";
+ var twoStarNoDot = "(?:(?!(?:\\/|^)\\.).)*?";
+ var charSet = /* @__PURE__ */ __name((s) => s.split("").reduce((set, c) => {
+ set[c] = true;
+ return set;
+ }, {}), "charSet");
+ var reSpecials = charSet("().*{}+?[]^$\\!");
+ var addPatternStartSet = charSet("[.(");
+ var slashSplit = /\/+/;
+ minimatch.filter = (pattern, options14 = {}) => (p, i, list) => minimatch(p, pattern, options14);
+ var ext = /* @__PURE__ */ __name((a, b = {}) => {
+ const t2 = {};
+ Object.keys(a).forEach((k) => t2[k] = a[k]);
+ Object.keys(b).forEach((k) => t2[k] = b[k]);
+ return t2;
+ }, "ext");
+ minimatch.defaults = (def) => {
+ if (!def || typeof def !== "object" || !Object.keys(def).length) {
+ return minimatch;
+ }
+ const orig = minimatch;
+ const m = /* @__PURE__ */ __name((p, pattern, options14) => orig(p, pattern, ext(def, options14)), "m");
+ m.Minimatch = /* @__PURE__ */ __name(class Minimatch extends orig.Minimatch {
+ constructor(pattern, options14) {
+ super(pattern, ext(def, options14));
+ }
+ }, "Minimatch");
+ m.Minimatch.defaults = (options14) => orig.defaults(ext(def, options14)).Minimatch;
+ m.filter = (pattern, options14) => orig.filter(pattern, ext(def, options14));
+ m.defaults = (options14) => orig.defaults(ext(def, options14));
+ m.makeRe = (pattern, options14) => orig.makeRe(pattern, ext(def, options14));
+ m.braceExpand = (pattern, options14) => orig.braceExpand(pattern, ext(def, options14));
+ m.match = (list, pattern, options14) => orig.match(list, pattern, ext(def, options14));
+ return m;
+ };
+ minimatch.braceExpand = (pattern, options14) => braceExpand(pattern, options14);
+ var braceExpand = /* @__PURE__ */ __name((pattern, options14 = {}) => {
+ assertValidPattern(pattern);
+ if (options14.nobrace || !/\{(?:(?!\{).)*\}/.test(pattern)) {
+ return [pattern];
+ }
+ return expand(pattern);
+ }, "braceExpand");
+ var MAX_PATTERN_LENGTH = 1024 * 64;
+ var assertValidPattern = /* @__PURE__ */ __name((pattern) => {
+ if (typeof pattern !== "string") {
+ throw new TypeError("invalid pattern");
+ }
+ if (pattern.length > MAX_PATTERN_LENGTH) {
+ throw new TypeError("pattern is too long");
+ }
+ }, "assertValidPattern");
+ var SUBPARSE = Symbol("subparse");
+ minimatch.makeRe = (pattern, options14) => new Minimatch2(pattern, options14 || {}).makeRe();
+ minimatch.match = (list, pattern, options14 = {}) => {
+ const mm = new Minimatch2(pattern, options14);
+ list = list.filter((f) => mm.match(f));
+ if (mm.options.nonull && !list.length) {
+ list.push(pattern);
+ }
+ return list;
+ };
+ var globUnescape = /* @__PURE__ */ __name((s) => s.replace(/\\(.)/g, "$1"), "globUnescape");
+ var regExpEscape = /* @__PURE__ */ __name((s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&"), "regExpEscape");
+ var Minimatch2 = class {
+ constructor(pattern, options14) {
+ assertValidPattern(pattern);
+ if (!options14)
+ options14 = {};
+ this.options = options14;
+ this.set = [];
+ this.pattern = pattern;
+ this.windowsPathsNoEscape = !!options14.windowsPathsNoEscape || options14.allowWindowsEscape === false;
+ if (this.windowsPathsNoEscape) {
+ this.pattern = this.pattern.replace(/\\/g, "/");
+ }
+ this.regexp = null;
+ this.negate = false;
+ this.comment = false;
+ this.empty = false;
+ this.partial = !!options14.partial;
+ this.make();
+ }
+ debug() {
+ }
+ make() {
+ const pattern = this.pattern;
+ const options14 = this.options;
+ if (!options14.nocomment && pattern.charAt(0) === "#") {
+ this.comment = true;
+ return;
+ }
+ if (!pattern) {
+ this.empty = true;
+ return;
+ }
+ this.parseNegate();
+ let set = this.globSet = this.braceExpand();
+ if (options14.debug)
+ this.debug = (...args) => console.error(...args);
+ this.debug(this.pattern, set);
+ set = this.globParts = set.map((s) => s.split(slashSplit));
+ this.debug(this.pattern, set);
+ set = set.map((s, si2, set2) => s.map(this.parse, this));
+ this.debug(this.pattern, set);
+ set = set.filter((s) => s.indexOf(false) === -1);
+ this.debug(this.pattern, set);
+ this.set = set;
+ }
+ parseNegate() {
+ if (this.options.nonegate)
+ return;
+ const pattern = this.pattern;
+ let negate = false;
+ let negateOffset = 0;
+ for (let i = 0; i < pattern.length && pattern.charAt(i) === "!"; i++) {
+ negate = !negate;
+ negateOffset++;
+ }
+ if (negateOffset)
+ this.pattern = pattern.substr(negateOffset);
+ this.negate = negate;
+ }
+ // set partial to true to test if, for example,
+ // "/a/b" matches the start of "/*/b/*/d"
+ // Partial means, if you run out of file before you run
+ // out of pattern, then that's fine, as long as all
+ // the parts match.
+ matchOne(file, pattern, partial) {
+ var options14 = this.options;
+ this.debug(
+ "matchOne",
+ { "this": this, file, pattern }
+ );
+ this.debug("matchOne", file.length, pattern.length);
+ for (var fi = 0, pi = 0, fl = file.length, pl2 = pattern.length; fi < fl && pi < pl2; fi++, pi++) {
+ this.debug("matchOne loop");
+ var p = pattern[pi];
+ var f = file[fi];
+ this.debug(pattern, p, f);
+ if (p === false)
+ return false;
+ if (p === GLOBSTAR) {
+ this.debug("GLOBSTAR", [pattern, p, f]);
+ var fr2 = fi;
+ var pr = pi + 1;
+ if (pr === pl2) {
+ this.debug("** at the end");
+ for (; fi < fl; fi++) {
+ if (file[fi] === "." || file[fi] === ".." || !options14.dot && file[fi].charAt(0) === ".")
+ return false;
+ }
+ return true;
+ }
+ while (fr2 < fl) {
+ var swallowee = file[fr2];
+ this.debug("\nglobstar while", file, fr2, pattern, pr, swallowee);
+ if (this.matchOne(file.slice(fr2), pattern.slice(pr), partial)) {
+ this.debug("globstar found match!", fr2, fl, swallowee);
+ return true;
+ } else {
+ if (swallowee === "." || swallowee === ".." || !options14.dot && swallowee.charAt(0) === ".") {
+ this.debug("dot detected!", file, fr2, pattern, pr);
+ break;
+ }
+ this.debug("globstar swallow a segment, and continue");
+ fr2++;
+ }
+ }
+ if (partial) {
+ this.debug("\n>>> no match, partial?", file, fr2, pattern, pr);
+ if (fr2 === fl)
+ return true;
+ }
+ return false;
+ }
+ var hit;
+ if (typeof p === "string") {
+ hit = f === p;
+ this.debug("string match", p, f, hit);
+ } else {
+ hit = f.match(p);
+ this.debug("pattern match", p, f, hit);
+ }
+ if (!hit)
+ return false;
+ }
+ if (fi === fl && pi === pl2) {
+ return true;
+ } else if (fi === fl) {
+ return partial;
+ } else if (pi === pl2) {
+ return fi === fl - 1 && file[fi] === "";
+ }
+ throw new Error("wtf?");
+ }
+ braceExpand() {
+ return braceExpand(this.pattern, this.options);
+ }
+ parse(pattern, isSub) {
+ assertValidPattern(pattern);
+ const options14 = this.options;
+ if (pattern === "**") {
+ if (!options14.noglobstar)
+ return GLOBSTAR;
+ else
+ pattern = "*";
+ }
+ if (pattern === "")
+ return "";
+ let re = "";
+ let hasMagic = !!options14.nocase;
+ let escaping = false;
+ const patternListStack = [];
+ const negativeLists = [];
+ let stateChar;
+ let inClass = false;
+ let reClassStart = -1;
+ let classStart = -1;
+ let cs2;
+ let pl2;
+ let sp;
+ const patternStart = pattern.charAt(0) === "." ? "" : options14.dot ? "(?!(?:^|\\/)\\.{1,2}(?:$|\\/))" : "(?!\\.)";
+ const clearStateChar = /* @__PURE__ */ __name(() => {
+ if (stateChar) {
+ switch (stateChar) {
+ case "*":
+ re += star;
+ hasMagic = true;
+ break;
+ case "?":
+ re += qmark;
+ hasMagic = true;
+ break;
+ default:
+ re += "\\" + stateChar;
+ break;
+ }
+ this.debug("clearStateChar %j %j", stateChar, re);
+ stateChar = false;
+ }
+ }, "clearStateChar");
+ for (let i = 0, c; i < pattern.length && (c = pattern.charAt(i)); i++) {
+ this.debug("%s %s %s %j", pattern, i, re, c);
+ if (escaping) {
+ if (c === "/") {
+ return false;
+ }
+ if (reSpecials[c]) {
+ re += "\\";
+ }
+ re += c;
+ escaping = false;
+ continue;
+ }
+ switch (c) {
+ case "/": {
+ return false;
+ }
+ case "\\":
+ clearStateChar();
+ escaping = true;
+ continue;
+ case "?":
+ case "*":
+ case "+":
+ case "@":
+ case "!":
+ this.debug("%s %s %s %j <-- stateChar", pattern, i, re, c);
+ if (inClass) {
+ this.debug(" in class");
+ if (c === "!" && i === classStart + 1)
+ c = "^";
+ re += c;
+ continue;
+ }
+ this.debug("call clearStateChar %j", stateChar);
+ clearStateChar();
+ stateChar = c;
+ if (options14.noext)
+ clearStateChar();
+ continue;
+ case "(":
+ if (inClass) {
+ re += "(";
+ continue;
+ }
+ if (!stateChar) {
+ re += "\\(";
+ continue;
+ }
+ patternListStack.push({
+ type: stateChar,
+ start: i - 1,
+ reStart: re.length,
+ open: plTypes[stateChar].open,
+ close: plTypes[stateChar].close
+ });
+ re += stateChar === "!" ? "(?:(?!(?:" : "(?:";
+ this.debug("plType %j %j", stateChar, re);
+ stateChar = false;
+ continue;
+ case ")":
+ if (inClass || !patternListStack.length) {
+ re += "\\)";
+ continue;
+ }
+ clearStateChar();
+ hasMagic = true;
+ pl2 = patternListStack.pop();
+ re += pl2.close;
+ if (pl2.type === "!") {
+ negativeLists.push(pl2);
+ }
+ pl2.reEnd = re.length;
+ continue;
+ case "|":
+ if (inClass || !patternListStack.length) {
+ re += "\\|";
+ continue;
+ }
+ clearStateChar();
+ re += "|";
+ continue;
+ case "[":
+ clearStateChar();
+ if (inClass) {
+ re += "\\" + c;
+ continue;
+ }
+ inClass = true;
+ classStart = i;
+ reClassStart = re.length;
+ re += c;
+ continue;
+ case "]":
+ if (i === classStart + 1 || !inClass) {
+ re += "\\" + c;
+ continue;
+ }
+ cs2 = pattern.substring(classStart + 1, i);
+ try {
+ RegExp("[" + cs2 + "]");
+ } catch (er) {
+ sp = this.parse(cs2, SUBPARSE);
+ re = re.substr(0, reClassStart) + "\\[" + sp[0] + "\\]";
+ hasMagic = hasMagic || sp[1];
+ inClass = false;
+ continue;
+ }
+ hasMagic = true;
+ inClass = false;
+ re += c;
+ continue;
+ default:
+ clearStateChar();
+ if (reSpecials[c] && !(c === "^" && inClass)) {
+ re += "\\";
+ }
+ re += c;
+ break;
+ }
+ }
+ if (inClass) {
+ cs2 = pattern.substr(classStart + 1);
+ sp = this.parse(cs2, SUBPARSE);
+ re = re.substr(0, reClassStart) + "\\[" + sp[0];
+ hasMagic = hasMagic || sp[1];
+ }
+ for (pl2 = patternListStack.pop(); pl2; pl2 = patternListStack.pop()) {
+ let tail;
+ tail = re.slice(pl2.reStart + pl2.open.length);
+ this.debug("setting tail", re, pl2);
+ tail = tail.replace(/((?:\\{2}){0,64})(\\?)\|/g, (_2, $1, $2) => {
+ if (!$2) {
+ $2 = "\\";
+ }
+ return $1 + $1 + $2 + "|";
+ });
+ this.debug("tail=%j\n %s", tail, tail, pl2, re);
+ const t2 = pl2.type === "*" ? star : pl2.type === "?" ? qmark : "\\" + pl2.type;
+ hasMagic = true;
+ re = re.slice(0, pl2.reStart) + t2 + "\\(" + tail;
+ }
+ clearStateChar();
+ if (escaping) {
+ re += "\\\\";
+ }
+ const addPatternStart = addPatternStartSet[re.charAt(0)];
+ for (let n = negativeLists.length - 1; n > -1; n--) {
+ const nl = negativeLists[n];
+ const nlBefore = re.slice(0, nl.reStart);
+ const nlFirst = re.slice(nl.reStart, nl.reEnd - 8);
+ let nlAfter = re.slice(nl.reEnd);
+ const nlLast = re.slice(nl.reEnd - 8, nl.reEnd) + nlAfter;
+ const openParensBefore = nlBefore.split("(").length - 1;
+ let cleanAfter = nlAfter;
+ for (let i = 0; i < openParensBefore; i++) {
+ cleanAfter = cleanAfter.replace(/\)[+*?]?/, "");
+ }
+ nlAfter = cleanAfter;
+ const dollar = nlAfter === "" && isSub !== SUBPARSE ? "$" : "";
+ re = nlBefore + nlFirst + nlAfter + dollar + nlLast;
+ }
+ if (re !== "" && hasMagic) {
+ re = "(?=.)" + re;
+ }
+ if (addPatternStart) {
+ re = patternStart + re;
+ }
+ if (isSub === SUBPARSE) {
+ return [re, hasMagic];
+ }
+ if (!hasMagic) {
+ return globUnescape(pattern);
+ }
+ const flags = options14.nocase ? "i" : "";
+ try {
+ return Object.assign(new RegExp("^" + re + "$", flags), {
+ _glob: pattern,
+ _src: re
+ });
+ } catch (er) {
+ return new RegExp("$.");
+ }
+ }
+ makeRe() {
+ if (this.regexp || this.regexp === false)
+ return this.regexp;
+ const set = this.set;
+ if (!set.length) {
+ this.regexp = false;
+ return this.regexp;
+ }
+ const options14 = this.options;
+ const twoStar = options14.noglobstar ? star : options14.dot ? twoStarDot : twoStarNoDot;
+ const flags = options14.nocase ? "i" : "";
+ let re = set.map((pattern) => {
+ pattern = pattern.map(
+ (p) => typeof p === "string" ? regExpEscape(p) : p === GLOBSTAR ? GLOBSTAR : p._src
+ ).reduce((set2, p) => {
+ if (!(set2[set2.length - 1] === GLOBSTAR && p === GLOBSTAR)) {
+ set2.push(p);
+ }
+ return set2;
+ }, []);
+ pattern.forEach((p, i) => {
+ if (p !== GLOBSTAR || pattern[i - 1] === GLOBSTAR) {
+ return;
+ }
+ if (i === 0) {
+ if (pattern.length > 1) {
+ pattern[i + 1] = "(?:\\/|" + twoStar + "\\/)?" + pattern[i + 1];
+ } else {
+ pattern[i] = twoStar;
+ }
+ } else if (i === pattern.length - 1) {
+ pattern[i - 1] += "(?:\\/|" + twoStar + ")?";
+ } else {
+ pattern[i - 1] += "(?:\\/|\\/" + twoStar + "\\/)" + pattern[i + 1];
+ pattern[i + 1] = GLOBSTAR;
+ }
+ });
+ return pattern.filter((p) => p !== GLOBSTAR).join("/");
+ }).join("|");
+ re = "^(?:" + re + ")$";
+ if (this.negate)
+ re = "^(?!" + re + ").*$";
+ try {
+ this.regexp = new RegExp(re, flags);
+ } catch (ex) {
+ this.regexp = false;
+ }
+ return this.regexp;
+ }
+ match(f, partial = this.partial) {
+ this.debug("match", f, this.pattern);
+ if (this.comment)
+ return false;
+ if (this.empty)
+ return f === "";
+ if (f === "/" && partial)
+ return true;
+ const options14 = this.options;
+ if (path45.sep !== "/") {
+ f = f.split(path45.sep).join("/");
+ }
+ f = f.split(slashSplit);
+ this.debug(this.pattern, "split", f);
+ const set = this.set;
+ this.debug(this.pattern, "set", set);
+ let filename;
+ for (let i = f.length - 1; i >= 0; i--) {
+ filename = f[i];
+ if (filename)
+ break;
+ }
+ for (let i = 0; i < set.length; i++) {
+ const pattern = set[i];
+ let file = f;
+ if (options14.matchBase && pattern.length === 1) {
+ file = [filename];
+ }
+ const hit = this.matchOne(file, pattern, partial);
+ if (hit) {
+ if (options14.flipNegate)
+ return true;
+ return !this.negate;
+ }
+ }
+ if (options14.flipNegate)
+ return false;
+ return this.negate;
+ }
+ static defaults(def) {
+ return minimatch.defaults(def).Minimatch;
+ }
+ };
+ __name(Minimatch2, "Minimatch");
+ minimatch.Minimatch = Minimatch2;
+ }
+});
+
+// ../../node_modules/.pnpm/ini@1.3.8/node_modules/ini/ini.js
+var require_ini = __commonJS({
+ "../../node_modules/.pnpm/ini@1.3.8/node_modules/ini/ini.js"(exports2) {
+ init_import_meta_url();
+ exports2.parse = exports2.decode = decode;
+ exports2.stringify = exports2.encode = encode;
+ exports2.safe = safe;
+ exports2.unsafe = unsafe;
+ var eol = typeof process !== "undefined" && process.platform === "win32" ? "\r\n" : "\n";
+ function encode(obj, opt) {
+ var children = [];
+ var out = "";
+ if (typeof opt === "string") {
+ opt = {
+ section: opt,
+ whitespace: false
+ };
+ } else {
+ opt = opt || {};
+ opt.whitespace = opt.whitespace === true;
+ }
+ var separator = opt.whitespace ? " = " : "=";
+ Object.keys(obj).forEach(function(k, _2, __) {
+ var val = obj[k];
+ if (val && Array.isArray(val)) {
+ val.forEach(function(item) {
+ out += safe(k + "[]") + separator + safe(item) + "\n";
+ });
+ } else if (val && typeof val === "object")
+ children.push(k);
+ else
+ out += safe(k) + separator + safe(val) + eol;
+ });
+ if (opt.section && out.length)
+ out = "[" + safe(opt.section) + "]" + eol + out;
+ children.forEach(function(k, _2, __) {
+ var nk = dotSplit(k).join("\\.");
+ var section = (opt.section ? opt.section + "." : "") + nk;
+ var child = encode(obj[k], {
+ section,
+ whitespace: opt.whitespace
+ });
+ if (out.length && child.length)
+ out += eol;
+ out += child;
+ });
+ return out;
+ }
+ __name(encode, "encode");
+ function dotSplit(str) {
+ return str.replace(/\1/g, "LITERAL\\1LITERAL").replace(/\\\./g, "").split(/\./).map(function(part) {
+ return part.replace(/\1/g, "\\.").replace(/\2LITERAL\\1LITERAL\2/g, "");
+ });
+ }
+ __name(dotSplit, "dotSplit");
+ function decode(str) {
+ var out = {};
+ var p = out;
+ var section = null;
+ var re = /^\[([^\]]*)\]$|^([^=]+)(=(.*))?$/i;
+ var lines = str.split(/[\r\n]+/g);
+ lines.forEach(function(line, _2, __) {
+ if (!line || line.match(/^\s*[;#]/))
+ return;
+ var match = line.match(re);
+ if (!match)
+ return;
+ if (match[1] !== void 0) {
+ section = unsafe(match[1]);
+ if (section === "__proto__") {
+ p = {};
+ return;
+ }
+ p = out[section] = out[section] || {};
+ return;
+ }
+ var key = unsafe(match[2]);
+ if (key === "__proto__")
+ return;
+ var value = match[3] ? unsafe(match[4]) : true;
+ switch (value) {
+ case "true":
+ case "false":
+ case "null":
+ value = JSON.parse(value);
+ }
+ if (key.length > 2 && key.slice(-2) === "[]") {
+ key = key.substring(0, key.length - 2);
+ if (key === "__proto__")
+ return;
+ if (!p[key])
+ p[key] = [];
+ else if (!Array.isArray(p[key]))
+ p[key] = [p[key]];
+ }
+ if (Array.isArray(p[key]))
+ p[key].push(value);
+ else
+ p[key] = value;
+ });
+ Object.keys(out).filter(function(k, _2, __) {
+ if (!out[k] || typeof out[k] !== "object" || Array.isArray(out[k]))
+ return false;
+ var parts = dotSplit(k);
+ var p2 = out;
+ var l = parts.pop();
+ var nl = l.replace(/\\\./g, ".");
+ parts.forEach(function(part, _3, __2) {
+ if (part === "__proto__")
+ return;
+ if (!p2[part] || typeof p2[part] !== "object")
+ p2[part] = {};
+ p2 = p2[part];
+ });
+ if (p2 === out && nl === l)
+ return false;
+ p2[nl] = out[k];
+ return true;
+ }).forEach(function(del, _2, __) {
+ delete out[del];
+ });
+ return out;
+ }
+ __name(decode, "decode");
+ function isQuoted(val) {
+ return val.charAt(0) === '"' && val.slice(-1) === '"' || val.charAt(0) === "'" && val.slice(-1) === "'";
+ }
+ __name(isQuoted, "isQuoted");
+ function safe(val) {
+ return typeof val !== "string" || val.match(/[=\r\n]/) || val.match(/^\[/) || val.length > 1 && isQuoted(val) || val !== val.trim() ? JSON.stringify(val) : val.replace(/;/g, "\\;").replace(/#/g, "\\#");
+ }
+ __name(safe, "safe");
+ function unsafe(val, doUnesc) {
+ val = (val || "").trim();
+ if (isQuoted(val)) {
+ if (val.charAt(0) === "'")
+ val = val.substr(1, val.length - 2);
+ try {
+ val = JSON.parse(val);
+ } catch (_2) {
+ }
+ } else {
+ var esc = false;
+ var unesc = "";
+ for (var i = 0, l = val.length; i < l; i++) {
+ var c = val.charAt(i);
+ if (esc) {
+ if ("\\;#".indexOf(c) !== -1)
+ unesc += c;
+ else
+ unesc += "\\" + c;
+ esc = false;
+ } else if (";#".indexOf(c) !== -1)
+ break;
+ else if (c === "\\")
+ esc = true;
+ else
+ unesc += c;
+ }
+ if (esc)
+ unesc += "\\";
+ return unesc.trim();
+ }
+ return val;
+ }
+ __name(unsafe, "unsafe");
+ }
+});
+
+// ../../node_modules/.pnpm/strip-json-comments@2.0.1/node_modules/strip-json-comments/index.js
+var require_strip_json_comments = __commonJS({
+ "../../node_modules/.pnpm/strip-json-comments@2.0.1/node_modules/strip-json-comments/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ var singleComment = 1;
+ var multiComment = 2;
+ function stripWithoutWhitespace() {
+ return "";
+ }
+ __name(stripWithoutWhitespace, "stripWithoutWhitespace");
+ function stripWithWhitespace(str, start, end) {
+ return str.slice(start, end).replace(/\S/g, " ");
+ }
+ __name(stripWithWhitespace, "stripWithWhitespace");
+ module2.exports = function(str, opts) {
+ opts = opts || {};
+ var currentChar;
+ var nextChar;
+ var insideString = false;
+ var insideComment = false;
+ var offset = 0;
+ var ret = "";
+ var strip = opts.whitespace === false ? stripWithoutWhitespace : stripWithWhitespace;
+ for (var i = 0; i < str.length; i++) {
+ currentChar = str[i];
+ nextChar = str[i + 1];
+ if (!insideComment && currentChar === '"') {
+ var escaped = str[i - 1] === "\\" && str[i - 2] !== "\\";
+ if (!escaped) {
+ insideString = !insideString;
+ }
+ }
+ if (insideString) {
+ continue;
+ }
+ if (!insideComment && currentChar + nextChar === "//") {
+ ret += str.slice(offset, i);
+ offset = i;
+ insideComment = singleComment;
+ i++;
+ } else if (insideComment === singleComment && currentChar + nextChar === "\r\n") {
+ i++;
+ insideComment = false;
+ ret += strip(str, offset, i);
+ offset = i;
+ continue;
+ } else if (insideComment === singleComment && currentChar === "\n") {
+ insideComment = false;
+ ret += strip(str, offset, i);
+ offset = i;
+ } else if (!insideComment && currentChar + nextChar === "/*") {
+ ret += str.slice(offset, i);
+ offset = i;
+ insideComment = multiComment;
+ i++;
+ continue;
+ } else if (insideComment === multiComment && currentChar + nextChar === "*/") {
+ i++;
+ insideComment = false;
+ ret += strip(str, offset, i + 1);
+ offset = i + 1;
+ continue;
+ }
+ }
+ return ret + (insideComment ? strip(str.substr(offset)) : str.substr(offset));
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/rc@1.2.8/node_modules/rc/lib/utils.js
+var require_utils6 = __commonJS({
+ "../../node_modules/.pnpm/rc@1.2.8/node_modules/rc/lib/utils.js"(exports2) {
+ "use strict";
+ init_import_meta_url();
+ var fs20 = require("fs");
+ var ini = require_ini();
+ var path45 = require("path");
+ var stripJsonComments = require_strip_json_comments();
+ var parse4 = exports2.parse = function(content) {
+ if (/^\s*{/.test(content))
+ return JSON.parse(stripJsonComments(content));
+ return ini.parse(content);
+ };
+ var file = exports2.file = function() {
+ var args = [].slice.call(arguments).filter(function(arg) {
+ return arg != null;
+ });
+ for (var i in args)
+ if ("string" !== typeof args[i])
+ return;
+ var file2 = path45.join.apply(null, args);
+ var content;
+ try {
+ return fs20.readFileSync(file2, "utf-8");
+ } catch (err) {
+ return;
+ }
+ };
+ var json = exports2.json = function() {
+ var content = file.apply(null, arguments);
+ return content ? parse4(content) : null;
+ };
+ var env5 = exports2.env = function(prefix, env6) {
+ env6 = env6 || process.env;
+ var obj = {};
+ var l = prefix.length;
+ for (var k in env6) {
+ if (k.toLowerCase().indexOf(prefix.toLowerCase()) === 0) {
+ var keypath = k.substring(l).split("__");
+ var _emptyStringIndex;
+ while ((_emptyStringIndex = keypath.indexOf("")) > -1) {
+ keypath.splice(_emptyStringIndex, 1);
+ }
+ var cursor = obj;
+ keypath.forEach(/* @__PURE__ */ __name(function _buildSubObj(_subkey, i) {
+ if (!_subkey || typeof cursor !== "object")
+ return;
+ if (i === keypath.length - 1)
+ cursor[_subkey] = env6[k];
+ if (cursor[_subkey] === void 0)
+ cursor[_subkey] = {};
+ cursor = cursor[_subkey];
+ }, "_buildSubObj"));
+ }
+ }
+ return obj;
+ };
+ var find = exports2.find = function() {
+ var rel = path45.join.apply(null, [].slice.call(arguments));
+ function find2(start, rel2) {
+ var file2 = path45.join(start, rel2);
+ try {
+ fs20.statSync(file2);
+ return file2;
+ } catch (err) {
+ if (path45.dirname(start) !== start)
+ return find2(path45.dirname(start), rel2);
+ }
+ }
+ __name(find2, "find");
+ return find2(process.cwd(), rel);
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/deep-extend@0.6.0/node_modules/deep-extend/lib/deep-extend.js
+var require_deep_extend = __commonJS({
+ "../../node_modules/.pnpm/deep-extend@0.6.0/node_modules/deep-extend/lib/deep-extend.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ function isSpecificValue(val) {
+ return val instanceof Buffer || val instanceof Date || val instanceof RegExp ? true : false;
+ }
+ __name(isSpecificValue, "isSpecificValue");
+ function cloneSpecificValue(val) {
+ if (val instanceof Buffer) {
+ var x = Buffer.alloc ? Buffer.alloc(val.length) : new Buffer(val.length);
+ val.copy(x);
+ return x;
+ } else if (val instanceof Date) {
+ return new Date(val.getTime());
+ } else if (val instanceof RegExp) {
+ return new RegExp(val);
+ } else {
+ throw new Error("Unexpected situation");
+ }
+ }
+ __name(cloneSpecificValue, "cloneSpecificValue");
+ function deepCloneArray(arr) {
+ var clone = [];
+ arr.forEach(function(item, index) {
+ if (typeof item === "object" && item !== null) {
+ if (Array.isArray(item)) {
+ clone[index] = deepCloneArray(item);
+ } else if (isSpecificValue(item)) {
+ clone[index] = cloneSpecificValue(item);
+ } else {
+ clone[index] = deepExtend({}, item);
+ }
+ } else {
+ clone[index] = item;
+ }
+ });
+ return clone;
+ }
+ __name(deepCloneArray, "deepCloneArray");
+ function safeGetProperty(object, property) {
+ return property === "__proto__" ? void 0 : object[property];
+ }
+ __name(safeGetProperty, "safeGetProperty");
+ var deepExtend = module2.exports = function() {
+ if (arguments.length < 1 || typeof arguments[0] !== "object") {
+ return false;
+ }
+ if (arguments.length < 2) {
+ return arguments[0];
+ }
+ var target = arguments[0];
+ var args = Array.prototype.slice.call(arguments, 1);
+ var val, src, clone;
+ args.forEach(function(obj) {
+ if (typeof obj !== "object" || obj === null || Array.isArray(obj)) {
+ return;
+ }
+ Object.keys(obj).forEach(function(key) {
+ src = safeGetProperty(target, key);
+ val = safeGetProperty(obj, key);
+ if (val === target) {
+ return;
+ } else if (typeof val !== "object" || val === null) {
+ target[key] = val;
+ return;
+ } else if (Array.isArray(val)) {
+ target[key] = deepCloneArray(val);
+ return;
+ } else if (isSpecificValue(val)) {
+ target[key] = cloneSpecificValue(val);
+ return;
+ } else if (typeof src !== "object" || src === null || Array.isArray(src)) {
+ target[key] = deepExtend({}, val);
+ return;
+ } else {
+ target[key] = deepExtend(src, val);
+ return;
+ }
+ });
+ });
+ return target;
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/minimist@1.2.6/node_modules/minimist/index.js
+var require_minimist = __commonJS({
+ "../../node_modules/.pnpm/minimist@1.2.6/node_modules/minimist/index.js"(exports2, module2) {
+ init_import_meta_url();
+ module2.exports = function(args, opts) {
+ if (!opts)
+ opts = {};
+ var flags = { bools: {}, strings: {}, unknownFn: null };
+ if (typeof opts["unknown"] === "function") {
+ flags.unknownFn = opts["unknown"];
+ }
+ if (typeof opts["boolean"] === "boolean" && opts["boolean"]) {
+ flags.allBools = true;
+ } else {
+ [].concat(opts["boolean"]).filter(Boolean).forEach(function(key2) {
+ flags.bools[key2] = true;
+ });
+ }
+ var aliases2 = {};
+ Object.keys(opts.alias || {}).forEach(function(key2) {
+ aliases2[key2] = [].concat(opts.alias[key2]);
+ aliases2[key2].forEach(function(x) {
+ aliases2[x] = [key2].concat(aliases2[key2].filter(function(y) {
+ return x !== y;
+ }));
+ });
+ });
+ [].concat(opts.string).filter(Boolean).forEach(function(key2) {
+ flags.strings[key2] = true;
+ if (aliases2[key2]) {
+ flags.strings[aliases2[key2]] = true;
+ }
+ });
+ var defaults = opts["default"] || {};
+ var argv = { _: [] };
+ Object.keys(flags.bools).forEach(function(key2) {
+ setArg(key2, defaults[key2] === void 0 ? false : defaults[key2]);
+ });
+ var notFlags = [];
+ if (args.indexOf("--") !== -1) {
+ notFlags = args.slice(args.indexOf("--") + 1);
+ args = args.slice(0, args.indexOf("--"));
+ }
+ function argDefined(key2, arg2) {
+ return flags.allBools && /^--[^=]+$/.test(arg2) || flags.strings[key2] || flags.bools[key2] || aliases2[key2];
+ }
+ __name(argDefined, "argDefined");
+ function setArg(key2, val, arg2) {
+ if (arg2 && flags.unknownFn && !argDefined(key2, arg2)) {
+ if (flags.unknownFn(arg2) === false)
+ return;
+ }
+ var value2 = !flags.strings[key2] && isNumber(val) ? Number(val) : val;
+ setKey(argv, key2.split("."), value2);
+ (aliases2[key2] || []).forEach(function(x) {
+ setKey(argv, x.split("."), value2);
+ });
+ }
+ __name(setArg, "setArg");
+ function setKey(obj, keys, value2) {
+ var o = obj;
+ for (var i2 = 0; i2 < keys.length - 1; i2++) {
+ var key2 = keys[i2];
+ if (isConstructorOrProto(o, key2))
+ return;
+ if (o[key2] === void 0)
+ o[key2] = {};
+ if (o[key2] === Object.prototype || o[key2] === Number.prototype || o[key2] === String.prototype)
+ o[key2] = {};
+ if (o[key2] === Array.prototype)
+ o[key2] = [];
+ o = o[key2];
+ }
+ var key2 = keys[keys.length - 1];
+ if (isConstructorOrProto(o, key2))
+ return;
+ if (o === Object.prototype || o === Number.prototype || o === String.prototype)
+ o = {};
+ if (o === Array.prototype)
+ o = [];
+ if (o[key2] === void 0 || flags.bools[key2] || typeof o[key2] === "boolean") {
+ o[key2] = value2;
+ } else if (Array.isArray(o[key2])) {
+ o[key2].push(value2);
+ } else {
+ o[key2] = [o[key2], value2];
+ }
+ }
+ __name(setKey, "setKey");
+ function aliasIsBoolean(key2) {
+ return aliases2[key2].some(function(x) {
+ return flags.bools[x];
+ });
+ }
+ __name(aliasIsBoolean, "aliasIsBoolean");
+ for (var i = 0; i < args.length; i++) {
+ var arg = args[i];
+ if (/^--.+=/.test(arg)) {
+ var m = arg.match(/^--([^=]+)=([\s\S]*)$/);
+ var key = m[1];
+ var value = m[2];
+ if (flags.bools[key]) {
+ value = value !== "false";
+ }
+ setArg(key, value, arg);
+ } else if (/^--no-.+/.test(arg)) {
+ var key = arg.match(/^--no-(.+)/)[1];
+ setArg(key, false, arg);
+ } else if (/^--.+/.test(arg)) {
+ var key = arg.match(/^--(.+)/)[1];
+ var next = args[i + 1];
+ if (next !== void 0 && !/^-/.test(next) && !flags.bools[key] && !flags.allBools && (aliases2[key] ? !aliasIsBoolean(key) : true)) {
+ setArg(key, next, arg);
+ i++;
+ } else if (/^(true|false)$/.test(next)) {
+ setArg(key, next === "true", arg);
+ i++;
+ } else {
+ setArg(key, flags.strings[key] ? "" : true, arg);
+ }
+ } else if (/^-[^-]+/.test(arg)) {
+ var letters = arg.slice(1, -1).split("");
+ var broken = false;
+ for (var j = 0; j < letters.length; j++) {
+ var next = arg.slice(j + 2);
+ if (next === "-") {
+ setArg(letters[j], next, arg);
+ continue;
+ }
+ if (/[A-Za-z]/.test(letters[j]) && /=/.test(next)) {
+ setArg(letters[j], next.split("=")[1], arg);
+ broken = true;
+ break;
+ }
+ if (/[A-Za-z]/.test(letters[j]) && /-?\d+(\.\d*)?(e-?\d+)?$/.test(next)) {
+ setArg(letters[j], next, arg);
+ broken = true;
+ break;
+ }
+ if (letters[j + 1] && letters[j + 1].match(/\W/)) {
+ setArg(letters[j], arg.slice(j + 2), arg);
+ broken = true;
+ break;
+ } else {
+ setArg(letters[j], flags.strings[letters[j]] ? "" : true, arg);
+ }
+ }
+ var key = arg.slice(-1)[0];
+ if (!broken && key !== "-") {
+ if (args[i + 1] && !/^(-|--)[^-]/.test(args[i + 1]) && !flags.bools[key] && (aliases2[key] ? !aliasIsBoolean(key) : true)) {
+ setArg(key, args[i + 1], arg);
+ i++;
+ } else if (args[i + 1] && /^(true|false)$/.test(args[i + 1])) {
+ setArg(key, args[i + 1] === "true", arg);
+ i++;
+ } else {
+ setArg(key, flags.strings[key] ? "" : true, arg);
+ }
+ }
+ } else {
+ if (!flags.unknownFn || flags.unknownFn(arg) !== false) {
+ argv._.push(
+ flags.strings["_"] || !isNumber(arg) ? arg : Number(arg)
+ );
+ }
+ if (opts.stopEarly) {
+ argv._.push.apply(argv._, args.slice(i + 1));
+ break;
+ }
+ }
+ }
+ Object.keys(defaults).forEach(function(key2) {
+ if (!hasKey2(argv, key2.split("."))) {
+ setKey(argv, key2.split("."), defaults[key2]);
+ (aliases2[key2] || []).forEach(function(x) {
+ setKey(argv, x.split("."), defaults[key2]);
+ });
+ }
+ });
+ if (opts["--"]) {
+ argv["--"] = new Array();
+ notFlags.forEach(function(key2) {
+ argv["--"].push(key2);
+ });
+ } else {
+ notFlags.forEach(function(key2) {
+ argv._.push(key2);
+ });
+ }
+ return argv;
+ };
+ function hasKey2(obj, keys) {
+ var o = obj;
+ keys.slice(0, -1).forEach(function(key2) {
+ o = o[key2] || {};
+ });
+ var key = keys[keys.length - 1];
+ return key in o;
+ }
+ __name(hasKey2, "hasKey");
+ function isNumber(x) {
+ if (typeof x === "number")
+ return true;
+ if (/^0x[0-9a-f]+$/i.test(x))
+ return true;
+ return /^[-+]?(?:\d+(?:\.\d*)?|\.\d+)(e[-+]?\d+)?$/.test(x);
+ }
+ __name(isNumber, "isNumber");
+ function isConstructorOrProto(obj, key) {
+ return key === "constructor" && typeof obj[key] === "function" || key === "__proto__";
+ }
+ __name(isConstructorOrProto, "isConstructorOrProto");
+ }
+});
+
+// ../../node_modules/.pnpm/rc@1.2.8/node_modules/rc/index.js
+var require_rc = __commonJS({
+ "../../node_modules/.pnpm/rc@1.2.8/node_modules/rc/index.js"(exports2, module2) {
+ init_import_meta_url();
+ var cc = require_utils6();
+ var join12 = require("path").join;
+ var deepExtend = require_deep_extend();
+ var etc = "/etc";
+ var win = process.platform === "win32";
+ var home = win ? process.env.USERPROFILE : process.env.HOME;
+ module2.exports = function(name, defaults, argv, parse4) {
+ if ("string" !== typeof name)
+ throw new Error("rc(name): name *must* be string");
+ if (!argv)
+ argv = require_minimist()(process.argv.slice(2));
+ defaults = ("string" === typeof defaults ? cc.json(defaults) : defaults) || {};
+ parse4 = parse4 || cc.parse;
+ var env5 = cc.env(name + "_");
+ var configs = [defaults];
+ var configFiles = [];
+ function addConfigFile(file) {
+ if (configFiles.indexOf(file) >= 0)
+ return;
+ var fileConfig = cc.file(file);
+ if (fileConfig) {
+ configs.push(parse4(fileConfig));
+ configFiles.push(file);
+ }
+ }
+ __name(addConfigFile, "addConfigFile");
+ if (!win)
+ [
+ join12(etc, name, "config"),
+ join12(etc, name + "rc")
+ ].forEach(addConfigFile);
+ if (home)
+ [
+ join12(home, ".config", name, "config"),
+ join12(home, ".config", name),
+ join12(home, "." + name, "config"),
+ join12(home, "." + name + "rc")
+ ].forEach(addConfigFile);
+ addConfigFile(cc.find("." + name + "rc"));
+ if (env5.config)
+ addConfigFile(env5.config);
+ if (argv.config)
+ addConfigFile(argv.config);
+ return deepExtend.apply(null, configs.concat([
+ env5,
+ argv,
+ configFiles.length ? { configs: configFiles, config: configFiles[configFiles.length - 1] } : void 0
+ ]));
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/registry-url@3.1.0/node_modules/registry-url/index.js
+var require_registry_url = __commonJS({
+ "../../node_modules/.pnpm/registry-url@3.1.0/node_modules/registry-url/index.js"(exports2, module2) {
+ "use strict";
+ init_import_meta_url();
+ module2.exports = function(scope) {
+ var rc = require_rc()("npm", { registry: "https://registry.npmjs.org/" });
+ var url3 = rc[scope + ":registry"] || rc.registry;
+ return url3.slice(-1) === "/" ? url3 : url3 + "/";
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/registry-auth-token@3.3.2/node_modules/registry-auth-token/base64.js
+var require_base64 = __commonJS({
+ "../../node_modules/.pnpm/registry-auth-token@3.3.2/node_modules/registry-auth-token/base64.js"(exports2, module2) {
+ init_import_meta_url();
+ var safeBuffer = require_safe_buffer().Buffer;
+ function decodeBase64(base64) {
+ return safeBuffer.from(base64, "base64").toString("utf8");
+ }
+ __name(decodeBase64, "decodeBase64");
+ function encodeBase64(string) {
+ return safeBuffer.from(string, "utf8").toString("base64");
+ }
+ __name(encodeBase64, "encodeBase64");
+ module2.exports = {
+ decodeBase64,
+ encodeBase64
+ };
+ }
+});
+
+// ../../node_modules/.pnpm/registry-auth-token@3.3.2/node_modules/registry-auth-token/index.js
+var require_registry_auth_token = __commonJS({
+ "../../node_modules/.pnpm/registry-auth-token@3.3.2/node_modules/registry-auth-token/index.js"(exports2, module2) {
+ init_import_meta_url();
+ var url3 = require("url");
+ var base64 = require_base64();
+ var decodeBase64 = base64.decodeBase64;
+ var encodeBase64 = base64.encodeBase64;
+ var tokenKey = ":_authToken";
+ var userKey = ":username";
+ var passwordKey = ":_password";
+ module2.exports = function() {
+ var checkUrl;
+ var options14;
+ if (arguments.length >= 2) {
+ checkUrl = arguments[0];
+ options14 = arguments[1];
+ } else if (typeof arguments[0] === "string") {
+ checkUrl = arguments[0];
+ } else {
+ options14 = arguments[0];
+ }
+ options14 = options14 || {};
+ options14.npmrc = options14.npmrc || require_rc()("npm", { registry: "https://registry.npmjs.org/" });
+ checkUrl = checkUrl || options14.npmrc.registry;
+ return getRegistryAuthInfo(checkUrl, options14) || getLegacyAuthInfo(options14.npmrc);
+ };
+ function getRegistryAuthInfo(checkUrl, options14) {
+ var parsed = url3.parse(checkUrl, false, true);
+ var pathname;
+ while (pathname !== "/" && parsed.pathname !== pathname) {
+ pathname = parsed.pathname || "/";
+ var regUrl = "//" + parsed.host + pathname.replace(/\/$/, "");
+ var authInfo = getAuthInfoForUrl(regUrl, options14.npmrc);
+ if (authInfo) {
+ return authInfo;
+ }
+ if (!options14.recursive) {
+ return /\/$/.test(checkUrl) ? void 0 : getRegistryAuthInfo(url3.resolve(checkUrl, "."), options14);
+ }
+ parsed.pathname = url3.resolve(normalizePath(pathname), "..") || "/";
+ }
+ return void 0;
+ }
+ __name(getRegistryAuthInfo, "getRegistryAuthInfo");
+ function getLegacyAuthInfo(npmrc) {
+ if (npmrc._auth) {
+ return { token: npmrc._auth, type: "Basic" };
+ }
+ return void 0;
+ }
+ __name(getLegacyAuthInfo, "getLegacyAuthInfo");
+ function normalizePath(path45) {
+ return path45[path45.length - 1] === "/" ? path45 : path45 + "/";
+ }
+ __name(normalizePath, "normalizePath");
+ function getAuthInfoForUrl(regUrl, npmrc) {
+ var bearerAuth = getBearerToken(npmrc[regUrl + tokenKey] || npmrc[regUrl + "/" + tokenKey]);
+ if (bearerAuth) {
+ return bearerAuth;
+ }
+ var username = npmrc[regUrl + userKey] || npmrc[regUrl + "/" + userKey];
+ var password = npmrc[regUrl + passwordKey] || npmrc[regUrl + "/" + passwordKey];
+ var basicAuth = getTokenForUsernameAndPassword(username, password);
+ if (basicAuth) {
+ return basicAuth;
+ }
+ return void 0;
+ }
+ __name(getAuthInfoForUrl, "getAuthInfoForUrl");
+ function getBearerToken(tok) {
+ if (!tok) {
+ return void 0;
+ }
+ var token = tok.replace(/^\$\{?([^}]*)\}?$/, function(fullMatch, envVar) {
+ return process.env[envVar];
+ });
+ return { token, type: "Bearer" };
+ }
+ __name(getBearerToken, "getBearerToken");
+ function getTokenForUsernameAndPassword(username, password) {
+ if (!username || !password) {
+ return void 0;
+ }
+ var pass = decodeBase64(password.replace(/^\$\{?([^}]*)\}?$/, function(fullMatch, envVar) {
+ return process.env[envVar];
+ }));
+ var token = encodeBase64(username + ":" + pass);
+ return {
+ token,
+ type: "Basic",
+ password: pass,
+ username
+ };
+ }
+ __name(getTokenForUsernameAndPassword, "getTokenForUsernameAndPassword");
+ }
+});
+
+// ../../node_modules/.pnpm/update-check@1.5.4/node_modules/update-check/index.js
+var require_update_check = __commonJS({
+ "../../node_modules/.pnpm/update-check@1.5.4/node_modules/update-check/index.js"(exports2, module2) {
+ init_import_meta_url();
+ var { URL: URL4 } = require("url");
+ var { join: join12 } = require("path");
+ var fs20 = require("fs");
+ var { promisify: promisify2 } = require("util");
+ var { tmpdir: tmpdir5 } = require("os");
+ var registryUrl = require_registry_url();
+ var writeFile4 = promisify2(fs20.writeFile);
+ var mkdir3 = promisify2(fs20.mkdir);
+ var readFile6 = promisify2(fs20.readFile);
+ var compareVersions = /* @__PURE__ */ __name((a, b) => a.localeCompare(b, "en-US", { numeric: true }), "compareVersions");
+ var encode = /* @__PURE__ */ __name((value) => encodeURIComponent(value).replace(/^%40/, "@"), "encode");
+ var getFile = /* @__PURE__ */ __name(async (details, distTag) => {
+ const rootDir = tmpdir5();
+ const subDir = join12(rootDir, "update-check");
+ if (!fs20.existsSync(subDir)) {
+ await mkdir3(subDir);
+ }
+ let name = `${details.name}-${distTag}.json`;
+ if (details.scope) {
+ name = `${details.scope}-${name}`;
+ }
+ return join12(subDir, name);
+ }, "getFile");
+ var evaluateCache = /* @__PURE__ */ __name(async (file, time, interval2) => {
+ if (fs20.existsSync(file)) {
+ const content = await readFile6(file, "utf8");
+ const { lastUpdate, latest } = JSON.parse(content);
+ const nextCheck = lastUpdate + interval2;
+ if (nextCheck > time) {
+ return {
+ shouldCheck: false,
+ latest
+ };
+ }
+ }
+ return {
+ shouldCheck: true,
+ latest: null
+ };
+ }, "evaluateCache");
+ var updateCache = /* @__PURE__ */ __name(async (file, latest, lastUpdate) => {
+ const content = JSON.stringify({
+ latest,
+ lastUpdate
+ });
+ await writeFile4(file, content, "utf8");
+ }, "updateCache");
+ var loadPackage = /* @__PURE__ */ __name((url3, authInfo) => new Promise((resolve18, reject) => {
+ const options14 = {
+ host: url3.hostname,
+ path: url3.pathname,
+ port: url3.port,
+ headers: {
+ accept: "application/vnd.npm.install-v1+json; q=1.0, application/json; q=0.8, */*"
+ },
+ timeout: 2e3
+ };
+ if (authInfo) {
+ options14.headers.authorization = `${authInfo.type} ${authInfo.token}`;
+ }
+ const { get } = url3.protocol === "https:" ? require("https") : require("http");
+ get(options14, (response) => {
+ const { statusCode } = response;
+ if (statusCode !== 200) {
+ const error = new Error(`Request failed with code ${statusCode}`);
+ error.code = statusCode;
+ reject(error);
+ response.resume();
+ return;
+ }
+ let rawData = "";
+ response.setEncoding("utf8");
+ response.on("data", (chunk) => {
+ rawData += chunk;
+ });
+ response.on("end", () => {
+ try {
+ const parsedData = JSON.parse(rawData);
+ resolve18(parsedData);
+ } catch (e2) {
+ reject(e2);
+ }
+ });
+ }).on("error", reject).on("timeout", reject);
+ }), "loadPackage");
+ var getMostRecent = /* @__PURE__ */ __name(async ({ full, scope }, distTag) => {
+ const regURL = registryUrl(scope);
+ const url3 = new URL4(full, regURL);
+ let spec = null;
+ try {
+ spec = await loadPackage(url3);
+ } catch (err) {
+ if (err.code && String(err.code).startsWith(4)) {
+ const registryAuthToken = require_registry_auth_token();
+ const authInfo = registryAuthToken(regURL, { recursive: true });
+ spec = await loadPackage(url3, authInfo);
+ } else {
+ throw err;
+ }
+ }
+ const version2 = spec["dist-tags"][distTag];
+ if (!version2) {
+ throw new Error(`Distribution tag ${distTag} is not available`);
+ }
+ return version2;
+ }, "getMostRecent");
+ var defaultConfig = {
+ interval: 36e5,
+ distTag: "latest"
+ };
+ var getDetails = /* @__PURE__ */ __name((name) => {
+ const spec = {
+ full: encode(name)
+ };
+ if (name.includes("/")) {
+ const parts = name.split("/");
+ spec.scope = parts[0];
+ spec.name = parts[1];
+ } else {
+ spec.scope = null;
+ spec.name = name;
+ }
+ return spec;
+ }, "getDetails");
+ module2.exports = async (pkg, config) => {
+ if (typeof pkg !== "object") {
+ throw new Error("The first parameter should be your package.json file content");
+ }
+ const details = getDetails(pkg.name);
+ const time = Date.now();
+ const { distTag, interval: interval2 } = Object.assign({}, defaultConfig, config);
+ const file = await getFile(details, distTag);
+ let latest = null;
+ let shouldCheck = true;
+ ({ shouldCheck, latest } = await evaluateCache(file, time, interval2));
+ if (shouldCheck) {
+ latest = await getMostRecent(details, distTag);
+ await updateCache(file, latest, time);
+ }
+ const comparision = compareVersions(pkg.version, latest);
+ if (comparision === -1) {
+ return {
+ latest,
+ fromCache: !shouldCheck
+ };
+ }
+ return null;
+ };
+ }
+});
+
+// src/cli.ts
+var cli_exports = {};
+__export(cli_exports, {
+ unstable_dev: () => unstable_dev,
+ unstable_pages: () => unstable_pages
+});
+module.exports = __toCommonJS(cli_exports);
+init_import_meta_url();
+var import_process = __toESM(require("process"));
+
+// ../../node_modules/.pnpm/yargs@17.7.1/node_modules/yargs/helpers/helpers.mjs
+init_import_meta_url();
+
+// ../../node_modules/.pnpm/yargs@17.7.1/node_modules/yargs/build/lib/utils/apply-extends.js
+init_import_meta_url();
+
+// ../../node_modules/.pnpm/yargs@17.7.1/node_modules/yargs/build/lib/yerror.js
+init_import_meta_url();
+var YError = class extends Error {
+ constructor(msg) {
+ super(msg || "yargs error");
+ this.name = "YError";
+ if (Error.captureStackTrace) {
+ Error.captureStackTrace(this, YError);
+ }
+ }
+};
+__name(YError, "YError");
+
+// ../../node_modules/.pnpm/yargs@17.7.1/node_modules/yargs/build/lib/utils/apply-extends.js
+var previouslyVisitedConfigs = [];
+var shim;
+function applyExtends(config, cwd2, mergeExtends, _shim) {
+ shim = _shim;
+ let defaultConfig = {};
+ if (Object.prototype.hasOwnProperty.call(config, "extends")) {
+ if (typeof config.extends !== "string")
+ return defaultConfig;
+ const isPath = /\.json|\..*rc$/.test(config.extends);
+ let pathToDefault = null;
+ if (!isPath) {
+ try {
+ pathToDefault = require.resolve(config.extends);
+ } catch (_err) {
+ return config;
+ }
+ } else {
+ pathToDefault = getPathToDefaultConfig(cwd2, config.extends);
+ }
+ checkForCircularExtends(pathToDefault);
+ previouslyVisitedConfigs.push(pathToDefault);
+ defaultConfig = isPath ? JSON.parse(shim.readFileSync(pathToDefault, "utf8")) : require(config.extends);
+ delete config.extends;
+ defaultConfig = applyExtends(defaultConfig, shim.path.dirname(pathToDefault), mergeExtends, shim);
+ }
+ previouslyVisitedConfigs = [];
+ return mergeExtends ? mergeDeep(defaultConfig, config) : Object.assign({}, defaultConfig, config);
+}
+__name(applyExtends, "applyExtends");
+function checkForCircularExtends(cfgPath) {
+ if (previouslyVisitedConfigs.indexOf(cfgPath) > -1) {
+ throw new YError(`Circular extended configurations: '${cfgPath}'.`);
+ }
+}
+__name(checkForCircularExtends, "checkForCircularExtends");
+function getPathToDefaultConfig(cwd2, pathToExtend) {
+ return shim.path.resolve(cwd2, pathToExtend);
+}
+__name(getPathToDefaultConfig, "getPathToDefaultConfig");
+function mergeDeep(config1, config2) {
+ const target = {};
+ function isObject2(obj) {
+ return obj && typeof obj === "object" && !Array.isArray(obj);
+ }
+ __name(isObject2, "isObject");
+ Object.assign(target, config1);
+ for (const key of Object.keys(config2)) {
+ if (isObject2(config2[key]) && isObject2(target[key])) {
+ target[key] = mergeDeep(config1[key], config2[key]);
+ } else {
+ target[key] = config2[key];
+ }
+ }
+ return target;
+}
+__name(mergeDeep, "mergeDeep");
+
+// ../../node_modules/.pnpm/yargs@17.7.1/node_modules/yargs/build/lib/utils/process-argv.js
+init_import_meta_url();
+function getProcessArgvBinIndex() {
+ if (isBundledElectronApp())
+ return 0;
+ return 1;
+}
+__name(getProcessArgvBinIndex, "getProcessArgvBinIndex");
+function isBundledElectronApp() {
+ return isElectronApp() && !process.defaultApp;
+}
+__name(isBundledElectronApp, "isBundledElectronApp");
+function isElectronApp() {
+ return !!process.versions.electron;
+}
+__name(isElectronApp, "isElectronApp");
+function hideBin(argv) {
+ return argv.slice(getProcessArgvBinIndex() + 1);
+}
+__name(hideBin, "hideBin");
+function getProcessArgvBin() {
+ return process.argv[getProcessArgvBinIndex()];
+}
+__name(getProcessArgvBin, "getProcessArgvBin");
+
+// ../../node_modules/.pnpm/yargs-parser@21.1.1/node_modules/yargs-parser/build/lib/index.js
+init_import_meta_url();
+var import_util = require("util");
+var import_path = require("path");
+
+// ../../node_modules/.pnpm/yargs-parser@21.1.1/node_modules/yargs-parser/build/lib/string-utils.js
+init_import_meta_url();
+function camelCase(str) {
+ const isCamelCase = str !== str.toLowerCase() && str !== str.toUpperCase();
+ if (!isCamelCase) {
+ str = str.toLowerCase();
+ }
+ if (str.indexOf("-") === -1 && str.indexOf("_") === -1) {
+ return str;
+ } else {
+ let camelcase = "";
+ let nextChrUpper = false;
+ const leadingHyphens = str.match(/^-+/);
+ for (let i = leadingHyphens ? leadingHyphens[0].length : 0; i < str.length; i++) {
+ let chr = str.charAt(i);
+ if (nextChrUpper) {
+ nextChrUpper = false;
+ chr = chr.toUpperCase();
+ }
+ if (i !== 0 && (chr === "-" || chr === "_")) {
+ nextChrUpper = true;
+ } else if (chr !== "-" && chr !== "_") {
+ camelcase += chr;
+ }
+ }
+ return camelcase;
+ }
+}
+__name(camelCase, "camelCase");
+function decamelize(str, joinString) {
+ const lowercase = str.toLowerCase();
+ joinString = joinString || "-";
+ let notCamelcase = "";
+ for (let i = 0; i < str.length; i++) {
+ const chrLower = lowercase.charAt(i);
+ const chrString = str.charAt(i);
+ if (chrLower !== chrString && i > 0) {
+ notCamelcase += `${joinString}${lowercase.charAt(i)}`;
+ } else {
+ notCamelcase += chrString;
+ }
+ }
+ return notCamelcase;
+}
+__name(decamelize, "decamelize");
+function looksLikeNumber(x) {
+ if (x === null || x === void 0)
+ return false;
+ if (typeof x === "number")
+ return true;
+ if (/^0x[0-9a-f]+$/i.test(x))
+ return true;
+ if (/^0[^.]/.test(x))
+ return false;
+ return /^[-]?(?:\d+(?:\.\d*)?|\.\d+)(e[-+]?\d+)?$/.test(x);
+}
+__name(looksLikeNumber, "looksLikeNumber");
+
+// ../../node_modules/.pnpm/yargs-parser@21.1.1/node_modules/yargs-parser/build/lib/yargs-parser.js
+init_import_meta_url();
+
+// ../../node_modules/.pnpm/yargs-parser@21.1.1/node_modules/yargs-parser/build/lib/tokenize-arg-string.js
+init_import_meta_url();
+function tokenizeArgString(argString) {
+ if (Array.isArray(argString)) {
+ return argString.map((e2) => typeof e2 !== "string" ? e2 + "" : e2);
+ }
+ argString = argString.trim();
+ let i = 0;
+ let prevC = null;
+ let c = null;
+ let opening = null;
+ const args = [];
+ for (let ii = 0; ii < argString.length; ii++) {
+ prevC = c;
+ c = argString.charAt(ii);
+ if (c === " " && !opening) {
+ if (!(prevC === " ")) {
+ i++;
+ }
+ continue;
+ }
+ if (c === opening) {
+ opening = null;
+ } else if ((c === "'" || c === '"') && !opening) {
+ opening = c;
+ }
+ if (!args[i])
+ args[i] = "";
+ args[i] += c;
+ }
+ return args;
+}
+__name(tokenizeArgString, "tokenizeArgString");
+
+// ../../node_modules/.pnpm/yargs-parser@21.1.1/node_modules/yargs-parser/build/lib/yargs-parser-types.js
+init_import_meta_url();
+var DefaultValuesForTypeKey;
+(function(DefaultValuesForTypeKey2) {
+ DefaultValuesForTypeKey2["BOOLEAN"] = "boolean";
+ DefaultValuesForTypeKey2["STRING"] = "string";
+ DefaultValuesForTypeKey2["NUMBER"] = "number";
+ DefaultValuesForTypeKey2["ARRAY"] = "array";
+})(DefaultValuesForTypeKey || (DefaultValuesForTypeKey = {}));
+
+// ../../node_modules/.pnpm/yargs-parser@21.1.1/node_modules/yargs-parser/build/lib/yargs-parser.js
+var mixin;
+var YargsParser = class {
+ constructor(_mixin) {
+ mixin = _mixin;
+ }
+ parse(argsInput, options14) {
+ const opts = Object.assign({
+ alias: void 0,
+ array: void 0,
+ boolean: void 0,
+ config: void 0,
+ configObjects: void 0,
+ configuration: void 0,
+ coerce: void 0,
+ count: void 0,
+ default: void 0,
+ envPrefix: void 0,
+ narg: void 0,
+ normalize: void 0,
+ string: void 0,
+ number: void 0,
+ __: void 0,
+ key: void 0
+ }, options14);
+ const args = tokenizeArgString(argsInput);
+ const inputIsString = typeof argsInput === "string";
+ const aliases2 = combineAliases(Object.assign(/* @__PURE__ */ Object.create(null), opts.alias));
+ const configuration = Object.assign({
+ "boolean-negation": true,
+ "camel-case-expansion": true,
+ "combine-arrays": false,
+ "dot-notation": true,
+ "duplicate-arguments-array": true,
+ "flatten-duplicate-arrays": true,
+ "greedy-arrays": true,
+ "halt-at-non-option": false,
+ "nargs-eats-options": false,
+ "negation-prefix": "no-",
+ "parse-numbers": true,
+ "parse-positional-numbers": true,
+ "populate--": false,
+ "set-placeholder-key": false,
+ "short-option-groups": true,
+ "strip-aliased": false,
+ "strip-dashed": false,
+ "unknown-options-as-args": false
+ }, opts.configuration);
+ const defaults = Object.assign(/* @__PURE__ */ Object.create(null), opts.default);
+ const configObjects = opts.configObjects || [];
+ const envPrefix = opts.envPrefix;
+ const notFlagsOption = configuration["populate--"];
+ const notFlagsArgv = notFlagsOption ? "--" : "_";
+ const newAliases = /* @__PURE__ */ Object.create(null);
+ const defaulted = /* @__PURE__ */ Object.create(null);
+ const __ = opts.__ || mixin.format;
+ const flags = {
+ aliases: /* @__PURE__ */ Object.create(null),
+ arrays: /* @__PURE__ */ Object.create(null),
+ bools: /* @__PURE__ */ Object.create(null),
+ strings: /* @__PURE__ */ Object.create(null),
+ numbers: /* @__PURE__ */ Object.create(null),
+ counts: /* @__PURE__ */ Object.create(null),
+ normalize: /* @__PURE__ */ Object.create(null),
+ configs: /* @__PURE__ */ Object.create(null),
+ nargs: /* @__PURE__ */ Object.create(null),
+ coercions: /* @__PURE__ */ Object.create(null),
+ keys: []
+ };
+ const negative = /^-([0-9]+(\.[0-9]+)?|\.[0-9]+)$/;
+ const negatedBoolean = new RegExp("^--" + configuration["negation-prefix"] + "(.+)");
+ [].concat(opts.array || []).filter(Boolean).forEach(function(opt) {
+ const key = typeof opt === "object" ? opt.key : opt;
+ const assignment = Object.keys(opt).map(function(key2) {
+ const arrayFlagKeys = {
+ boolean: "bools",
+ string: "strings",
+ number: "numbers"
+ };
+ return arrayFlagKeys[key2];
+ }).filter(Boolean).pop();
+ if (assignment) {
+ flags[assignment][key] = true;
+ }
+ flags.arrays[key] = true;
+ flags.keys.push(key);
+ });
+ [].concat(opts.boolean || []).filter(Boolean).forEach(function(key) {
+ flags.bools[key] = true;
+ flags.keys.push(key);
+ });
+ [].concat(opts.string || []).filter(Boolean).forEach(function(key) {
+ flags.strings[key] = true;
+ flags.keys.push(key);
+ });
+ [].concat(opts.number || []).filter(Boolean).forEach(function(key) {
+ flags.numbers[key] = true;
+ flags.keys.push(key);
+ });
+ [].concat(opts.count || []).filter(Boolean).forEach(function(key) {
+ flags.counts[key] = true;
+ flags.keys.push(key);
+ });
+ [].concat(opts.normalize || []).filter(Boolean).forEach(function(key) {
+ flags.normalize[key] = true;
+ flags.keys.push(key);
+ });
+ if (typeof opts.narg === "object") {
+ Object.entries(opts.narg).forEach(([key, value]) => {
+ if (typeof value === "number") {
+ flags.nargs[key] = value;
+ flags.keys.push(key);
+ }
+ });
+ }
+ if (typeof opts.coerce === "object") {
+ Object.entries(opts.coerce).forEach(([key, value]) => {
+ if (typeof value === "function") {
+ flags.coercions[key] = value;
+ flags.keys.push(key);
+ }
+ });
+ }
+ if (typeof opts.config !== "undefined") {
+ if (Array.isArray(opts.config) || typeof opts.config === "string") {
+ ;
+ [].concat(opts.config).filter(Boolean).forEach(function(key) {
+ flags.configs[key] = true;
+ });
+ } else if (typeof opts.config === "object") {
+ Object.entries(opts.config).forEach(([key, value]) => {
+ if (typeof value === "boolean" || typeof value === "function") {
+ flags.configs[key] = value;
+ }
+ });
+ }
+ }
+ extendAliases(opts.key, aliases2, opts.default, flags.arrays);
+ Object.keys(defaults).forEach(function(key) {
+ (flags.aliases[key] || []).forEach(function(alias) {
+ defaults[alias] = defaults[key];
+ });
+ });
+ let error = null;
+ checkConfiguration();
+ let notFlags = [];
+ const argv = Object.assign(/* @__PURE__ */ Object.create(null), { _: [] });
+ const argvReturn = {};
+ for (let i = 0; i < args.length; i++) {
+ const arg = args[i];
+ const truncatedArg = arg.replace(/^-{3,}/, "---");
+ let broken;
+ let key;
+ let letters;
+ let m;
+ let next;
+ let value;
+ if (arg !== "--" && /^-/.test(arg) && isUnknownOptionAsArg(arg)) {
+ pushPositional(arg);
+ } else if (truncatedArg.match(/^---+(=|$)/)) {
+ pushPositional(arg);
+ continue;
+ } else if (arg.match(/^--.+=/) || !configuration["short-option-groups"] && arg.match(/^-.+=/)) {
+ m = arg.match(/^--?([^=]+)=([\s\S]*)$/);
+ if (m !== null && Array.isArray(m) && m.length >= 3) {
+ if (checkAllAliases(m[1], flags.arrays)) {
+ i = eatArray(i, m[1], args, m[2]);
+ } else if (checkAllAliases(m[1], flags.nargs) !== false) {
+ i = eatNargs(i, m[1], args, m[2]);
+ } else {
+ setArg(m[1], m[2], true);
+ }
+ }
+ } else if (arg.match(negatedBoolean) && configuration["boolean-negation"]) {
+ m = arg.match(negatedBoolean);
+ if (m !== null && Array.isArray(m) && m.length >= 2) {
+ key = m[1];
+ setArg(key, checkAllAliases(key, flags.arrays) ? [false] : false);
+ }
+ } else if (arg.match(/^--.+/) || !configuration["short-option-groups"] && arg.match(/^-[^-]+/)) {
+ m = arg.match(/^--?(.+)/);
+ if (m !== null && Array.isArray(m) && m.length >= 2) {
+ key = m[1];
+ if (checkAllAliases(key, flags.arrays)) {
+ i = eatArray(i, key, args);
+ } else if (checkAllAliases(key, flags.nargs) !== false) {
+ i = eatNargs(i, key, args);
+ } else {
+ next = args[i + 1];
+ if (next !== void 0 && (!next.match(/^-/) || next.match(negative)) && !checkAllAliases(key, flags.bools) && !checkAllAliases(key, flags.counts)) {
+ setArg(key, next);
+ i++;
+ } else if (/^(true|false)$/.test(next)) {
+ setArg(key, next);
+ i++;
+ } else {
+ setArg(key, defaultValue(key));
+ }
+ }
+ }
+ } else if (arg.match(/^-.\..+=/)) {
+ m = arg.match(/^-([^=]+)=([\s\S]*)$/);
+ if (m !== null && Array.isArray(m) && m.length >= 3) {
+ setArg(m[1], m[2]);
+ }
+ } else if (arg.match(/^-.\..+/) && !arg.match(negative)) {
+ next = args[i + 1];
+ m = arg.match(/^-(.\..+)/);
+ if (m !== null && Array.isArray(m) && m.length >= 2) {
+ key = m[1];
+ if (next !== void 0 && !next.match(/^-/) && !checkAllAliases(key, flags.bools) && !checkAllAliases(key, flags.counts)) {
+ setArg(key, next);
+ i++;
+ } else {
+ setArg(key, defaultValue(key));
+ }
+ }
+ } else if (arg.match(/^-[^-]+/) && !arg.match(negative)) {
+ letters = arg.slice(1, -1).split("");
+ broken = false;
+ for (let j = 0; j < letters.length; j++) {
+ next = arg.slice(j + 2);
+ if (letters[j + 1] && letters[j + 1] === "=") {
+ value = arg.slice(j + 3);
+ key = letters[j];
+ if (checkAllAliases(key, flags.arrays)) {
+ i = eatArray(i, key, args, value);
+ } else if (checkAllAliases(key, flags.nargs) !== false) {
+ i = eatNargs(i, key, args, value);
+ } else {
+ setArg(key, value);
+ }
+ broken = true;
+ break;
+ }
+ if (next === "-") {
+ setArg(letters[j], next);
+ continue;
+ }
+ if (/[A-Za-z]/.test(letters[j]) && /^-?\d+(\.\d*)?(e-?\d+)?$/.test(next) && checkAllAliases(next, flags.bools) === false) {
+ setArg(letters[j], next);
+ broken = true;
+ break;
+ }
+ if (letters[j + 1] && letters[j + 1].match(/\W/)) {
+ setArg(letters[j], next);
+ broken = true;
+ break;
+ } else {
+ setArg(letters[j], defaultValue(letters[j]));
+ }
+ }
+ key = arg.slice(-1)[0];
+ if (!broken && key !== "-") {
+ if (checkAllAliases(key, flags.arrays)) {
+ i = eatArray(i, key, args);
+ } else if (checkAllAliases(key, flags.nargs) !== false) {
+ i = eatNargs(i, key, args);
+ } else {
+ next = args[i + 1];
+ if (next !== void 0 && (!/^(-|--)[^-]/.test(next) || next.match(negative)) && !checkAllAliases(key, flags.bools) && !checkAllAliases(key, flags.counts)) {
+ setArg(key, next);
+ i++;
+ } else if (/^(true|false)$/.test(next)) {
+ setArg(key, next);
+ i++;
+ } else {
+ setArg(key, defaultValue(key));
+ }
+ }
+ }
+ } else if (arg.match(/^-[0-9]$/) && arg.match(negative) && checkAllAliases(arg.slice(1), flags.bools)) {
+ key = arg.slice(1);
+ setArg(key, defaultValue(key));
+ } else if (arg === "--") {
+ notFlags = args.slice(i + 1);
+ break;
+ } else if (configuration["halt-at-non-option"]) {
+ notFlags = args.slice(i);
+ break;
+ } else {
+ pushPositional(arg);
+ }
+ }
+ applyEnvVars(argv, true);
+ applyEnvVars(argv, false);
+ setConfig(argv);
+ setConfigObjects();
+ applyDefaultsAndAliases(argv, flags.aliases, defaults, true);
+ applyCoercions(argv);
+ if (configuration["set-placeholder-key"])
+ setPlaceholderKeys(argv);
+ Object.keys(flags.counts).forEach(function(key) {
+ if (!hasKey2(argv, key.split(".")))
+ setArg(key, 0);
+ });
+ if (notFlagsOption && notFlags.length)
+ argv[notFlagsArgv] = [];
+ notFlags.forEach(function(key) {
+ argv[notFlagsArgv].push(key);
+ });
+ if (configuration["camel-case-expansion"] && configuration["strip-dashed"]) {
+ Object.keys(argv).filter((key) => key !== "--" && key.includes("-")).forEach((key) => {
+ delete argv[key];
+ });
+ }
+ if (configuration["strip-aliased"]) {
+ ;
+ [].concat(...Object.keys(aliases2).map((k) => aliases2[k])).forEach((alias) => {
+ if (configuration["camel-case-expansion"] && alias.includes("-")) {
+ delete argv[alias.split(".").map((prop) => camelCase(prop)).join(".")];
+ }
+ delete argv[alias];
+ });
+ }
+ function pushPositional(arg) {
+ const maybeCoercedNumber = maybeCoerceNumber("_", arg);
+ if (typeof maybeCoercedNumber === "string" || typeof maybeCoercedNumber === "number") {
+ argv._.push(maybeCoercedNumber);
+ }
+ }
+ __name(pushPositional, "pushPositional");
+ function eatNargs(i, key, args2, argAfterEqualSign) {
+ let ii;
+ let toEat = checkAllAliases(key, flags.nargs);
+ toEat = typeof toEat !== "number" || isNaN(toEat) ? 1 : toEat;
+ if (toEat === 0) {
+ if (!isUndefined(argAfterEqualSign)) {
+ error = Error(__("Argument unexpected for: %s", key));
+ }
+ setArg(key, defaultValue(key));
+ return i;
+ }
+ let available = isUndefined(argAfterEqualSign) ? 0 : 1;
+ if (configuration["nargs-eats-options"]) {
+ if (args2.length - (i + 1) + available < toEat) {
+ error = Error(__("Not enough arguments following: %s", key));
+ }
+ available = toEat;
+ } else {
+ for (ii = i + 1; ii < args2.length; ii++) {
+ if (!args2[ii].match(/^-[^0-9]/) || args2[ii].match(negative) || isUnknownOptionAsArg(args2[ii]))
+ available++;
+ else
+ break;
+ }
+ if (available < toEat)
+ error = Error(__("Not enough arguments following: %s", key));
+ }
+ let consumed = Math.min(available, toEat);
+ if (!isUndefined(argAfterEqualSign) && consumed > 0) {
+ setArg(key, argAfterEqualSign);
+ consumed--;
+ }
+ for (ii = i + 1; ii < consumed + i + 1; ii++) {
+ setArg(key, args2[ii]);
+ }
+ return i + consumed;
+ }
+ __name(eatNargs, "eatNargs");
+ function eatArray(i, key, args2, argAfterEqualSign) {
+ let argsToSet = [];
+ let next = argAfterEqualSign || args2[i + 1];
+ const nargsCount = checkAllAliases(key, flags.nargs);
+ if (checkAllAliases(key, flags.bools) && !/^(true|false)$/.test(next)) {
+ argsToSet.push(true);
+ } else if (isUndefined(next) || isUndefined(argAfterEqualSign) && /^-/.test(next) && !negative.test(next) && !isUnknownOptionAsArg(next)) {
+ if (defaults[key] !== void 0) {
+ const defVal = defaults[key];
+ argsToSet = Array.isArray(defVal) ? defVal : [defVal];
+ }
+ } else {
+ if (!isUndefined(argAfterEqualSign)) {
+ argsToSet.push(processValue(key, argAfterEqualSign, true));
+ }
+ for (let ii = i + 1; ii < args2.length; ii++) {
+ if (!configuration["greedy-arrays"] && argsToSet.length > 0 || nargsCount && typeof nargsCount === "number" && argsToSet.length >= nargsCount)
+ break;
+ next = args2[ii];
+ if (/^-/.test(next) && !negative.test(next) && !isUnknownOptionAsArg(next))
+ break;
+ i = ii;
+ argsToSet.push(processValue(key, next, inputIsString));
+ }
+ }
+ if (typeof nargsCount === "number" && (nargsCount && argsToSet.length < nargsCount || isNaN(nargsCount) && argsToSet.length === 0)) {
+ error = Error(__("Not enough arguments following: %s", key));
+ }
+ setArg(key, argsToSet);
+ return i;
+ }
+ __name(eatArray, "eatArray");
+ function setArg(key, val, shouldStripQuotes = inputIsString) {
+ if (/-/.test(key) && configuration["camel-case-expansion"]) {
+ const alias = key.split(".").map(function(prop) {
+ return camelCase(prop);
+ }).join(".");
+ addNewAlias(key, alias);
+ }
+ const value = processValue(key, val, shouldStripQuotes);
+ const splitKey = key.split(".");
+ setKey(argv, splitKey, value);
+ if (flags.aliases[key]) {
+ flags.aliases[key].forEach(function(x) {
+ const keyProperties = x.split(".");
+ setKey(argv, keyProperties, value);
+ });
+ }
+ if (splitKey.length > 1 && configuration["dot-notation"]) {
+ ;
+ (flags.aliases[splitKey[0]] || []).forEach(function(x) {
+ let keyProperties = x.split(".");
+ const a = [].concat(splitKey);
+ a.shift();
+ keyProperties = keyProperties.concat(a);
+ if (!(flags.aliases[key] || []).includes(keyProperties.join("."))) {
+ setKey(argv, keyProperties, value);
+ }
+ });
+ }
+ if (checkAllAliases(key, flags.normalize) && !checkAllAliases(key, flags.arrays)) {
+ const keys = [key].concat(flags.aliases[key] || []);
+ keys.forEach(function(key2) {
+ Object.defineProperty(argvReturn, key2, {
+ enumerable: true,
+ get() {
+ return val;
+ },
+ set(value2) {
+ val = typeof value2 === "string" ? mixin.normalize(value2) : value2;
+ }
+ });
+ });
+ }
+ }
+ __name(setArg, "setArg");
+ function addNewAlias(key, alias) {
+ if (!(flags.aliases[key] && flags.aliases[key].length)) {
+ flags.aliases[key] = [alias];
+ newAliases[alias] = true;
+ }
+ if (!(flags.aliases[alias] && flags.aliases[alias].length)) {
+ addNewAlias(alias, key);
+ }
+ }
+ __name(addNewAlias, "addNewAlias");
+ function processValue(key, val, shouldStripQuotes) {
+ if (shouldStripQuotes) {
+ val = stripQuotes(val);
+ }
+ if (checkAllAliases(key, flags.bools) || checkAllAliases(key, flags.counts)) {
+ if (typeof val === "string")
+ val = val === "true";
+ }
+ let value = Array.isArray(val) ? val.map(function(v) {
+ return maybeCoerceNumber(key, v);
+ }) : maybeCoerceNumber(key, val);
+ if (checkAllAliases(key, flags.counts) && (isUndefined(value) || typeof value === "boolean")) {
+ value = increment();
+ }
+ if (checkAllAliases(key, flags.normalize) && checkAllAliases(key, flags.arrays)) {
+ if (Array.isArray(val))
+ value = val.map((val2) => {
+ return mixin.normalize(val2);
+ });
+ else
+ value = mixin.normalize(val);
+ }
+ return value;
+ }
+ __name(processValue, "processValue");
+ function maybeCoerceNumber(key, value) {
+ if (!configuration["parse-positional-numbers"] && key === "_")
+ return value;
+ if (!checkAllAliases(key, flags.strings) && !checkAllAliases(key, flags.bools) && !Array.isArray(value)) {
+ const shouldCoerceNumber = looksLikeNumber(value) && configuration["parse-numbers"] && Number.isSafeInteger(Math.floor(parseFloat(`${value}`)));
+ if (shouldCoerceNumber || !isUndefined(value) && checkAllAliases(key, flags.numbers)) {
+ value = Number(value);
+ }
+ }
+ return value;
+ }
+ __name(maybeCoerceNumber, "maybeCoerceNumber");
+ function setConfig(argv2) {
+ const configLookup = /* @__PURE__ */ Object.create(null);
+ applyDefaultsAndAliases(configLookup, flags.aliases, defaults);
+ Object.keys(flags.configs).forEach(function(configKey) {
+ const configPath = argv2[configKey] || configLookup[configKey];
+ if (configPath) {
+ try {
+ let config = null;
+ const resolvedConfigPath = mixin.resolve(mixin.cwd(), configPath);
+ const resolveConfig = flags.configs[configKey];
+ if (typeof resolveConfig === "function") {
+ try {
+ config = resolveConfig(resolvedConfigPath);
+ } catch (e2) {
+ config = e2;
+ }
+ if (config instanceof Error) {
+ error = config;
+ return;
+ }
+ } else {
+ config = mixin.require(resolvedConfigPath);
+ }
+ setConfigObject(config);
+ } catch (ex) {
+ if (ex.name === "PermissionDenied")
+ error = ex;
+ else if (argv2[configKey])
+ error = Error(__("Invalid JSON config file: %s", configPath));
+ }
+ }
+ });
+ }
+ __name(setConfig, "setConfig");
+ function setConfigObject(config, prev) {
+ Object.keys(config).forEach(function(key) {
+ const value = config[key];
+ const fullKey = prev ? prev + "." + key : key;
+ if (typeof value === "object" && value !== null && !Array.isArray(value) && configuration["dot-notation"]) {
+ setConfigObject(value, fullKey);
+ } else {
+ if (!hasKey2(argv, fullKey.split(".")) || checkAllAliases(fullKey, flags.arrays) && configuration["combine-arrays"]) {
+ setArg(fullKey, value);
+ }
+ }
+ });
+ }
+ __name(setConfigObject, "setConfigObject");
+ function setConfigObjects() {
+ if (typeof configObjects !== "undefined") {
+ configObjects.forEach(function(configObject) {
+ setConfigObject(configObject);
+ });
+ }
+ }
+ __name(setConfigObjects, "setConfigObjects");
+ function applyEnvVars(argv2, configOnly) {
+ if (typeof envPrefix === "undefined")
+ return;
+ const prefix = typeof envPrefix === "string" ? envPrefix : "";
+ const env5 = mixin.env();
+ Object.keys(env5).forEach(function(envVar) {
+ if (prefix === "" || envVar.lastIndexOf(prefix, 0) === 0) {
+ const keys = envVar.split("__").map(function(key, i) {
+ if (i === 0) {
+ key = key.substring(prefix.length);
+ }
+ return camelCase(key);
+ });
+ if ((configOnly && flags.configs[keys.join(".")] || !configOnly) && !hasKey2(argv2, keys)) {
+ setArg(keys.join("."), env5[envVar]);
+ }
+ }
+ });
+ }
+ __name(applyEnvVars, "applyEnvVars");
+ function applyCoercions(argv2) {
+ let coerce;
+ const applied = /* @__PURE__ */ new Set();
+ Object.keys(argv2).forEach(function(key) {
+ if (!applied.has(key)) {
+ coerce = checkAllAliases(key, flags.coercions);
+ if (typeof coerce === "function") {
+ try {
+ const value = maybeCoerceNumber(key, coerce(argv2[key]));
+ [].concat(flags.aliases[key] || [], key).forEach((ali) => {
+ applied.add(ali);
+ argv2[ali] = value;
+ });
+ } catch (err) {
+ error = err;
+ }
+ }
+ }
+ });
+ }
+ __name(applyCoercions, "applyCoercions");
+ function setPlaceholderKeys(argv2) {
+ flags.keys.forEach((key) => {
+ if (~key.indexOf("."))
+ return;
+ if (typeof argv2[key] === "undefined")
+ argv2[key] = void 0;
+ });
+ return argv2;
+ }
+ __name(setPlaceholderKeys, "setPlaceholderKeys");
+ function applyDefaultsAndAliases(obj, aliases3, defaults2, canLog = false) {
+ Object.keys(defaults2).forEach(function(key) {
+ if (!hasKey2(obj, key.split("."))) {
+ setKey(obj, key.split("."), defaults2[key]);
+ if (canLog)
+ defaulted[key] = true;
+ (aliases3[key] || []).forEach(function(x) {
+ if (hasKey2(obj, x.split(".")))
+ return;
+ setKey(obj, x.split("."), defaults2[key]);
+ });
+ }
+ });
+ }
+ __name(applyDefaultsAndAliases, "applyDefaultsAndAliases");
+ function hasKey2(obj, keys) {
+ let o = obj;
+ if (!configuration["dot-notation"])
+ keys = [keys.join(".")];
+ keys.slice(0, -1).forEach(function(key2) {
+ o = o[key2] || {};
+ });
+ const key = keys[keys.length - 1];
+ if (typeof o !== "object")
+ return false;
+ else
+ return key in o;
+ }
+ __name(hasKey2, "hasKey");
+ function setKey(obj, keys, value) {
+ let o = obj;
+ if (!configuration["dot-notation"])
+ keys = [keys.join(".")];
+ keys.slice(0, -1).forEach(function(key2) {
+ key2 = sanitizeKey(key2);
+ if (typeof o === "object" && o[key2] === void 0) {
+ o[key2] = {};
+ }
+ if (typeof o[key2] !== "object" || Array.isArray(o[key2])) {
+ if (Array.isArray(o[key2])) {
+ o[key2].push({});
+ } else {
+ o[key2] = [o[key2], {}];
+ }
+ o = o[key2][o[key2].length - 1];
+ } else {
+ o = o[key2];
+ }
+ });
+ const key = sanitizeKey(keys[keys.length - 1]);
+ const isTypeArray = checkAllAliases(keys.join("."), flags.arrays);
+ const isValueArray = Array.isArray(value);
+ let duplicate = configuration["duplicate-arguments-array"];
+ if (!duplicate && checkAllAliases(key, flags.nargs)) {
+ duplicate = true;
+ if (!isUndefined(o[key]) && flags.nargs[key] === 1 || Array.isArray(o[key]) && o[key].length === flags.nargs[key]) {
+ o[key] = void 0;
+ }
+ }
+ if (value === increment()) {
+ o[key] = increment(o[key]);
+ } else if (Array.isArray(o[key])) {
+ if (duplicate && isTypeArray && isValueArray) {
+ o[key] = configuration["flatten-duplicate-arrays"] ? o[key].concat(value) : (Array.isArray(o[key][0]) ? o[key] : [o[key]]).concat([value]);
+ } else if (!duplicate && Boolean(isTypeArray) === Boolean(isValueArray)) {
+ o[key] = value;
+ } else {
+ o[key] = o[key].concat([value]);
+ }
+ } else if (o[key] === void 0 && isTypeArray) {
+ o[key] = isValueArray ? value : [value];
+ } else if (duplicate && !(o[key] === void 0 || checkAllAliases(key, flags.counts) || checkAllAliases(key, flags.bools))) {
+ o[key] = [o[key], value];
+ } else {
+ o[key] = value;
+ }
+ }
+ __name(setKey, "setKey");
+ function extendAliases(...args2) {
+ args2.forEach(function(obj) {
+ Object.keys(obj || {}).forEach(function(key) {
+ if (flags.aliases[key])
+ return;
+ flags.aliases[key] = [].concat(aliases2[key] || []);
+ flags.aliases[key].concat(key).forEach(function(x) {
+ if (/-/.test(x) && configuration["camel-case-expansion"]) {
+ const c = camelCase(x);
+ if (c !== key && flags.aliases[key].indexOf(c) === -1) {
+ flags.aliases[key].push(c);
+ newAliases[c] = true;
+ }
+ }
+ });
+ flags.aliases[key].concat(key).forEach(function(x) {
+ if (x.length > 1 && /[A-Z]/.test(x) && configuration["camel-case-expansion"]) {
+ const c = decamelize(x, "-");
+ if (c !== key && flags.aliases[key].indexOf(c) === -1) {
+ flags.aliases[key].push(c);
+ newAliases[c] = true;
+ }
+ }
+ });
+ flags.aliases[key].forEach(function(x) {
+ flags.aliases[x] = [key].concat(flags.aliases[key].filter(function(y) {
+ return x !== y;
+ }));
+ });
+ });
+ });
+ }
+ __name(extendAliases, "extendAliases");
+ function checkAllAliases(key, flag) {
+ const toCheck = [].concat(flags.aliases[key] || [], key);
+ const keys = Object.keys(flag);
+ const setAlias = toCheck.find((key2) => keys.includes(key2));
+ return setAlias ? flag[setAlias] : false;
+ }
+ __name(checkAllAliases, "checkAllAliases");
+ function hasAnyFlag(key) {
+ const flagsKeys = Object.keys(flags);
+ const toCheck = [].concat(flagsKeys.map((k) => flags[k]));
+ return toCheck.some(function(flag) {
+ return Array.isArray(flag) ? flag.includes(key) : flag[key];
+ });
+ }
+ __name(hasAnyFlag, "hasAnyFlag");
+ function hasFlagsMatching(arg, ...patterns) {
+ const toCheck = [].concat(...patterns);
+ return toCheck.some(function(pattern) {
+ const match = arg.match(pattern);
+ return match && hasAnyFlag(match[1]);
+ });
+ }
+ __name(hasFlagsMatching, "hasFlagsMatching");
+ function hasAllShortFlags(arg) {
+ if (arg.match(negative) || !arg.match(/^-[^-]+/)) {
+ return false;
+ }
+ let hasAllFlags = true;
+ let next;
+ const letters = arg.slice(1).split("");
+ for (let j = 0; j < letters.length; j++) {
+ next = arg.slice(j + 2);
+ if (!hasAnyFlag(letters[j])) {
+ hasAllFlags = false;
+ break;
+ }
+ if (letters[j + 1] && letters[j + 1] === "=" || next === "-" || /[A-Za-z]/.test(letters[j]) && /^-?\d+(\.\d*)?(e-?\d+)?$/.test(next) || letters[j + 1] && letters[j + 1].match(/\W/)) {
+ break;
+ }
+ }
+ return hasAllFlags;
+ }
+ __name(hasAllShortFlags, "hasAllShortFlags");
+ function isUnknownOptionAsArg(arg) {
+ return configuration["unknown-options-as-args"] && isUnknownOption(arg);
+ }
+ __name(isUnknownOptionAsArg, "isUnknownOptionAsArg");
+ function isUnknownOption(arg) {
+ arg = arg.replace(/^-{3,}/, "--");
+ if (arg.match(negative)) {
+ return false;
+ }
+ if (hasAllShortFlags(arg)) {
+ return false;
+ }
+ const flagWithEquals = /^-+([^=]+?)=[\s\S]*$/;
+ const normalFlag = /^-+([^=]+?)$/;
+ const flagEndingInHyphen = /^-+([^=]+?)-$/;
+ const flagEndingInDigits = /^-+([^=]+?\d+)$/;
+ const flagEndingInNonWordCharacters = /^-+([^=]+?)\W+.*$/;
+ return !hasFlagsMatching(arg, flagWithEquals, negatedBoolean, normalFlag, flagEndingInHyphen, flagEndingInDigits, flagEndingInNonWordCharacters);
+ }
+ __name(isUnknownOption, "isUnknownOption");
+ function defaultValue(key) {
+ if (!checkAllAliases(key, flags.bools) && !checkAllAliases(key, flags.counts) && `${key}` in defaults) {
+ return defaults[key];
+ } else {
+ return defaultForType(guessType2(key));
+ }
+ }
+ __name(defaultValue, "defaultValue");
+ function defaultForType(type) {
+ const def = {
+ [DefaultValuesForTypeKey.BOOLEAN]: true,
+ [DefaultValuesForTypeKey.STRING]: "",
+ [DefaultValuesForTypeKey.NUMBER]: void 0,
+ [DefaultValuesForTypeKey.ARRAY]: []
+ };
+ return def[type];
+ }
+ __name(defaultForType, "defaultForType");
+ function guessType2(key) {
+ let type = DefaultValuesForTypeKey.BOOLEAN;
+ if (checkAllAliases(key, flags.strings))
+ type = DefaultValuesForTypeKey.STRING;
+ else if (checkAllAliases(key, flags.numbers))
+ type = DefaultValuesForTypeKey.NUMBER;
+ else if (checkAllAliases(key, flags.bools))
+ type = DefaultValuesForTypeKey.BOOLEAN;
+ else if (checkAllAliases(key, flags.arrays))
+ type = DefaultValuesForTypeKey.ARRAY;
+ return type;
+ }
+ __name(guessType2, "guessType");
+ function isUndefined(num) {
+ return num === void 0;
+ }
+ __name(isUndefined, "isUndefined");
+ function checkConfiguration() {
+ Object.keys(flags.counts).find((key) => {
+ if (checkAllAliases(key, flags.arrays)) {
+ error = Error(__("Invalid configuration: %s, opts.count excludes opts.array.", key));
+ return true;
+ } else if (checkAllAliases(key, flags.nargs)) {
+ error = Error(__("Invalid configuration: %s, opts.count excludes opts.narg.", key));
+ return true;
+ }
+ return false;
+ });
+ }
+ __name(checkConfiguration, "checkConfiguration");
+ return {
+ aliases: Object.assign({}, flags.aliases),
+ argv: Object.assign(argvReturn, argv),
+ configuration,
+ defaulted: Object.assign({}, defaulted),
+ error,
+ newAliases: Object.assign({}, newAliases)
+ };
+ }
+};
+__name(YargsParser, "YargsParser");
+function combineAliases(aliases2) {
+ const aliasArrays = [];
+ const combined = /* @__PURE__ */ Object.create(null);
+ let change = true;
+ Object.keys(aliases2).forEach(function(key) {
+ aliasArrays.push([].concat(aliases2[key], key));
+ });
+ while (change) {
+ change = false;
+ for (let i = 0; i < aliasArrays.length; i++) {
+ for (let ii = i + 1; ii < aliasArrays.length; ii++) {
+ const intersect = aliasArrays[i].filter(function(v) {
+ return aliasArrays[ii].indexOf(v) !== -1;
+ });
+ if (intersect.length) {
+ aliasArrays[i] = aliasArrays[i].concat(aliasArrays[ii]);
+ aliasArrays.splice(ii, 1);
+ change = true;
+ break;
+ }
+ }
+ }
+ }
+ aliasArrays.forEach(function(aliasArray) {
+ aliasArray = aliasArray.filter(function(v, i, self2) {
+ return self2.indexOf(v) === i;
+ });
+ const lastAlias = aliasArray.pop();
+ if (lastAlias !== void 0 && typeof lastAlias === "string") {
+ combined[lastAlias] = aliasArray;
+ }
+ });
+ return combined;
+}
+__name(combineAliases, "combineAliases");
+function increment(orig) {
+ return orig !== void 0 ? orig + 1 : 1;
+}
+__name(increment, "increment");
+function sanitizeKey(key) {
+ if (key === "__proto__")
+ return "___proto___";
+ return key;
+}
+__name(sanitizeKey, "sanitizeKey");
+function stripQuotes(val) {
+ return typeof val === "string" && (val[0] === "'" || val[0] === '"') && val[val.length - 1] === val[0] ? val.substring(1, val.length - 1) : val;
+}
+__name(stripQuotes, "stripQuotes");
+
+// ../../node_modules/.pnpm/yargs-parser@21.1.1/node_modules/yargs-parser/build/lib/index.js
+var import_fs = require("fs");
+var _a;
+var _b;
+var _c;
+var minNodeVersion = process && process.env && process.env.YARGS_MIN_NODE_VERSION ? Number(process.env.YARGS_MIN_NODE_VERSION) : 12;
+var nodeVersion = (_b = (_a = process === null || process === void 0 ? void 0 : process.versions) === null || _a === void 0 ? void 0 : _a.node) !== null && _b !== void 0 ? _b : (_c = process === null || process === void 0 ? void 0 : process.version) === null || _c === void 0 ? void 0 : _c.slice(1);
+if (nodeVersion) {
+ const major = Number(nodeVersion.match(/^([^.]+)/)[1]);
+ if (major < minNodeVersion) {
+ throw Error(`yargs parser supports a minimum Node.js version of ${minNodeVersion}. Read our version support policy: https://github.com/yargs/yargs-parser#supported-nodejs-versions`);
+ }
+}
+var env = process ? process.env : {};
+var parser = new YargsParser({
+ cwd: process.cwd,
+ env: () => {
+ return env;
+ },
+ format: import_util.format,
+ normalize: import_path.normalize,
+ resolve: import_path.resolve,
+ // TODO: figure out a way to combine ESM and CJS coverage, such that
+ // we can exercise all the lines below:
+ require: (path45) => {
+ if (typeof require !== "undefined") {
+ return require(path45);
+ } else if (path45.match(/\.json$/)) {
+ return JSON.parse((0, import_fs.readFileSync)(path45, "utf8"));
+ } else {
+ throw Error("only .json config files are supported in ESM");
+ }
+ }
+});
+var yargsParser = /* @__PURE__ */ __name(function Parser(args, opts) {
+ const result = parser.parse(args.slice(), opts);
+ return result.argv;
+}, "Parser");
+yargsParser.detailed = function(args, opts) {
+ return parser.parse(args.slice(), opts);
+};
+yargsParser.camelCase = camelCase;
+yargsParser.decamelize = decamelize;
+yargsParser.looksLikeNumber = looksLikeNumber;
+var lib_default = yargsParser;
+
+// ../../node_modules/.pnpm/yargs@17.7.1/node_modules/yargs/lib/platform-shims/esm.mjs
+init_import_meta_url();
+var import_assert = require("assert");
+
+// ../../node_modules/.pnpm/cliui@8.0.1/node_modules/cliui/index.mjs
+init_import_meta_url();
+
+// ../../node_modules/.pnpm/cliui@8.0.1/node_modules/cliui/build/lib/index.js
+init_import_meta_url();
+var align = {
+ right: alignRight,
+ center: alignCenter
+};
+var top = 0;
+var right = 1;
+var bottom = 2;
+var left = 3;
+var UI = class {
+ constructor(opts) {
+ var _a2;
+ this.width = opts.width;
+ this.wrap = (_a2 = opts.wrap) !== null && _a2 !== void 0 ? _a2 : true;
+ this.rows = [];
+ }
+ span(...args) {
+ const cols = this.div(...args);
+ cols.span = true;
+ }
+ resetOutput() {
+ this.rows = [];
+ }
+ div(...args) {
+ if (args.length === 0) {
+ this.div("");
+ }
+ if (this.wrap && this.shouldApplyLayoutDSL(...args) && typeof args[0] === "string") {
+ return this.applyLayoutDSL(args[0]);
+ }
+ const cols = args.map((arg) => {
+ if (typeof arg === "string") {
+ return this.colFromString(arg);
+ }
+ return arg;
+ });
+ this.rows.push(cols);
+ return cols;
+ }
+ shouldApplyLayoutDSL(...args) {
+ return args.length === 1 && typeof args[0] === "string" && /[\t\n]/.test(args[0]);
+ }
+ applyLayoutDSL(str) {
+ const rows = str.split("\n").map((row) => row.split(" "));
+ let leftColumnWidth = 0;
+ rows.forEach((columns) => {
+ if (columns.length > 1 && mixin2.stringWidth(columns[0]) > leftColumnWidth) {
+ leftColumnWidth = Math.min(Math.floor(this.width * 0.5), mixin2.stringWidth(columns[0]));
+ }
+ });
+ rows.forEach((columns) => {
+ this.div(...columns.map((r, i) => {
+ return {
+ text: r.trim(),
+ padding: this.measurePadding(r),
+ width: i === 0 && columns.length > 1 ? leftColumnWidth : void 0
+ };
+ }));
+ });
+ return this.rows[this.rows.length - 1];
+ }
+ colFromString(text) {
+ return {
+ text,
+ padding: this.measurePadding(text)
+ };
+ }
+ measurePadding(str) {
+ const noAnsi = mixin2.stripAnsi(str);
+ return [0, noAnsi.match(/\s*$/)[0].length, 0, noAnsi.match(/^\s*/)[0].length];
+ }
+ toString() {
+ const lines = [];
+ this.rows.forEach((row) => {
+ this.rowToString(row, lines);
+ });
+ return lines.filter((line) => !line.hidden).map((line) => line.text).join("\n");
+ }
+ rowToString(row, lines) {
+ this.rasterize(row).forEach((rrow, r) => {
+ let str = "";
+ rrow.forEach((col, c) => {
+ const { width } = row[c];
+ const wrapWidth = this.negatePadding(row[c]);
+ let ts = col;
+ if (wrapWidth > mixin2.stringWidth(col)) {
+ ts += " ".repeat(wrapWidth - mixin2.stringWidth(col));
+ }
+ if (row[c].align && row[c].align !== "left" && this.wrap) {
+ const fn2 = align[row[c].align];
+ ts = fn2(ts, wrapWidth);
+ if (mixin2.stringWidth(ts) < wrapWidth) {
+ ts += " ".repeat((width || 0) - mixin2.stringWidth(ts) - 1);
+ }
+ }
+ const padding = row[c].padding || [0, 0, 0, 0];
+ if (padding[left]) {
+ str += " ".repeat(padding[left]);
+ }
+ str += addBorder(row[c], ts, "| ");
+ str += ts;
+ str += addBorder(row[c], ts, " |");
+ if (padding[right]) {
+ str += " ".repeat(padding[right]);
+ }
+ if (r === 0 && lines.length > 0) {
+ str = this.renderInline(str, lines[lines.length - 1]);
+ }
+ });
+ lines.push({
+ text: str.replace(/ +$/, ""),
+ span: row.span
+ });
+ });
+ return lines;
+ }
+ // if the full 'source' can render in
+ // the target line, do so.
+ renderInline(source, previousLine) {
+ const match = source.match(/^ */);
+ const leadingWhitespace = match ? match[0].length : 0;
+ const target = previousLine.text;
+ const targetTextWidth = mixin2.stringWidth(target.trimRight());
+ if (!previousLine.span) {
+ return source;
+ }
+ if (!this.wrap) {
+ previousLine.hidden = true;
+ return target + source;
+ }
+ if (leadingWhitespace < targetTextWidth) {
+ return source;
+ }
+ previousLine.hidden = true;
+ return target.trimRight() + " ".repeat(leadingWhitespace - targetTextWidth) + source.trimLeft();
+ }
+ rasterize(row) {
+ const rrows = [];
+ const widths = this.columnWidths(row);
+ let wrapped;
+ row.forEach((col, c) => {
+ col.width = widths[c];
+ if (this.wrap) {
+ wrapped = mixin2.wrap(col.text, this.negatePadding(col), { hard: true }).split("\n");
+ } else {
+ wrapped = col.text.split("\n");
+ }
+ if (col.border) {
+ wrapped.unshift("." + "-".repeat(this.negatePadding(col) + 2) + ".");
+ wrapped.push("'" + "-".repeat(this.negatePadding(col) + 2) + "'");
+ }
+ if (col.padding) {
+ wrapped.unshift(...new Array(col.padding[top] || 0).fill(""));
+ wrapped.push(...new Array(col.padding[bottom] || 0).fill(""));
+ }
+ wrapped.forEach((str, r) => {
+ if (!rrows[r]) {
+ rrows.push([]);
+ }
+ const rrow = rrows[r];
+ for (let i = 0; i < c; i++) {
+ if (rrow[i] === void 0) {
+ rrow.push("");
+ }
+ }
+ rrow.push(str);
+ });
+ });
+ return rrows;
+ }
+ negatePadding(col) {
+ let wrapWidth = col.width || 0;
+ if (col.padding) {
+ wrapWidth -= (col.padding[left] || 0) + (col.padding[right] || 0);
+ }
+ if (col.border) {
+ wrapWidth -= 4;
+ }
+ return wrapWidth;
+ }
+ columnWidths(row) {
+ if (!this.wrap) {
+ return row.map((col) => {
+ return col.width || mixin2.stringWidth(col.text);
+ });
+ }
+ let unset = row.length;
+ let remainingWidth = this.width;
+ const widths = row.map((col) => {
+ if (col.width) {
+ unset--;
+ remainingWidth -= col.width;
+ return col.width;
+ }
+ return void 0;
+ });
+ const unsetWidth = unset ? Math.floor(remainingWidth / unset) : 0;
+ return widths.map((w, i) => {
+ if (w === void 0) {
+ return Math.max(unsetWidth, _minWidth(row[i]));
+ }
+ return w;
+ });
+ }
+};
+__name(UI, "UI");
+function addBorder(col, ts, style) {
+ if (col.border) {
+ if (/[.']-+[.']/.test(ts)) {
+ return "";
+ }
+ if (ts.trim().length !== 0) {
+ return style;
+ }
+ return " ";
+ }
+ return "";
+}
+__name(addBorder, "addBorder");
+function _minWidth(col) {
+ const padding = col.padding || [];
+ const minWidth = 1 + (padding[left] || 0) + (padding[right] || 0);
+ if (col.border) {
+ return minWidth + 4;
+ }
+ return minWidth;
+}
+__name(_minWidth, "_minWidth");
+function getWindowWidth() {
+ if (typeof process === "object" && process.stdout && process.stdout.columns) {
+ return process.stdout.columns;
+ }
+ return 80;
+}
+__name(getWindowWidth, "getWindowWidth");
+function alignRight(str, width) {
+ str = str.trim();
+ const strWidth = mixin2.stringWidth(str);
+ if (strWidth < width) {
+ return " ".repeat(width - strWidth) + str;
+ }
+ return str;
+}
+__name(alignRight, "alignRight");
+function alignCenter(str, width) {
+ str = str.trim();
+ const strWidth = mixin2.stringWidth(str);
+ if (strWidth >= width) {
+ return str;
+ }
+ return " ".repeat(width - strWidth >> 1) + str;
+}
+__name(alignCenter, "alignCenter");
+var mixin2;
+function cliui(opts, _mixin) {
+ mixin2 = _mixin;
+ return new UI({
+ width: (opts === null || opts === void 0 ? void 0 : opts.width) || getWindowWidth(),
+ wrap: opts === null || opts === void 0 ? void 0 : opts.wrap
+ });
+}
+__name(cliui, "cliui");
+
+// ../../node_modules/.pnpm/cliui@8.0.1/node_modules/cliui/build/lib/string-utils.js
+init_import_meta_url();
+var ansi = new RegExp("\x1B(?:\\[(?:\\d+[ABCDEFGJKSTm]|\\d+;\\d+[Hfm]|\\d+;\\d+;\\d+m|6n|s|u|\\?25[lh])|\\w)", "g");
+function stripAnsi(str) {
+ return str.replace(ansi, "");
+}
+__name(stripAnsi, "stripAnsi");
+function wrap(str, width) {
+ const [start, end] = str.match(ansi) || ["", ""];
+ str = stripAnsi(str);
+ let wrapped = "";
+ for (let i = 0; i < str.length; i++) {
+ if (i !== 0 && i % width === 0) {
+ wrapped += "\n";
+ }
+ wrapped += str.charAt(i);
+ }
+ if (start && end) {
+ wrapped = `${start}${wrapped}${end}`;
+ }
+ return wrapped;
+}
+__name(wrap, "wrap");
+
+// ../../node_modules/.pnpm/cliui@8.0.1/node_modules/cliui/index.mjs
+function ui(opts) {
+ return cliui(opts, {
+ stringWidth: (str) => {
+ return [...str].length;
+ },
+ stripAnsi,
+ wrap
+ });
+}
+__name(ui, "ui");
+
+// ../../node_modules/.pnpm/escalade@3.1.1/node_modules/escalade/sync/index.mjs
+init_import_meta_url();
+var import_path2 = require("path");
+var import_fs2 = require("fs");
+function sync_default(start, callback) {
+ let dir = (0, import_path2.resolve)(".", start);
+ let tmp5, stats = (0, import_fs2.statSync)(dir);
+ if (!stats.isDirectory()) {
+ dir = (0, import_path2.dirname)(dir);
+ }
+ while (true) {
+ tmp5 = callback(dir, (0, import_fs2.readdirSync)(dir));
+ if (tmp5)
+ return (0, import_path2.resolve)(dir, tmp5);
+ dir = (0, import_path2.dirname)(tmp5 = dir);
+ if (tmp5 === dir)
+ break;
+ }
+}
+__name(sync_default, "default");
+
+// ../../node_modules/.pnpm/yargs@17.7.1/node_modules/yargs/lib/platform-shims/esm.mjs
+var import_util3 = require("util");
+var import_fs4 = require("fs");
+var import_url = require("url");
+var import_path4 = require("path");
+
+// ../../node_modules/.pnpm/y18n@5.0.8/node_modules/y18n/index.mjs
+init_import_meta_url();
+
+// ../../node_modules/.pnpm/y18n@5.0.8/node_modules/y18n/build/lib/platform-shims/node.js
+init_import_meta_url();
+var import_fs3 = require("fs");
+var import_util2 = require("util");
+var import_path3 = require("path");
+var node_default = {
+ fs: {
+ readFileSync: import_fs3.readFileSync,
+ writeFile: import_fs3.writeFile
+ },
+ format: import_util2.format,
+ resolve: import_path3.resolve,
+ exists: (file) => {
+ try {
+ return (0, import_fs3.statSync)(file).isFile();
+ } catch (err) {
+ return false;
+ }
+ }
+};
+
+// ../../node_modules/.pnpm/y18n@5.0.8/node_modules/y18n/build/lib/index.js
+init_import_meta_url();
+var shim2;
+var Y18N = class {
+ constructor(opts) {
+ opts = opts || {};
+ this.directory = opts.directory || "./locales";
+ this.updateFiles = typeof opts.updateFiles === "boolean" ? opts.updateFiles : true;
+ this.locale = opts.locale || "en";
+ this.fallbackToLanguage = typeof opts.fallbackToLanguage === "boolean" ? opts.fallbackToLanguage : true;
+ this.cache = /* @__PURE__ */ Object.create(null);
+ this.writeQueue = [];
+ }
+ __(...args) {
+ if (typeof arguments[0] !== "string") {
+ return this._taggedLiteral(arguments[0], ...arguments);
+ }
+ const str = args.shift();
+ let cb = /* @__PURE__ */ __name(function() {
+ }, "cb");
+ if (typeof args[args.length - 1] === "function")
+ cb = args.pop();
+ cb = cb || function() {
+ };
+ if (!this.cache[this.locale])
+ this._readLocaleFile();
+ if (!this.cache[this.locale][str] && this.updateFiles) {
+ this.cache[this.locale][str] = str;
+ this._enqueueWrite({
+ directory: this.directory,
+ locale: this.locale,
+ cb
+ });
+ } else {
+ cb();
+ }
+ return shim2.format.apply(shim2.format, [this.cache[this.locale][str] || str].concat(args));
+ }
+ __n() {
+ const args = Array.prototype.slice.call(arguments);
+ const singular = args.shift();
+ const plural = args.shift();
+ const quantity = args.shift();
+ let cb = /* @__PURE__ */ __name(function() {
+ }, "cb");
+ if (typeof args[args.length - 1] === "function")
+ cb = args.pop();
+ if (!this.cache[this.locale])
+ this._readLocaleFile();
+ let str = quantity === 1 ? singular : plural;
+ if (this.cache[this.locale][singular]) {
+ const entry = this.cache[this.locale][singular];
+ str = entry[quantity === 1 ? "one" : "other"];
+ }
+ if (!this.cache[this.locale][singular] && this.updateFiles) {
+ this.cache[this.locale][singular] = {
+ one: singular,
+ other: plural
+ };
+ this._enqueueWrite({
+ directory: this.directory,
+ locale: this.locale,
+ cb
+ });
+ } else {
+ cb();
+ }
+ const values = [str];
+ if (~str.indexOf("%d"))
+ values.push(quantity);
+ return shim2.format.apply(shim2.format, values.concat(args));
+ }
+ setLocale(locale) {
+ this.locale = locale;
+ }
+ getLocale() {
+ return this.locale;
+ }
+ updateLocale(obj) {
+ if (!this.cache[this.locale])
+ this._readLocaleFile();
+ for (const key in obj) {
+ if (Object.prototype.hasOwnProperty.call(obj, key)) {
+ this.cache[this.locale][key] = obj[key];
+ }
+ }
+ }
+ _taggedLiteral(parts, ...args) {
+ let str = "";
+ parts.forEach(function(part, i) {
+ const arg = args[i + 1];
+ str += part;
+ if (typeof arg !== "undefined") {
+ str += "%s";
+ }
+ });
+ return this.__.apply(this, [str].concat([].slice.call(args, 1)));
+ }
+ _enqueueWrite(work) {
+ this.writeQueue.push(work);
+ if (this.writeQueue.length === 1)
+ this._processWriteQueue();
+ }
+ _processWriteQueue() {
+ const _this = this;
+ const work = this.writeQueue[0];
+ const directory = work.directory;
+ const locale = work.locale;
+ const cb = work.cb;
+ const languageFile = this._resolveLocaleFile(directory, locale);
+ const serializedLocale = JSON.stringify(this.cache[locale], null, 2);
+ shim2.fs.writeFile(languageFile, serializedLocale, "utf-8", function(err) {
+ _this.writeQueue.shift();
+ if (_this.writeQueue.length > 0)
+ _this._processWriteQueue();
+ cb(err);
+ });
+ }
+ _readLocaleFile() {
+ let localeLookup = {};
+ const languageFile = this._resolveLocaleFile(this.directory, this.locale);
+ try {
+ if (shim2.fs.readFileSync) {
+ localeLookup = JSON.parse(shim2.fs.readFileSync(languageFile, "utf-8"));
+ }
+ } catch (err) {
+ if (err instanceof SyntaxError) {
+ err.message = "syntax error in " + languageFile;
+ }
+ if (err.code === "ENOENT")
+ localeLookup = {};
+ else
+ throw err;
+ }
+ this.cache[this.locale] = localeLookup;
+ }
+ _resolveLocaleFile(directory, locale) {
+ let file = shim2.resolve(directory, "./", locale + ".json");
+ if (this.fallbackToLanguage && !this._fileExistsSync(file) && ~locale.lastIndexOf("_")) {
+ const languageFile = shim2.resolve(directory, "./", locale.split("_")[0] + ".json");
+ if (this._fileExistsSync(languageFile))
+ file = languageFile;
+ }
+ return file;
+ }
+ _fileExistsSync(file) {
+ return shim2.exists(file);
+ }
+};
+__name(Y18N, "Y18N");
+function y18n(opts, _shim) {
+ shim2 = _shim;
+ const y18n3 = new Y18N(opts);
+ return {
+ __: y18n3.__.bind(y18n3),
+ __n: y18n3.__n.bind(y18n3),
+ setLocale: y18n3.setLocale.bind(y18n3),
+ getLocale: y18n3.getLocale.bind(y18n3),
+ updateLocale: y18n3.updateLocale.bind(y18n3),
+ locale: y18n3.locale
+ };
+}
+__name(y18n, "y18n");
+
+// ../../node_modules/.pnpm/y18n@5.0.8/node_modules/y18n/index.mjs
+var y18n2 = /* @__PURE__ */ __name((opts) => {
+ return y18n(opts, node_default);
+}, "y18n");
+var y18n_default = y18n2;
+
+// ../../node_modules/.pnpm/yargs@17.7.1/node_modules/yargs/lib/platform-shims/esm.mjs
+var REQUIRE_ERROR = "require is not supported by ESM";
+var REQUIRE_DIRECTORY_ERROR = "loading a directory of commands is not supported yet for ESM";
+var __dirname2;
+try {
+ __dirname2 = (0, import_url.fileURLToPath)(import_meta_url);
+} catch (e2) {
+ __dirname2 = process.cwd();
+}
+var mainFilename = __dirname2.substring(0, __dirname2.lastIndexOf("node_modules"));
+var esm_default = {
+ assert: {
+ notStrictEqual: import_assert.notStrictEqual,
+ strictEqual: import_assert.strictEqual
+ },
+ cliui: ui,
+ findUp: sync_default,
+ getEnv: (key) => {
+ return process.env[key];
+ },
+ inspect: import_util3.inspect,
+ getCallerFile: () => {
+ throw new YError(REQUIRE_DIRECTORY_ERROR);
+ },
+ getProcessArgvBin,
+ mainFilename: mainFilename || process.cwd(),
+ Parser: lib_default,
+ path: {
+ basename: import_path4.basename,
+ dirname: import_path4.dirname,
+ extname: import_path4.extname,
+ relative: import_path4.relative,
+ resolve: import_path4.resolve
+ },
+ process: {
+ argv: () => process.argv,
+ cwd: process.cwd,
+ emitWarning: (warning, type) => process.emitWarning(warning, type),
+ execPath: () => process.execPath,
+ exit: process.exit,
+ nextTick: process.nextTick,
+ stdColumns: typeof process.stdout.columns !== "undefined" ? process.stdout.columns : null
+ },
+ readFileSync: import_fs4.readFileSync,
+ require: () => {
+ throw new YError(REQUIRE_ERROR);
+ },
+ requireDirectory: () => {
+ throw new YError(REQUIRE_DIRECTORY_ERROR);
+ },
+ stringWidth: (str) => {
+ return [...str].length;
+ },
+ y18n: y18n_default({
+ directory: (0, import_path4.resolve)(__dirname2, "../../../locales"),
+ updateFiles: false
+ })
+};
+
+// src/api/index.ts
+init_import_meta_url();
+
+// src/api/dev.ts
+init_import_meta_url();
+var import_undici18 = __toESM(require_undici());
+
+// src/dev.tsx
+init_import_meta_url();
+var import_node_path46 = __toESM(require("node:path"));
+var import_env = __toESM(require_dist());
+var import_chalk16 = __toESM(require_chalk());
+var import_chokidar5 = require("chokidar");
+
+// ../../node_modules/.pnpm/get-port@6.1.2/node_modules/get-port/index.js
+init_import_meta_url();
+var import_node_net = __toESM(require("node:net"), 1);
+var import_node_os = __toESM(require("node:os"), 1);
+var Locked = class extends Error {
+ constructor(port2) {
+ super(`${port2} is locked`);
+ }
+};
+__name(Locked, "Locked");
+var lockedPorts = {
+ old: /* @__PURE__ */ new Set(),
+ young: /* @__PURE__ */ new Set()
+};
+var releaseOldLockedPortsIntervalMs = 1e3 * 15;
+var interval;
+var getLocalHosts = /* @__PURE__ */ __name(() => {
+ const interfaces = import_node_os.default.networkInterfaces();
+ const results = /* @__PURE__ */ new Set([void 0, "0.0.0.0"]);
+ for (const _interface of Object.values(interfaces)) {
+ for (const config of _interface) {
+ results.add(config.address);
+ }
+ }
+ return results;
+}, "getLocalHosts");
+var checkAvailablePort = /* @__PURE__ */ __name((options14) => new Promise((resolve18, reject) => {
+ const server2 = import_node_net.default.createServer();
+ server2.unref();
+ server2.on("error", reject);
+ server2.listen(options14, () => {
+ const { port: port2 } = server2.address();
+ server2.close(() => {
+ resolve18(port2);
+ });
+ });
+}), "checkAvailablePort");
+var getAvailablePort = /* @__PURE__ */ __name(async (options14, hosts) => {
+ if (options14.host || options14.port === 0) {
+ return checkAvailablePort(options14);
+ }
+ for (const host of hosts) {
+ try {
+ await checkAvailablePort({ port: options14.port, host });
+ } catch (error) {
+ if (!["EADDRNOTAVAIL", "EINVAL"].includes(error.code)) {
+ throw error;
+ }
+ }
+ }
+ return options14.port;
+}, "getAvailablePort");
+var portCheckSequence = /* @__PURE__ */ __name(function* (ports) {
+ if (ports) {
+ yield* ports;
+ }
+ yield 0;
+}, "portCheckSequence");
+async function getPorts(options14) {
+ let ports;
+ let exclude = /* @__PURE__ */ new Set();
+ if (options14) {
+ if (options14.port) {
+ ports = typeof options14.port === "number" ? [options14.port] : options14.port;
+ }
+ if (options14.exclude) {
+ const excludeIterable = options14.exclude;
+ if (typeof excludeIterable[Symbol.iterator] !== "function") {
+ throw new TypeError("The `exclude` option must be an iterable.");
+ }
+ for (const element of excludeIterable) {
+ if (typeof element !== "number") {
+ throw new TypeError("Each item in the `exclude` option must be a number corresponding to the port you want excluded.");
+ }
+ if (!Number.isSafeInteger(element)) {
+ throw new TypeError(`Number ${element} in the exclude option is not a safe integer and can't be used`);
+ }
+ }
+ exclude = new Set(excludeIterable);
+ }
+ }
+ if (interval === void 0) {
+ interval = setInterval(() => {
+ lockedPorts.old = lockedPorts.young;
+ lockedPorts.young = /* @__PURE__ */ new Set();
+ }, releaseOldLockedPortsIntervalMs);
+ if (interval.unref) {
+ interval.unref();
+ }
+ }
+ const hosts = getLocalHosts();
+ for (const port2 of portCheckSequence(ports)) {
+ try {
+ if (exclude.has(port2)) {
+ continue;
+ }
+ let availablePort = await getAvailablePort({ ...options14, port: port2 }, hosts);
+ while (lockedPorts.old.has(availablePort) || lockedPorts.young.has(availablePort)) {
+ if (port2 !== 0) {
+ throw new Locked(port2);
+ }
+ availablePort = await getAvailablePort({ ...options14, port: port2 }, hosts);
+ }
+ lockedPorts.young.add(availablePort);
+ return availablePort;
+ } catch (error) {
+ if (!["EADDRINUSE", "EACCES"].includes(error.code) && !(error instanceof Locked)) {
+ throw error;
+ }
+ }
+ }
+ throw new Error("No available ports found");
+}
+__name(getPorts, "getPorts");
+
+// src/dev.tsx
+var import_ink13 = __toESM(require_build2());
+var import_react20 = __toESM(require_react());
+
+// src/config/index.ts
+init_import_meta_url();
+var import_node_fs4 = __toESM(require("node:fs"));
+var import_dotenv = __toESM(require_main());
+
+// ../../node_modules/.pnpm/find-up@6.3.0/node_modules/find-up/index.js
+init_import_meta_url();
+var import_node_path2 = __toESM(require("node:path"), 1);
+var import_node_url2 = require("node:url");
+
+// ../../node_modules/.pnpm/locate-path@7.1.0/node_modules/locate-path/index.js
+init_import_meta_url();
+var import_node_process = __toESM(require("node:process"), 1);
+var import_node_path = __toESM(require("node:path"), 1);
+var import_node_fs = __toESM(require("node:fs"), 1);
+var import_node_url = require("node:url");
+
+// ../../node_modules/.pnpm/p-locate@6.0.0/node_modules/p-locate/index.js
+init_import_meta_url();
+
+// ../../node_modules/.pnpm/p-limit@4.0.0/node_modules/p-limit/index.js
+init_import_meta_url();
+
+// ../../node_modules/.pnpm/yocto-queue@1.0.0/node_modules/yocto-queue/index.js
+init_import_meta_url();
+var Node2 = class {
+ value;
+ next;
+ constructor(value) {
+ this.value = value;
+ }
+};
+__name(Node2, "Node");
+var Queue = class {
+ #head;
+ #tail;
+ #size;
+ constructor() {
+ this.clear();
+ }
+ enqueue(value) {
+ const node = new Node2(value);
+ if (this.#head) {
+ this.#tail.next = node;
+ this.#tail = node;
+ } else {
+ this.#head = node;
+ this.#tail = node;
+ }
+ this.#size++;
+ }
+ dequeue() {
+ const current = this.#head;
+ if (!current) {
+ return;
+ }
+ this.#head = this.#head.next;
+ this.#size--;
+ return current.value;
+ }
+ clear() {
+ this.#head = void 0;
+ this.#tail = void 0;
+ this.#size = 0;
+ }
+ get size() {
+ return this.#size;
+ }
+ *[Symbol.iterator]() {
+ let current = this.#head;
+ while (current) {
+ yield current.value;
+ current = current.next;
+ }
+ }
+};
+__name(Queue, "Queue");
+
+// ../../node_modules/.pnpm/p-limit@4.0.0/node_modules/p-limit/index.js
+function pLimit(concurrency) {
+ if (!((Number.isInteger(concurrency) || concurrency === Number.POSITIVE_INFINITY) && concurrency > 0)) {
+ throw new TypeError("Expected `concurrency` to be a number from 1 and up");
+ }
+ const queue = new Queue();
+ let activeCount = 0;
+ const next = /* @__PURE__ */ __name(() => {
+ activeCount--;
+ if (queue.size > 0) {
+ queue.dequeue()();
+ }
+ }, "next");
+ const run = /* @__PURE__ */ __name(async (fn2, resolve18, args) => {
+ activeCount++;
+ const result = (async () => fn2(...args))();
+ resolve18(result);
+ try {
+ await result;
+ } catch {
+ }
+ next();
+ }, "run");
+ const enqueue = /* @__PURE__ */ __name((fn2, resolve18, args) => {
+ queue.enqueue(run.bind(void 0, fn2, resolve18, args));
+ (async () => {
+ await Promise.resolve();
+ if (activeCount < concurrency && queue.size > 0) {
+ queue.dequeue()();
+ }
+ })();
+ }, "enqueue");
+ const generator = /* @__PURE__ */ __name((fn2, ...args) => new Promise((resolve18) => {
+ enqueue(fn2, resolve18, args);
+ }), "generator");
+ Object.defineProperties(generator, {
+ activeCount: {
+ get: () => activeCount
+ },
+ pendingCount: {
+ get: () => queue.size
+ },
+ clearQueue: {
+ value: () => {
+ queue.clear();
+ }
+ }
+ });
+ return generator;
+}
+__name(pLimit, "pLimit");
+
+// ../../node_modules/.pnpm/p-locate@6.0.0/node_modules/p-locate/index.js
+var EndError = class extends Error {
+ constructor(value) {
+ super();
+ this.value = value;
+ }
+};
+__name(EndError, "EndError");
+var testElement = /* @__PURE__ */ __name(async (element, tester) => tester(await element), "testElement");
+var finder = /* @__PURE__ */ __name(async (element) => {
+ const values = await Promise.all(element);
+ if (values[1] === true) {
+ throw new EndError(values[0]);
+ }
+ return false;
+}, "finder");
+async function pLocate(iterable, tester, {
+ concurrency = Number.POSITIVE_INFINITY,
+ preserveOrder = true
+} = {}) {
+ const limit = pLimit(concurrency);
+ const items = [...iterable].map((element) => [element, limit(testElement, element, tester)]);
+ const checkLimit = pLimit(preserveOrder ? 1 : Number.POSITIVE_INFINITY);
+ try {
+ await Promise.all(items.map((element) => checkLimit(finder, element)));
+ } catch (error) {
+ if (error instanceof EndError) {
+ return error.value;
+ }
+ throw error;
+ }
+}
+__name(pLocate, "pLocate");
+
+// ../../node_modules/.pnpm/locate-path@7.1.0/node_modules/locate-path/index.js
+var typeMappings = {
+ directory: "isDirectory",
+ file: "isFile"
+};
+function checkType(type) {
+ if (type in typeMappings) {
+ return;
+ }
+ throw new Error(`Invalid type specified: ${type}`);
+}
+__name(checkType, "checkType");
+var matchType = /* @__PURE__ */ __name((type, stat3) => type === void 0 || stat3[typeMappings[type]](), "matchType");
+var toPath = /* @__PURE__ */ __name((urlOrPath) => urlOrPath instanceof URL ? (0, import_node_url.fileURLToPath)(urlOrPath) : urlOrPath, "toPath");
+async function locatePath(paths, {
+ cwd: cwd2 = import_node_process.default.cwd(),
+ type = "file",
+ allowSymlinks = true,
+ concurrency,
+ preserveOrder
+} = {}) {
+ checkType(type);
+ cwd2 = toPath(cwd2);
+ const statFunction = allowSymlinks ? import_node_fs.promises.stat : import_node_fs.promises.lstat;
+ return pLocate(paths, async (path_) => {
+ try {
+ const stat3 = await statFunction(import_node_path.default.resolve(cwd2, path_));
+ return matchType(type, stat3);
+ } catch {
+ return false;
+ }
+ }, { concurrency, preserveOrder });
+}
+__name(locatePath, "locatePath");
+function locatePathSync(paths, {
+ cwd: cwd2 = import_node_process.default.cwd(),
+ type = "file",
+ allowSymlinks = true
+} = {}) {
+ checkType(type);
+ cwd2 = toPath(cwd2);
+ const statFunction = allowSymlinks ? import_node_fs.default.statSync : import_node_fs.default.lstatSync;
+ for (const path_ of paths) {
+ try {
+ const stat3 = statFunction(import_node_path.default.resolve(cwd2, path_));
+ if (matchType(type, stat3)) {
+ return path_;
+ }
+ } catch {
+ }
+ }
+}
+__name(locatePathSync, "locatePathSync");
+
+// ../../node_modules/.pnpm/path-exists@5.0.0/node_modules/path-exists/index.js
+init_import_meta_url();
+
+// ../../node_modules/.pnpm/find-up@6.3.0/node_modules/find-up/index.js
+var toPath2 = /* @__PURE__ */ __name((urlOrPath) => urlOrPath instanceof URL ? (0, import_node_url2.fileURLToPath)(urlOrPath) : urlOrPath, "toPath");
+var findUpStop = Symbol("findUpStop");
+async function findUpMultiple(name, options14 = {}) {
+ let directory = import_node_path2.default.resolve(toPath2(options14.cwd) || "");
+ const { root } = import_node_path2.default.parse(directory);
+ const stopAt = import_node_path2.default.resolve(directory, options14.stopAt || root);
+ const limit = options14.limit || Number.POSITIVE_INFINITY;
+ const paths = [name].flat();
+ const runMatcher = /* @__PURE__ */ __name(async (locateOptions) => {
+ if (typeof name !== "function") {
+ return locatePath(paths, locateOptions);
+ }
+ const foundPath = await name(locateOptions.cwd);
+ if (typeof foundPath === "string") {
+ return locatePath([foundPath], locateOptions);
+ }
+ return foundPath;
+ }, "runMatcher");
+ const matches = [];
+ while (true) {
+ const foundPath = await runMatcher({ ...options14, cwd: directory });
+ if (foundPath === findUpStop) {
+ break;
+ }
+ if (foundPath) {
+ matches.push(import_node_path2.default.resolve(directory, foundPath));
+ }
+ if (directory === stopAt || matches.length >= limit) {
+ break;
+ }
+ directory = import_node_path2.default.dirname(directory);
+ }
+ return matches;
+}
+__name(findUpMultiple, "findUpMultiple");
+function findUpMultipleSync(name, options14 = {}) {
+ let directory = import_node_path2.default.resolve(toPath2(options14.cwd) || "");
+ const { root } = import_node_path2.default.parse(directory);
+ const stopAt = options14.stopAt || root;
+ const limit = options14.limit || Number.POSITIVE_INFINITY;
+ const paths = [name].flat();
+ const runMatcher = /* @__PURE__ */ __name((locateOptions) => {
+ if (typeof name !== "function") {
+ return locatePathSync(paths, locateOptions);
+ }
+ const foundPath = name(locateOptions.cwd);
+ if (typeof foundPath === "string") {
+ return locatePathSync([foundPath], locateOptions);
+ }
+ return foundPath;
+ }, "runMatcher");
+ const matches = [];
+ while (true) {
+ const foundPath = runMatcher({ ...options14, cwd: directory });
+ if (foundPath === findUpStop) {
+ break;
+ }
+ if (foundPath) {
+ matches.push(import_node_path2.default.resolve(directory, foundPath));
+ }
+ if (directory === stopAt || matches.length >= limit) {
+ break;
+ }
+ directory = import_node_path2.default.dirname(directory);
+ }
+ return matches;
+}
+__name(findUpMultipleSync, "findUpMultipleSync");
+async function findUp(name, options14 = {}) {
+ const matches = await findUpMultiple(name, { ...options14, limit: 1 });
+ return matches[0];
+}
+__name(findUp, "findUp");
+function findUpSync(name, options14 = {}) {
+ const matches = findUpMultipleSync(name, { ...options14, limit: 1 });
+ return matches[0];
+}
+__name(findUpSync, "findUpSync");
+
+// src/logger.ts
+init_import_meta_url();
+var import_node_util = require("node:util");
+var import_chalk = __toESM(require_chalk());
+var import_cli_table3 = __toESM(require_cli_table3());
+var import_esbuild = require("esbuild");
+
+// src/environment-variables/factory.ts
+init_import_meta_url();
+function getEnvironmentVariableFactory({
+ variableName,
+ deprecatedName,
+ defaultValue
+}) {
+ let hasWarned = false;
+ return () => {
+ if (process.env[variableName]) {
+ return process.env[variableName];
+ } else if (deprecatedName && process.env[deprecatedName]) {
+ if (!hasWarned) {
+ hasWarned = true;
+ logger.warn(
+ `Using "${deprecatedName}" environment variable. This is deprecated. Please use "${variableName}", instead.`
+ );
+ }
+ return process.env[deprecatedName];
+ } else {
+ return defaultValue?.();
+ }
+ };
+}
+__name(getEnvironmentVariableFactory, "getEnvironmentVariableFactory");
+
+// src/logger.ts
+var LOGGER_LEVELS = {
+ none: -1,
+ error: 0,
+ warn: 1,
+ info: 2,
+ log: 3,
+ debug: 4
+};
+var LOGGER_LEVEL_FORMAT_TYPE_MAP = {
+ error: "error",
+ warn: "warning",
+ info: void 0,
+ log: void 0,
+ debug: void 0
+};
+var getLogLevelFromEnv = getEnvironmentVariableFactory({
+ variableName: "WRANGLER_LOG"
+});
+function getLoggerLevel() {
+ const fromEnv = getLogLevelFromEnv()?.toLowerCase();
+ if (fromEnv !== void 0) {
+ if (fromEnv in LOGGER_LEVELS)
+ return fromEnv;
+ const expected = Object.keys(LOGGER_LEVELS).map((level) => `"${level}"`).join(" | ");
+ console.warn(
+ `Unrecognised WRANGLER_LOG value ${JSON.stringify(
+ fromEnv
+ )}, expected ${expected}, defaulting to "log"...`
+ );
+ }
+ return "log";
+}
+__name(getLoggerLevel, "getLoggerLevel");
+var Logger = class {
+ constructor() {
+ }
+ loggerLevel = getLoggerLevel();
+ columns = process.stdout.columns;
+ debug = (...args) => this.doLog("debug", args);
+ info = (...args) => this.doLog("info", args);
+ log = (...args) => this.doLog("log", args);
+ warn = (...args) => this.doLog("warn", args);
+ error = (...args) => this.doLog("error", args);
+ table(data) {
+ const keys = data.length === 0 ? [] : Object.keys(data[0]);
+ const t2 = new import_cli_table3.default({
+ head: keys,
+ style: {
+ head: import_chalk.default.level ? ["blue"] : [],
+ border: import_chalk.default.level ? ["gray"] : []
+ }
+ });
+ t2.push(...data.map((row) => keys.map((k) => row[k])));
+ return this.doLog("log", [t2.toString()]);
+ }
+ doLog(messageLevel, args) {
+ if (LOGGER_LEVELS[this.loggerLevel] >= LOGGER_LEVELS[messageLevel]) {
+ console[messageLevel](this.formatMessage(messageLevel, (0, import_node_util.format)(...args)));
+ }
+ }
+ formatMessage(level, message) {
+ const kind = LOGGER_LEVEL_FORMAT_TYPE_MAP[level];
+ if (kind) {
+ const [firstLine, ...otherLines] = message.split("\n");
+ const notes = otherLines.length > 0 ? otherLines.map((text) => ({ text })) : void 0;
+ return (0, import_esbuild.formatMessagesSync)([{ text: firstLine, notes }], {
+ color: true,
+ kind,
+ terminalWidth: this.columns
+ })[0];
+ } else {
+ return message;
+ }
+ }
+};
+__name(Logger, "Logger");
+var logger = new Logger();
+function logBuildWarnings(warnings) {
+ const logs = (0, import_esbuild.formatMessagesSync)(warnings, { kind: "warning", color: true });
+ for (const log of logs)
+ console.warn(log);
+}
+__name(logBuildWarnings, "logBuildWarnings");
+function logBuildFailure(errors, warnings) {
+ const logs = (0, import_esbuild.formatMessagesSync)(errors, { kind: "error", color: true });
+ for (const log of logs)
+ console.error(log);
+ logBuildWarnings(warnings);
+}
+__name(logBuildFailure, "logBuildFailure");
+
+// src/parse.ts
+init_import_meta_url();
+var fs2 = __toESM(require("node:fs"));
+var import_node_path3 = require("node:path");
+var import_toml = __toESM(require_toml());
+var import_esbuild2 = require("esbuild");
+
+// ../../node_modules/.pnpm/jsonc-parser@3.2.0/node_modules/jsonc-parser/lib/esm/main.js
+init_import_meta_url();
+
+// ../../node_modules/.pnpm/jsonc-parser@3.2.0/node_modules/jsonc-parser/lib/esm/impl/format.js
+init_import_meta_url();
+
+// ../../node_modules/.pnpm/jsonc-parser@3.2.0/node_modules/jsonc-parser/lib/esm/impl/scanner.js
+init_import_meta_url();
+function createScanner(text, ignoreTrivia = false) {
+ const len = text.length;
+ let pos = 0, value = "", tokenOffset = 0, token = 16, lineNumber = 0, lineStartOffset = 0, tokenLineStartOffset = 0, prevTokenLineStartOffset = 0, scanError = 0;
+ function scanHexDigits(count, exact) {
+ let digits = 0;
+ let value2 = 0;
+ while (digits < count || !exact) {
+ let ch = text.charCodeAt(pos);
+ if (ch >= 48 && ch <= 57) {
+ value2 = value2 * 16 + ch - 48;
+ } else if (ch >= 65 && ch <= 70) {
+ value2 = value2 * 16 + ch - 65 + 10;
+ } else if (ch >= 97 && ch <= 102) {
+ value2 = value2 * 16 + ch - 97 + 10;
+ } else {
+ break;
+ }
+ pos++;
+ digits++;
+ }
+ if (digits < count) {
+ value2 = -1;
+ }
+ return value2;
+ }
+ __name(scanHexDigits, "scanHexDigits");
+ function setPosition(newPosition) {
+ pos = newPosition;
+ value = "";
+ tokenOffset = 0;
+ token = 16;
+ scanError = 0;
+ }
+ __name(setPosition, "setPosition");
+ function scanNumber() {
+ let start = pos;
+ if (text.charCodeAt(pos) === 48) {
+ pos++;
+ } else {
+ pos++;
+ while (pos < text.length && isDigit2(text.charCodeAt(pos))) {
+ pos++;
+ }
+ }
+ if (pos < text.length && text.charCodeAt(pos) === 46) {
+ pos++;
+ if (pos < text.length && isDigit2(text.charCodeAt(pos))) {
+ pos++;
+ while (pos < text.length && isDigit2(text.charCodeAt(pos))) {
+ pos++;
+ }
+ } else {
+ scanError = 3;
+ return text.substring(start, pos);
+ }
+ }
+ let end = pos;
+ if (pos < text.length && (text.charCodeAt(pos) === 69 || text.charCodeAt(pos) === 101)) {
+ pos++;
+ if (pos < text.length && text.charCodeAt(pos) === 43 || text.charCodeAt(pos) === 45) {
+ pos++;
+ }
+ if (pos < text.length && isDigit2(text.charCodeAt(pos))) {
+ pos++;
+ while (pos < text.length && isDigit2(text.charCodeAt(pos))) {
+ pos++;
+ }
+ end = pos;
+ } else {
+ scanError = 3;
+ }
+ }
+ return text.substring(start, end);
+ }
+ __name(scanNumber, "scanNumber");
+ function scanString() {
+ let result = "", start = pos;
+ while (true) {
+ if (pos >= len) {
+ result += text.substring(start, pos);
+ scanError = 2;
+ break;
+ }
+ const ch = text.charCodeAt(pos);
+ if (ch === 34) {
+ result += text.substring(start, pos);
+ pos++;
+ break;
+ }
+ if (ch === 92) {
+ result += text.substring(start, pos);
+ pos++;
+ if (pos >= len) {
+ scanError = 2;
+ break;
+ }
+ const ch2 = text.charCodeAt(pos++);
+ switch (ch2) {
+ case 34:
+ result += '"';
+ break;
+ case 92:
+ result += "\\";
+ break;
+ case 47:
+ result += "/";
+ break;
+ case 98:
+ result += "\b";
+ break;
+ case 102:
+ result += "\f";
+ break;
+ case 110:
+ result += "\n";
+ break;
+ case 114:
+ result += "\r";
+ break;
+ case 116:
+ result += " ";
+ break;
+ case 117:
+ const ch3 = scanHexDigits(4, true);
+ if (ch3 >= 0) {
+ result += String.fromCharCode(ch3);
+ } else {
+ scanError = 4;
+ }
+ break;
+ default:
+ scanError = 5;
+ }
+ start = pos;
+ continue;
+ }
+ if (ch >= 0 && ch <= 31) {
+ if (isLineBreak(ch)) {
+ result += text.substring(start, pos);
+ scanError = 2;
+ break;
+ } else {
+ scanError = 6;
+ }
+ }
+ pos++;
+ }
+ return result;
+ }
+ __name(scanString, "scanString");
+ function scanNext() {
+ value = "";
+ scanError = 0;
+ tokenOffset = pos;
+ lineStartOffset = lineNumber;
+ prevTokenLineStartOffset = tokenLineStartOffset;
+ if (pos >= len) {
+ tokenOffset = len;
+ return token = 17;
+ }
+ let code = text.charCodeAt(pos);
+ if (isWhiteSpace(code)) {
+ do {
+ pos++;
+ value += String.fromCharCode(code);
+ code = text.charCodeAt(pos);
+ } while (isWhiteSpace(code));
+ return token = 15;
+ }
+ if (isLineBreak(code)) {
+ pos++;
+ value += String.fromCharCode(code);
+ if (code === 13 && text.charCodeAt(pos) === 10) {
+ pos++;
+ value += "\n";
+ }
+ lineNumber++;
+ tokenLineStartOffset = pos;
+ return token = 14;
+ }
+ switch (code) {
+ case 123:
+ pos++;
+ return token = 1;
+ case 125:
+ pos++;
+ return token = 2;
+ case 91:
+ pos++;
+ return token = 3;
+ case 93:
+ pos++;
+ return token = 4;
+ case 58:
+ pos++;
+ return token = 6;
+ case 44:
+ pos++;
+ return token = 5;
+ case 34:
+ pos++;
+ value = scanString();
+ return token = 10;
+ case 47:
+ const start = pos - 1;
+ if (text.charCodeAt(pos + 1) === 47) {
+ pos += 2;
+ while (pos < len) {
+ if (isLineBreak(text.charCodeAt(pos))) {
+ break;
+ }
+ pos++;
+ }
+ value = text.substring(start, pos);
+ return token = 12;
+ }
+ if (text.charCodeAt(pos + 1) === 42) {
+ pos += 2;
+ const safeLength = len - 1;
+ let commentClosed = false;
+ while (pos < safeLength) {
+ const ch = text.charCodeAt(pos);
+ if (ch === 42 && text.charCodeAt(pos + 1) === 47) {
+ pos += 2;
+ commentClosed = true;
+ break;
+ }
+ pos++;
+ if (isLineBreak(ch)) {
+ if (ch === 13 && text.charCodeAt(pos) === 10) {
+ pos++;
+ }
+ lineNumber++;
+ tokenLineStartOffset = pos;
+ }
+ }
+ if (!commentClosed) {
+ pos++;
+ scanError = 1;
+ }
+ value = text.substring(start, pos);
+ return token = 13;
+ }
+ value += String.fromCharCode(code);
+ pos++;
+ return token = 16;
+ case 45:
+ value += String.fromCharCode(code);
+ pos++;
+ if (pos === len || !isDigit2(text.charCodeAt(pos))) {
+ return token = 16;
+ }
+ case 48:
+ case 49:
+ case 50:
+ case 51:
+ case 52:
+ case 53:
+ case 54:
+ case 55:
+ case 56:
+ case 57:
+ value += scanNumber();
+ return token = 11;
+ default:
+ while (pos < len && isUnknownContentCharacter(code)) {
+ pos++;
+ code = text.charCodeAt(pos);
+ }
+ if (tokenOffset !== pos) {
+ value = text.substring(tokenOffset, pos);
+ switch (value) {
+ case "true":
+ return token = 8;
+ case "false":
+ return token = 9;
+ case "null":
+ return token = 7;
+ }
+ return token = 16;
+ }
+ value += String.fromCharCode(code);
+ pos++;
+ return token = 16;
+ }
+ }
+ __name(scanNext, "scanNext");
+ function isUnknownContentCharacter(code) {
+ if (isWhiteSpace(code) || isLineBreak(code)) {
+ return false;
+ }
+ switch (code) {
+ case 125:
+ case 93:
+ case 123:
+ case 91:
+ case 34:
+ case 58:
+ case 44:
+ case 47:
+ return false;
+ }
+ return true;
+ }
+ __name(isUnknownContentCharacter, "isUnknownContentCharacter");
+ function scanNextNonTrivia() {
+ let result;
+ do {
+ result = scanNext();
+ } while (result >= 12 && result <= 15);
+ return result;
+ }
+ __name(scanNextNonTrivia, "scanNextNonTrivia");
+ return {
+ setPosition,
+ getPosition: () => pos,
+ scan: ignoreTrivia ? scanNextNonTrivia : scanNext,
+ getToken: () => token,
+ getTokenValue: () => value,
+ getTokenOffset: () => tokenOffset,
+ getTokenLength: () => pos - tokenOffset,
+ getTokenStartLine: () => lineStartOffset,
+ getTokenStartCharacter: () => tokenOffset - prevTokenLineStartOffset,
+ getTokenError: () => scanError
+ };
+}
+__name(createScanner, "createScanner");
+function isWhiteSpace(ch) {
+ return ch === 32 || ch === 9;
+}
+__name(isWhiteSpace, "isWhiteSpace");
+function isLineBreak(ch) {
+ return ch === 10 || ch === 13;
+}
+__name(isLineBreak, "isLineBreak");
+function isDigit2(ch) {
+ return ch >= 48 && ch <= 57;
+}
+__name(isDigit2, "isDigit");
+var CharacterCodes;
+(function(CharacterCodes2) {
+ CharacterCodes2[CharacterCodes2["lineFeed"] = 10] = "lineFeed";
+ CharacterCodes2[CharacterCodes2["carriageReturn"] = 13] = "carriageReturn";
+ CharacterCodes2[CharacterCodes2["space"] = 32] = "space";
+ CharacterCodes2[CharacterCodes2["_0"] = 48] = "_0";
+ CharacterCodes2[CharacterCodes2["_1"] = 49] = "_1";
+ CharacterCodes2[CharacterCodes2["_2"] = 50] = "_2";
+ CharacterCodes2[CharacterCodes2["_3"] = 51] = "_3";
+ CharacterCodes2[CharacterCodes2["_4"] = 52] = "_4";
+ CharacterCodes2[CharacterCodes2["_5"] = 53] = "_5";
+ CharacterCodes2[CharacterCodes2["_6"] = 54] = "_6";
+ CharacterCodes2[CharacterCodes2["_7"] = 55] = "_7";
+ CharacterCodes2[CharacterCodes2["_8"] = 56] = "_8";
+ CharacterCodes2[CharacterCodes2["_9"] = 57] = "_9";
+ CharacterCodes2[CharacterCodes2["a"] = 97] = "a";
+ CharacterCodes2[CharacterCodes2["b"] = 98] = "b";
+ CharacterCodes2[CharacterCodes2["c"] = 99] = "c";
+ CharacterCodes2[CharacterCodes2["d"] = 100] = "d";
+ CharacterCodes2[CharacterCodes2["e"] = 101] = "e";
+ CharacterCodes2[CharacterCodes2["f"] = 102] = "f";
+ CharacterCodes2[CharacterCodes2["g"] = 103] = "g";
+ CharacterCodes2[CharacterCodes2["h"] = 104] = "h";
+ CharacterCodes2[CharacterCodes2["i"] = 105] = "i";
+ CharacterCodes2[CharacterCodes2["j"] = 106] = "j";
+ CharacterCodes2[CharacterCodes2["k"] = 107] = "k";
+ CharacterCodes2[CharacterCodes2["l"] = 108] = "l";
+ CharacterCodes2[CharacterCodes2["m"] = 109] = "m";
+ CharacterCodes2[CharacterCodes2["n"] = 110] = "n";
+ CharacterCodes2[CharacterCodes2["o"] = 111] = "o";
+ CharacterCodes2[CharacterCodes2["p"] = 112] = "p";
+ CharacterCodes2[CharacterCodes2["q"] = 113] = "q";
+ CharacterCodes2[CharacterCodes2["r"] = 114] = "r";
+ CharacterCodes2[CharacterCodes2["s"] = 115] = "s";
+ CharacterCodes2[CharacterCodes2["t"] = 116] = "t";
+ CharacterCodes2[CharacterCodes2["u"] = 117] = "u";
+ CharacterCodes2[CharacterCodes2["v"] = 118] = "v";
+ CharacterCodes2[CharacterCodes2["w"] = 119] = "w";
+ CharacterCodes2[CharacterCodes2["x"] = 120] = "x";
+ CharacterCodes2[CharacterCodes2["y"] = 121] = "y";
+ CharacterCodes2[CharacterCodes2["z"] = 122] = "z";
+ CharacterCodes2[CharacterCodes2["A"] = 65] = "A";
+ CharacterCodes2[CharacterCodes2["B"] = 66] = "B";
+ CharacterCodes2[CharacterCodes2["C"] = 67] = "C";
+ CharacterCodes2[CharacterCodes2["D"] = 68] = "D";
+ CharacterCodes2[CharacterCodes2["E"] = 69] = "E";
+ CharacterCodes2[CharacterCodes2["F"] = 70] = "F";
+ CharacterCodes2[CharacterCodes2["G"] = 71] = "G";
+ CharacterCodes2[CharacterCodes2["H"] = 72] = "H";
+ CharacterCodes2[CharacterCodes2["I"] = 73] = "I";
+ CharacterCodes2[CharacterCodes2["J"] = 74] = "J";
+ CharacterCodes2[CharacterCodes2["K"] = 75] = "K";
+ CharacterCodes2[CharacterCodes2["L"] = 76] = "L";
+ CharacterCodes2[CharacterCodes2["M"] = 77] = "M";
+ CharacterCodes2[CharacterCodes2["N"] = 78] = "N";
+ CharacterCodes2[CharacterCodes2["O"] = 79] = "O";
+ CharacterCodes2[CharacterCodes2["P"] = 80] = "P";
+ CharacterCodes2[CharacterCodes2["Q"] = 81] = "Q";
+ CharacterCodes2[CharacterCodes2["R"] = 82] = "R";
+ CharacterCodes2[CharacterCodes2["S"] = 83] = "S";
+ CharacterCodes2[CharacterCodes2["T"] = 84] = "T";
+ CharacterCodes2[CharacterCodes2["U"] = 85] = "U";
+ CharacterCodes2[CharacterCodes2["V"] = 86] = "V";
+ CharacterCodes2[CharacterCodes2["W"] = 87] = "W";
+ CharacterCodes2[CharacterCodes2["X"] = 88] = "X";
+ CharacterCodes2[CharacterCodes2["Y"] = 89] = "Y";
+ CharacterCodes2[CharacterCodes2["Z"] = 90] = "Z";
+ CharacterCodes2[CharacterCodes2["asterisk"] = 42] = "asterisk";
+ CharacterCodes2[CharacterCodes2["backslash"] = 92] = "backslash";
+ CharacterCodes2[CharacterCodes2["closeBrace"] = 125] = "closeBrace";
+ CharacterCodes2[CharacterCodes2["closeBracket"] = 93] = "closeBracket";
+ CharacterCodes2[CharacterCodes2["colon"] = 58] = "colon";
+ CharacterCodes2[CharacterCodes2["comma"] = 44] = "comma";
+ CharacterCodes2[CharacterCodes2["dot"] = 46] = "dot";
+ CharacterCodes2[CharacterCodes2["doubleQuote"] = 34] = "doubleQuote";
+ CharacterCodes2[CharacterCodes2["minus"] = 45] = "minus";
+ CharacterCodes2[CharacterCodes2["openBrace"] = 123] = "openBrace";
+ CharacterCodes2[CharacterCodes2["openBracket"] = 91] = "openBracket";
+ CharacterCodes2[CharacterCodes2["plus"] = 43] = "plus";
+ CharacterCodes2[CharacterCodes2["slash"] = 47] = "slash";
+ CharacterCodes2[CharacterCodes2["formFeed"] = 12] = "formFeed";
+ CharacterCodes2[CharacterCodes2["tab"] = 9] = "tab";
+})(CharacterCodes || (CharacterCodes = {}));
+
+// ../../node_modules/.pnpm/jsonc-parser@3.2.0/node_modules/jsonc-parser/lib/esm/impl/edit.js
+init_import_meta_url();
+
+// ../../node_modules/.pnpm/jsonc-parser@3.2.0/node_modules/jsonc-parser/lib/esm/impl/parser.js
+init_import_meta_url();
+var ParseOptions;
+(function(ParseOptions2) {
+ ParseOptions2.DEFAULT = {
+ allowTrailingComma: false
+ };
+})(ParseOptions || (ParseOptions = {}));
+function parse(text, errors = [], options14 = ParseOptions.DEFAULT) {
+ let currentProperty = null;
+ let currentParent = [];
+ const previousParents = [];
+ function onValue(value) {
+ if (Array.isArray(currentParent)) {
+ currentParent.push(value);
+ } else if (currentProperty !== null) {
+ currentParent[currentProperty] = value;
+ }
+ }
+ __name(onValue, "onValue");
+ const visitor = {
+ onObjectBegin: () => {
+ const object = {};
+ onValue(object);
+ previousParents.push(currentParent);
+ currentParent = object;
+ currentProperty = null;
+ },
+ onObjectProperty: (name) => {
+ currentProperty = name;
+ },
+ onObjectEnd: () => {
+ currentParent = previousParents.pop();
+ },
+ onArrayBegin: () => {
+ const array = [];
+ onValue(array);
+ previousParents.push(currentParent);
+ currentParent = array;
+ currentProperty = null;
+ },
+ onArrayEnd: () => {
+ currentParent = previousParents.pop();
+ },
+ onLiteralValue: onValue,
+ onError: (error, offset, length) => {
+ errors.push({ error, offset, length });
+ }
+ };
+ visit(text, visitor, options14);
+ return currentParent[0];
+}
+__name(parse, "parse");
+function visit(text, visitor, options14 = ParseOptions.DEFAULT) {
+ const _scanner = createScanner(text, false);
+ const _jsonPath = [];
+ function toNoArgVisit(visitFunction) {
+ return visitFunction ? () => visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()) : () => true;
+ }
+ __name(toNoArgVisit, "toNoArgVisit");
+ function toNoArgVisitWithPath(visitFunction) {
+ return visitFunction ? () => visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter(), () => _jsonPath.slice()) : () => true;
+ }
+ __name(toNoArgVisitWithPath, "toNoArgVisitWithPath");
+ function toOneArgVisit(visitFunction) {
+ return visitFunction ? (arg) => visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()) : () => true;
+ }
+ __name(toOneArgVisit, "toOneArgVisit");
+ function toOneArgVisitWithPath(visitFunction) {
+ return visitFunction ? (arg) => visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter(), () => _jsonPath.slice()) : () => true;
+ }
+ __name(toOneArgVisitWithPath, "toOneArgVisitWithPath");
+ const onObjectBegin = toNoArgVisitWithPath(visitor.onObjectBegin), onObjectProperty = toOneArgVisitWithPath(visitor.onObjectProperty), onObjectEnd = toNoArgVisit(visitor.onObjectEnd), onArrayBegin = toNoArgVisitWithPath(visitor.onArrayBegin), onArrayEnd = toNoArgVisit(visitor.onArrayEnd), onLiteralValue = toOneArgVisitWithPath(visitor.onLiteralValue), onSeparator = toOneArgVisit(visitor.onSeparator), onComment = toNoArgVisit(visitor.onComment), onError = toOneArgVisit(visitor.onError);
+ const disallowComments = options14 && options14.disallowComments;
+ const allowTrailingComma = options14 && options14.allowTrailingComma;
+ function scanNext() {
+ while (true) {
+ const token = _scanner.scan();
+ switch (_scanner.getTokenError()) {
+ case 4:
+ handleError(
+ 14
+ /* ParseErrorCode.InvalidUnicode */
+ );
+ break;
+ case 5:
+ handleError(
+ 15
+ /* ParseErrorCode.InvalidEscapeCharacter */
+ );
+ break;
+ case 3:
+ handleError(
+ 13
+ /* ParseErrorCode.UnexpectedEndOfNumber */
+ );
+ break;
+ case 1:
+ if (!disallowComments) {
+ handleError(
+ 11
+ /* ParseErrorCode.UnexpectedEndOfComment */
+ );
+ }
+ break;
+ case 2:
+ handleError(
+ 12
+ /* ParseErrorCode.UnexpectedEndOfString */
+ );
+ break;
+ case 6:
+ handleError(
+ 16
+ /* ParseErrorCode.InvalidCharacter */
+ );
+ break;
+ }
+ switch (token) {
+ case 12:
+ case 13:
+ if (disallowComments) {
+ handleError(
+ 10
+ /* ParseErrorCode.InvalidCommentToken */
+ );
+ } else {
+ onComment();
+ }
+ break;
+ case 16:
+ handleError(
+ 1
+ /* ParseErrorCode.InvalidSymbol */
+ );
+ break;
+ case 15:
+ case 14:
+ break;
+ default:
+ return token;
+ }
+ }
+ }
+ __name(scanNext, "scanNext");
+ function handleError(error, skipUntilAfter = [], skipUntil = []) {
+ onError(error);
+ if (skipUntilAfter.length + skipUntil.length > 0) {
+ let token = _scanner.getToken();
+ while (token !== 17) {
+ if (skipUntilAfter.indexOf(token) !== -1) {
+ scanNext();
+ break;
+ } else if (skipUntil.indexOf(token) !== -1) {
+ break;
+ }
+ token = scanNext();
+ }
+ }
+ }
+ __name(handleError, "handleError");
+ function parseString(isValue) {
+ const value = _scanner.getTokenValue();
+ if (isValue) {
+ onLiteralValue(value);
+ } else {
+ onObjectProperty(value);
+ _jsonPath.push(value);
+ }
+ scanNext();
+ return true;
+ }
+ __name(parseString, "parseString");
+ function parseLiteral() {
+ switch (_scanner.getToken()) {
+ case 11:
+ const tokenValue = _scanner.getTokenValue();
+ let value = Number(tokenValue);
+ if (isNaN(value)) {
+ handleError(
+ 2
+ /* ParseErrorCode.InvalidNumberFormat */
+ );
+ value = 0;
+ }
+ onLiteralValue(value);
+ break;
+ case 7:
+ onLiteralValue(null);
+ break;
+ case 8:
+ onLiteralValue(true);
+ break;
+ case 9:
+ onLiteralValue(false);
+ break;
+ default:
+ return false;
+ }
+ scanNext();
+ return true;
+ }
+ __name(parseLiteral, "parseLiteral");
+ function parseProperty() {
+ if (_scanner.getToken() !== 10) {
+ handleError(3, [], [
+ 2,
+ 5
+ /* SyntaxKind.CommaToken */
+ ]);
+ return false;
+ }
+ parseString(false);
+ if (_scanner.getToken() === 6) {
+ onSeparator(":");
+ scanNext();
+ if (!parseValue()) {
+ handleError(4, [], [
+ 2,
+ 5
+ /* SyntaxKind.CommaToken */
+ ]);
+ }
+ } else {
+ handleError(5, [], [
+ 2,
+ 5
+ /* SyntaxKind.CommaToken */
+ ]);
+ }
+ _jsonPath.pop();
+ return true;
+ }
+ __name(parseProperty, "parseProperty");
+ function parseObject() {
+ onObjectBegin();
+ scanNext();
+ let needsComma = false;
+ while (_scanner.getToken() !== 2 && _scanner.getToken() !== 17) {
+ if (_scanner.getToken() === 5) {
+ if (!needsComma) {
+ handleError(4, [], []);
+ }
+ onSeparator(",");
+ scanNext();
+ if (_scanner.getToken() === 2 && allowTrailingComma) {
+ break;
+ }
+ } else if (needsComma) {
+ handleError(6, [], []);
+ }
+ if (!parseProperty()) {
+ handleError(4, [], [
+ 2,
+ 5
+ /* SyntaxKind.CommaToken */
+ ]);
+ }
+ needsComma = true;
+ }
+ onObjectEnd();
+ if (_scanner.getToken() !== 2) {
+ handleError(7, [
+ 2
+ /* SyntaxKind.CloseBraceToken */
+ ], []);
+ } else {
+ scanNext();
+ }
+ return true;
+ }
+ __name(parseObject, "parseObject");
+ function parseArray() {
+ onArrayBegin();
+ scanNext();
+ let isFirstElement = true;
+ let needsComma = false;
+ while (_scanner.getToken() !== 4 && _scanner.getToken() !== 17) {
+ if (_scanner.getToken() === 5) {
+ if (!needsComma) {
+ handleError(4, [], []);
+ }
+ onSeparator(",");
+ scanNext();
+ if (_scanner.getToken() === 4 && allowTrailingComma) {
+ break;
+ }
+ } else if (needsComma) {
+ handleError(6, [], []);
+ }
+ if (isFirstElement) {
+ _jsonPath.push(0);
+ isFirstElement = false;
+ } else {
+ _jsonPath[_jsonPath.length - 1]++;
+ }
+ if (!parseValue()) {
+ handleError(4, [], [
+ 4,
+ 5
+ /* SyntaxKind.CommaToken */
+ ]);
+ }
+ needsComma = true;
+ }
+ onArrayEnd();
+ if (!isFirstElement) {
+ _jsonPath.pop();
+ }
+ if (_scanner.getToken() !== 4) {
+ handleError(8, [
+ 4
+ /* SyntaxKind.CloseBracketToken */
+ ], []);
+ } else {
+ scanNext();
+ }
+ return true;
+ }
+ __name(parseArray, "parseArray");
+ function parseValue() {
+ switch (_scanner.getToken()) {
+ case 3:
+ return parseArray();
+ case 1:
+ return parseObject();
+ case 10:
+ return parseString(true);
+ default:
+ return parseLiteral();
+ }
+ }
+ __name(parseValue, "parseValue");
+ scanNext();
+ if (_scanner.getToken() === 17) {
+ if (options14.allowEmptyContent) {
+ return true;
+ }
+ handleError(4, [], []);
+ return false;
+ }
+ if (!parseValue()) {
+ handleError(4, [], []);
+ return false;
+ }
+ if (_scanner.getToken() !== 17) {
+ handleError(9, [], []);
+ }
+ return true;
+}
+__name(visit, "visit");
+
+// ../../node_modules/.pnpm/jsonc-parser@3.2.0/node_modules/jsonc-parser/lib/esm/main.js
+var ScanError;
+(function(ScanError2) {
+ ScanError2[ScanError2["None"] = 0] = "None";
+ ScanError2[ScanError2["UnexpectedEndOfComment"] = 1] = "UnexpectedEndOfComment";
+ ScanError2[ScanError2["UnexpectedEndOfString"] = 2] = "UnexpectedEndOfString";
+ ScanError2[ScanError2["UnexpectedEndOfNumber"] = 3] = "UnexpectedEndOfNumber";
+ ScanError2[ScanError2["InvalidUnicode"] = 4] = "InvalidUnicode";
+ ScanError2[ScanError2["InvalidEscapeCharacter"] = 5] = "InvalidEscapeCharacter";
+ ScanError2[ScanError2["InvalidCharacter"] = 6] = "InvalidCharacter";
+})(ScanError || (ScanError = {}));
+var SyntaxKind;
+(function(SyntaxKind2) {
+ SyntaxKind2[SyntaxKind2["OpenBraceToken"] = 1] = "OpenBraceToken";
+ SyntaxKind2[SyntaxKind2["CloseBraceToken"] = 2] = "CloseBraceToken";
+ SyntaxKind2[SyntaxKind2["OpenBracketToken"] = 3] = "OpenBracketToken";
+ SyntaxKind2[SyntaxKind2["CloseBracketToken"] = 4] = "CloseBracketToken";
+ SyntaxKind2[SyntaxKind2["CommaToken"] = 5] = "CommaToken";
+ SyntaxKind2[SyntaxKind2["ColonToken"] = 6] = "ColonToken";
+ SyntaxKind2[SyntaxKind2["NullKeyword"] = 7] = "NullKeyword";
+ SyntaxKind2[SyntaxKind2["TrueKeyword"] = 8] = "TrueKeyword";
+ SyntaxKind2[SyntaxKind2["FalseKeyword"] = 9] = "FalseKeyword";
+ SyntaxKind2[SyntaxKind2["StringLiteral"] = 10] = "StringLiteral";
+ SyntaxKind2[SyntaxKind2["NumericLiteral"] = 11] = "NumericLiteral";
+ SyntaxKind2[SyntaxKind2["LineCommentTrivia"] = 12] = "LineCommentTrivia";
+ SyntaxKind2[SyntaxKind2["BlockCommentTrivia"] = 13] = "BlockCommentTrivia";
+ SyntaxKind2[SyntaxKind2["LineBreakTrivia"] = 14] = "LineBreakTrivia";
+ SyntaxKind2[SyntaxKind2["Trivia"] = 15] = "Trivia";
+ SyntaxKind2[SyntaxKind2["Unknown"] = 16] = "Unknown";
+ SyntaxKind2[SyntaxKind2["EOF"] = 17] = "EOF";
+})(SyntaxKind || (SyntaxKind = {}));
+var parse2 = parse;
+var ParseErrorCode;
+(function(ParseErrorCode2) {
+ ParseErrorCode2[ParseErrorCode2["InvalidSymbol"] = 1] = "InvalidSymbol";
+ ParseErrorCode2[ParseErrorCode2["InvalidNumberFormat"] = 2] = "InvalidNumberFormat";
+ ParseErrorCode2[ParseErrorCode2["PropertyNameExpected"] = 3] = "PropertyNameExpected";
+ ParseErrorCode2[ParseErrorCode2["ValueExpected"] = 4] = "ValueExpected";
+ ParseErrorCode2[ParseErrorCode2["ColonExpected"] = 5] = "ColonExpected";
+ ParseErrorCode2[ParseErrorCode2["CommaExpected"] = 6] = "CommaExpected";
+ ParseErrorCode2[ParseErrorCode2["CloseBraceExpected"] = 7] = "CloseBraceExpected";
+ ParseErrorCode2[ParseErrorCode2["CloseBracketExpected"] = 8] = "CloseBracketExpected";
+ ParseErrorCode2[ParseErrorCode2["EndOfFileExpected"] = 9] = "EndOfFileExpected";
+ ParseErrorCode2[ParseErrorCode2["InvalidCommentToken"] = 10] = "InvalidCommentToken";
+ ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfComment"] = 11] = "UnexpectedEndOfComment";
+ ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfString"] = 12] = "UnexpectedEndOfString";
+ ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfNumber"] = 13] = "UnexpectedEndOfNumber";
+ ParseErrorCode2[ParseErrorCode2["InvalidUnicode"] = 14] = "InvalidUnicode";
+ ParseErrorCode2[ParseErrorCode2["InvalidEscapeCharacter"] = 15] = "InvalidEscapeCharacter";
+ ParseErrorCode2[ParseErrorCode2["InvalidCharacter"] = 16] = "InvalidCharacter";
+})(ParseErrorCode || (ParseErrorCode = {}));
+function printParseErrorCode(code) {
+ switch (code) {
+ case 1:
+ return "InvalidSymbol";
+ case 2:
+ return "InvalidNumberFormat";
+ case 3:
+ return "PropertyNameExpected";
+ case 4:
+ return "ValueExpected";
+ case 5:
+ return "ColonExpected";
+ case 6:
+ return "CommaExpected";
+ case 7:
+ return "CloseBraceExpected";
+ case 8:
+ return "CloseBracketExpected";
+ case 9:
+ return "EndOfFileExpected";
+ case 10:
+ return "InvalidCommentToken";
+ case 11:
+ return "UnexpectedEndOfComment";
+ case 12:
+ return "UnexpectedEndOfString";
+ case 13:
+ return "UnexpectedEndOfNumber";
+ case 14:
+ return "InvalidUnicode";
+ case 15:
+ return "InvalidEscapeCharacter";
+ case 16:
+ return "InvalidCharacter";
+ }
+ return "";
+}
+__name(printParseErrorCode, "printParseErrorCode");
+
+// src/parse.ts
+function formatMessage({ text, notes, location, kind = "error" }, color = true) {
+ const input = { text, notes, location };
+ delete input.location?.fileText;
+ for (const note of notes ?? []) {
+ delete note.location?.fileText;
+ }
+ const lines = (0, import_esbuild2.formatMessagesSync)([input], {
+ color,
+ kind,
+ terminalWidth: logger.columns
+ });
+ return lines.join("\n");
+}
+__name(formatMessage, "formatMessage");
+var ParseError = class extends Error {
+ text;
+ notes;
+ location;
+ kind;
+ constructor({ text, notes, location, kind }) {
+ super(text);
+ this.name = this.constructor.name;
+ this.text = text;
+ this.notes = notes ?? [];
+ this.location = location;
+ this.kind = kind ?? "error";
+ }
+};
+__name(ParseError, "ParseError");
+var TOML_ERROR_NAME = "TomlError";
+var TOML_ERROR_SUFFIX = " at row ";
+function parseTOML(input, file) {
+ try {
+ const normalizedInput = input.replace(/\r\n/g, "\n");
+ return import_toml.default.parse(normalizedInput);
+ } catch (err) {
+ const { name, message, line, col } = err;
+ if (name !== TOML_ERROR_NAME) {
+ throw err;
+ }
+ const text = message.substring(0, message.lastIndexOf(TOML_ERROR_SUFFIX));
+ const lineText = input.split("\n")[line];
+ const location = {
+ lineText,
+ line: line + 1,
+ column: col - 1,
+ file,
+ fileText: input
+ };
+ throw new ParseError({ text, location });
+ }
+}
+__name(parseTOML, "parseTOML");
+var JSON_ERROR_SUFFIX = " in JSON at position ";
+function parsePackageJSON(input, file) {
+ return parseJSON(input, file);
+}
+__name(parsePackageJSON, "parsePackageJSON");
+function parseJSON(input, file) {
+ try {
+ return JSON.parse(input);
+ } catch (err) {
+ const { message } = err;
+ const index = message.lastIndexOf(JSON_ERROR_SUFFIX);
+ if (index < 0) {
+ throw err;
+ }
+ const text = message.substring(0, index);
+ const position = parseInt(
+ message.substring(index + JSON_ERROR_SUFFIX.length)
+ );
+ const location = indexLocation({ file, fileText: input }, position);
+ throw new ParseError({ text, location });
+ }
+}
+__name(parseJSON, "parseJSON");
+function parseJSONC(input, file) {
+ const errors = [];
+ const data = parse2(input, errors);
+ if (errors.length) {
+ throw new ParseError({
+ text: printParseErrorCode(errors[0].error),
+ location: {
+ ...indexLocation({ file, fileText: input }, errors[0].offset + 1),
+ length: errors[0].length
+ }
+ });
+ }
+ return data;
+}
+__name(parseJSONC, "parseJSONC");
+function readFileSyncToBuffer(file) {
+ try {
+ return fs2.readFileSync(file);
+ } catch (err) {
+ const { message } = err;
+ throw new ParseError({
+ text: `Could not read file: ${file}`,
+ notes: [
+ {
+ text: message.replace(file, (0, import_node_path3.resolve)(file))
+ }
+ ]
+ });
+ }
+}
+__name(readFileSyncToBuffer, "readFileSyncToBuffer");
+function readFileSync5(file) {
+ try {
+ return fs2.readFileSync(file, { encoding: "utf-8" });
+ } catch (err) {
+ const { message } = err;
+ throw new ParseError({
+ text: `Could not read file: ${file}`,
+ notes: [
+ {
+ text: message.replace(file, (0, import_node_path3.resolve)(file))
+ }
+ ]
+ });
+ }
+}
+__name(readFileSync5, "readFileSync");
+function indexLocation(file, index) {
+ let lineText, line = 0, column = 0, cursor = 0;
+ const { fileText = "" } = file;
+ for (const row of fileText.split("\n")) {
+ line++;
+ cursor += row.length + 1;
+ if (cursor >= index) {
+ lineText = row;
+ column = row.length - (cursor - index);
+ break;
+ }
+ }
+ return { lineText, line, column, ...file };
+}
+__name(indexLocation, "indexLocation");
+var units = {
+ nanoseconds: 1e-9,
+ nanosecond: 1e-9,
+ microseconds: 1e-6,
+ microsecond: 1e-6,
+ milliseconds: 1e-3,
+ millisecond: 1e-3,
+ seconds: 1,
+ second: 1,
+ minutes: 60,
+ minute: 60,
+ hours: 3600,
+ hour: 3600,
+ days: 86400,
+ day: 86400,
+ weeks: 604800,
+ week: 604800,
+ month: 18144e3,
+ year: 220752e3,
+ nsecs: 1e-9,
+ nsec: 1e-9,
+ usecs: 1e-6,
+ usec: 1e-6,
+ msecs: 1e-3,
+ msec: 1e-3,
+ secs: 1,
+ sec: 1,
+ mins: 60,
+ min: 60,
+ ns: 1e-9,
+ us: 1e-6,
+ ms: 1e-3,
+ mo: 18144e3,
+ yr: 220752e3,
+ s: 1,
+ m: 60,
+ h: 3600,
+ d: 86400,
+ w: 604800,
+ y: 220752e3
+};
+function parseHumanDuration(s) {
+ const unitsMap = new Map(Object.entries(units));
+ s = s.trim().toLowerCase();
+ let base = 1;
+ for (const [name, _2] of unitsMap) {
+ if (s.endsWith(name)) {
+ s = s.substring(0, s.length - name.length);
+ base = unitsMap.get(name) || 1;
+ break;
+ }
+ }
+ return Number(s) * base;
+}
+__name(parseHumanDuration, "parseHumanDuration");
+
+// src/config/validation.ts
+init_import_meta_url();
+var import_node_path6 = __toESM(require("node:path"));
+var import_toml3 = __toESM(require_toml());
+
+// src/constellation/utils.ts
+init_import_meta_url();
+
+// src/cfetch/index.ts
+init_import_meta_url();
+var import_node_url4 = require("node:url");
+
+// src/cfetch/internal.ts
+init_import_meta_url();
+var import_node_assert2 = __toESM(require("node:assert"));
+var import_undici3 = __toESM(require_undici());
+var import_undici4 = __toESM(require_undici());
+
+// package.json
+var version = "3.9.0";
+var package_default = {
+ name: "wrangler",
+ version,
+ description: "Command-line interface for all things Cloudflare Workers",
+ keywords: [
+ "wrangler",
+ "cloudflare",
+ "workers",
+ "cloudflare workers",
+ "edge",
+ "compute",
+ "serverless",
+ "serverless application",
+ "serverless module",
+ "wasm",
+ "web",
+ "assembly",
+ "webassembly",
+ "rust",
+ "emscripten",
+ "typescript",
+ "graphql",
+ "router",
+ "http",
+ "cli"
+ ],
+ homepage: "https://github.com/cloudflare/workers-sdk#readme",
+ bugs: {
+ url: "https://github.com/cloudflare/workers-sdk/issues"
+ },
+ repository: {
+ type: "git",
+ url: "https://github.com/cloudflare/workers-sdk.git",
+ directory: "packages/wrangler"
+ },
+ license: "MIT OR Apache-2.0",
+ author: "wrangler@cloudflare.com",
+ main: "wrangler-dist/cli.js",
+ types: "wrangler-dist/cli.d.ts",
+ bin: {
+ wrangler: "./bin/wrangler.js",
+ wrangler2: "./bin/wrangler.js"
+ },
+ files: [
+ "bin",
+ "miniflare-dist",
+ "wrangler-dist",
+ "templates",
+ "kv-asset-handler.js",
+ "Cloudflare_CA.pem"
+ ],
+ scripts: {
+ "assert-git-version": "node -r esbuild-register scripts/assert-git-version.ts",
+ build: "pnpm run clean && pnpm run bundle && pnpm run emit-types",
+ bundle: "node -r esbuild-register scripts/bundle.ts",
+ "check:lint": "eslint .",
+ "check:type": "tsc",
+ clean: "rimraf wrangler-dist miniflare-dist emitted-types",
+ dev: "pnpm run clean && concurrently -c black,blue --kill-others-on-fail false 'pnpm run bundle --watch' 'pnpm run check:type --watch --preserveWatchOutput'",
+ "emit-types": "tsc -p tsconfig.emit.json && node -r esbuild-register scripts/emit-types.ts",
+ prepublishOnly: "SOURCEMAPS=false npm run build",
+ start: "pnpm run bundle && cross-env NODE_OPTIONS=--enable-source-maps ./bin/wrangler.js",
+ test: "pnpm run assert-git-version && jest",
+ "test:ci": "pnpm run test --coverage",
+ "test:debug": "pnpm run test --silent=false --verbose=true",
+ "test:e2e": "vitest --test-timeout 240000 --single-thread --dir ./e2e run",
+ "test:watch": "pnpm run test --runInBand --testTimeout=50000 --watch",
+ "type:tests": "tsc -p ./src/__tests__/tsconfig.json && tsc -p ./e2e/tsconfig.json"
+ },
+ jest: {
+ coverageReporters: [
+ "json",
+ "html",
+ "text",
+ "cobertura"
+ ],
+ moduleNameMapper: {
+ clipboardy: "/src/__tests__/helpers/clipboardy-mock.js",
+ "miniflare/cli": "/../../node_modules/miniflare/dist/src/cli.js"
+ },
+ restoreMocks: true,
+ setupFilesAfterEnv: [
+ "/src/__tests__/jest.setup.ts"
+ ],
+ testRegex: "src/__tests__/.*\\.(test|spec)\\.[jt]sx?$",
+ testTimeout: 5e4,
+ transform: {
+ "^.+\\.c?(t|j)sx?$": [
+ "esbuild-jest",
+ {
+ sourcemap: true
+ }
+ ]
+ },
+ transformIgnorePatterns: [
+ "node_modules/.pnpm/(?!find-up|locate-path|p-locate|p-limit|p-timeout|p-queue|yocto-queue|path-exists|execa|strip-final-newline|npm-run-path|path-key|onetime|mimic-fn|human-signals|is-stream|get-port|supports-color|pretty-bytes|npx-import)"
+ ],
+ snapshotFormat: {
+ escapeString: true,
+ printBasicPrototype: true
+ }
+ },
+ dependencies: {
+ "@cloudflare/kv-asset-handler": "^0.2.0",
+ "@esbuild-plugins/node-globals-polyfill": "^0.2.3",
+ "@esbuild-plugins/node-modules-polyfill": "^0.2.2",
+ "blake3-wasm": "^2.1.5",
+ chokidar: "^3.5.3",
+ esbuild: "0.17.19",
+ miniflare: "3.20230918.0",
+ nanoid: "^3.3.3",
+ "path-to-regexp": "^6.2.0",
+ selfsigned: "^2.0.1",
+ "source-map": "0.6.1",
+ "source-map-support": "0.5.21",
+ "xxhash-wasm": "^1.0.1"
+ },
+ devDependencies: {
+ "@cloudflare/pages-shared": "workspace:^",
+ "@cloudflare/eslint-config-worker": "*",
+ "@cloudflare/types": "^6.18.4",
+ "@cloudflare/workers-tsconfig": "workspace:*",
+ "@cloudflare/workers-types": "^4.20230724.0",
+ "@iarna/toml": "^3.0.0",
+ "@microsoft/api-extractor": "^7.28.3",
+ "@types/body-parser": "^1.19.2",
+ "@types/busboy": "^1.5.0",
+ "@types/command-exists": "^1.2.0",
+ "@types/express": "^4.17.13",
+ "@types/glob-to-regexp": "0.4.1",
+ "@types/is-ci": "^3.0.0",
+ "@types/javascript-time-ago": "^2.0.3",
+ "@types/mime": "^2.0.3",
+ "@types/minimatch": "^5.1.2",
+ "@types/prompts": "^2.0.14",
+ "@types/react": "^17.0.37",
+ "@types/serve-static": "^1.13.10",
+ "@types/signal-exit": "^3.0.1",
+ "@types/source-map-support": "^0.5.7",
+ "@types/supports-color": "^8.1.1",
+ "@types/ws": "^8.5.3",
+ "@types/yargs": "^17.0.10",
+ "@webcontainer/env": "^1.1.0",
+ "@types/jest": "^29.5.5",
+ "esbuild-jest": "0.5.0",
+ jest: "^29.7.0",
+ "body-parser": "^1.20.0",
+ chalk: "^2.4.2",
+ "cli-table3": "^0.6.3",
+ clipboardy: "^3.0.0",
+ "cmd-shim": "^4.1.0",
+ "command-exists": "^1.2.9",
+ concurrently: "^7.2.2",
+ "devtools-protocol": "^0.0.955664",
+ dotenv: "^16.0.0",
+ execa: "^6.1.0",
+ express: "^4.18.1",
+ finalhandler: "^1.2.0",
+ "find-up": "^6.3.0",
+ "get-port": "^6.1.2",
+ "glob-to-regexp": "0.4.1",
+ "http-terminator": "^3.2.0",
+ ignore: "^5.2.0",
+ ink: "^3.2.0",
+ "ink-select-input": "^4.2.1",
+ "ink-spinner": "^4.0.3",
+ "ink-table": "^3.0.0",
+ "ink-testing-library": "^2.1.0",
+ "ink-text-input": "^4.0.3",
+ "is-ci": "^3.0.1",
+ "javascript-time-ago": "^2.5.4",
+ "jest-fetch-mock": "^3.0.3",
+ "jest-websocket-mock": "^2.5.0",
+ mime: "^3.0.0",
+ minimatch: "^5.1.0",
+ msw: "^0.49.1",
+ "npx-import": "^1.1.3",
+ open: "^8.4.0",
+ "p-queue": "^7.2.0",
+ "patch-console": "^1.0.0",
+ "pretty-bytes": "^6.0.0",
+ prompts: "^2.4.2",
+ react: "^17.0.2",
+ "react-error-boundary": "^3.1.4",
+ "remove-accents-esm": "^0.0.1",
+ semiver: "^1.1.0",
+ "serve-static": "^1.15.0",
+ shellac: "^0.8.0",
+ "signal-exit": "^3.0.7",
+ "strip-ansi": "^7.0.1",
+ "supports-color": "^9.2.2",
+ "timeago.js": "^4.0.2",
+ "tmp-promise": "^3.0.3",
+ "ts-dedent": "^2.2.0",
+ undici: "5.20.0",
+ "update-check": "^1.5.4",
+ vitest: "^0.34.4",
+ ws: "^8.5.0",
+ "xdg-app-paths": "^7.3.0",
+ yargs: "^17.4.1",
+ "yoga-layout": "file:../../vendor/yoga-layout-2.0.0-beta.1.tgz"
+ },
+ optionalDependencies: {
+ fsevents: "~2.3.2"
+ },
+ engines: {
+ node: ">=16.13.0"
+ }
+};
+
+// src/environment-variables/misc-variables.ts
+init_import_meta_url();
+var getC3CommandFromEnv = getEnvironmentVariableFactory({
+ variableName: "WRANGLER_C3_COMMAND",
+ defaultValue: () => "create cloudflare@2"
+});
+var getWranglerSendMetricsFromEnv = getEnvironmentVariableFactory({
+ variableName: "WRANGLER_SEND_METRICS"
+});
+var getCloudflareApiEnvironmentFromEnv = getEnvironmentVariableFactory(
+ {
+ variableName: "WRANGLER_API_ENVIRONMENT",
+ defaultValue: () => "production"
+ }
+);
+var getCloudflareApiBaseUrl = getEnvironmentVariableFactory({
+ variableName: "CLOUDFLARE_API_BASE_URL",
+ deprecatedName: "CF_API_BASE_URL",
+ defaultValue: () => getCloudflareApiEnvironmentFromEnv() === "staging" ? "https://api.staging.cloudflare.com/client/v4" : "https://api.cloudflare.com/client/v4"
+});
+
+// src/user/index.ts
+init_import_meta_url();
+
+// src/user/user.ts
+init_import_meta_url();
+var import_node_assert = __toESM(require("node:assert"));
+var import_node_crypto2 = require("node:crypto");
+var import_node_fs3 = require("node:fs");
+var import_node_http = __toESM(require("node:http"));
+var import_node_path5 = __toESM(require("node:path"));
+var import_node_url3 = __toESM(require("node:url"));
+var import_node_util2 = require("node:util");
+var import_toml2 = __toESM(require_toml());
+var import_undici2 = __toESM(require_undici());
+
+// src/config-cache.ts
+init_import_meta_url();
+var import_fs5 = require("fs");
+var path3 = __toESM(require("path"));
+
+// src/is-ci.ts
+init_import_meta_url();
+var import_is_ci = __toESM(require_is_ci2());
+var CI = {
+ /** Is Wrangler currently running in a CI? */
+ isCI() {
+ return import_is_ci.default;
+ }
+};
+
+// src/is-interactive.ts
+init_import_meta_url();
+function isInteractive() {
+ if (process.env.CF_PAGES === "1") {
+ return false;
+ }
+ try {
+ return Boolean(process.stdin.isTTY && process.stdout.isTTY);
+ } catch {
+ return false;
+ }
+}
+__name(isInteractive, "isInteractive");
+
+// src/config-cache.ts
+var cacheMessageShown = false;
+var __cacheFolder;
+function getCacheFolder() {
+ if (__cacheFolder || __cacheFolder === null)
+ return __cacheFolder;
+ const closestNodeModulesDirectory = findUpSync("node_modules", {
+ type: "directory"
+ });
+ __cacheFolder = closestNodeModulesDirectory ? path3.join(closestNodeModulesDirectory, ".cache/wrangler") : null;
+ if (!__cacheFolder) {
+ logger.debug("No folder available to cache configuration");
+ }
+ return __cacheFolder;
+}
+__name(getCacheFolder, "getCacheFolder");
+var arrayFormatter = new Intl.ListFormat("en", {
+ style: "long",
+ type: "conjunction"
+});
+function showCacheMessage(fields, folder) {
+ if (!cacheMessageShown && isInteractive() && !CI.isCI()) {
+ if (fields.length > 0) {
+ logger.debug(
+ `Retrieving cached values for ${arrayFormatter.format(
+ fields
+ )} from ${path3.relative(process.cwd(), folder)}`
+ );
+ cacheMessageShown = true;
+ }
+ }
+}
+__name(showCacheMessage, "showCacheMessage");
+function getConfigCache(fileName) {
+ try {
+ const cacheFolder = getCacheFolder();
+ if (cacheFolder) {
+ const configCacheLocation = path3.join(cacheFolder, fileName);
+ const configCache = JSON.parse(
+ (0, import_fs5.readFileSync)(configCacheLocation, "utf-8")
+ );
+ showCacheMessage(Object.keys(configCache), cacheFolder);
+ return configCache;
+ } else
+ return {};
+ } catch (err) {
+ return {};
+ }
+}
+__name(getConfigCache, "getConfigCache");
+function saveToConfigCache(fileName, newValues) {
+ const cacheFolder = getCacheFolder();
+ if (cacheFolder) {
+ logger.debug(`Saving to cache: ${JSON.stringify(newValues)}`);
+ const configCacheLocation = path3.join(cacheFolder, fileName);
+ const existingValues = getConfigCache(fileName);
+ (0, import_fs5.mkdirSync)(path3.dirname(configCacheLocation), { recursive: true });
+ (0, import_fs5.writeFileSync)(
+ configCacheLocation,
+ JSON.stringify({ ...existingValues, ...newValues }, null, 2)
+ );
+ }
+}
+__name(saveToConfigCache, "saveToConfigCache");
+function purgeConfigCaches() {
+ const cacheFolder = getCacheFolder();
+ if (cacheFolder) {
+ (0, import_fs5.rmSync)(cacheFolder, { recursive: true, force: true });
+ }
+ __cacheFolder = void 0;
+}
+__name(purgeConfigCaches, "purgeConfigCaches");
+
+// src/dialogs.ts
+init_import_meta_url();
+var import_chalk2 = __toESM(require_chalk());
+var import_prompts = __toESM(require_prompts3());
+function isNonInteractiveOrCI() {
+ return !isInteractive() || CI.isCI();
+}
+__name(isNonInteractiveOrCI, "isNonInteractiveOrCI");
+var NoDefaultValueProvided = class extends Error {
+ constructor() {
+ super("This command cannot be run in a non-interactive context");
+ Object.setPrototypeOf(this, new.target.prototype);
+ }
+};
+__name(NoDefaultValueProvided, "NoDefaultValueProvided");
+async function confirm(text, { defaultValue = true } = {}) {
+ if (isNonInteractiveOrCI()) {
+ logger.log(`? ${text}`);
+ logger.log(
+ `\u{1F916} ${import_chalk2.default.dim(
+ "Using default value in non-interactive context:"
+ )} ${import_chalk2.default.white.bold(defaultValue ? "yes" : "no")}`
+ );
+ return defaultValue;
+ }
+ const { value } = await (0, import_prompts.default)({
+ type: "confirm",
+ name: "value",
+ message: text,
+ initial: defaultValue,
+ onState: (state) => {
+ if (state.aborted) {
+ process.nextTick(() => {
+ process.exit(1);
+ });
+ }
+ }
+ });
+ return value;
+}
+__name(confirm, "confirm");
+async function prompt(text, options14 = {}) {
+ if (isNonInteractiveOrCI()) {
+ if (options14?.defaultValue === void 0) {
+ throw new NoDefaultValueProvided();
+ }
+ logger.log(`? ${text}`);
+ logger.log(
+ `\u{1F916} ${import_chalk2.default.dim(
+ "Using default value in non-interactive context:"
+ )} ${import_chalk2.default.white.bold(options14.defaultValue)}`
+ );
+ return options14.defaultValue;
+ }
+ const { value } = await (0, import_prompts.default)({
+ type: "text",
+ name: "value",
+ message: text,
+ initial: options14?.defaultValue,
+ style: options14?.isSecret ? "password" : "default",
+ onState: (state) => {
+ if (state.aborted) {
+ process.nextTick(() => {
+ process.exit(1);
+ });
+ }
+ }
+ });
+ return value;
+}
+__name(prompt, "prompt");
+async function select(text, options14) {
+ if (isNonInteractiveOrCI()) {
+ if (options14?.defaultOption === void 0) {
+ throw new NoDefaultValueProvided();
+ }
+ logger.log(`? ${text}`);
+ logger.log(
+ `\u{1F916} ${import_chalk2.default.dim(
+ "Using default value in non-interactive context:"
+ )} ${import_chalk2.default.white.bold(options14.choices[options14.defaultOption].title)}`
+ );
+ return options14.choices[options14.defaultOption].value;
+ }
+ const { value } = await (0, import_prompts.default)({
+ type: "select",
+ name: "value",
+ message: text,
+ choices: options14.choices,
+ initial: options14.defaultOption,
+ onState: (state) => {
+ if (state.aborted) {
+ process.nextTick(() => {
+ process.exit(1);
+ });
+ }
+ }
+ });
+ return value;
+}
+__name(select, "select");
+
+// src/global-wrangler-config-path.ts
+init_import_meta_url();
+var import_node_fs2 = __toESM(require("node:fs"));
+var import_node_os2 = __toESM(require("node:os"));
+var import_node_path4 = __toESM(require("node:path"));
+
+// ../../node_modules/.pnpm/xdg-app-paths@7.3.0/node_modules/xdg-app-paths/dist/cjs/esm-wrapper/mod.esm.js
+var mod_esm_exports = {};
+__export(mod_esm_exports, {
+ default: () => mod_esm_default
+});
+init_import_meta_url();
+var import_mod_cjs = __toESM(require_mod_cjs3(), 1);
+__reExport(mod_esm_exports, __toESM(require_mod_cjs3(), 1));
+var mod_esm_default = import_mod_cjs.default;
+
+// src/global-wrangler-config-path.ts
+function isDirectory(configPath) {
+ try {
+ return import_node_fs2.default.statSync(configPath).isDirectory();
+ } catch (error) {
+ return false;
+ }
+}
+__name(isDirectory, "isDirectory");
+function getGlobalWranglerConfigPath() {
+ const configDir = mod_esm_default(".wrangler").config();
+ const legacyConfigDir = import_node_path4.default.join(import_node_os2.default.homedir(), ".wrangler");
+ if (isDirectory(legacyConfigDir)) {
+ return legacyConfigDir;
+ } else {
+ return configDir;
+ }
+}
+__name(getGlobalWranglerConfigPath, "getGlobalWranglerConfigPath");
+
+// src/open-in-browser.ts
+init_import_meta_url();
+var import_open = __toESM(require_open());
+async function openInBrowser(url3) {
+ const childProcess2 = await (0, import_open.default)(url3);
+ childProcess2.on("error", () => {
+ logger.warn("Failed to open");
+ });
+}
+__name(openInBrowser, "openInBrowser");
+
+// src/user/access.ts
+init_import_meta_url();
+var import_child_process = require("child_process");
+var import_undici = __toESM(require_undici());
+var cache = {};
+var usesAccessCache = /* @__PURE__ */ new Map();
+async function domainUsesAccess(domain) {
+ logger.debug("Checking if domain has Access enabled:", domain);
+ if (usesAccessCache.has(domain)) {
+ logger.debug(
+ "Using cached Access switch for:",
+ domain,
+ usesAccessCache.get(domain)
+ );
+ return usesAccessCache.get(domain);
+ }
+ logger.debug("Access switch not cached for:", domain);
+ try {
+ const controller = new AbortController();
+ const cancel2 = setTimeout(() => {
+ controller.abort();
+ }, 1e3);
+ const output = await (0, import_undici.fetch)(`https://${domain}`, {
+ redirect: "manual",
+ signal: controller.signal
+ });
+ clearTimeout(cancel2);
+ const usesAccess = !!(output.status === 302 && output.headers.get("location")?.includes("cloudflareaccess.com"));
+ logger.debug("Caching access switch for:", domain);
+ usesAccessCache.set(domain, usesAccess);
+ return usesAccess;
+ } catch (e2) {
+ usesAccessCache.set(domain, false);
+ return false;
+ }
+}
+__name(domainUsesAccess, "domainUsesAccess");
+async function getAccessToken(domain) {
+ if (!await domainUsesAccess(domain)) {
+ return void 0;
+ }
+ if (cache[domain]) {
+ return cache[domain];
+ }
+ const output = (0, import_child_process.spawnSync)("cloudflared", ["access", "login", domain]);
+ if (output.error) {
+ throw new Error(
+ "To use Wrangler with Cloudflare Access, please install `cloudflared` from https://developers.cloudflare.com/cloudflare-one/connections/connect-apps/install-and-setup/installation"
+ );
+ }
+ const stringOutput = output.stdout.toString();
+ const matches = stringOutput.match(/fetched your token:\n\n(.*)/m);
+ if (matches && matches.length >= 2) {
+ cache[domain] = matches[1];
+ return matches[1];
+ }
+ throw new Error("Failed to authenticate with Cloudflare Access");
+}
+__name(getAccessToken, "getAccessToken");
+
+// src/user/auth-variables.ts
+init_import_meta_url();
+var getCloudflareAccountIdFromEnv = getEnvironmentVariableFactory({
+ variableName: "CLOUDFLARE_ACCOUNT_ID",
+ deprecatedName: "CF_ACCOUNT_ID"
+});
+var getCloudflareAPITokenFromEnv = getEnvironmentVariableFactory({
+ variableName: "CLOUDFLARE_API_TOKEN",
+ deprecatedName: "CF_API_TOKEN"
+});
+var getCloudflareGlobalAuthKeyFromEnv = getEnvironmentVariableFactory({
+ variableName: "CLOUDFLARE_API_KEY",
+ deprecatedName: "CF_API_KEY"
+});
+var getCloudflareGlobalAuthEmailFromEnv = getEnvironmentVariableFactory({
+ variableName: "CLOUDFLARE_EMAIL",
+ deprecatedName: "CF_EMAIL"
+});
+var getClientIdFromEnv = getEnvironmentVariableFactory({
+ variableName: "WRANGLER_CLIENT_ID",
+ defaultValue: () => getCloudflareApiEnvironmentFromEnv() === "staging" ? "4b2ea6cc-9421-4761-874b-ce550e0e3def" : "54d11594-84e4-41aa-b438-e81b8fa78ee7"
+});
+var getAuthDomainFromEnv = getEnvironmentVariableFactory({
+ variableName: "WRANGLER_AUTH_DOMAIN",
+ defaultValue: () => getCloudflareApiEnvironmentFromEnv() === "staging" ? "dash.staging.cloudflare.com" : "dash.cloudflare.com"
+});
+var getAuthUrlFromEnv = getEnvironmentVariableFactory({
+ variableName: "WRANGLER_AUTH_URL",
+ defaultValue: () => `https://${getAuthDomainFromEnv()}/oauth2/auth`
+});
+var getTokenUrlFromEnv = getEnvironmentVariableFactory({
+ variableName: "WRANGLER_TOKEN_URL",
+ defaultValue: () => `https://${getAuthDomainFromEnv()}/oauth2/token`
+});
+var getRevokeUrlFromEnv = getEnvironmentVariableFactory({
+ variableName: "WRANGLER_REVOKE_URL",
+ defaultValue: () => `https://${getAuthDomainFromEnv()}/oauth2/revoke`
+});
+var getCloudflareAccessToken = /* @__PURE__ */ __name(async () => {
+ const env5 = getEnvironmentVariableFactory({
+ variableName: "WRANGLER_CF_AUTHORIZATION_TOKEN"
+ })();
+ if (env5 !== void 0) {
+ return env5;
+ }
+ return getAccessToken(getAuthDomainFromEnv());
+}, "getCloudflareAccessToken");
+
+// src/user/choose-account.tsx
+init_import_meta_url();
+async function getAccountChoices() {
+ const accountIdFromEnv = getCloudflareAccountIdFromEnv();
+ if (accountIdFromEnv) {
+ return [{ id: accountIdFromEnv, name: "" }];
+ } else {
+ try {
+ const response = await fetchListResult(`/memberships`);
+ const accounts = response.map((r) => r.account);
+ if (accounts.length === 0) {
+ throw new Error(
+ "Failed to automatically retrieve account IDs for the logged in user.\nIn a non-interactive environment, it is mandatory to specify an account ID, either by assigning its value to CLOUDFLARE_ACCOUNT_ID, or as `account_id` in your `wrangler.toml` file."
+ );
+ } else {
+ return accounts;
+ }
+ } catch (err) {
+ if (err.code === 9109) {
+ throw new Error(
+ `Failed to automatically retrieve account IDs for the logged in user.
+You may have incorrect permissions on your API token. You can skip this account check by adding an \`account_id\` in your \`wrangler.toml\`, or by setting the value of CLOUDFLARE_ACCOUNT_ID"`
+ );
+ } else
+ throw err;
+ }
+ }
+}
+__name(getAccountChoices, "getAccountChoices");
+
+// src/user/generate-auth-url.ts
+init_import_meta_url();
+var generateAuthUrl = /* @__PURE__ */ __name(({
+ authUrl,
+ clientId,
+ callbackUrl,
+ scopes,
+ stateQueryParam,
+ codeChallenge
+}) => {
+ return authUrl + `?response_type=code&client_id=${encodeURIComponent(clientId)}&redirect_uri=${encodeURIComponent(callbackUrl)}&scope=${encodeURIComponent([...scopes, "offline_access"].join(" "))}&state=${stateQueryParam}&code_challenge=${encodeURIComponent(codeChallenge)}&code_challenge_method=S256`;
+}, "generateAuthUrl");
+
+// src/user/generate-random-state.ts
+init_import_meta_url();
+var import_node_crypto = require("node:crypto");
+function generateRandomState(lengthOfState) {
+ const output = new Uint32Array(lengthOfState);
+ import_node_crypto.webcrypto.getRandomValues(output);
+ return Array.from(output).map((num) => PKCE_CHARSET[num % PKCE_CHARSET.length]).join("");
+}
+__name(generateRandomState, "generateRandomState");
+
+// src/user/user.ts
+function getAuthFromEnv() {
+ const globalApiKey = getCloudflareGlobalAuthKeyFromEnv();
+ const globalApiEmail = getCloudflareGlobalAuthEmailFromEnv();
+ const apiToken = getCloudflareAPITokenFromEnv();
+ if (globalApiKey && globalApiEmail) {
+ return { authKey: globalApiKey, authEmail: globalApiEmail };
+ } else if (apiToken) {
+ return { apiToken };
+ }
+}
+__name(getAuthFromEnv, "getAuthFromEnv");
+var USER_AUTH_CONFIG_FILE = "config/default.toml";
+var Scopes = {
+ "account:read": "See your account info such as account details, analytics, and memberships.",
+ "user:read": "See your user info such as name, email address, and account memberships.",
+ "workers:write": "See and change Cloudflare Workers data such as zones, KV storage, namespaces, scripts, and routes.",
+ "workers_kv:write": "See and change Cloudflare Workers KV Storage data such as keys and namespaces.",
+ "workers_routes:write": "See and change Cloudflare Workers data such as filters and routes.",
+ "workers_scripts:write": "See and change Cloudflare Workers scripts, durable objects, subdomains, triggers, and tail data.",
+ "workers_tail:read": "See Cloudflare Workers tail and script data.",
+ "d1:write": "See and change D1 Databases.",
+ "pages:write": "See and change Cloudflare Pages projects, settings and deployments.",
+ "zone:read": "Grants read level access to account zone.",
+ "ssl_certs:write": "See and manage mTLS certificates for your account",
+ "constellation:write": "Manage Constellation projects/models"
+};
+var ScopeKeys = Object.keys(Scopes);
+function validateScopeKeys(scopes) {
+ return scopes.every((scope) => scope in Scopes);
+}
+__name(validateScopeKeys, "validateScopeKeys");
+var CALLBACK_URL = "http://localhost:8976/oauth/callback";
+var LocalState = {
+ ...getAuthTokens()
+};
+function getAuthTokens(config) {
+ try {
+ if (getAuthFromEnv())
+ return;
+ const { oauth_token, refresh_token, expiration_time, scopes, api_token } = config || readAuthConfigFile();
+ if (oauth_token) {
+ return {
+ accessToken: {
+ value: oauth_token,
+ // If there is no `expiration_time` field then set it to an old date, to cause it to expire immediately.
+ expiry: expiration_time ?? "2000-01-01:00:00:00+00:00"
+ },
+ refreshToken: { value: refresh_token ?? "" },
+ scopes
+ };
+ } else if (api_token) {
+ logger.warn(
+ "It looks like you have used Wrangler v1's `config` command to login with an API token.\nThis is no longer supported in the current version of Wrangler.\nIf you wish to authenticate via an API token then please set the `CLOUDFLARE_API_TOKEN` environment variable."
+ );
+ return { apiToken: api_token };
+ }
+ } catch {
+ return void 0;
+ }
+}
+__name(getAuthTokens, "getAuthTokens");
+function reinitialiseAuthTokens(config) {
+ LocalState = {
+ ...getAuthTokens(config)
+ };
+}
+__name(reinitialiseAuthTokens, "reinitialiseAuthTokens");
+function getAPIToken() {
+ if (LocalState.apiToken) {
+ return { apiToken: LocalState.apiToken };
+ }
+ const localAPIToken = getAuthFromEnv();
+ if (localAPIToken)
+ return localAPIToken;
+ const storedAccessToken = LocalState.accessToken?.value;
+ if (storedAccessToken)
+ return { apiToken: storedAccessToken };
+ return void 0;
+}
+__name(getAPIToken, "getAPIToken");
+var ErrorOAuth2 = class extends Error {
+ toString() {
+ return "ErrorOAuth2";
+ }
+};
+__name(ErrorOAuth2, "ErrorOAuth2");
+var ErrorUnknown = class extends ErrorOAuth2 {
+ toString() {
+ return "ErrorUnknown";
+ }
+};
+__name(ErrorUnknown, "ErrorUnknown");
+var ErrorNoAuthCode = class extends ErrorOAuth2 {
+ toString() {
+ return "ErrorNoAuthCode";
+ }
+};
+__name(ErrorNoAuthCode, "ErrorNoAuthCode");
+var ErrorInvalidReturnedStateParam = class extends ErrorOAuth2 {
+ toString() {
+ return "ErrorInvalidReturnedStateParam";
+ }
+};
+__name(ErrorInvalidReturnedStateParam, "ErrorInvalidReturnedStateParam");
+var ErrorInvalidJson = class extends ErrorOAuth2 {
+ toString() {
+ return "ErrorInvalidJson";
+ }
+};
+__name(ErrorInvalidJson, "ErrorInvalidJson");
+var ErrorInvalidScope = class extends ErrorOAuth2 {
+ toString() {
+ return "ErrorInvalidScope";
+ }
+};
+__name(ErrorInvalidScope, "ErrorInvalidScope");
+var ErrorInvalidRequest = class extends ErrorOAuth2 {
+ toString() {
+ return "ErrorInvalidRequest";
+ }
+};
+__name(ErrorInvalidRequest, "ErrorInvalidRequest");
+var ErrorInvalidToken = class extends ErrorOAuth2 {
+ toString() {
+ return "ErrorInvalidToken";
+ }
+};
+__name(ErrorInvalidToken, "ErrorInvalidToken");
+var ErrorAuthenticationGrant = class extends ErrorOAuth2 {
+ toString() {
+ return "ErrorAuthenticationGrant";
+ }
+};
+__name(ErrorAuthenticationGrant, "ErrorAuthenticationGrant");
+var ErrorUnauthorizedClient = class extends ErrorAuthenticationGrant {
+ toString() {
+ return "ErrorUnauthorizedClient";
+ }
+};
+__name(ErrorUnauthorizedClient, "ErrorUnauthorizedClient");
+var ErrorAccessDenied = class extends ErrorAuthenticationGrant {
+ toString() {
+ return "ErrorAccessDenied";
+ }
+};
+__name(ErrorAccessDenied, "ErrorAccessDenied");
+var ErrorUnsupportedResponseType = class extends ErrorAuthenticationGrant {
+ toString() {
+ return "ErrorUnsupportedResponseType";
+ }
+};
+__name(ErrorUnsupportedResponseType, "ErrorUnsupportedResponseType");
+var ErrorServerError = class extends ErrorAuthenticationGrant {
+ toString() {
+ return "ErrorServerError";
+ }
+};
+__name(ErrorServerError, "ErrorServerError");
+var ErrorTemporarilyUnavailable = class extends ErrorAuthenticationGrant {
+ toString() {
+ return "ErrorTemporarilyUnavailable";
+ }
+};
+__name(ErrorTemporarilyUnavailable, "ErrorTemporarilyUnavailable");
+var ErrorAccessTokenResponse = class extends ErrorOAuth2 {
+ toString() {
+ return "ErrorAccessTokenResponse";
+ }
+};
+__name(ErrorAccessTokenResponse, "ErrorAccessTokenResponse");
+var ErrorInvalidClient = class extends ErrorAccessTokenResponse {
+ toString() {
+ return "ErrorInvalidClient";
+ }
+};
+__name(ErrorInvalidClient, "ErrorInvalidClient");
+var ErrorInvalidGrant = class extends ErrorAccessTokenResponse {
+ toString() {
+ return "ErrorInvalidGrant";
+ }
+};
+__name(ErrorInvalidGrant, "ErrorInvalidGrant");
+var ErrorUnsupportedGrantType = class extends ErrorAccessTokenResponse {
+ toString() {
+ return "ErrorUnsupportedGrantType";
+ }
+};
+__name(ErrorUnsupportedGrantType, "ErrorUnsupportedGrantType");
+var RawErrorToErrorClassMap = {
+ invalid_request: ErrorInvalidRequest,
+ invalid_grant: ErrorInvalidGrant,
+ unauthorized_client: ErrorUnauthorizedClient,
+ access_denied: ErrorAccessDenied,
+ unsupported_response_type: ErrorUnsupportedResponseType,
+ invalid_scope: ErrorInvalidScope,
+ server_error: ErrorServerError,
+ temporarily_unavailable: ErrorTemporarilyUnavailable,
+ invalid_client: ErrorInvalidClient,
+ unsupported_grant_type: ErrorUnsupportedGrantType,
+ invalid_json: ErrorInvalidJson,
+ invalid_token: ErrorInvalidToken
+};
+function toErrorClass(rawError) {
+ return new (RawErrorToErrorClassMap[rawError] || ErrorUnknown)();
+}
+__name(toErrorClass, "toErrorClass");
+var RECOMMENDED_CODE_VERIFIER_LENGTH = 96;
+var RECOMMENDED_STATE_LENGTH = 32;
+var PKCE_CHARSET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-._~";
+function isReturningFromAuthServer(query) {
+ if (query.error) {
+ if (Array.isArray(query.error)) {
+ throw toErrorClass(query.error[0]);
+ }
+ throw toErrorClass(query.error);
+ }
+ const code = query.code;
+ if (!code) {
+ return false;
+ }
+ const state = LocalState;
+ const stateQueryParam = query.state;
+ if (stateQueryParam !== state.stateQueryParam) {
+ logger.warn(
+ "Received query string parameter doesn't match the one sent! Possible malicious activity somewhere."
+ );
+ throw new ErrorInvalidReturnedStateParam();
+ }
+ (0, import_node_assert.default)(!Array.isArray(code));
+ state.authorizationCode = code;
+ state.hasAuthCodeBeenExchangedForAccessToken = false;
+ return true;
+}
+__name(isReturningFromAuthServer, "isReturningFromAuthServer");
+async function getAuthURL(scopes = ScopeKeys) {
+ const { codeChallenge, codeVerifier } = await generatePKCECodes();
+ const stateQueryParam = generateRandomState(RECOMMENDED_STATE_LENGTH);
+ Object.assign(LocalState, {
+ codeChallenge,
+ codeVerifier,
+ stateQueryParam
+ });
+ return generateAuthUrl({
+ authUrl: getAuthUrlFromEnv(),
+ clientId: getClientIdFromEnv(),
+ callbackUrl: CALLBACK_URL,
+ scopes,
+ stateQueryParam,
+ codeChallenge
+ });
+}
+__name(getAuthURL, "getAuthURL");
+async function exchangeRefreshTokenForAccessToken() {
+ if (!LocalState.refreshToken) {
+ logger.warn("No refresh token is present.");
+ }
+ const params = new URLSearchParams({
+ grant_type: "refresh_token",
+ refresh_token: LocalState.refreshToken?.value ?? "",
+ client_id: getClientIdFromEnv()
+ });
+ const response = await fetchAuthToken(params);
+ if (response.status >= 400) {
+ let tokenExchangeResErr = void 0;
+ try {
+ tokenExchangeResErr = await response.text();
+ tokenExchangeResErr = JSON.parse(tokenExchangeResErr);
+ } catch (e2) {
+ }
+ if (tokenExchangeResErr !== void 0) {
+ throw typeof tokenExchangeResErr === "string" ? new Error(tokenExchangeResErr) : tokenExchangeResErr;
+ } else {
+ throw new ErrorUnknown(
+ "Failed to parse Error from exchangeRefreshTokenForAccessToken"
+ );
+ }
+ } else {
+ try {
+ const json = await response.json();
+ if ("error" in json) {
+ throw json.error;
+ }
+ const { access_token, expires_in, refresh_token, scope } = json;
+ let scopes = [];
+ const accessToken = {
+ value: access_token,
+ expiry: new Date(Date.now() + expires_in * 1e3).toISOString()
+ };
+ LocalState.accessToken = accessToken;
+ if (refresh_token) {
+ LocalState.refreshToken = {
+ value: refresh_token
+ };
+ }
+ if (scope) {
+ scopes = scope.split(" ");
+ LocalState.scopes = scopes;
+ }
+ const accessContext = {
+ token: accessToken,
+ scopes,
+ refreshToken: LocalState.refreshToken
+ };
+ return accessContext;
+ } catch (error) {
+ if (typeof error === "string") {
+ throw toErrorClass(error);
+ } else {
+ throw error;
+ }
+ }
+ }
+}
+__name(exchangeRefreshTokenForAccessToken, "exchangeRefreshTokenForAccessToken");
+async function exchangeAuthCodeForAccessToken() {
+ const { authorizationCode, codeVerifier = "" } = LocalState;
+ if (!codeVerifier) {
+ logger.warn("No code verifier is being sent.");
+ } else if (!authorizationCode) {
+ logger.warn("No authorization grant code is being passed.");
+ }
+ const params = new URLSearchParams({
+ grant_type: `authorization_code`,
+ code: authorizationCode ?? "",
+ redirect_uri: CALLBACK_URL,
+ client_id: getClientIdFromEnv(),
+ code_verifier: codeVerifier
+ });
+ const response = await fetchAuthToken(params);
+ if (!response.ok) {
+ const { error } = await response.json();
+ if (error === "invalid_grant") {
+ logger.log("Expired! Auth code or refresh token needs to be renewed.");
+ }
+ throw toErrorClass(error);
+ }
+ const json = await response.json();
+ if ("error" in json) {
+ throw new Error(json.error);
+ }
+ const { access_token, expires_in, refresh_token, scope } = json;
+ let scopes = [];
+ LocalState.hasAuthCodeBeenExchangedForAccessToken = true;
+ const expiryDate = new Date(Date.now() + expires_in * 1e3);
+ const accessToken = {
+ value: access_token,
+ expiry: expiryDate.toISOString()
+ };
+ LocalState.accessToken = accessToken;
+ if (refresh_token) {
+ LocalState.refreshToken = {
+ value: refresh_token
+ };
+ }
+ if (scope) {
+ scopes = scope.split(" ");
+ LocalState.scopes = scopes;
+ }
+ const accessContext = {
+ token: accessToken,
+ scopes,
+ refreshToken: LocalState.refreshToken
+ };
+ return accessContext;
+}
+__name(exchangeAuthCodeForAccessToken, "exchangeAuthCodeForAccessToken");
+function base64urlEncode(value) {
+ let base64 = btoa(value);
+ base64 = base64.replace(/\+/g, "-");
+ base64 = base64.replace(/\//g, "_");
+ base64 = base64.replace(/=/g, "");
+ return base64;
+}
+__name(base64urlEncode, "base64urlEncode");
+async function generatePKCECodes() {
+ const output = new Uint32Array(RECOMMENDED_CODE_VERIFIER_LENGTH);
+ import_node_crypto2.webcrypto.getRandomValues(output);
+ const codeVerifier = base64urlEncode(
+ Array.from(output).map((num) => PKCE_CHARSET[num % PKCE_CHARSET.length]).join("")
+ );
+ const buffer = await import_node_crypto2.webcrypto.subtle.digest(
+ "SHA-256",
+ new import_node_util2.TextEncoder().encode(codeVerifier)
+ );
+ const hash = new Uint8Array(buffer);
+ let binary = "";
+ const hashLength = hash.byteLength;
+ for (let i = 0; i < hashLength; i++) {
+ binary += String.fromCharCode(hash[i]);
+ }
+ const codeChallenge = base64urlEncode(binary);
+ return { codeChallenge, codeVerifier };
+}
+__name(generatePKCECodes, "generatePKCECodes");
+function writeAuthConfigFile(config) {
+ const authConfigFilePath = import_node_path5.default.join(
+ getGlobalWranglerConfigPath(),
+ USER_AUTH_CONFIG_FILE
+ );
+ (0, import_node_fs3.mkdirSync)(import_node_path5.default.dirname(authConfigFilePath), {
+ recursive: true
+ });
+ (0, import_node_fs3.writeFileSync)(
+ import_node_path5.default.join(authConfigFilePath),
+ import_toml2.default.stringify(config),
+ { encoding: "utf-8" }
+ );
+ reinitialiseAuthTokens();
+}
+__name(writeAuthConfigFile, "writeAuthConfigFile");
+function readAuthConfigFile() {
+ const authConfigFilePath = import_node_path5.default.join(
+ getGlobalWranglerConfigPath(),
+ USER_AUTH_CONFIG_FILE
+ );
+ const toml = parseTOML(readFileSync5(authConfigFilePath));
+ return toml;
+}
+__name(readAuthConfigFile, "readAuthConfigFile");
+async function loginOrRefreshIfRequired() {
+ const { isCI: isCI2 } = CI;
+ if (!getAPIToken()) {
+ return isInteractive() && !isCI2() && await login();
+ } else if (isAccessTokenExpired()) {
+ const didRefresh = await refreshToken();
+ if (didRefresh) {
+ return true;
+ } else {
+ return isInteractive() && !isCI2() && await login();
+ }
+ } else {
+ return true;
+ }
+}
+__name(loginOrRefreshIfRequired, "loginOrRefreshIfRequired");
+async function login(props = { browser: true }) {
+ logger.log("Attempting to login via OAuth...");
+ const urlToOpen = await getAuthURL(props?.scopes);
+ let server2;
+ let loginTimeoutHandle;
+ const timerPromise = new Promise((resolve18) => {
+ loginTimeoutHandle = setTimeout(() => {
+ logger.error(
+ "Timed out waiting for authorization code, please try again."
+ );
+ server2.close();
+ clearTimeout(loginTimeoutHandle);
+ resolve18(false);
+ }, 12e4);
+ });
+ const loginPromise = new Promise((resolve18, reject) => {
+ server2 = import_node_http.default.createServer(async (req, res) => {
+ function finish(status, error) {
+ clearTimeout(loginTimeoutHandle);
+ server2.close((closeErr) => {
+ if (error || closeErr) {
+ reject(error || closeErr);
+ } else
+ resolve18(status);
+ });
+ }
+ __name(finish, "finish");
+ (0, import_node_assert.default)(req.url, "This request doesn't have a URL");
+ const { pathname, query } = import_node_url3.default.parse(req.url, true);
+ switch (pathname) {
+ case "/oauth/callback": {
+ let hasAuthCode = false;
+ try {
+ hasAuthCode = isReturningFromAuthServer(query);
+ } catch (err) {
+ if (err instanceof ErrorAccessDenied) {
+ res.writeHead(307, {
+ Location: "https://welcome.developers.workers.dev/wrangler-oauth-consent-denied"
+ });
+ res.end(() => {
+ finish(false);
+ });
+ logger.error(
+ "Error: Consent denied. You must grant consent to Wrangler in order to login.\nIf you don't want to do this consider passing an API token via the `CLOUDFLARE_API_TOKEN` environment variable"
+ );
+ return;
+ } else {
+ finish(false, err);
+ return;
+ }
+ }
+ if (!hasAuthCode) {
+ finish(false, new ErrorNoAuthCode());
+ return;
+ } else {
+ const exchange = await exchangeAuthCodeForAccessToken();
+ writeAuthConfigFile({
+ oauth_token: exchange.token?.value ?? "",
+ expiration_time: exchange.token?.expiry,
+ refresh_token: exchange.refreshToken?.value,
+ scopes: exchange.scopes
+ });
+ res.writeHead(307, {
+ Location: "https://welcome.developers.workers.dev/wrangler-oauth-consent-granted"
+ });
+ res.end(() => {
+ finish(true);
+ });
+ logger.log(`Successfully logged in.`);
+ purgeConfigCaches();
+ return;
+ }
+ }
+ }
+ });
+ server2.listen(8976);
+ });
+ if (props?.browser) {
+ logger.log(`Opening a link in your default browser: ${urlToOpen}`);
+ await openInBrowser(urlToOpen);
+ } else {
+ logger.log(`Visit this link to authenticate: ${urlToOpen}`);
+ }
+ return Promise.race([timerPromise, loginPromise]);
+}
+__name(login, "login");
+function isAccessTokenExpired() {
+ const { accessToken } = LocalState;
+ return Boolean(accessToken && /* @__PURE__ */ new Date() >= new Date(accessToken.expiry));
+}
+__name(isAccessTokenExpired, "isAccessTokenExpired");
+async function refreshToken() {
+ try {
+ const {
+ token: { value: oauth_token, expiry: expiration_time } = {
+ value: "",
+ expiry: ""
+ },
+ refreshToken: { value: refresh_token } = {},
+ scopes
+ } = await exchangeRefreshTokenForAccessToken();
+ writeAuthConfigFile({
+ oauth_token,
+ expiration_time,
+ refresh_token,
+ scopes
+ });
+ return true;
+ } catch (err) {
+ return false;
+ }
+}
+__name(refreshToken, "refreshToken");
+async function logout() {
+ if (!LocalState.accessToken) {
+ if (!LocalState.refreshToken) {
+ logger.log("Not logged in, exiting...");
+ return;
+ }
+ const body2 = `client_id=${encodeURIComponent(getClientIdFromEnv())}&token_type_hint=refresh_token&token=${encodeURIComponent(LocalState.refreshToken?.value || "")}`;
+ const response2 = await (0, import_undici2.fetch)(getRevokeUrlFromEnv(), {
+ method: "POST",
+ body: body2,
+ headers: {
+ "Content-Type": "application/x-www-form-urlencoded"
+ }
+ });
+ await response2.text();
+ logger.log(
+ "\u{1F481} Wrangler is configured with an OAuth token. The token has been successfully revoked"
+ );
+ }
+ const body = `client_id=${encodeURIComponent(getClientIdFromEnv())}&token_type_hint=refresh_token&token=${encodeURIComponent(LocalState.refreshToken?.value || "")}`;
+ const response = await (0, import_undici2.fetch)(getRevokeUrlFromEnv(), {
+ method: "POST",
+ body,
+ headers: {
+ "Content-Type": "application/x-www-form-urlencoded"
+ }
+ });
+ await response.text();
+ (0, import_node_fs3.rmSync)(import_node_path5.default.join(getGlobalWranglerConfigPath(), USER_AUTH_CONFIG_FILE));
+ logger.log(`Successfully logged out.`);
+}
+__name(logout, "logout");
+function listScopes(message = "\u{1F481} Available scopes:") {
+ logger.log(message);
+ const data = ScopeKeys.map((scope) => ({
+ Scope: scope,
+ Description: Scopes[scope]
+ }));
+ logger.table(data);
+}
+__name(listScopes, "listScopes");
+async function getAccountId() {
+ const apiToken = getAPIToken();
+ if (!apiToken)
+ return;
+ const cachedAccount = getAccountFromCache();
+ if (cachedAccount && !getCloudflareAccountIdFromEnv()) {
+ return cachedAccount.id;
+ }
+ const accounts = await getAccountChoices();
+ if (accounts.length === 1) {
+ saveAccountToCache({ id: accounts[0].id, name: accounts[0].name });
+ return accounts[0].id;
+ }
+ try {
+ const accountID = await select("Select an account", {
+ choices: accounts.map((account2) => ({
+ title: account2.name,
+ value: account2.id
+ }))
+ });
+ const account = accounts.find(
+ (a) => a.id === accountID
+ );
+ saveAccountToCache({ id: account.id, name: account.name });
+ return accountID;
+ } catch (e2) {
+ if (e2 instanceof NoDefaultValueProvided) {
+ throw new Error(
+ `More than one account available but unable to select one in non-interactive mode.
+Please set the appropriate \`account_id\` in your \`wrangler.toml\` file.
+Available accounts are (\`\`: \`\`):
+${accounts.map((account) => ` \`${account.name}\`: \`${account.id}\``).join("\n")}`
+ );
+ }
+ throw e2;
+ }
+}
+__name(getAccountId, "getAccountId");
+async function requireAuth(config) {
+ const loggedIn = await loginOrRefreshIfRequired();
+ if (!loggedIn) {
+ if (!isInteractive() || CI.isCI()) {
+ throw new Error(
+ "In a non-interactive environment, it's necessary to set a CLOUDFLARE_API_TOKEN environment variable for wrangler to work. Please go to https://developers.cloudflare.com/fundamentals/api/get-started/create-token/ for instructions on how to create an api token, and assign its value to CLOUDFLARE_API_TOKEN."
+ );
+ } else {
+ throw new Error("Did not login, quitting...");
+ }
+ }
+ const accountId = config.account_id || await getAccountId();
+ if (!accountId) {
+ throw new Error("No account id found, quitting...");
+ }
+ return accountId;
+}
+__name(requireAuth, "requireAuth");
+function requireApiToken() {
+ const credentials = getAPIToken();
+ if (!credentials) {
+ throw new Error("No API token found.");
+ }
+ return credentials;
+}
+__name(requireApiToken, "requireApiToken");
+function saveAccountToCache(account) {
+ saveToConfigCache(
+ "wrangler-account.json",
+ { account }
+ );
+}
+__name(saveAccountToCache, "saveAccountToCache");
+function getAccountFromCache() {
+ return getConfigCache(
+ "wrangler-account.json"
+ ).account;
+}
+__name(getAccountFromCache, "getAccountFromCache");
+function getScopes() {
+ return LocalState.scopes;
+}
+__name(getScopes, "getScopes");
+async function fetchAuthToken(body) {
+ const headers = {
+ "Content-Type": "application/x-www-form-urlencoded"
+ };
+ if (await domainUsesAccess(getAuthDomainFromEnv())) {
+ headers["Cookie"] = `CF_Authorization=${await getCloudflareAccessToken()}`;
+ }
+ return await (0, import_undici2.fetch)(getTokenUrlFromEnv(), {
+ method: "POST",
+ body: body.toString(),
+ headers
+ });
+}
+__name(fetchAuthToken, "fetchAuthToken");
+
+// src/cfetch/internal.ts
+async function performApiFetch(resource, init = {}, queryParams, abortSignal) {
+ const method = init.method ?? "GET";
+ (0, import_node_assert2.default)(
+ resource.startsWith("/"),
+ `CF API fetch - resource path must start with a "/" but got "${resource}"`
+ );
+ await requireLoggedIn();
+ const apiToken = requireApiToken();
+ const headers = cloneHeaders(init.headers);
+ addAuthorizationHeaderIfUnspecified(headers, apiToken);
+ addUserAgent(headers);
+ const queryString = queryParams ? `?${queryParams.toString()}` : "";
+ logger.debug(
+ `-- START CF API REQUEST: ${method} ${getCloudflareApiBaseUrl()}${resource}${queryString}`
+ );
+ const logHeaders = cloneHeaders(headers);
+ delete logHeaders["Authorization"];
+ logger.debug("HEADERS:", JSON.stringify(logHeaders, null, 2));
+ logger.debug(
+ "INIT:",
+ JSON.stringify({ ...init, headers: logHeaders }, null, 2)
+ );
+ logger.debug("-- END CF API REQUEST");
+ return await (0, import_undici3.fetch)(`${getCloudflareApiBaseUrl()}${resource}${queryString}`, {
+ method,
+ ...init,
+ headers,
+ signal: abortSignal
+ });
+}
+__name(performApiFetch, "performApiFetch");
+async function fetchInternal(resource, init = {}, queryParams, abortSignal) {
+ const method = init.method ?? "GET";
+ const response = await performApiFetch(
+ resource,
+ init,
+ queryParams,
+ abortSignal
+ );
+ const jsonText = await response.text();
+ logger.debug(
+ "-- START CF API RESPONSE:",
+ response.statusText,
+ response.status
+ );
+ const logHeaders = cloneHeaders(response.headers);
+ delete logHeaders["Authorization"];
+ logger.debug("HEADERS:", JSON.stringify(logHeaders, null, 2));
+ logger.debug("RESPONSE:", jsonText);
+ logger.debug("-- END CF API RESPONSE");
+ try {
+ return parseJSON(jsonText);
+ } catch (err) {
+ throw new ParseError({
+ text: "Received a malformed response from the API",
+ notes: [
+ {
+ text: truncate(jsonText, 100)
+ },
+ {
+ text: `${method} ${resource} -> ${response.status} ${response.statusText}`
+ }
+ ]
+ });
+ }
+}
+__name(fetchInternal, "fetchInternal");
+function truncate(text, maxLength) {
+ const { length } = text;
+ if (length <= maxLength) {
+ return text;
+ }
+ return `${text.substring(0, maxLength)}... (length = ${length})`;
+}
+__name(truncate, "truncate");
+function cloneHeaders(headers) {
+ return headers instanceof import_undici3.Headers ? Object.fromEntries(headers.entries()) : Array.isArray(headers) ? Object.fromEntries(headers) : { ...headers };
+}
+__name(cloneHeaders, "cloneHeaders");
+async function requireLoggedIn() {
+ const loggedIn = await loginOrRefreshIfRequired();
+ if (!loggedIn) {
+ throw new Error("Not logged in.");
+ }
+}
+__name(requireLoggedIn, "requireLoggedIn");
+function addAuthorizationHeaderIfUnspecified(headers, auth) {
+ if (!("Authorization" in headers)) {
+ if ("apiToken" in auth) {
+ headers["Authorization"] = `Bearer ${auth.apiToken}`;
+ } else {
+ headers["X-Auth-Key"] = auth.authKey;
+ headers["X-Auth-Email"] = auth.authEmail;
+ }
+ }
+}
+__name(addAuthorizationHeaderIfUnspecified, "addAuthorizationHeaderIfUnspecified");
+function addUserAgent(headers) {
+ headers["User-Agent"] = `wrangler/${version}`;
+}
+__name(addUserAgent, "addUserAgent");
+async function fetchKVGetValue(accountId, namespaceId, key) {
+ await requireLoggedIn();
+ const auth = requireApiToken();
+ const headers = {};
+ addAuthorizationHeaderIfUnspecified(headers, auth);
+ const resource = `${getCloudflareApiBaseUrl()}/accounts/${accountId}/storage/kv/namespaces/${namespaceId}/values/${key}`;
+ const response = await (0, import_undici3.fetch)(resource, {
+ method: "GET",
+ headers
+ });
+ if (response.ok) {
+ return await response.arrayBuffer();
+ } else {
+ throw new Error(
+ `Failed to fetch ${resource} - ${response.status}: ${response.statusText});`
+ );
+ }
+}
+__name(fetchKVGetValue, "fetchKVGetValue");
+async function fetchR2Objects(resource, bodyInit = {}) {
+ await requireLoggedIn();
+ const auth = requireApiToken();
+ const headers = cloneHeaders(bodyInit.headers);
+ addAuthorizationHeaderIfUnspecified(headers, auth);
+ addUserAgent(headers);
+ const response = await (0, import_undici3.fetch)(`${getCloudflareApiBaseUrl()}${resource}`, {
+ ...bodyInit,
+ headers
+ });
+ if (response.ok && response.body) {
+ return response;
+ } else {
+ throw new Error(
+ `Failed to fetch ${resource} - ${response.status}: ${response.statusText});`
+ );
+ }
+}
+__name(fetchR2Objects, "fetchR2Objects");
+async function fetchDashboardScript(resource, bodyInit = {}) {
+ await requireLoggedIn();
+ const auth = requireApiToken();
+ const headers = cloneHeaders(bodyInit.headers);
+ addAuthorizationHeaderIfUnspecified(headers, auth);
+ addUserAgent(headers);
+ let response = await (0, import_undici3.fetch)(`${getCloudflareApiBaseUrl()}${resource}`, {
+ ...bodyInit,
+ headers
+ });
+ if (!response.ok || !response.body) {
+ console.error(response.ok, response.body);
+ throw new Error(
+ `Failed to fetch ${resource} - ${response.status}: ${response.statusText});`
+ );
+ }
+ const usesModules = response.headers.get("content-type")?.startsWith("multipart");
+ if (usesModules) {
+ if (!response.formData) {
+ response = new import_undici4.Response(await response.text(), response);
+ }
+ const form = await response.formData();
+ const files = Array.from(form.entries()).map(
+ ([filename, contents]) => contents instanceof import_undici3.File ? contents : new import_undici3.File([contents], filename)
+ );
+ return files;
+ } else {
+ const contents = await response.text();
+ const filename = response.headers.get("cf-entrypoint") ?? "index.js";
+ const file = new import_undici3.File([contents], filename, { type: "text" });
+ return [file];
+ }
+}
+__name(fetchDashboardScript, "fetchDashboardScript");
+
+// src/cfetch/index.ts
+async function fetchResult(resource, init = {}, queryParams, abortSignal) {
+ const json = await fetchInternal(
+ resource,
+ init,
+ queryParams,
+ abortSignal
+ );
+ if (json.success) {
+ return json.result;
+ } else {
+ throwFetchError(resource, json);
+ }
+}
+__name(fetchResult, "fetchResult");
+async function fetchGraphqlResult(init = {}, abortSignal) {
+ const json = await fetchInternal(
+ "/graphql",
+ { ...init, method: "POST" },
+ //Cloudflare API v4 doesn't allow GETs to /graphql
+ void 0,
+ abortSignal
+ );
+ if (json) {
+ return json;
+ } else {
+ throw new Error("A request to the Cloudflare API (/graphql) failed.");
+ }
+}
+__name(fetchGraphqlResult, "fetchGraphqlResult");
+async function fetchListResult(resource, init = {}, queryParams) {
+ const results = [];
+ let getMoreResults = true;
+ let cursor;
+ while (getMoreResults) {
+ if (cursor) {
+ queryParams = new import_node_url4.URLSearchParams(queryParams);
+ queryParams.set("cursor", cursor);
+ }
+ const json = await fetchInternal(
+ resource,
+ init,
+ queryParams
+ );
+ if (json.success) {
+ results.push(...json.result);
+ if (hasCursor(json.result_info)) {
+ cursor = json.result_info?.cursor;
+ } else {
+ getMoreResults = false;
+ }
+ } else {
+ throwFetchError(resource, json);
+ }
+ }
+ return results;
+}
+__name(fetchListResult, "fetchListResult");
+function throwFetchError(resource, response) {
+ const error = new ParseError({
+ text: `A request to the Cloudflare API (${resource}) failed.`,
+ notes: response.errors.map((err) => ({
+ text: renderError(err)
+ }))
+ });
+ const code = response.errors[0]?.code;
+ if (code) {
+ error.code = code;
+ }
+ throw error;
+}
+__name(throwFetchError, "throwFetchError");
+function hasCursor(result_info) {
+ const cursor = result_info?.cursor;
+ return cursor !== void 0 && cursor !== null && cursor !== "";
+}
+__name(hasCursor, "hasCursor");
+function renderError(err, level = 0) {
+ const chainedMessages = err.error_chain?.map(
+ (chainedError) => `
+${" ".repeat(level)}- ${renderError(chainedError, level + 1)}`
+ ).join("\n") ?? "";
+ return (err.code ? `${err.message} [code: ${err.code}]` : err.message) + chainedMessages;
+}
+__name(renderError, "renderError");
+async function fetchScriptContent(resource, init = {}, queryParams, abortSignal) {
+ const response = await performApiFetch(
+ resource,
+ init,
+ queryParams,
+ abortSignal
+ );
+ logger.debug(
+ "-- START CF API RESPONSE:",
+ response.statusText,
+ response.status
+ );
+ logger.debug("HEADERS:", { ...response.headers });
+ logger.debug("-- END CF API RESPONSE");
+ const contentType = response.headers.get("content-type");
+ const usesModules = contentType?.startsWith("multipart");
+ if (usesModules && contentType) {
+ const form = await response.formData();
+ const entries = Array.from(form.entries());
+ return entries.map((e2) => e2[1]).join("\n");
+ } else {
+ return await response.text();
+ }
+}
+__name(fetchScriptContent, "fetchScriptContent");
+
+// src/constellation/utils.ts
+var getConstellationWarningFromEnv = getEnvironmentVariableFactory({
+ variableName: "NO_CONSTELLATION_WARNING"
+});
+var constellationBetaWarning = getConstellationWarningFromEnv() !== void 0 ? "" : "--------------------\n\u{1F6A7} Constellation is currently in open alpha and is not recommended for production data and traffic\n\u{1F6A7} Please report any bugs to https://github.com/cloudflare/workers-sdk/issues/new/choose\n\u{1F6A7} To give feedback, visit https://discord.gg/cloudflaredev\n--------------------\n";
+var getProjectByName = /* @__PURE__ */ __name(async (config, accountId, name) => {
+ const allProjects = await listProjects(accountId);
+ const matchingProj = allProjects.find((proj) => proj.name === name);
+ if (!matchingProj) {
+ throw new Error(`Couldn't find Project with name '${name}'`);
+ }
+ return matchingProj;
+}, "getProjectByName");
+var getProjectModelByName = /* @__PURE__ */ __name(async (config, accountId, proj, modelName) => {
+ const allModels = await listModels(accountId, proj);
+ const matchingModel = allModels.find((model) => model.name === modelName);
+ if (!matchingModel) {
+ throw new Error(`Couldn't find Model with name '${modelName}'`);
+ }
+ return matchingModel;
+}, "getProjectModelByName");
+async function constellationList(accountId, partialUrl) {
+ const pageSize = 50;
+ let page = 1;
+ const results = [];
+ while (results.length % pageSize === 0) {
+ const json = await fetchResult(
+ `/accounts/${accountId}/constellation/${partialUrl}`,
+ {},
+ new URLSearchParams({
+ per_page: pageSize.toString(),
+ page: page.toString()
+ })
+ );
+ page++;
+ results.push(...json);
+ if (json.length < pageSize) {
+ break;
+ }
+ }
+ return results;
+}
+__name(constellationList, "constellationList");
+var listCatalogEntries = /* @__PURE__ */ __name(async (accountId) => {
+ return await constellationList(accountId, "catalog");
+}, "listCatalogEntries");
+var listModels = /* @__PURE__ */ __name(async (accountId, proj) => {
+ return constellationList(accountId, `project/${proj.id}/model`);
+}, "listModels");
+var listProjects = /* @__PURE__ */ __name(async (accountId) => {
+ return await constellationList(accountId, "project");
+}, "listProjects");
+var listRuntimes = /* @__PURE__ */ __name(async (accountId) => {
+ return await constellationList(accountId, "runtime");
+}, "listRuntimes");
+
+// src/config/diagnostics.ts
+init_import_meta_url();
+var Diagnostics = class {
+ /**
+ * Create a new Diagnostics object.
+ * @param description A general description of this collection of messages.
+ */
+ constructor(description) {
+ this.description = description;
+ }
+ errors = [];
+ warnings = [];
+ children = [];
+ /**
+ * Merge the given `diagnostics` into this as a child.
+ */
+ addChild(diagnostics) {
+ if (diagnostics.hasErrors() || diagnostics.hasWarnings()) {
+ this.children.push(diagnostics);
+ }
+ }
+ /** Does this or any of its children have errors. */
+ hasErrors() {
+ if (this.errors.length > 0) {
+ return true;
+ } else {
+ return this.children.some((child) => child.hasErrors());
+ }
+ }
+ /** Render the errors of this and all its children. */
+ renderErrors() {
+ return this.render("errors");
+ }
+ /** Does this or any of its children have warnings. */
+ hasWarnings() {
+ if (this.warnings.length > 0) {
+ return true;
+ } else {
+ return this.children.some((child) => child.hasWarnings());
+ }
+ }
+ /** Render the warnings of this and all its children. */
+ renderWarnings() {
+ return this.render("warnings");
+ }
+ render(field) {
+ const hasMethod = field === "errors" ? "hasErrors" : "hasWarnings";
+ return indentText(
+ `${this.description}
+` + // Output all the fields (errors or warnings) at this level
+ this[field].map((message) => `- ${indentText(message)}`).join("\n") + // Output all the child diagnostics at the next level
+ this.children.map(
+ (child) => child[hasMethod]() ? "\n- " + child.render(field) : ""
+ ).filter((output) => output !== "").join("\n")
+ );
+ }
+};
+__name(Diagnostics, "Diagnostics");
+function indentText(str) {
+ return str.split("\n").map(
+ (line, index) => (index === 0 ? line : ` ${line}`).replace(/^\s*$/, "")
+ ).join("\n");
+}
+__name(indentText, "indentText");
+
+// src/config/validation-helpers.ts
+init_import_meta_url();
+function deprecated(diagnostics, config, fieldPath, message, remove, title = "Deprecation", type = "warning") {
+ const BOLD = "\x1B[1m";
+ const NORMAL = "\x1B[0m";
+ const diagnosticMessage = `${BOLD}${title}${NORMAL}: "${fieldPath}":
+${message}`;
+ const result = unwindPropertyPath(config, fieldPath);
+ if (result !== void 0 && result.field in result.container) {
+ diagnostics[`${type}s`].push(diagnosticMessage);
+ if (remove) {
+ delete result.container[result.field];
+ }
+ }
+}
+__name(deprecated, "deprecated");
+function experimental(diagnostics, config, fieldPath) {
+ const result = unwindPropertyPath(config, fieldPath);
+ if (result !== void 0 && result.field in result.container) {
+ diagnostics.warnings.push(
+ `"${fieldPath}" fields are experimental and may change or break at any time.`
+ );
+ }
+}
+__name(experimental, "experimental");
+function inheritable(diagnostics, topLevelEnv, rawEnv, field, validate2, defaultValue, transformFn = (v) => v) {
+ validate2(diagnostics, field, rawEnv[field], topLevelEnv);
+ return rawEnv[field] ?? transformFn(topLevelEnv?.[field]) ?? defaultValue;
+}
+__name(inheritable, "inheritable");
+function inheritableInLegacyEnvironments(diagnostics, isLegacyEnv2, topLevelEnv, rawEnv, field, validate2, transformFn = (v) => v, defaultValue) {
+ return topLevelEnv === void 0 || isLegacyEnv2 === true ? inheritable(
+ diagnostics,
+ topLevelEnv,
+ rawEnv,
+ field,
+ validate2,
+ defaultValue,
+ transformFn
+ ) : notAllowedInNamedServiceEnvironment(
+ diagnostics,
+ topLevelEnv,
+ rawEnv,
+ field
+ );
+}
+__name(inheritableInLegacyEnvironments, "inheritableInLegacyEnvironments");
+var appendEnvName = /* @__PURE__ */ __name((envName) => (fieldValue) => fieldValue ? `${fieldValue}-${envName}` : void 0, "appendEnvName");
+function notAllowedInNamedServiceEnvironment(diagnostics, topLevelEnv, rawEnv, field) {
+ if (field in rawEnv) {
+ diagnostics.errors.push(
+ `The "${field}" field is not allowed in named service environments.
+Please remove the field from this environment.`
+ );
+ }
+ return topLevelEnv[field];
+}
+__name(notAllowedInNamedServiceEnvironment, "notAllowedInNamedServiceEnvironment");
+function notInheritable(diagnostics, topLevelEnv, rawConfig, rawEnv, envName, field, validate2, defaultValue) {
+ if (rawEnv[field] !== void 0) {
+ validate2(diagnostics, field, rawEnv[field], topLevelEnv);
+ } else {
+ if (rawConfig?.[field] !== void 0) {
+ diagnostics.warnings.push(
+ `"${field}" exists at the top level, but not on "env.${envName}".
+This is not what you probably want, since "${field}" is not inherited by environments.
+Please add "${field}" to "env.${envName}".`
+ );
+ }
+ }
+ return rawEnv[field] ?? defaultValue;
+}
+__name(notInheritable, "notInheritable");
+function unwindPropertyPath(root, path45) {
+ let container = root;
+ const parts = path45.split(".");
+ for (let i = 0; i < parts.length - 1; i++) {
+ if (!hasProperty(container, parts[i])) {
+ return;
+ }
+ container = container[parts[i]];
+ }
+ return { container, field: parts[parts.length - 1] };
+}
+__name(unwindPropertyPath, "unwindPropertyPath");
+var isString = /* @__PURE__ */ __name((diagnostics, field, value) => {
+ if (value !== void 0 && typeof value !== "string") {
+ diagnostics.errors.push(
+ `Expected "${field}" to be of type string but got ${JSON.stringify(
+ value
+ )}.`
+ );
+ return false;
+ }
+ return true;
+}, "isString");
+var isValidName = /* @__PURE__ */ __name((diagnostics, field, value) => {
+ if (typeof value === "string" && /^$|^[a-z0-9_ ][a-z0-9-_ ]*$/.test(value) || value === void 0) {
+ return true;
+ } else {
+ diagnostics.errors.push(
+ `Expected "${field}" to be of type string, alphanumeric and lowercase with dashes only but got ${JSON.stringify(
+ value
+ )}.`
+ );
+ return false;
+ }
+}, "isValidName");
+var isStringArray = /* @__PURE__ */ __name((diagnostics, field, value) => {
+ if (value !== void 0 && (!Array.isArray(value) || value.some((item) => typeof item !== "string"))) {
+ diagnostics.errors.push(
+ `Expected "${field}" to be of type string array but got ${JSON.stringify(
+ value
+ )}.`
+ );
+ return false;
+ }
+ return true;
+}, "isStringArray");
+var isObjectWith = /* @__PURE__ */ __name((...properties) => (diagnostics, field, value) => {
+ if (value !== void 0 && (typeof value !== "object" || value === null || !properties.every((prop) => prop in value))) {
+ diagnostics.errors.push(
+ `Expected "${field}" to be of type object, containing only properties ${properties}, but got ${JSON.stringify(
+ value
+ )}.`
+ );
+ return false;
+ }
+ if (value !== void 0) {
+ const restFields = Object.keys(value).filter(
+ (key) => !properties.includes(key)
+ );
+ validateAdditionalProperties(diagnostics, field, restFields, []);
+ }
+ return true;
+}, "isObjectWith");
+var isOneOf = /* @__PURE__ */ __name((...choices) => (diagnostics, field, value) => {
+ if (value !== void 0 && !choices.some((choice) => value === choice)) {
+ diagnostics.errors.push(
+ `Expected "${field}" field to be one of ${JSON.stringify(
+ choices
+ )} but got ${JSON.stringify(value)}.`
+ );
+ return false;
+ }
+ return true;
+}, "isOneOf");
+var all = /* @__PURE__ */ __name((...validations) => {
+ return (diagnostics, field, value, config) => {
+ let passedValidations = true;
+ for (const validate2 of validations) {
+ if (!validate2(diagnostics, field, value, config)) {
+ passedValidations = false;
+ }
+ }
+ return passedValidations;
+ };
+}, "all");
+var isMutuallyExclusiveWith = /* @__PURE__ */ __name((container, ...fields) => {
+ return (diagnostics, field, value) => {
+ if (value === void 0) {
+ return true;
+ }
+ for (const exclusiveWith of fields) {
+ if (container[exclusiveWith] !== void 0) {
+ diagnostics.errors.push(
+ `Expected exactly one of the following fields ${JSON.stringify([
+ field,
+ ...fields
+ ])}.`
+ );
+ return false;
+ }
+ }
+ return true;
+ };
+}, "isMutuallyExclusiveWith");
+var isBoolean = /* @__PURE__ */ __name((diagnostics, field, value) => {
+ if (value !== void 0 && typeof value !== "boolean") {
+ diagnostics.errors.push(
+ `Expected "${field}" to be of type boolean but got ${JSON.stringify(
+ value
+ )}.`
+ );
+ return false;
+ }
+ return true;
+}, "isBoolean");
+var validateRequiredProperty = /* @__PURE__ */ __name((diagnostics, container, key, value, type, choices) => {
+ if (container) {
+ container += ".";
+ }
+ if (value === void 0) {
+ diagnostics.errors.push(`"${container}${key}" is a required field.`);
+ return false;
+ } else if (typeof value !== type) {
+ diagnostics.errors.push(
+ `Expected "${container}${key}" to be of type ${type} but got ${JSON.stringify(
+ value
+ )}.`
+ );
+ return false;
+ } else if (choices) {
+ if (!isOneOf(...choices)(diagnostics, `${container}${key}`, value, void 0)) {
+ return false;
+ }
+ }
+ return true;
+}, "validateRequiredProperty");
+var validateOptionalProperty = /* @__PURE__ */ __name((diagnostics, container, key, value, type, choices) => {
+ if (value !== void 0) {
+ return validateRequiredProperty(
+ diagnostics,
+ container,
+ key,
+ value,
+ type,
+ choices
+ );
+ }
+ return true;
+}, "validateOptionalProperty");
+var validateTypedArray = /* @__PURE__ */ __name((diagnostics, container, value, type) => {
+ let isValid = true;
+ if (!Array.isArray(value)) {
+ diagnostics.errors.push(
+ `Expected "${container}" to be an array of ${type}s but got ${JSON.stringify(
+ value
+ )}`
+ );
+ isValid = false;
+ } else {
+ for (let i = 0; i < value.length; i++) {
+ isValid = validateRequiredProperty(
+ diagnostics,
+ container,
+ `[${i}]`,
+ value[i],
+ type
+ ) && isValid;
+ }
+ }
+ return isValid;
+}, "validateTypedArray");
+var validateOptionalTypedArray = /* @__PURE__ */ __name((diagnostics, container, value, type) => {
+ if (value !== void 0) {
+ return validateTypedArray(diagnostics, container, value, type);
+ }
+ return true;
+}, "validateOptionalTypedArray");
+var isRequiredProperty = /* @__PURE__ */ __name((obj, prop, type, choices) => hasProperty(obj, prop) && typeof obj[prop] === type && (choices === void 0 || choices.includes(obj[prop])), "isRequiredProperty");
+var isOptionalProperty = /* @__PURE__ */ __name((obj, prop, type) => !hasProperty(obj, prop) || typeof obj[prop] === type, "isOptionalProperty");
+var hasProperty = /* @__PURE__ */ __name((obj, property) => property in obj, "hasProperty");
+var validateAdditionalProperties = /* @__PURE__ */ __name((diagnostics, fieldPath, restProps, knownProps) => {
+ const restPropSet = new Set(restProps);
+ for (const knownProp of knownProps) {
+ restPropSet.delete(knownProp);
+ }
+ if (restPropSet.size > 0) {
+ const fields = Array.from(restPropSet.keys()).map((field) => `"${field}"`);
+ diagnostics.warnings.push(
+ `Unexpected fields found in ${fieldPath} field: ${fields}`
+ );
+ return false;
+ }
+ return true;
+}, "validateAdditionalProperties");
+var validateSmartPlacementConfig = /* @__PURE__ */ __name((diagnostics, placement, triggers) => {
+ if (placement?.mode === "smart" && !!triggers?.crons?.length) {
+ diagnostics.errors.push(
+ `You cannot configure both [triggers] and [placement] in your wrangler.toml. Placement is not supported with cron triggers.`
+ );
+ return false;
+ }
+ return true;
+}, "validateSmartPlacementConfig");
+var getBindingNames = /* @__PURE__ */ __name((value) => {
+ if (typeof value !== "object" || value === null) {
+ return [];
+ }
+ if (isBindingList(value)) {
+ return value.bindings.map(({ name }) => name);
+ } else if (isNamespaceList(value)) {
+ return value.map(({ binding }) => binding);
+ } else if (isRecord(value)) {
+ return Object.keys(value).filter((k) => value[k] !== void 0);
+ } else {
+ return [];
+ }
+}, "getBindingNames");
+var isBindingList = /* @__PURE__ */ __name((value) => isRecord(value) && "bindings" in value && Array.isArray(value.bindings) && value.bindings.every(
+ (binding) => isRecord(binding) && "name" in binding && typeof binding.name === "string"
+), "isBindingList");
+var isNamespaceList = /* @__PURE__ */ __name((value) => Array.isArray(value) && value.every(
+ (entry) => isRecord(entry) && "binding" in entry && typeof entry.binding === "string"
+), "isNamespaceList");
+var isRecord = /* @__PURE__ */ __name((value) => typeof value === "object" && value !== null && !Array.isArray(value), "isRecord");
+
+// src/config/validation.ts
+var ENGLISH = new Intl.ListFormat("en");
+function normalizeAndValidateConfig(rawConfig, configPath, args) {
+ const diagnostics = new Diagnostics(
+ `Processing ${configPath ? import_node_path6.default.relative(process.cwd(), configPath) : "wrangler"} configuration:`
+ );
+ deprecated(
+ diagnostics,
+ rawConfig,
+ "miniflare",
+ "Wrangler does not use configuration in the `miniflare` section. Unless you are using Miniflare directly you can remove this section.",
+ true,
+ "\u{1F636} Ignored"
+ );
+ deprecated(
+ diagnostics,
+ rawConfig,
+ "type",
+ "Most common features now work out of the box with wrangler, including modules, jsx, typescript, etc. If you need anything more, use a custom build.",
+ true,
+ "\u{1F636} Ignored"
+ );
+ deprecated(
+ diagnostics,
+ rawConfig,
+ "webpack_config",
+ "Most common features now work out of the box with wrangler, including modules, jsx, typescript, etc. If you need anything more, use a custom build.",
+ true,
+ "\u{1F636} Ignored"
+ );
+ validateOptionalProperty(
+ diagnostics,
+ "",
+ "legacy_env",
+ rawConfig.legacy_env,
+ "boolean"
+ );
+ validateOptionalProperty(
+ diagnostics,
+ "",
+ "send_metrics",
+ rawConfig.send_metrics,
+ "boolean"
+ );
+ validateOptionalProperty(
+ diagnostics,
+ "",
+ "keep_vars",
+ rawConfig.keep_vars,
+ "boolean"
+ );
+ const isLegacyEnv2 = args["legacy-env"] ?? rawConfig.legacy_env ?? true;
+ if (!isLegacyEnv2) {
+ diagnostics.warnings.push(
+ "Experimental: Service environments are in beta, and their behaviour is guaranteed to change in the future. DO NOT USE IN PRODUCTION."
+ );
+ }
+ const topLevelEnv = normalizeAndValidateEnvironment(
+ diagnostics,
+ configPath,
+ rawConfig
+ );
+ const envName = args.env;
+ let activeEnv = topLevelEnv;
+ if (envName !== void 0) {
+ const envDiagnostics = new Diagnostics(
+ `"env.${envName}" environment configuration`
+ );
+ const rawEnv = rawConfig.env?.[envName];
+ if (rawEnv !== void 0) {
+ activeEnv = normalizeAndValidateEnvironment(
+ envDiagnostics,
+ configPath,
+ rawEnv,
+ envName,
+ topLevelEnv,
+ isLegacyEnv2,
+ rawConfig
+ );
+ diagnostics.addChild(envDiagnostics);
+ } else {
+ activeEnv = normalizeAndValidateEnvironment(
+ envDiagnostics,
+ configPath,
+ {},
+ envName,
+ topLevelEnv,
+ isLegacyEnv2,
+ rawConfig
+ );
+ const envNames = rawConfig.env ? `The available configured environment names are: ${JSON.stringify(
+ Object.keys(rawConfig.env)
+ )}
+` : "";
+ const message = `No environment found in configuration with name "${envName}".
+Before using \`--env=${envName}\` there should be an equivalent environment section in the configuration.
+${envNames}
+Consider adding an environment configuration section to the wrangler.toml file:
+\`\`\`
+[env.` + envName + "]\n```\n";
+ if (envNames.length > 0) {
+ diagnostics.errors.push(message);
+ } else {
+ diagnostics.warnings.push(message);
+ }
+ }
+ }
+ const config = {
+ configPath,
+ legacy_env: isLegacyEnv2,
+ send_metrics: rawConfig.send_metrics,
+ keep_vars: rawConfig.keep_vars,
+ ...activeEnv,
+ dev: normalizeAndValidateDev(diagnostics, rawConfig.dev ?? {}),
+ migrations: normalizeAndValidateMigrations(
+ diagnostics,
+ rawConfig.migrations ?? [],
+ activeEnv.durable_objects
+ ),
+ site: normalizeAndValidateSite(
+ diagnostics,
+ configPath,
+ rawConfig,
+ activeEnv.main
+ ),
+ assets: normalizeAndValidateAssets(diagnostics, configPath, rawConfig),
+ wasm_modules: normalizeAndValidateModulePaths(
+ diagnostics,
+ configPath,
+ "wasm_modules",
+ rawConfig.wasm_modules
+ ),
+ text_blobs: normalizeAndValidateModulePaths(
+ diagnostics,
+ configPath,
+ "text_blobs",
+ rawConfig.text_blobs
+ ),
+ data_blobs: normalizeAndValidateModulePaths(
+ diagnostics,
+ configPath,
+ "data_blobs",
+ rawConfig.data_blobs
+ )
+ };
+ validateBindingsHaveUniqueNames(diagnostics, config);
+ validateAdditionalProperties(
+ diagnostics,
+ "top-level",
+ Object.keys(rawConfig),
+ [...Object.keys(config), "env"]
+ );
+ validateSmartPlacementConfig(diagnostics, config.placement, config.triggers);
+ experimental(diagnostics, rawConfig, "assets");
+ return { config, diagnostics };
+}
+__name(normalizeAndValidateConfig, "normalizeAndValidateConfig");
+function normalizeAndValidateBuild(diagnostics, rawEnv, rawBuild, configPath) {
+ const { command: command2, cwd: cwd2, watch_dir = "./src", upload: upload2, ...rest } = rawBuild;
+ const deprecatedUpload = { ...upload2 };
+ validateAdditionalProperties(diagnostics, "build", Object.keys(rest), []);
+ validateOptionalProperty(diagnostics, "build", "command", command2, "string");
+ validateOptionalProperty(diagnostics, "build", "cwd", cwd2, "string");
+ if (Array.isArray(watch_dir)) {
+ validateTypedArray(diagnostics, "build.watch_dir", watch_dir, "string");
+ } else {
+ validateOptionalProperty(
+ diagnostics,
+ "build",
+ "watch_dir",
+ watch_dir,
+ "string"
+ );
+ }
+ deprecated(
+ diagnostics,
+ rawEnv,
+ "build.upload.format",
+ "The format is inferred automatically from the code.",
+ true
+ );
+ if (rawEnv.main !== void 0 && rawBuild.upload?.main) {
+ diagnostics.errors.push(
+ `Don't define both the \`main\` and \`build.upload.main\` fields in your configuration.
+They serve the same purpose: to point to the entry-point of your worker.
+Delete the \`build.upload.main\` and \`build.upload.dir\` field from your config.`
+ );
+ } else {
+ deprecated(
+ diagnostics,
+ rawEnv,
+ "build.upload.main",
+ `Delete the \`build.upload.main\` and \`build.upload.dir\` fields.
+Then add the top level \`main\` field to your configuration file:
+\`\`\`
+main = "${import_node_path6.default.join(
+ rawBuild.upload?.dir ?? "./dist",
+ rawBuild.upload?.main ?? "."
+ )}"
+\`\`\``,
+ true
+ );
+ deprecated(
+ diagnostics,
+ rawEnv,
+ "build.upload.dir",
+ `Use the top level "main" field or a command-line argument to specify the entry-point for the Worker.`,
+ true
+ );
+ }
+ return {
+ command: command2,
+ watch_dir: (
+ // - `watch_dir` only matters when `command` is defined, so we apply
+ // a default only when `command` is defined
+ // - `configPath` will always be defined since `build` can only
+ // be configured in `wrangler.toml`, but who knows, that may
+ // change in the future, so we do a check anyway
+ command2 && configPath ? Array.isArray(watch_dir) ? watch_dir.map(
+ (dir) => import_node_path6.default.relative(
+ process.cwd(),
+ import_node_path6.default.join(import_node_path6.default.dirname(configPath), `${dir}`)
+ )
+ ) : import_node_path6.default.relative(
+ process.cwd(),
+ import_node_path6.default.join(import_node_path6.default.dirname(configPath), `${watch_dir}`)
+ ) : watch_dir
+ ),
+ cwd: cwd2,
+ deprecatedUpload
+ };
+}
+__name(normalizeAndValidateBuild, "normalizeAndValidateBuild");
+function normalizeAndValidateMainField(configPath, rawMain, deprecatedUpload) {
+ const configDir = import_node_path6.default.dirname(configPath ?? "wrangler.toml");
+ if (rawMain !== void 0) {
+ if (typeof rawMain === "string") {
+ const directory = import_node_path6.default.resolve(configDir);
+ return import_node_path6.default.resolve(directory, rawMain);
+ } else {
+ return rawMain;
+ }
+ } else if (deprecatedUpload?.main !== void 0) {
+ const directory = import_node_path6.default.resolve(
+ configDir,
+ deprecatedUpload?.dir || "./dist"
+ );
+ return import_node_path6.default.resolve(directory, deprecatedUpload.main);
+ } else {
+ return;
+ }
+}
+__name(normalizeAndValidateMainField, "normalizeAndValidateMainField");
+function normalizeAndValidateBaseDirField(configPath, rawDir) {
+ const configDir = import_node_path6.default.dirname(configPath ?? "wrangler.toml");
+ if (rawDir !== void 0) {
+ if (typeof rawDir === "string") {
+ const directory = import_node_path6.default.resolve(configDir);
+ return import_node_path6.default.resolve(directory, rawDir);
+ } else {
+ return rawDir;
+ }
+ } else {
+ return;
+ }
+}
+__name(normalizeAndValidateBaseDirField, "normalizeAndValidateBaseDirField");
+function normalizeAndValidateDev(diagnostics, rawDev) {
+ const {
+ ip: ip2 = "0.0.0.0",
+ port: port2,
+ inspector_port,
+ local_protocol = "http",
+ upstream_protocol = "https",
+ host,
+ ...rest
+ } = rawDev;
+ validateAdditionalProperties(diagnostics, "dev", Object.keys(rest), []);
+ validateOptionalProperty(diagnostics, "dev", "ip", ip2, "string");
+ validateOptionalProperty(diagnostics, "dev", "port", port2, "number");
+ validateOptionalProperty(
+ diagnostics,
+ "dev",
+ "inspector_port",
+ inspector_port,
+ "number"
+ );
+ validateOptionalProperty(
+ diagnostics,
+ "dev",
+ "local_protocol",
+ local_protocol,
+ "string",
+ ["http", "https"]
+ );
+ validateOptionalProperty(
+ diagnostics,
+ "dev",
+ "upstream_protocol",
+ upstream_protocol,
+ "string",
+ ["http", "https"]
+ );
+ validateOptionalProperty(diagnostics, "dev", "host", host, "string");
+ return { ip: ip2, port: port2, inspector_port, local_protocol, upstream_protocol, host };
+}
+__name(normalizeAndValidateDev, "normalizeAndValidateDev");
+function normalizeAndValidateMigrations(diagnostics, rawMigrations, durableObjects) {
+ if (!Array.isArray(rawMigrations)) {
+ diagnostics.errors.push(
+ `The optional "migrations" field should be an array, but got ${JSON.stringify(
+ rawMigrations
+ )}`
+ );
+ return [];
+ } else {
+ for (let i = 0; i < rawMigrations.length; i++) {
+ const { tag, new_classes, renamed_classes, deleted_classes, ...rest } = rawMigrations[i];
+ validateAdditionalProperties(
+ diagnostics,
+ "migrations",
+ Object.keys(rest),
+ []
+ );
+ validateRequiredProperty(
+ diagnostics,
+ `migrations[${i}]`,
+ `tag`,
+ tag,
+ "string"
+ );
+ validateOptionalTypedArray(
+ diagnostics,
+ `migrations[${i}].new_classes`,
+ new_classes,
+ "string"
+ );
+ if (renamed_classes !== void 0) {
+ if (!Array.isArray(renamed_classes)) {
+ diagnostics.errors.push(
+ `Expected "migrations[${i}].renamed_classes" to be an array of "{from: string, to: string}" objects but got ${JSON.stringify(
+ renamed_classes
+ )}.`
+ );
+ } else if (renamed_classes.some(
+ (c) => typeof c !== "object" || !isRequiredProperty(c, "from", "string") || !isRequiredProperty(c, "to", "string")
+ )) {
+ diagnostics.errors.push(
+ `Expected "migrations[${i}].renamed_classes" to be an array of "{from: string, to: string}" objects but got ${JSON.stringify(
+ renamed_classes
+ )}.`
+ );
+ }
+ }
+ validateOptionalTypedArray(
+ diagnostics,
+ `migrations[${i}].deleted_classes`,
+ deleted_classes,
+ "string"
+ );
+ }
+ if (Array.isArray(durableObjects?.bindings) && durableObjects.bindings.length > 0) {
+ const exportedDurableObjects = (durableObjects.bindings || []).filter(
+ (binding) => !binding.script_name
+ );
+ if (exportedDurableObjects.length > 0 && rawMigrations.length === 0) {
+ if (!exportedDurableObjects.some(
+ (exportedDurableObject) => typeof exportedDurableObject.class_name !== "string"
+ )) {
+ const durableObjectClassnames = exportedDurableObjects.map(
+ (durable) => durable.class_name
+ );
+ diagnostics.warnings.push(
+ `In wrangler.toml, you have configured [durable_objects] exported by this Worker (${durableObjectClassnames.join(
+ ", "
+ )}), but no [migrations] for them. This may not work as expected until you add a [migrations] section to your wrangler.toml. Add this configuration to your wrangler.toml:
+
+ \`\`\`
+ [[migrations]]
+ tag = "v1" # Should be unique for each entry
+ new_classes = [${durableObjectClassnames.map((name) => `"${name}"`).join(", ")}]
+ \`\`\`
+
+Refer to https://developers.cloudflare.com/workers/learning/using-durable-objects/#durable-object-migrations-in-wranglertoml for more details.`
+ );
+ }
+ }
+ }
+ return rawMigrations;
+ }
+}
+__name(normalizeAndValidateMigrations, "normalizeAndValidateMigrations");
+function normalizeAndValidateSite(diagnostics, configPath, rawConfig, mainEntryPoint) {
+ if (rawConfig?.site !== void 0) {
+ const { bucket, include = [], exclude = [], ...rest } = rawConfig.site;
+ validateAdditionalProperties(diagnostics, "site", Object.keys(rest), [
+ "entry-point"
+ ]);
+ validateRequiredProperty(diagnostics, "site", "bucket", bucket, "string");
+ validateTypedArray(diagnostics, "sites.include", include, "string");
+ validateTypedArray(diagnostics, "sites.exclude", exclude, "string");
+ validateOptionalProperty(
+ diagnostics,
+ "site",
+ "entry-point",
+ rawConfig.site["entry-point"],
+ "string"
+ );
+ deprecated(
+ diagnostics,
+ rawConfig,
+ `site.entry-point`,
+ `Delete the \`site.entry-point\` field, then add the top level \`main\` field to your configuration file:
+\`\`\`
+main = "${import_node_path6.default.join(
+ String(rawConfig.site["entry-point"]) || "workers-site",
+ import_node_path6.default.extname(String(rawConfig.site["entry-point"]) || "workers-site") ? "" : "index.js"
+ )}"
+\`\`\``,
+ false,
+ void 0,
+ "warning"
+ );
+ let siteEntryPoint = rawConfig.site["entry-point"];
+ if (!mainEntryPoint && !siteEntryPoint) {
+ diagnostics.warnings.push(
+ `Because you've defined a [site] configuration, we're defaulting to "workers-site" for the deprecated \`site.entry-point\`field.
+Add the top level \`main\` field to your configuration file:
+\`\`\`
+main = "workers-site/index.js"
+\`\`\``
+ );
+ siteEntryPoint = "workers-site";
+ } else if (mainEntryPoint && siteEntryPoint) {
+ diagnostics.errors.push(
+ `Don't define both the \`main\` and \`site.entry-point\` fields in your configuration.
+They serve the same purpose: to point to the entry-point of your worker.
+Delete the deprecated \`site.entry-point\` field from your config.`
+ );
+ }
+ if (configPath && siteEntryPoint) {
+ siteEntryPoint = import_node_path6.default.relative(
+ process.cwd(),
+ import_node_path6.default.join(import_node_path6.default.dirname(configPath), siteEntryPoint)
+ );
+ }
+ return {
+ bucket,
+ "entry-point": siteEntryPoint,
+ include,
+ exclude
+ };
+ }
+ return void 0;
+}
+__name(normalizeAndValidateSite, "normalizeAndValidateSite");
+function normalizeAndValidateAssets(diagnostics, configPath, rawConfig) {
+ if (typeof rawConfig?.assets === "string") {
+ return {
+ bucket: rawConfig.assets,
+ include: [],
+ exclude: [],
+ browser_TTL: void 0,
+ serve_single_page_app: false
+ };
+ }
+ if (rawConfig?.assets === void 0) {
+ return void 0;
+ }
+ if (typeof rawConfig.assets !== "object") {
+ diagnostics.errors.push(
+ `Expected the \`assets\` field to be a string or an object, but got ${typeof rawConfig.assets}.`
+ );
+ return void 0;
+ }
+ const {
+ bucket,
+ include = [],
+ exclude = [],
+ browser_TTL,
+ serve_single_page_app,
+ ...rest
+ } = rawConfig.assets;
+ validateAdditionalProperties(diagnostics, "assets", Object.keys(rest), []);
+ validateRequiredProperty(diagnostics, "assets", "bucket", bucket, "string");
+ validateTypedArray(diagnostics, "assets.include", include, "string");
+ validateTypedArray(diagnostics, "assets.exclude", exclude, "string");
+ validateOptionalProperty(
+ diagnostics,
+ "assets",
+ "browser_TTL",
+ browser_TTL,
+ "number"
+ );
+ validateOptionalProperty(
+ diagnostics,
+ "assets",
+ "serve_single_page_app",
+ serve_single_page_app,
+ "boolean"
+ );
+ return {
+ bucket,
+ include,
+ exclude,
+ browser_TTL,
+ serve_single_page_app
+ };
+}
+__name(normalizeAndValidateAssets, "normalizeAndValidateAssets");
+function normalizeAndValidateModulePaths(diagnostics, configPath, field, rawMapping) {
+ if (rawMapping === void 0) {
+ return void 0;
+ }
+ const mapping = {};
+ for (const [name, filePath] of Object.entries(rawMapping)) {
+ if (isString(diagnostics, `${field}['${name}']`, filePath, void 0)) {
+ if (configPath) {
+ mapping[name] = configPath ? import_node_path6.default.relative(
+ process.cwd(),
+ import_node_path6.default.join(import_node_path6.default.dirname(configPath), filePath)
+ ) : filePath;
+ }
+ }
+ }
+ return mapping;
+}
+__name(normalizeAndValidateModulePaths, "normalizeAndValidateModulePaths");
+function isValidRouteValue(item) {
+ if (!item) {
+ return false;
+ }
+ if (typeof item === "string") {
+ return true;
+ }
+ if (typeof item === "object") {
+ if (!hasProperty(item, "pattern") || typeof item.pattern !== "string") {
+ return false;
+ }
+ const otherKeys = Object.keys(item).length - 1;
+ const hasZoneId = hasProperty(item, "zone_id") && typeof item.zone_id === "string";
+ const hasZoneName = hasProperty(item, "zone_name") && typeof item.zone_name === "string";
+ const hasCustomDomainFlag = hasProperty(item, "custom_domain") && typeof item.custom_domain === "boolean";
+ if (otherKeys === 2 && hasCustomDomainFlag && (hasZoneId || hasZoneName)) {
+ return true;
+ } else if (otherKeys === 1 && (hasZoneId || hasZoneName || hasCustomDomainFlag)) {
+ return true;
+ }
+ }
+ return false;
+}
+__name(isValidRouteValue, "isValidRouteValue");
+function mutateEmptyStringAccountIDValue(diagnostics, rawEnv) {
+ if (rawEnv.account_id === "") {
+ diagnostics.warnings.push(
+ `The "account_id" field in your configuration is an empty string and will be ignored.
+Please remove the "account_id" field from your configuration.`
+ );
+ rawEnv.account_id = void 0;
+ }
+ return rawEnv;
+}
+__name(mutateEmptyStringAccountIDValue, "mutateEmptyStringAccountIDValue");
+function mutateEmptyStringRouteValue(diagnostics, rawEnv) {
+ if (rawEnv["route"] === "") {
+ diagnostics.warnings.push(
+ `The "route" field in your configuration is an empty string and will be ignored.
+Please remove the "route" field from your configuration.`
+ );
+ rawEnv["route"] = void 0;
+ }
+ return rawEnv;
+}
+__name(mutateEmptyStringRouteValue, "mutateEmptyStringRouteValue");
+var isRoute = /* @__PURE__ */ __name((diagnostics, field, value) => {
+ if (value !== void 0 && !isValidRouteValue(value)) {
+ diagnostics.errors.push(
+ `Expected "${field}" to be either a string, or an object with shape { pattern, custom_domain, zone_id | zone_name }, but got ${JSON.stringify(
+ value
+ )}.`
+ );
+ return false;
+ }
+ return true;
+}, "isRoute");
+var isRouteArray = /* @__PURE__ */ __name((diagnostics, field, value) => {
+ if (value === void 0) {
+ return true;
+ }
+ if (!Array.isArray(value)) {
+ diagnostics.errors.push(
+ `Expected "${field}" to be an array but got ${JSON.stringify(value)}.`
+ );
+ return false;
+ }
+ const invalidRoutes = [];
+ for (const item of value) {
+ if (!isValidRouteValue(item)) {
+ invalidRoutes.push(item);
+ }
+ }
+ if (invalidRoutes.length > 0) {
+ diagnostics.errors.push(
+ `Expected "${field}" to be an array of either strings or objects with the shape { pattern, custom_domain, zone_id | zone_name }, but these weren't valid: ${JSON.stringify(
+ invalidRoutes,
+ null,
+ 2
+ )}.`
+ );
+ }
+ return invalidRoutes.length === 0;
+}, "isRouteArray");
+function normalizeAndValidateRoute(diagnostics, topLevelEnv, rawEnv) {
+ return inheritable(
+ diagnostics,
+ topLevelEnv,
+ mutateEmptyStringRouteValue(diagnostics, rawEnv),
+ "route",
+ isRoute,
+ void 0
+ );
+}
+__name(normalizeAndValidateRoute, "normalizeAndValidateRoute");
+function validateRoutes(diagnostics, topLevelEnv, rawEnv) {
+ return inheritable(
+ diagnostics,
+ topLevelEnv,
+ rawEnv,
+ "routes",
+ all(isRouteArray, isMutuallyExclusiveWith(rawEnv, "route")),
+ void 0
+ );
+}
+__name(validateRoutes, "validateRoutes");
+function normalizeAndValidatePlacement(diagnostics, topLevelEnv, rawEnv) {
+ if (rawEnv.placement) {
+ validateRequiredProperty(
+ diagnostics,
+ "placement",
+ "mode",
+ rawEnv.placement.mode,
+ "string",
+ ["off", "smart"]
+ );
+ }
+ return inheritable(
+ diagnostics,
+ topLevelEnv,
+ rawEnv,
+ "placement",
+ () => true,
+ void 0
+ );
+}
+__name(normalizeAndValidatePlacement, "normalizeAndValidatePlacement");
+function validateTailConsumer(diagnostics, field, value) {
+ if (typeof value !== "object" || value === null) {
+ diagnostics.errors.push(
+ `"${field}" should be an object but got ${JSON.stringify(value)}.`
+ );
+ return false;
+ }
+ let isValid = true;
+ isValid = isValid && validateRequiredProperty(
+ diagnostics,
+ field,
+ "service",
+ value.service,
+ "string"
+ );
+ isValid = isValid && validateOptionalProperty(
+ diagnostics,
+ field,
+ "environment",
+ value.environment,
+ "string"
+ );
+ return isValid;
+}
+__name(validateTailConsumer, "validateTailConsumer");
+var validateTailConsumers = /* @__PURE__ */ __name((diagnostics, field, value) => {
+ if (!value) {
+ return true;
+ }
+ if (!Array.isArray(value)) {
+ diagnostics.errors.push(
+ `Expected "${field}" to be an array but got ${JSON.stringify(value)}.`
+ );
+ return false;
+ }
+ let isValid = true;
+ for (let i = 0; i < value.length; i++) {
+ isValid = validateTailConsumer(diagnostics, `${field}[${i}]`, value[i]) && isValid;
+ }
+ return isValid;
+}, "validateTailConsumers");
+function normalizeAndValidateEnvironment(diagnostics, configPath, rawEnv, envName = "top level", topLevelEnv, isLegacyEnv2, rawConfig) {
+ deprecated(
+ diagnostics,
+ rawEnv,
+ "kv-namespaces",
+ `The "kv-namespaces" field is no longer supported, please rename to "kv_namespaces"`,
+ true
+ );
+ deprecated(
+ diagnostics,
+ rawEnv,
+ "zone_id",
+ "This is unnecessary since we can deduce this from routes directly.",
+ false
+ // We need to leave this in-place for the moment since `route` commands might use it.
+ );
+ deprecated(
+ diagnostics,
+ rawEnv,
+ "experimental_services",
+ `The "experimental_services" field is no longer supported. Simply rename the [experimental_services] field to [services].`,
+ true
+ );
+ experimental(diagnostics, rawEnv, "unsafe");
+ experimental(diagnostics, rawEnv, "services");
+ const route2 = normalizeAndValidateRoute(diagnostics, topLevelEnv, rawEnv);
+ const account_id = inheritableInLegacyEnvironments(
+ diagnostics,
+ isLegacyEnv2,
+ topLevelEnv,
+ mutateEmptyStringAccountIDValue(diagnostics, rawEnv),
+ "account_id",
+ isString,
+ void 0,
+ void 0
+ );
+ const routes = validateRoutes(diagnostics, topLevelEnv, rawEnv);
+ const workers_dev = inheritable(
+ diagnostics,
+ topLevelEnv,
+ rawEnv,
+ "workers_dev",
+ isBoolean,
+ void 0
+ );
+ const { deprecatedUpload, ...build5 } = normalizeAndValidateBuild(
+ diagnostics,
+ rawEnv,
+ rawEnv.build ?? topLevelEnv?.build ?? {},
+ configPath
+ );
+ const environment = {
+ // Inherited fields
+ account_id,
+ compatibility_date: inheritable(
+ diagnostics,
+ topLevelEnv,
+ rawEnv,
+ "compatibility_date",
+ isString,
+ void 0
+ ),
+ compatibility_flags: inheritable(
+ diagnostics,
+ topLevelEnv,
+ rawEnv,
+ "compatibility_flags",
+ isStringArray,
+ []
+ ),
+ jsx_factory: inheritable(
+ diagnostics,
+ topLevelEnv,
+ rawEnv,
+ "jsx_factory",
+ isString,
+ "React.createElement"
+ ),
+ jsx_fragment: inheritable(
+ diagnostics,
+ topLevelEnv,
+ rawEnv,
+ "jsx_fragment",
+ isString,
+ "React.Fragment"
+ ),
+ tsconfig: validateAndNormalizeTsconfig(
+ diagnostics,
+ topLevelEnv,
+ rawEnv,
+ configPath
+ ),
+ rules: validateAndNormalizeRules(
+ diagnostics,
+ topLevelEnv,
+ rawEnv,
+ deprecatedUpload?.rules,
+ envName
+ ),
+ name: inheritableInLegacyEnvironments(
+ diagnostics,
+ isLegacyEnv2,
+ topLevelEnv,
+ rawEnv,
+ "name",
+ isValidName,
+ appendEnvName(envName),
+ void 0
+ ),
+ main: normalizeAndValidateMainField(
+ configPath,
+ inheritable(
+ diagnostics,
+ topLevelEnv,
+ rawEnv,
+ "main",
+ isString,
+ void 0
+ ),
+ deprecatedUpload
+ ),
+ base_dir: normalizeAndValidateBaseDirField(
+ configPath,
+ inheritable(
+ diagnostics,
+ topLevelEnv,
+ rawEnv,
+ "base_dir",
+ isString,
+ void 0
+ )
+ ),
+ route: route2,
+ routes,
+ triggers: inheritable(
+ diagnostics,
+ topLevelEnv,
+ rawEnv,
+ "triggers",
+ isObjectWith("crons"),
+ { crons: [] }
+ ),
+ usage_model: inheritable(
+ diagnostics,
+ topLevelEnv,
+ rawEnv,
+ "usage_model",
+ isOneOf("bundled", "unbound"),
+ void 0
+ ),
+ placement: normalizeAndValidatePlacement(diagnostics, topLevelEnv, rawEnv),
+ build: build5,
+ workers_dev,
+ // Not inherited fields
+ vars: notInheritable(
+ diagnostics,
+ topLevelEnv,
+ rawConfig,
+ rawEnv,
+ envName,
+ "vars",
+ validateVars(envName),
+ {}
+ ),
+ define: notInheritable(
+ diagnostics,
+ topLevelEnv,
+ rawConfig,
+ rawEnv,
+ envName,
+ "define",
+ validateDefines(envName),
+ {}
+ ),
+ durable_objects: notInheritable(
+ diagnostics,
+ topLevelEnv,
+ rawConfig,
+ rawEnv,
+ envName,
+ "durable_objects",
+ validateBindingsProperty(envName, validateDurableObjectBinding),
+ {
+ bindings: []
+ }
+ ),
+ kv_namespaces: notInheritable(
+ diagnostics,
+ topLevelEnv,
+ rawConfig,
+ rawEnv,
+ envName,
+ "kv_namespaces",
+ validateBindingArray(envName, validateKVBinding),
+ []
+ ),
+ send_email: notInheritable(
+ diagnostics,
+ topLevelEnv,
+ rawConfig,
+ rawEnv,
+ envName,
+ "send_email",
+ validateBindingArray(envName, validateSendEmailBinding),
+ []
+ ),
+ queues: notInheritable(
+ diagnostics,
+ topLevelEnv,
+ rawConfig,
+ rawEnv,
+ envName,
+ "queues",
+ validateQueues(envName),
+ { producers: [], consumers: [] }
+ ),
+ r2_buckets: notInheritable(
+ diagnostics,
+ topLevelEnv,
+ rawConfig,
+ rawEnv,
+ envName,
+ "r2_buckets",
+ validateBindingArray(envName, validateR2Binding),
+ []
+ ),
+ d1_databases: notInheritable(
+ diagnostics,
+ topLevelEnv,
+ rawConfig,
+ rawEnv,
+ envName,
+ "d1_databases",
+ validateBindingArray(envName, validateD1Binding),
+ []
+ ),
+ constellation: notInheritable(
+ diagnostics,
+ topLevelEnv,
+ rawConfig,
+ rawEnv,
+ envName,
+ "constellation",
+ validateBindingArray(envName, validateConstellationBinding),
+ []
+ ),
+ services: notInheritable(
+ diagnostics,
+ topLevelEnv,
+ rawConfig,
+ rawEnv,
+ envName,
+ "services",
+ validateBindingArray(envName, validateServiceBinding),
+ []
+ ),
+ analytics_engine_datasets: notInheritable(
+ diagnostics,
+ topLevelEnv,
+ rawConfig,
+ rawEnv,
+ envName,
+ "analytics_engine_datasets",
+ validateBindingArray(envName, validateAnalyticsEngineBinding),
+ []
+ ),
+ dispatch_namespaces: notInheritable(
+ diagnostics,
+ topLevelEnv,
+ rawConfig,
+ rawEnv,
+ envName,
+ "dispatch_namespaces",
+ validateBindingArray(envName, validateWorkerNamespaceBinding),
+ []
+ ),
+ mtls_certificates: notInheritable(
+ diagnostics,
+ topLevelEnv,
+ rawConfig,
+ rawEnv,
+ envName,
+ "mtls_certificates",
+ validateBindingArray(envName, validateMTlsCertificateBinding),
+ []
+ ),
+ tail_consumers: notInheritable(
+ diagnostics,
+ topLevelEnv,
+ rawConfig,
+ rawEnv,
+ envName,
+ "tail_consumers",
+ validateTailConsumers,
+ void 0
+ ),
+ unsafe: notInheritable(
+ diagnostics,
+ topLevelEnv,
+ rawConfig,
+ rawEnv,
+ envName,
+ "unsafe",
+ validateUnsafeSettings(envName),
+ {}
+ ),
+ browser: notInheritable(
+ diagnostics,
+ topLevelEnv,
+ rawConfig,
+ rawEnv,
+ envName,
+ "browser",
+ validateBrowserBinding(envName),
+ void 0
+ ),
+ zone_id: rawEnv.zone_id,
+ logfwdr: inheritable(
+ diagnostics,
+ topLevelEnv,
+ rawEnv,
+ "logfwdr",
+ validateCflogfwdrObject(envName),
+ {
+ bindings: []
+ }
+ ),
+ no_bundle: inheritable(
+ diagnostics,
+ topLevelEnv,
+ rawEnv,
+ "no_bundle",
+ isBoolean,
+ void 0
+ ),
+ minify: inheritable(
+ diagnostics,
+ topLevelEnv,
+ rawEnv,
+ "minify",
+ isBoolean,
+ void 0
+ ),
+ node_compat: inheritable(
+ diagnostics,
+ topLevelEnv,
+ rawEnv,
+ "node_compat",
+ isBoolean,
+ void 0
+ ),
+ first_party_worker: inheritable(
+ diagnostics,
+ topLevelEnv,
+ rawEnv,
+ "first_party_worker",
+ isBoolean,
+ void 0
+ ),
+ logpush: inheritable(
+ diagnostics,
+ topLevelEnv,
+ rawEnv,
+ "logpush",
+ isBoolean,
+ void 0
+ )
+ };
+ return environment;
+}
+__name(normalizeAndValidateEnvironment, "normalizeAndValidateEnvironment");
+function validateAndNormalizeTsconfig(diagnostics, topLevelEnv, rawEnv, configPath) {
+ const tsconfig = inheritable(
+ diagnostics,
+ topLevelEnv,
+ rawEnv,
+ "tsconfig",
+ isString,
+ void 0
+ );
+ return configPath && tsconfig ? import_node_path6.default.relative(
+ process.cwd(),
+ import_node_path6.default.join(import_node_path6.default.dirname(configPath), tsconfig)
+ ) : tsconfig;
+}
+__name(validateAndNormalizeTsconfig, "validateAndNormalizeTsconfig");
+var validateAndNormalizeRules = /* @__PURE__ */ __name((diagnostics, topLevelEnv, rawEnv, deprecatedRules, envName) => {
+ if (topLevelEnv === void 0) {
+ if (rawEnv.rules && deprecatedRules) {
+ diagnostics.errors.push(
+ `You cannot configure both [rules] and [build.upload.rules] in your wrangler.toml. Delete the \`build.upload\` section.`
+ );
+ } else if (deprecatedRules) {
+ diagnostics.warnings.push(
+ `Deprecation: The \`build.upload.rules\` config field is no longer used, the rules should be specified via the \`rules\` config field. Delete the \`build.upload\` field from the configuration file, and add this:
+\`\`\`
+` + import_toml3.default.stringify({ rules: deprecatedRules }) + "```"
+ );
+ }
+ }
+ return inheritable(
+ diagnostics,
+ topLevelEnv,
+ rawEnv,
+ "rules",
+ validateRules(envName),
+ deprecatedRules ?? []
+ );
+}, "validateAndNormalizeRules");
+var validateRules = /* @__PURE__ */ __name((envName) => (diagnostics, field, envValue, config) => {
+ if (!envValue) {
+ return true;
+ }
+ const fieldPath = config === void 0 ? `${field}` : `env.${envName}.${field}`;
+ if (!Array.isArray(envValue)) {
+ diagnostics.errors.push(
+ `The field "${fieldPath}" should be an array but got ${JSON.stringify(
+ envValue
+ )}.`
+ );
+ return false;
+ }
+ let isValid = true;
+ for (let i = 0; i < envValue.length; i++) {
+ isValid = validateRule(diagnostics, `${fieldPath}[${i}]`, envValue[i], config) && isValid;
+ }
+ return isValid;
+}, "validateRules");
+var validateRule = /* @__PURE__ */ __name((diagnostics, field, value) => {
+ if (typeof value !== "object" || value === null) {
+ diagnostics.errors.push(
+ `"${field}" should be an object but got ${JSON.stringify(value)}.`
+ );
+ return false;
+ }
+ let isValid = true;
+ const rule = value;
+ if (!isRequiredProperty(rule, "type", "string", [
+ "ESModule",
+ "CommonJS",
+ "CompiledWasm",
+ "Text",
+ "Data"
+ ])) {
+ diagnostics.errors.push(
+ `bindings should have a string "type" field, which contains one of "ESModule", "CommonJS", "CompiledWasm", "Text", or "Data".`
+ );
+ isValid = false;
+ }
+ isValid = validateTypedArray(diagnostics, `${field}.globs`, rule.globs, "string") && isValid;
+ if (!isOptionalProperty(rule, "fallthrough", "boolean")) {
+ diagnostics.errors.push(
+ `the field "fallthrough", when present, should be a boolean.`
+ );
+ isValid = false;
+ }
+ return isValid;
+}, "validateRule");
+var validateDefines = /* @__PURE__ */ __name((envName) => (diagnostics, field, value, config) => {
+ let isValid = true;
+ const fieldPath = config === void 0 ? `${field}` : `env.${envName}.${field}`;
+ if (typeof value === "object" && value !== null) {
+ for (const varName in value) {
+ if (typeof value[varName] !== "string") {
+ diagnostics.errors.push(
+ `The field "${fieldPath}.${varName}" should be a string but got ${JSON.stringify(
+ value[varName]
+ )}.`
+ );
+ isValid = false;
+ }
+ }
+ } else {
+ if (value !== void 0) {
+ diagnostics.errors.push(
+ `The field "${fieldPath}" should be an object but got ${JSON.stringify(
+ value
+ )}.
+`
+ );
+ isValid = false;
+ }
+ }
+ const configDefines = Object.keys(config?.define ?? {});
+ if (configDefines.length > 0) {
+ if (typeof value === "object" && value !== null) {
+ const configEnvDefines = config === void 0 ? [] : Object.keys(value);
+ for (const varName of configDefines) {
+ if (!(varName in value)) {
+ diagnostics.warnings.push(
+ `"define.${varName}" exists at the top level, but not on "${fieldPath}".
+This is not what you probably want, since "define" configuration is not inherited by environments.
+Please add "define.${varName}" to "env.${envName}".`
+ );
+ }
+ }
+ for (const varName of configEnvDefines) {
+ if (!configDefines.includes(varName)) {
+ diagnostics.warnings.push(
+ `"${varName}" exists on "env.${envName}", but not on the top level.
+This is not what you probably want, since "define" configuration within environments can only override existing top level "define" configuration
+Please remove "${fieldPath}.${varName}", or add "define.${varName}".`
+ );
+ }
+ }
+ }
+ }
+ return isValid;
+}, "validateDefines");
+var validateVars = /* @__PURE__ */ __name((envName) => (diagnostics, field, value, config) => {
+ let isValid = true;
+ const fieldPath = config === void 0 ? `${field}` : `env.${envName}.${field}`;
+ const configVars = Object.keys(config?.vars ?? {});
+ if (configVars.length > 0) {
+ if (typeof value !== "object" || value === null) {
+ diagnostics.errors.push(
+ `The field "${fieldPath}" should be an object but got ${JSON.stringify(
+ value
+ )}.
+`
+ );
+ isValid = false;
+ } else {
+ for (const varName of configVars) {
+ if (!(varName in value)) {
+ diagnostics.warnings.push(
+ `"vars.${varName}" exists at the top level, but not on "${fieldPath}".
+This is not what you probably want, since "vars" configuration is not inherited by environments.
+Please add "vars.${varName}" to "env.${envName}".`
+ );
+ }
+ }
+ }
+ }
+ return isValid;
+}, "validateVars");
+var validateBindingsProperty = /* @__PURE__ */ __name((envName, validateBinding) => (diagnostics, field, value, config) => {
+ let isValid = true;
+ const fieldPath = config === void 0 ? `${field}` : `env.${envName}.${field}`;
+ if (value !== void 0) {
+ if (typeof value !== "object" || value === null || Array.isArray(value)) {
+ diagnostics.errors.push(
+ `The field "${fieldPath}" should be an object but got ${JSON.stringify(
+ value
+ )}.`
+ );
+ isValid = false;
+ } else if (!hasProperty(value, "bindings")) {
+ diagnostics.errors.push(
+ `The field "${fieldPath}" is missing the required "bindings" property.`
+ );
+ isValid = false;
+ } else if (!Array.isArray(value.bindings)) {
+ diagnostics.errors.push(
+ `The field "${fieldPath}.bindings" should be an array but got ${JSON.stringify(
+ value.bindings
+ )}.`
+ );
+ isValid = false;
+ } else {
+ for (let i = 0; i < value.bindings.length; i++) {
+ const binding = value.bindings[i];
+ const bindingDiagnostics = new Diagnostics(
+ `"${fieldPath}.bindings[${i}]": ${JSON.stringify(binding)}`
+ );
+ isValid = validateBinding(
+ bindingDiagnostics,
+ `${fieldPath}.bindings[${i}]`,
+ binding,
+ config
+ ) && isValid;
+ diagnostics.addChild(bindingDiagnostics);
+ }
+ }
+ const configBindingNames = getBindingNames(
+ config?.[field]
+ );
+ if (isValid && configBindingNames.length > 0) {
+ const envBindingNames = new Set(getBindingNames(value));
+ const missingBindings = configBindingNames.filter(
+ (name) => !envBindingNames.has(name)
+ );
+ if (missingBindings.length > 0) {
+ diagnostics.warnings.push(
+ `The following bindings are at the top level, but not on "env.${envName}".
+This is not what you probably want, since "${field}" configuration is not inherited by environments.
+Please add a binding for each to "${fieldPath}.bindings":
+` + missingBindings.map((name) => `- ${name}`).join("\n")
+ );
+ }
+ }
+ }
+ return isValid;
+}, "validateBindingsProperty");
+var validateUnsafeSettings = /* @__PURE__ */ __name((envName) => (diagnostics, field, value, config) => {
+ const fieldPath = config === void 0 ? `${field}` : `env.${envName}.${field}`;
+ if (typeof value !== "object" || value === null || Array.isArray(value)) {
+ diagnostics.errors.push(
+ `The field "${fieldPath}" should be an object but got ${JSON.stringify(
+ value
+ )}.`
+ );
+ return false;
+ }
+ if (!hasProperty(value, "bindings") && !hasProperty(value, "metadata") && !hasProperty(value, "capnp")) {
+ diagnostics.errors.push(
+ `The field "${fieldPath}" should contain at least one of "bindings", "metadata" or "capnp" properties but got ${JSON.stringify(
+ value
+ )}.`
+ );
+ return false;
+ }
+ if (hasProperty(value, "bindings") && value.bindings !== void 0) {
+ const validateBindingsFn = validateBindingsProperty(
+ envName,
+ validateUnsafeBinding
+ );
+ const valid = validateBindingsFn(diagnostics, field, value, config);
+ if (!valid) {
+ return false;
+ }
+ }
+ if (hasProperty(value, "metadata") && value.metadata !== void 0 && (typeof value.metadata !== "object" || value.metadata === null || Array.isArray(value.metadata))) {
+ diagnostics.errors.push(
+ `The field "${fieldPath}.metadata" should be an object but got ${JSON.stringify(
+ value.metadata
+ )}.`
+ );
+ return false;
+ }
+ if (hasProperty(value, "capnp") && value.capnp !== void 0) {
+ if (typeof value.capnp !== "object" || value.capnp === null || Array.isArray(value.capnp)) {
+ diagnostics.errors.push(
+ `The field "${fieldPath}.capnp" should be an object but got ${JSON.stringify(
+ value.capnp
+ )}.`
+ );
+ return false;
+ }
+ if (hasProperty(value.capnp, "compiled_schema")) {
+ if (hasProperty(value.capnp, "base_path") || hasProperty(value.capnp, "source_schemas")) {
+ diagnostics.errors.push(
+ `The field "${fieldPath}.capnp" cannot contain both "compiled_schema" and one of "base_path" or "source_schemas".`
+ );
+ return false;
+ }
+ if (typeof value.capnp.compiled_schema !== "string") {
+ diagnostics.errors.push(
+ `The field "${fieldPath}.capnp.compiled_schema", when present, should be a string but got ${JSON.stringify(
+ value.capnp.compiled_schema
+ )}.`
+ );
+ return false;
+ }
+ } else {
+ if (!isRequiredProperty(value.capnp, "base_path", "string")) {
+ diagnostics.errors.push(
+ `The field "${fieldPath}.capnp.base_path", when present, should be a string but got ${JSON.stringify(
+ value.capnp.base_path
+ )}`
+ );
+ }
+ if (!validateTypedArray(
+ diagnostics,
+ `${fieldPath}.capnp.source_schemas`,
+ value.capnp.source_schemas,
+ "string"
+ )) {
+ return false;
+ }
+ }
+ }
+ return true;
+}, "validateUnsafeSettings");
+var validateDurableObjectBinding = /* @__PURE__ */ __name((diagnostics, field, value) => {
+ if (typeof value !== "object" || value === null) {
+ diagnostics.errors.push(
+ `Expected "${field}" to be an object but got ${JSON.stringify(value)}`
+ );
+ return false;
+ }
+ let isValid = true;
+ if (!isRequiredProperty(value, "name", "string")) {
+ diagnostics.errors.push(`binding should have a string "name" field.`);
+ isValid = false;
+ }
+ if (!isRequiredProperty(value, "class_name", "string")) {
+ diagnostics.errors.push(`binding should have a string "class_name" field.`);
+ isValid = false;
+ }
+ if (!isOptionalProperty(value, "script_name", "string")) {
+ diagnostics.errors.push(
+ `the field "script_name", when present, should be a string.`
+ );
+ isValid = false;
+ }
+ if (!isOptionalProperty(value, "environment", "string")) {
+ diagnostics.errors.push(
+ `the field "environment", when present, should be a string.`
+ );
+ isValid = false;
+ }
+ if ("environment" in value && !("script_name" in value)) {
+ diagnostics.errors.push(
+ `binding should have a "script_name" field if "environment" is present.`
+ );
+ isValid = false;
+ }
+ return isValid;
+}, "validateDurableObjectBinding");
+var validateCflogfwdrObject = /* @__PURE__ */ __name((envName) => (diagnostics, field, value, topLevelEnv) => {
+ const bindingsValidation = validateBindingsProperty(
+ envName,
+ validateCflogfwdrBinding
+ );
+ if (!bindingsValidation(diagnostics, field, value, topLevelEnv))
+ return false;
+ const v = value;
+ if (v?.schema !== void 0) {
+ diagnostics.errors.push(
+ `"${field}" binding "schema" property has been replaced with the "unsafe.capnp" object, which expects a "base_path" and an array of "source_schemas" to compile, or a "compiled_schema" property.`
+ );
+ return false;
+ }
+ return true;
+}, "validateCflogfwdrObject");
+var validateCflogfwdrBinding = /* @__PURE__ */ __name((diagnostics, field, value) => {
+ if (typeof value !== "object" || value === null) {
+ diagnostics.errors.push(
+ `Expected "${field}" to be an object but got ${JSON.stringify(value)}`
+ );
+ return false;
+ }
+ let isValid = true;
+ if (!isRequiredProperty(value, "name", "string")) {
+ diagnostics.errors.push(`binding should have a string "name" field.`);
+ isValid = false;
+ }
+ if (!isRequiredProperty(value, "destination", "string")) {
+ diagnostics.errors.push(
+ `binding should have a string "destination" field.`
+ );
+ isValid = false;
+ }
+ return isValid;
+}, "validateCflogfwdrBinding");
+var validateBrowserBinding = /* @__PURE__ */ __name((envName) => (diagnostics, field, value, config) => {
+ const fieldPath = config === void 0 ? `${field}` : `env.${envName}.${field}`;
+ if (typeof value !== "object" || value === null || Array.isArray(value)) {
+ diagnostics.errors.push(
+ `The field "${fieldPath}" should be an object but got ${JSON.stringify(
+ value
+ )}.`
+ );
+ return false;
+ }
+ let isValid = true;
+ if (!isRequiredProperty(value, "binding", "string")) {
+ diagnostics.errors.push(`binding should have a string "binding" field.`);
+ isValid = false;
+ }
+ return isValid;
+}, "validateBrowserBinding");
+var validateUnsafeBinding = /* @__PURE__ */ __name((diagnostics, field, value) => {
+ if (typeof value !== "object" || value === null) {
+ diagnostics.errors.push(
+ `Expected ${field} to be an object but got ${JSON.stringify(value)}.`
+ );
+ return false;
+ }
+ let isValid = true;
+ if (!isRequiredProperty(value, "name", "string")) {
+ diagnostics.errors.push(`binding should have a string "name" field.`);
+ isValid = false;
+ }
+ if (isRequiredProperty(value, "type", "string")) {
+ const safeBindings = [
+ "plain_text",
+ "json",
+ "wasm_module",
+ "data_blob",
+ "text_blob",
+ "browser",
+ "kv_namespace",
+ "durable_object_namespace",
+ "d1_database",
+ "constellation",
+ "r2_bucket",
+ "service",
+ "logfwdr",
+ "mtls_certificate"
+ ];
+ if (safeBindings.includes(value.type)) {
+ diagnostics.warnings.push(
+ `The binding type "${value.type}" is directly supported by wrangler.
+Consider migrating this unsafe binding to a format for '${value.type}' bindings that is supported by wrangler for optimal support.
+For more details, see https://developers.cloudflare.com/workers/cli-wrangler/configuration`
+ );
+ }
+ } else {
+ diagnostics.errors.push(`binding should have a string "type" field.`);
+ isValid = false;
+ }
+ return isValid;
+}, "validateUnsafeBinding");
+var validateBindingArray = /* @__PURE__ */ __name((envName, validateBinding) => (diagnostics, field, envValue, config) => {
+ if (envValue === void 0) {
+ return true;
+ }
+ const fieldPath = config === void 0 ? `${field}` : `env.${envName}.${field}`;
+ if (!Array.isArray(envValue)) {
+ diagnostics.errors.push(
+ `The field "${fieldPath}" should be an array but got ${JSON.stringify(
+ envValue
+ )}.`
+ );
+ return false;
+ }
+ let isValid = true;
+ for (let i = 0; i < envValue.length; i++) {
+ isValid = validateBinding(
+ diagnostics,
+ `${fieldPath}[${i}]`,
+ envValue[i],
+ config
+ ) && isValid;
+ }
+ const configValue = config?.[field];
+ if (Array.isArray(configValue)) {
+ const configBindingNames = configValue.map((value) => value.binding);
+ if (configBindingNames.length > 0) {
+ const envBindingNames = new Set(envValue.map((value) => value.binding));
+ for (const configBindingName of configBindingNames) {
+ if (!envBindingNames.has(configBindingName)) {
+ diagnostics.warnings.push(
+ `There is a ${field} binding with name "${configBindingName}" at the top level, but not on "env.${envName}".
+This is not what you probably want, since "${field}" configuration is not inherited by environments.
+Please add a binding for "${configBindingName}" to "env.${envName}.${field}.bindings".`
+ );
+ }
+ }
+ }
+ }
+ return isValid;
+}, "validateBindingArray");
+var validateKVBinding = /* @__PURE__ */ __name((diagnostics, field, value) => {
+ if (typeof value !== "object" || value === null) {
+ diagnostics.errors.push(
+ `"kv_namespaces" bindings should be objects, but got ${JSON.stringify(
+ value
+ )}`
+ );
+ return false;
+ }
+ let isValid = true;
+ if (!isRequiredProperty(value, "binding", "string")) {
+ diagnostics.errors.push(
+ `"${field}" bindings should have a string "binding" field but got ${JSON.stringify(
+ value
+ )}.`
+ );
+ isValid = false;
+ }
+ if (!isRequiredProperty(value, "id", "string") || value.id.length === 0) {
+ diagnostics.errors.push(
+ `"${field}" bindings should have a string "id" field but got ${JSON.stringify(
+ value
+ )}.`
+ );
+ isValid = false;
+ }
+ if (!isOptionalProperty(value, "preview_id", "string")) {
+ diagnostics.errors.push(
+ `"${field}" bindings should, optionally, have a string "preview_id" field but got ${JSON.stringify(
+ value
+ )}.`
+ );
+ isValid = false;
+ }
+ return isValid;
+}, "validateKVBinding");
+var validateSendEmailBinding = /* @__PURE__ */ __name((diagnostics, field, value) => {
+ if (typeof value !== "object" || value === null) {
+ diagnostics.errors.push(
+ `"send_email" bindings should be objects, but got ${JSON.stringify(
+ value
+ )}`
+ );
+ return false;
+ }
+ let isValid = true;
+ if (!isRequiredProperty(value, "name", "string")) {
+ diagnostics.errors.push(
+ `"${field}" bindings should have a string "name" field but got ${JSON.stringify(
+ value
+ )}.`
+ );
+ isValid = false;
+ }
+ if (!isOptionalProperty(value, "destination_address", "string")) {
+ diagnostics.errors.push(
+ `"${field}" bindings should, optionally, have a string "destination_address" field but got ${JSON.stringify(
+ value
+ )}.`
+ );
+ isValid = false;
+ }
+ if (!isOptionalProperty(value, "allowed_destination_addresses", "object")) {
+ diagnostics.errors.push(
+ `"${field}" bindings should, optionally, have a []string "allowed_destination_addresses" field but got ${JSON.stringify(
+ value
+ )}.`
+ );
+ isValid = false;
+ }
+ if ("destination_address" in value && "allowed_destination_addresses" in value) {
+ diagnostics.errors.push(
+ `"${field}" bindings should have either a "destination_address" or "allowed_destination_addresses" field, but not both.`
+ );
+ isValid = false;
+ }
+ return isValid;
+}, "validateSendEmailBinding");
+var validateQueueBinding = /* @__PURE__ */ __name((diagnostics, field, value) => {
+ if (typeof value !== "object" || value === null) {
+ diagnostics.errors.push(
+ `"queue" bindings should be objects, but got ${JSON.stringify(value)}`
+ );
+ return false;
+ }
+ if (!validateAdditionalProperties(diagnostics, field, Object.keys(value), [
+ "binding",
+ "queue"
+ ])) {
+ return false;
+ }
+ let isValid = true;
+ if (!isRequiredProperty(value, "binding", "string")) {
+ diagnostics.errors.push(
+ `"${field}" bindings should have a string "binding" field but got ${JSON.stringify(
+ value
+ )}.`
+ );
+ isValid = false;
+ }
+ if (!isRequiredProperty(value, "queue", "string") || value.queue.length === 0) {
+ diagnostics.errors.push(
+ `"${field}" bindings should have a string "queue" field but got ${JSON.stringify(
+ value
+ )}.`
+ );
+ isValid = false;
+ }
+ return isValid;
+}, "validateQueueBinding");
+var validateR2Binding = /* @__PURE__ */ __name((diagnostics, field, value) => {
+ if (typeof value !== "object" || value === null) {
+ diagnostics.errors.push(
+ `"r2_buckets" bindings should be objects, but got ${JSON.stringify(
+ value
+ )}`
+ );
+ return false;
+ }
+ let isValid = true;
+ if (!isRequiredProperty(value, "binding", "string")) {
+ diagnostics.errors.push(
+ `"${field}" bindings should have a string "binding" field but got ${JSON.stringify(
+ value
+ )}.`
+ );
+ isValid = false;
+ }
+ if (!isRequiredProperty(value, "bucket_name", "string") || value.bucket_name.length === 0) {
+ diagnostics.errors.push(
+ `"${field}" bindings should have a string "bucket_name" field but got ${JSON.stringify(
+ value
+ )}.`
+ );
+ isValid = false;
+ }
+ if (!isOptionalProperty(value, "preview_bucket_name", "string")) {
+ diagnostics.errors.push(
+ `"${field}" bindings should, optionally, have a string "preview_bucket_name" field but got ${JSON.stringify(
+ value
+ )}.`
+ );
+ isValid = false;
+ }
+ if (!isOptionalProperty(value, "jurisdiction", "string")) {
+ diagnostics.errors.push(
+ `"${field}" bindings should, optionally, have a string "jurisdiction" field but got ${JSON.stringify(
+ value
+ )}.`
+ );
+ isValid = false;
+ }
+ return isValid;
+}, "validateR2Binding");
+var validateD1Binding = /* @__PURE__ */ __name((diagnostics, field, value) => {
+ if (typeof value !== "object" || value === null) {
+ diagnostics.errors.push(
+ `"d1_databases" bindings should be objects, but got ${JSON.stringify(
+ value
+ )}`
+ );
+ return false;
+ }
+ let isValid = true;
+ if (!isRequiredProperty(value, "binding", "string")) {
+ diagnostics.errors.push(
+ `"${field}" bindings should have a string "binding" field but got ${JSON.stringify(
+ value
+ )}.`
+ );
+ isValid = false;
+ }
+ if (
+ // TODO: allow name only, where we look up the ID dynamically
+ // !isOptionalProperty(value, "database_name", "string") &&
+ !isRequiredProperty(value, "database_id", "string")
+ ) {
+ diagnostics.errors.push(
+ `"${field}" bindings must have a "database_id" field but got ${JSON.stringify(
+ value
+ )}.`
+ );
+ isValid = false;
+ }
+ if (!isOptionalProperty(value, "preview_database_id", "string")) {
+ diagnostics.errors.push(
+ `"${field}" bindings should, optionally, have a string "preview_database_id" field but got ${JSON.stringify(
+ value
+ )}.`
+ );
+ isValid = false;
+ }
+ if (isValid && !process.env.NO_D1_WARNING) {
+ diagnostics.warnings.push(
+ "D1 Bindings are currently in alpha to allow the API to evolve before general availability.\nPlease report any issues to https://github.com/cloudflare/workers-sdk/issues/new/choose\nNote: Run this command with the environment variable NO_D1_WARNING=true to hide this message\n\nFor example: `export NO_D1_WARNING=true && wrangler `"
+ );
+ }
+ return isValid;
+}, "validateD1Binding");
+var validateConstellationBinding = /* @__PURE__ */ __name((diagnostics, field, value) => {
+ if (typeof value !== "object" || value === null) {
+ diagnostics.errors.push(
+ `"constellation" bindings should be objects, but got ${JSON.stringify(
+ value
+ )}`
+ );
+ return false;
+ }
+ let isValid = true;
+ if (!isRequiredProperty(value, "binding", "string")) {
+ diagnostics.errors.push(
+ `"${field}" bindings should have a string "binding" field but got ${JSON.stringify(
+ value
+ )}.`
+ );
+ isValid = false;
+ }
+ if (!isRequiredProperty(value, "project_id", "string")) {
+ diagnostics.errors.push(
+ `"${field}" bindings must have a "project_id" field but got ${JSON.stringify(
+ value
+ )}.`
+ );
+ isValid = false;
+ }
+ if (isValid && getConstellationWarningFromEnv() === void 0) {
+ diagnostics.warnings.push(
+ "Constellation Bindings are currently in beta to allow the API to evolve before general availability.\nPlease report any issues to https://github.com/cloudflare/workers-sdk/issues/new/choose\nNote: Run this command with the environment variable NO_CONSTELLATION_WARNING=true to hide this message\n\nFor example: `export NO_CONSTELLATION_WARNING=true && wrangler `"
+ );
+ }
+ return isValid;
+}, "validateConstellationBinding");
+var validateBindingsHaveUniqueNames = /* @__PURE__ */ __name((diagnostics, {
+ durable_objects,
+ kv_namespaces,
+ r2_buckets,
+ analytics_engine_datasets,
+ text_blobs,
+ browser,
+ unsafe,
+ vars,
+ define: define2,
+ wasm_modules,
+ data_blobs
+}) => {
+ let hasDuplicates = false;
+ const bindingsGroupedByType = {
+ "Durable Object": getBindingNames(durable_objects),
+ "KV Namespace": getBindingNames(kv_namespaces),
+ "R2 Bucket": getBindingNames(r2_buckets),
+ "Analytics Engine Dataset": getBindingNames(analytics_engine_datasets),
+ "Text Blob": getBindingNames(text_blobs),
+ Browser: getBindingNames(browser),
+ Unsafe: getBindingNames(unsafe),
+ "Environment Variable": getBindingNames(vars),
+ Definition: getBindingNames(define2),
+ "WASM Module": getBindingNames(wasm_modules),
+ "Data Blob": getBindingNames(data_blobs)
+ };
+ const bindingsGroupedByName = {};
+ for (const bindingType in bindingsGroupedByType) {
+ const bindingNames = bindingsGroupedByType[bindingType];
+ for (const bindingName of bindingNames) {
+ if (!(bindingName in bindingsGroupedByName)) {
+ bindingsGroupedByName[bindingName] = [];
+ }
+ bindingsGroupedByName[bindingName].push(bindingType);
+ }
+ }
+ for (const bindingName in bindingsGroupedByName) {
+ const bindingTypes = bindingsGroupedByName[bindingName];
+ if (bindingTypes.length < 2) {
+ continue;
+ }
+ hasDuplicates = true;
+ const sameType = bindingTypes.filter((type, i) => bindingTypes.indexOf(type) !== i).filter(
+ (type, i, duplicateBindingTypes) => duplicateBindingTypes.indexOf(type) === i
+ );
+ const differentTypes = bindingTypes.filter(
+ (type, i) => bindingTypes.indexOf(type) === i
+ );
+ if (differentTypes.length > 1) {
+ diagnostics.errors.push(
+ `${bindingName} assigned to ${ENGLISH.format(differentTypes)} bindings.`
+ );
+ }
+ sameType.forEach((bindingType) => {
+ diagnostics.errors.push(
+ `${bindingName} assigned to multiple ${bindingType} bindings.`
+ );
+ });
+ }
+ if (hasDuplicates) {
+ const problem = "Bindings must have unique names, so that they can all be referenced in the worker.";
+ const resolution = "Please change your bindings to have unique names.";
+ diagnostics.errors.push(`${problem}
+${resolution}`);
+ }
+ return !hasDuplicates;
+}, "validateBindingsHaveUniqueNames");
+var validateServiceBinding = /* @__PURE__ */ __name((diagnostics, field, value) => {
+ if (typeof value !== "object" || value === null) {
+ diagnostics.errors.push(
+ `"services" bindings should be objects, but got ${JSON.stringify(value)}`
+ );
+ return false;
+ }
+ let isValid = true;
+ if (!isRequiredProperty(value, "binding", "string")) {
+ diagnostics.errors.push(
+ `"${field}" bindings should have a string "binding" field but got ${JSON.stringify(
+ value
+ )}.`
+ );
+ isValid = false;
+ }
+ if (!isRequiredProperty(value, "service", "string")) {
+ diagnostics.errors.push(
+ `"${field}" bindings should have a string "service" field but got ${JSON.stringify(
+ value
+ )}.`
+ );
+ isValid = false;
+ }
+ if (!isOptionalProperty(value, "environment", "string")) {
+ diagnostics.errors.push(
+ `"${field}" bindings should have a string "environment" field but got ${JSON.stringify(
+ value
+ )}.`
+ );
+ isValid = false;
+ }
+ return isValid;
+}, "validateServiceBinding");
+var validateAnalyticsEngineBinding = /* @__PURE__ */ __name((diagnostics, field, value) => {
+ if (typeof value !== "object" || value === null) {
+ diagnostics.errors.push(
+ `"analytics_engine" bindings should be objects, but got ${JSON.stringify(
+ value
+ )}`
+ );
+ return false;
+ }
+ let isValid = true;
+ if (!isRequiredProperty(value, "binding", "string")) {
+ diagnostics.errors.push(
+ `"${field}" bindings should have a string "binding" field but got ${JSON.stringify(
+ value
+ )}.`
+ );
+ isValid = false;
+ }
+ if (!isOptionalProperty(value, "dataset", "string") || value.dataset?.length === 0) {
+ diagnostics.errors.push(
+ `"${field}" bindings should, optionally, have a string "dataset" field but got ${JSON.stringify(
+ value
+ )}.`
+ );
+ isValid = false;
+ }
+ return isValid;
+}, "validateAnalyticsEngineBinding");
+var validateWorkerNamespaceBinding = /* @__PURE__ */ __name((diagnostics, field, value) => {
+ if (typeof value !== "object" || value === null) {
+ diagnostics.errors.push(
+ `"${field}" binding should be objects, but got ${JSON.stringify(value)}`
+ );
+ return false;
+ }
+ let isValid = true;
+ if (!isRequiredProperty(value, "binding", "string")) {
+ diagnostics.errors.push(
+ `"${field}" should have a string "binding" field but got ${JSON.stringify(
+ value
+ )}.`
+ );
+ isValid = false;
+ }
+ if (!isRequiredProperty(value, "namespace", "string")) {
+ diagnostics.errors.push(
+ `"${field}" should have a string "namespace" field but got ${JSON.stringify(
+ value
+ )}.`
+ );
+ isValid = false;
+ }
+ if (hasProperty(value, "outbound")) {
+ if (!validateWorkerNamespaceOutbound(
+ diagnostics,
+ `${field}.outbound`,
+ value.outbound ?? {}
+ )) {
+ diagnostics.errors.push(`"${field}" has an invalid outbound definition.`);
+ isValid = false;
+ }
+ }
+ return isValid;
+}, "validateWorkerNamespaceBinding");
+function validateWorkerNamespaceOutbound(diagnostics, field, value) {
+ if (typeof value !== "object" || value === null) {
+ diagnostics.errors.push(
+ `"${field}" should be an object, but got ${JSON.stringify(value)}`
+ );
+ return false;
+ }
+ let isValid = true;
+ isValid = isValid && validateRequiredProperty(
+ diagnostics,
+ field,
+ "service",
+ value.service,
+ "string"
+ );
+ isValid = isValid && validateOptionalProperty(
+ diagnostics,
+ field,
+ "environment",
+ value.environment,
+ "string"
+ );
+ isValid = isValid && validateOptionalTypedArray(
+ diagnostics,
+ `${field}.parameters`,
+ value.parameters,
+ "string"
+ );
+ return isValid;
+}
+__name(validateWorkerNamespaceOutbound, "validateWorkerNamespaceOutbound");
+var validateMTlsCertificateBinding = /* @__PURE__ */ __name((diagnostics, field, value) => {
+ if (typeof value !== "object" || value === null) {
+ diagnostics.errors.push(
+ `"mtls_certificates" bindings should be objects, but got ${JSON.stringify(
+ value
+ )}`
+ );
+ return false;
+ }
+ let isValid = true;
+ if (!isRequiredProperty(value, "binding", "string")) {
+ diagnostics.errors.push(
+ `"${field}" bindings should have a string "binding" field but got ${JSON.stringify(
+ value
+ )}.`
+ );
+ isValid = false;
+ }
+ if (!isRequiredProperty(value, "certificate_id", "string") || value.certificate_id.length === 0) {
+ diagnostics.errors.push(
+ `"${field}" bindings should have a string "certificate_id" field but got ${JSON.stringify(
+ value
+ )}.`
+ );
+ isValid = false;
+ }
+ return isValid;
+}, "validateMTlsCertificateBinding");
+function validateQueues(envName) {
+ return (diagnostics, field, value, config) => {
+ const fieldPath = config === void 0 ? `${field}` : `env.${envName}.${field}`;
+ if (typeof value !== "object" || Array.isArray(value) || value === null) {
+ diagnostics.errors.push(
+ `The field "${fieldPath}" should be an object but got ${JSON.stringify(
+ value
+ )}.`
+ );
+ return false;
+ }
+ let isValid = true;
+ if (!validateAdditionalProperties(
+ diagnostics,
+ fieldPath,
+ Object.keys(value),
+ ["consumers", "producers"]
+ )) {
+ isValid = false;
+ }
+ if (hasProperty(value, "consumers")) {
+ const consumers2 = value.consumers;
+ if (!Array.isArray(consumers2)) {
+ diagnostics.errors.push(
+ `The field "${fieldPath}.consumers" should be an array but got ${JSON.stringify(
+ consumers2
+ )}.`
+ );
+ isValid = false;
+ }
+ for (let i = 0; i < consumers2.length; i++) {
+ const consumer = consumers2[i];
+ const consumerPath = `${fieldPath}.consumers[${i}]`;
+ if (!validateConsumer(diagnostics, consumerPath, consumer, config)) {
+ isValid = false;
+ }
+ }
+ }
+ if (hasProperty(value, "producers")) {
+ if (!validateBindingArray(envName, validateQueueBinding)(
+ diagnostics,
+ `${field}.producers`,
+ value.producers,
+ config
+ )) {
+ isValid = false;
+ }
+ }
+ return isValid;
+ };
+}
+__name(validateQueues, "validateQueues");
+var validateConsumer = /* @__PURE__ */ __name((diagnostics, field, value, _config) => {
+ if (typeof value !== "object" || value === null) {
+ diagnostics.errors.push(
+ `"${field}" should be a objects, but got ${JSON.stringify(value)}`
+ );
+ return false;
+ }
+ let isValid = true;
+ if (!validateAdditionalProperties(diagnostics, field, Object.keys(value), [
+ "queue",
+ "max_batch_size",
+ "max_batch_timeout",
+ "max_retries",
+ "dead_letter_queue",
+ "max_concurrency"
+ ])) {
+ isValid = false;
+ }
+ if (!isRequiredProperty(value, "queue", "string")) {
+ diagnostics.errors.push(
+ `"${field}" should have a string "queue" field but got ${JSON.stringify(
+ value
+ )}.`
+ );
+ }
+ const options14 = [
+ { key: "max_batch_size", type: "number" },
+ { key: "max_batch_timeout", type: "number" },
+ { key: "max_retries", type: "number" },
+ { key: "dead_letter_queue", type: "string" },
+ { key: "max_concurrency", type: "number" }
+ ];
+ for (const optionalOpt of options14) {
+ if (!isOptionalProperty(value, optionalOpt.key, optionalOpt.type)) {
+ diagnostics.errors.push(
+ `"${field}" should, optionally, have a ${optionalOpt.type} "${optionalOpt.key}" field but got ${JSON.stringify(value)}.`
+ );
+ isValid = false;
+ }
+ }
+ return isValid;
+}, "validateConsumer");
+
+// src/config/index.ts
+function readConfig(configPath, args) {
+ let rawConfig = {};
+ if (!configPath) {
+ configPath = findWranglerToml(process.cwd(), args.experimentalJsonConfig);
+ }
+ if (configPath?.endsWith("toml")) {
+ rawConfig = parseTOML(readFileSync5(configPath), configPath);
+ } else if (configPath?.endsWith("json")) {
+ rawConfig = parseJSONC(readFileSync5(configPath), configPath);
+ }
+ const { config, diagnostics } = normalizeAndValidateConfig(
+ rawConfig,
+ configPath,
+ args
+ );
+ if (diagnostics.hasWarnings()) {
+ logger.warn(diagnostics.renderWarnings());
+ }
+ if (diagnostics.hasErrors()) {
+ throw new Error(diagnostics.renderErrors());
+ }
+ return config;
+}
+__name(readConfig, "readConfig");
+function findWranglerToml(referencePath = process.cwd(), preferJson = false) {
+ if (preferJson) {
+ return findUpSync(`wrangler.json`, { cwd: referencePath }) ?? findUpSync(`wrangler.toml`, { cwd: referencePath });
+ }
+ return findUpSync(`wrangler.toml`, { cwd: referencePath });
+}
+__name(findWranglerToml, "findWranglerToml");
+function printBindings(bindings) {
+ const truncate2 = /* @__PURE__ */ __name((item) => {
+ const s = typeof item === "string" ? item : JSON.stringify(item);
+ const maxLength = 40;
+ if (s.length < maxLength) {
+ return s;
+ }
+ return `${s.substring(0, maxLength - 3)}...`;
+ }, "truncate");
+ const output = [];
+ const {
+ data_blobs,
+ durable_objects,
+ kv_namespaces,
+ send_email,
+ queues: queues2,
+ d1_databases,
+ constellation: constellation2,
+ r2_buckets,
+ logfwdr,
+ services,
+ analytics_engine_datasets,
+ text_blobs,
+ browser,
+ unsafe,
+ vars,
+ wasm_modules,
+ dispatch_namespaces,
+ mtls_certificates
+ } = bindings;
+ if (data_blobs !== void 0 && Object.keys(data_blobs).length > 0) {
+ output.push({
+ type: "Data Blobs",
+ entries: Object.entries(data_blobs).map(([key, value]) => ({
+ key,
+ value: truncate2(value)
+ }))
+ });
+ }
+ if (durable_objects !== void 0 && durable_objects.bindings.length > 0) {
+ output.push({
+ type: "Durable Objects",
+ entries: durable_objects.bindings.map(
+ ({ name, class_name, script_name, environment }) => {
+ let value = class_name;
+ if (script_name) {
+ value += ` (defined in ${script_name})`;
+ }
+ if (environment) {
+ value += ` - ${environment}`;
+ }
+ return {
+ key: name,
+ value
+ };
+ }
+ )
+ });
+ }
+ if (kv_namespaces !== void 0 && kv_namespaces.length > 0) {
+ output.push({
+ type: "KV Namespaces",
+ entries: kv_namespaces.map(({ binding, id }) => {
+ return {
+ key: binding,
+ value: id
+ };
+ })
+ });
+ }
+ if (send_email !== void 0 && send_email.length > 0) {
+ output.push({
+ type: "Send Email",
+ entries: send_email.map(
+ ({ name, destination_address, allowed_destination_addresses }) => {
+ return {
+ key: name,
+ value: destination_address || allowed_destination_addresses?.join(", ") || "unrestricted"
+ };
+ }
+ )
+ });
+ }
+ if (queues2 !== void 0 && queues2.length > 0) {
+ output.push({
+ type: "Queues",
+ entries: queues2.map(({ binding, queue_name }) => {
+ return {
+ key: binding,
+ value: queue_name
+ };
+ })
+ });
+ }
+ if (d1_databases !== void 0 && d1_databases.length > 0) {
+ output.push({
+ type: "D1 Databases",
+ entries: d1_databases.map(
+ ({ binding, database_name, database_id, preview_database_id }) => {
+ let databaseValue = `${database_id}`;
+ if (database_name) {
+ databaseValue = `${database_name} (${database_id})`;
+ }
+ if (preview_database_id && database_id !== "local") {
+ databaseValue += `, Preview: (${preview_database_id})`;
+ }
+ return {
+ key: binding,
+ value: databaseValue
+ };
+ }
+ )
+ });
+ }
+ if (constellation2 !== void 0 && constellation2.length > 0) {
+ output.push({
+ type: "Constellation Projects",
+ entries: constellation2.map(({ binding, project_id }) => {
+ return {
+ key: binding,
+ value: project_id
+ };
+ })
+ });
+ }
+ if (r2_buckets !== void 0 && r2_buckets.length > 0) {
+ output.push({
+ type: "R2 Buckets",
+ entries: r2_buckets.map(({ binding, bucket_name, jurisdiction }) => {
+ if (jurisdiction !== void 0) {
+ bucket_name += ` (${jurisdiction})`;
+ }
+ return {
+ key: binding,
+ value: bucket_name
+ };
+ })
+ });
+ }
+ if (logfwdr !== void 0 && logfwdr.bindings.length > 0) {
+ output.push({
+ type: "logfwdr",
+ entries: logfwdr.bindings.map((binding) => {
+ return {
+ key: binding.name,
+ value: binding.destination
+ };
+ })
+ });
+ }
+ if (services !== void 0 && services.length > 0) {
+ output.push({
+ type: "Services",
+ entries: services.map(({ binding, service, environment }) => {
+ let value = service;
+ if (environment) {
+ value += ` - ${environment}`;
+ }
+ return {
+ key: binding,
+ value
+ };
+ })
+ });
+ }
+ if (analytics_engine_datasets !== void 0 && analytics_engine_datasets.length > 0) {
+ output.push({
+ type: "Analytics Engine Datasets",
+ entries: analytics_engine_datasets.map(({ binding, dataset }) => {
+ return {
+ key: binding,
+ value: dataset ?? binding
+ };
+ })
+ });
+ }
+ if (text_blobs !== void 0 && Object.keys(text_blobs).length > 0) {
+ output.push({
+ type: "Text Blobs",
+ entries: Object.entries(text_blobs).map(([key, value]) => ({
+ key,
+ value: truncate2(value)
+ }))
+ });
+ }
+ if (browser !== void 0) {
+ output.push({
+ type: "Browser",
+ entries: [{ key: "Name", value: browser.binding }]
+ });
+ }
+ if (unsafe?.bindings !== void 0 && unsafe.bindings.length > 0) {
+ output.push({
+ type: "Unsafe",
+ entries: unsafe.bindings.map(({ name, type }) => ({
+ key: type,
+ value: name
+ }))
+ });
+ }
+ if (vars !== void 0 && Object.keys(vars).length > 0) {
+ output.push({
+ type: "Vars",
+ entries: Object.entries(vars).map(([key, value]) => {
+ let parsedValue;
+ if (typeof value === "string") {
+ parsedValue = `"${truncate2(value)}"`;
+ } else if (typeof value === "object") {
+ parsedValue = JSON.stringify(value, null, 1);
+ } else {
+ parsedValue = `${truncate2(`${value}`)}`;
+ }
+ return {
+ key,
+ value: parsedValue
+ };
+ })
+ });
+ }
+ if (wasm_modules !== void 0 && Object.keys(wasm_modules).length > 0) {
+ output.push({
+ type: "Wasm Modules",
+ entries: Object.entries(wasm_modules).map(([key, value]) => ({
+ key,
+ value: truncate2(value)
+ }))
+ });
+ }
+ if (dispatch_namespaces !== void 0 && dispatch_namespaces.length > 0) {
+ output.push({
+ type: "dispatch namespaces",
+ entries: dispatch_namespaces.map(({ binding, namespace, outbound }) => {
+ return {
+ key: binding,
+ value: outbound ? `${namespace} (outbound -> ${outbound.service})` : namespace
+ };
+ })
+ });
+ }
+ if (mtls_certificates !== void 0 && mtls_certificates.length > 0) {
+ output.push({
+ type: "mTLS Certificates",
+ entries: mtls_certificates.map(({ binding, certificate_id }) => {
+ return {
+ key: binding,
+ value: certificate_id
+ };
+ })
+ });
+ }
+ if (unsafe?.metadata !== void 0) {
+ output.push({
+ type: "Unsafe Metadata",
+ entries: Object.entries(unsafe.metadata).map(([key, value]) => ({
+ key,
+ value: `${value}`
+ }))
+ });
+ }
+ if (output.length === 0) {
+ return;
+ }
+ const message = [
+ `Your worker has access to the following bindings:`,
+ ...output.map((bindingGroup) => {
+ return [
+ `- ${bindingGroup.type}:`,
+ bindingGroup.entries.map(({ key, value }) => ` - ${key}: ${value}`)
+ ];
+ }).flat(2)
+ ].join("\n");
+ logger.log(message);
+}
+__name(printBindings, "printBindings");
+function withConfig(handler15) {
+ return (t2) => {
+ return handler15({ ...t2, config: readConfig(t2.config, t2) });
+ };
+}
+__name(withConfig, "withConfig");
+function tryLoadDotEnv(path45) {
+ try {
+ const parsed = import_dotenv.default.parse(import_node_fs4.default.readFileSync(path45));
+ return { path: path45, parsed };
+ } catch (e2) {
+ logger.debug(`Failed to load .env file "${path45}":`, e2);
+ }
+}
+__name(tryLoadDotEnv, "tryLoadDotEnv");
+function loadDotEnv(path45, env5) {
+ if (env5 === void 0) {
+ return tryLoadDotEnv(path45);
+ } else {
+ return tryLoadDotEnv(`${path45}.${env5}`) ?? tryLoadDotEnv(path45);
+ }
+}
+__name(loadDotEnv, "loadDotEnv");
+
+// src/deployment-bundle/entry.ts
+init_import_meta_url();
+var import_node_path13 = __toESM(require("node:path"));
+
+// src/paths.ts
+init_import_meta_url();
+var import_node_console = require("node:console");
+var import_node_path7 = require("node:path");
+function toUrlPath(filePath) {
+ (0, import_node_console.assert)(
+ !/^[a-z]:/i.test(filePath),
+ "Tried to convert a Windows file path with a drive to a URL path."
+ );
+ return filePath.replace(/\\/g, "/");
+}
+__name(toUrlPath, "toUrlPath");
+function readableRelative(to) {
+ const relativePath = (0, import_node_path7.relative)(process.cwd(), to);
+ if (
+ // No directory nesting, return as-is
+ (0, import_node_path7.basename)(relativePath) === relativePath || // Outside current directory
+ relativePath.startsWith(".")
+ ) {
+ return relativePath;
+ } else {
+ return "./" + relativePath;
+ }
+}
+__name(readableRelative, "readableRelative");
+function getBasePath() {
+ return (0, import_node_path7.resolve)(__dirname, "..");
+}
+__name(getBasePath, "getBasePath");
+
+// src/deployment-bundle/guess-worker-format.ts
+init_import_meta_url();
+var import_node_path9 = __toESM(require("node:path"));
+var esbuild2 = __toESM(require("esbuild"));
+
+// src/deployment-bundle/bundle.ts
+init_import_meta_url();
+var fs5 = __toESM(require("node:fs"));
+var import_node_module = require("node:module");
+var path8 = __toESM(require("node:path"));
+var import_node_globals_polyfill = __toESM(require("@esbuild-plugins/node-globals-polyfill"));
+var import_node_modules_polyfill = __toESM(require("@esbuild-plugins/node-modules-polyfill"));
+var esbuild = __toESM(require("esbuild"));
+var import_tmp_promise = __toESM(require_tmp_promise());
+
+// src/module-collection.ts
+init_import_meta_url();
+var import_node_crypto3 = __toESM(require("node:crypto"));
+var import_promises = require("node:fs/promises");
+var import_node_path8 = __toESM(require("node:path"));
+var import_chalk3 = __toESM(require_chalk());
+var import_glob_to_regexp = __toESM(require_glob_to_regexp());
+function flipObject(obj) {
+ return Object.fromEntries(Object.entries(obj).map(([k, v]) => [v, k]));
+}
+__name(flipObject, "flipObject");
+var RuleTypeToModuleType = {
+ ESModule: "esm",
+ CommonJS: "commonjs",
+ CompiledWasm: "compiled-wasm",
+ Data: "buffer",
+ Text: "text"
+};
+var ModuleTypeToRuleType = flipObject(RuleTypeToModuleType);
+var DEFAULT_MODULE_RULES = [
+ { type: "Text", globs: ["**/*.txt", "**/*.html"] },
+ { type: "Data", globs: ["**/*.bin"] },
+ { type: "CompiledWasm", globs: ["**/*.wasm", "**/*.wasm?module"] }
+];
+function parseRules(userRules = []) {
+ const rules = [...userRules, ...DEFAULT_MODULE_RULES];
+ const completedRuleLocations = {};
+ let index = 0;
+ const rulesToRemove = [];
+ for (const rule of rules) {
+ if (rule.type in completedRuleLocations) {
+ if (rules[completedRuleLocations[rule.type]].fallthrough !== false) {
+ if (index < userRules.length) {
+ logger.warn(
+ `The module rule at position ${index} (${JSON.stringify(
+ rule
+ )}) has the same type as a previous rule (at position ${completedRuleLocations[rule.type]}, ${JSON.stringify(
+ rules[completedRuleLocations[rule.type]]
+ )}). This rule will be ignored. To the previous rule, add \`fallthrough = true\` to allow this one to also be used, or \`fallthrough = false\` to silence this warning.`
+ );
+ } else {
+ logger.warn(
+ `The default module rule ${JSON.stringify(
+ rule
+ )} has the same type as a previous rule (at position ${completedRuleLocations[rule.type]}, ${JSON.stringify(
+ rules[completedRuleLocations[rule.type]]
+ )}). This rule will be ignored. To the previous rule, add \`fallthrough = true\` to allow the default one to also be used, or \`fallthrough = false\` to silence this warning.`
+ );
+ }
+ }
+ rulesToRemove.push(rule);
+ }
+ if (!(rule.type in completedRuleLocations) && rule.fallthrough !== true) {
+ completedRuleLocations[rule.type] = index;
+ }
+ index++;
+ }
+ rulesToRemove.forEach((rule) => rules.splice(rules.indexOf(rule), 1));
+ return { rules, removedRules: rulesToRemove };
+}
+__name(parseRules, "parseRules");
+async function matchFiles(files, relativeTo, {
+ rules,
+ removedRules
+}) {
+ const modules = [];
+ const moduleNames = /* @__PURE__ */ new Set();
+ for (const rule of rules) {
+ for (const glob of rule.globs) {
+ const regexp = (0, import_glob_to_regexp.default)(glob, {
+ globstar: true
+ });
+ const newModules = await Promise.all(
+ files.filter((f) => regexp.test(f)).map(async (name) => {
+ const filePath = import_node_path8.default.join(relativeTo, name);
+ const fileContent = await (0, import_promises.readFile)(filePath);
+ return {
+ name,
+ filePath,
+ content: fileContent,
+ type: RuleTypeToModuleType[rule.type]
+ };
+ })
+ );
+ for (const module2 of newModules) {
+ if (!moduleNames.has(module2.name)) {
+ moduleNames.add(module2.name);
+ modules.push(module2);
+ } else {
+ logger.warn(
+ `Ignoring duplicate module: ${import_chalk3.default.blue(
+ module2.name
+ )} (${import_chalk3.default.green(module2.type ?? "")})`
+ );
+ }
+ }
+ }
+ }
+ for (const rule of removedRules) {
+ for (const glob of rule.globs) {
+ const regexp = (0, import_glob_to_regexp.default)(glob);
+ for (const file of files) {
+ if (regexp.test(file)) {
+ throw new Error(
+ `The file ${file} matched a module rule in your configuration (${JSON.stringify(
+ rule
+ )}), but was ignored because a previous rule with the same type was not marked as \`fallthrough = true\`.`
+ );
+ }
+ }
+ }
+ }
+ return modules;
+}
+__name(matchFiles, "matchFiles");
+function createModuleCollector(props) {
+ const { rules, removedRules } = parseRules(props.rules);
+ const modules = [];
+ return {
+ modules,
+ plugin: {
+ name: "wrangler-module-collector",
+ setup(build5) {
+ build5.onStart(() => {
+ modules.splice(0);
+ });
+ const rulesMatchers = rules.flatMap((rule) => {
+ return rule.globs.map((glob) => {
+ const regex = (0, import_glob_to_regexp.default)(glob);
+ return {
+ regex,
+ rule
+ };
+ });
+ });
+ if (props.wrangler1xlegacyModuleReferences.fileNames.size > 0) {
+ build5.onResolve(
+ {
+ filter: new RegExp(
+ "^(" + [...props.wrangler1xlegacyModuleReferences.fileNames].map((name) => name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|") + ")$"
+ )
+ },
+ async (args) => {
+ if (args.kind !== "import-statement" && args.kind !== "require-call") {
+ return;
+ }
+ logger.warn(
+ `Deprecation: detected a legacy module import in "./${import_node_path8.default.relative(
+ process.cwd(),
+ args.importer
+ )}". This will stop working in the future. Replace references to "${args.path}" with "./${args.path}";`
+ );
+ const filePath = import_node_path8.default.join(
+ props.wrangler1xlegacyModuleReferences.rootDirectory,
+ args.path
+ );
+ const fileContent = await (0, import_promises.readFile)(filePath);
+ const fileHash = import_node_crypto3.default.createHash("sha1").update(fileContent).digest("hex");
+ const fileName = `./${fileHash}-${import_node_path8.default.basename(args.path)}`;
+ const { rule } = rulesMatchers.find(({ regex }) => regex.test(fileName)) || {};
+ if (rule) {
+ modules.push({
+ name: fileName,
+ filePath,
+ content: fileContent,
+ type: RuleTypeToModuleType[rule.type]
+ });
+ return {
+ path: fileName,
+ // change the reference to the changed module
+ external: props.format === "modules",
+ // mark it as external in the bundle
+ namespace: `wrangler-module-${rule.type}`,
+ // just a tag, this isn't strictly necessary
+ watchFiles: [filePath]
+ // we also add the file to esbuild's watch list
+ };
+ }
+ }
+ );
+ }
+ rules?.forEach((rule) => {
+ if (rule.type === "ESModule" || rule.type === "CommonJS")
+ return;
+ rule.globs.forEach((glob) => {
+ build5.onResolve(
+ { filter: (0, import_glob_to_regexp.default)(glob) },
+ async (args) => {
+ const filePath = import_node_path8.default.join(args.resolveDir, args.path);
+ const fileContent = await (0, import_promises.readFile)(filePath);
+ const fileHash = import_node_crypto3.default.createHash("sha1").update(fileContent).digest("hex");
+ const fileName = props.preserveFileNames ? filePath : `./${fileHash}-${import_node_path8.default.basename(args.path)}`;
+ modules.push({
+ name: fileName,
+ filePath,
+ content: fileContent,
+ type: RuleTypeToModuleType[rule.type]
+ });
+ return {
+ path: fileName,
+ // change the reference to the changed module
+ external: props.format === "modules",
+ // mark it as external in the bundle
+ namespace: `wrangler-module-${rule.type}`,
+ // just a tag, this isn't strictly necessary
+ watchFiles: [filePath]
+ // we also add the file to esbuild's watch list
+ };
+ }
+ );
+ if (props.format === "service-worker") {
+ build5.onLoad(
+ { filter: (0, import_glob_to_regexp.default)(glob) },
+ async (args) => {
+ return {
+ // We replace the the module with an identifier
+ // that we'll separately add to the form upload
+ // as part of [wasm_modules]/[text_blobs]/[data_blobs]. This identifier has to be a valid
+ // JS identifier, so we replace all non alphanumeric characters
+ // with an underscore.
+ contents: `export default ${args.path.replace(
+ /[^a-zA-Z0-9_$]/g,
+ "_"
+ )};`
+ };
+ }
+ );
+ }
+ });
+ });
+ removedRules.forEach((rule) => {
+ rule.globs.forEach((glob) => {
+ build5.onResolve(
+ { filter: (0, import_glob_to_regexp.default)(glob) },
+ async (args) => {
+ throw new Error(
+ `The file ${args.path} matched a module rule in your configuration (${JSON.stringify(
+ rule
+ )}), but was ignored because a previous rule with the same type was not marked as \`fallthrough = true\`.`
+ );
+ }
+ );
+ });
+ });
+ }
+ }
+ };
+}
+__name(createModuleCollector, "createModuleCollector");
+
+// src/utils/dedent.ts
+init_import_meta_url();
+var import_node_assert3 = __toESM(require("node:assert"));
+function dedent(strings, ...values) {
+ const raw = String.raw({ raw: strings }, ...values);
+ let lines = raw.split("\n");
+ (0, import_node_assert3.default)(lines.length > 0);
+ if (lines[lines.length - 1].trim() === "") {
+ lines = lines.slice(0, lines.length - 1);
+ }
+ let minIndent = "";
+ let minIndentLength = Infinity;
+ for (const line of lines.slice(1)) {
+ const indent = line.match(/^[ \t]*/)?.[0];
+ if (indent != null && indent.length < minIndentLength) {
+ minIndent = indent;
+ minIndentLength = indent.length;
+ }
+ }
+ if (lines.length > 0 && lines[0].trim() === "")
+ lines = lines.slice(1);
+ lines = lines.map(
+ (line) => line.startsWith(minIndent) ? line.substring(minIndent.length) : line
+ );
+ return lines.join("\n");
+}
+__name(dedent, "dedent");
+
+// src/deployment-bundle/entry-point-from-metafile.ts
+init_import_meta_url();
+var import_node_assert4 = __toESM(require("node:assert"));
+function getEntryPointFromMetafile(entryFile, metafile) {
+ const entryPoints = Object.entries(metafile.outputs).filter(
+ ([_path, output]) => output.entryPoint !== void 0
+ );
+ if (entryPoints.length !== 1) {
+ const entryPointList = entryPoints.map(([_input, output]) => output.entryPoint).join("\n");
+ (0, import_node_assert4.default)(
+ entryPoints.length > 0,
+ `Cannot find entry-point "${entryFile}" in generated bundle.
+${entryPointList}`
+ );
+ (0, import_node_assert4.default)(
+ entryPoints.length < 2,
+ `More than one entry-point found for generated bundle.
+${entryPointList}`
+ );
+ }
+ const [relativePath, entryPoint] = entryPoints[0];
+ return {
+ relativePath,
+ exports: entryPoint.exports,
+ dependencies: entryPoint.inputs
+ };
+}
+__name(getEntryPointFromMetafile, "getEntryPointFromMetafile");
+
+// src/deployment-bundle/esbuild-plugins/cloudflare-internal.ts
+init_import_meta_url();
+var cloudflareInternalPlugin = {
+ name: "Cloudflare internal imports plugin",
+ setup(pluginBuild) {
+ pluginBuild.onResolve({ filter: /^cloudflare:.*/ }, () => {
+ return { external: true };
+ });
+ }
+};
+
+// src/deployment-bundle/esbuild-plugins/config-provider.ts
+init_import_meta_url();
+function configProviderPlugin(config) {
+ return {
+ name: "middleware config provider plugin",
+ setup(build5) {
+ build5.onResolve({ filter: /^config:/ }, (args) => ({
+ path: args.path,
+ namespace: "wrangler-config"
+ }));
+ build5.onLoad(
+ { filter: /.*/, namespace: "wrangler-config" },
+ async (args) => {
+ const middleware = args.path.split("config:middleware/")[1];
+ if (!config[middleware]) {
+ throw new Error(`No config found for ${middleware}`);
+ }
+ return {
+ loader: "json",
+ contents: JSON.stringify(config[middleware])
+ };
+ }
+ );
+ }
+ };
+}
+__name(configProviderPlugin, "configProviderPlugin");
+
+// src/deployment-bundle/esbuild-plugins/nodejs-compat.ts
+init_import_meta_url();
+var nodejsCompatPlugin = {
+ name: "nodejs_compat imports plugin",
+ setup(pluginBuild) {
+ pluginBuild.onResolve({ filter: /node:.*/ }, () => {
+ return { external: true };
+ });
+ }
+};
+
+// src/deployment-bundle/bundle.ts
+var COMMON_ESBUILD_OPTIONS = {
+ // Our workerd runtime uses the same V8 version as recent Chrome, which is highly ES2022 compliant: https://kangax.github.io/compat-table/es2016plus/
+ target: "es2022",
+ loader: { ".js": "jsx", ".mjs": "jsx", ".cjs": "jsx" }
+};
+var nodeBuiltinResolveErrorText = new RegExp(
+ '^Could not resolve "(' + import_node_module.builtinModules.join("|") + "|" + import_node_module.builtinModules.map((module2) => "node:" + module2).join("|") + ')"$'
+);
+function isBuildFailure(err) {
+ return typeof err === "object" && err !== null && "errors" in err && "warnings" in err;
+}
+__name(isBuildFailure, "isBuildFailure");
+function rewriteNodeCompatBuildFailure(errors, forPages = false) {
+ for (const error of errors) {
+ const match = nodeBuiltinResolveErrorText.exec(error.text);
+ if (match !== null) {
+ const issue = `The package "${match[1]}" wasn't found on the file system but is built into node.`;
+ const instructionForUser = `${forPages ? 'Add the "nodejs_compat" compatibility flag to your Pages project' : 'Add "node_compat = true" to your wrangler.toml file'} to enable Node.js compatibility.`;
+ error.notes = [
+ {
+ location: null,
+ text: `${issue}
+${instructionForUser}`
+ }
+ ];
+ }
+ }
+}
+__name(rewriteNodeCompatBuildFailure, "rewriteNodeCompatBuildFailure");
+async function bundleWorker(entry, destination, options14) {
+ const {
+ bundle = true,
+ serveAssetsFromWorker,
+ doBindings,
+ jsxFactory,
+ jsxFragment,
+ entryName,
+ rules,
+ watch: watch6,
+ tsconfig,
+ minify,
+ legacyNodeCompat,
+ nodejsCompat,
+ checkFetch,
+ assets,
+ workerDefinitions,
+ services,
+ targetConsumer,
+ testScheduled,
+ inject: injectOption,
+ loader,
+ sourcemap,
+ plugins,
+ disableModuleCollection,
+ isOutfile,
+ forPages,
+ additionalModules = [],
+ local
+ } = options14;
+ const unsafeTmpDir = await import_tmp_promise.default.dir({ unsafeCleanup: true });
+ const tmpDirPath = fs5.realpathSync(unsafeTmpDir.path);
+ const entryDirectory = path8.dirname(entry.file);
+ let moduleCollector = createModuleCollector({
+ wrangler1xlegacyModuleReferences: {
+ rootDirectory: entryDirectory,
+ fileNames: new Set(
+ fs5.readdirSync(entryDirectory, { withFileTypes: true }).filter(
+ (dirEntry) => dirEntry.isFile() && dirEntry.name !== path8.basename(entry.file)
+ ).map((dirEnt) => dirEnt.name)
+ )
+ },
+ format: entry.format,
+ rules
+ });
+ if (disableModuleCollection) {
+ moduleCollector = {
+ modules: [],
+ plugin: {
+ name: moduleCollector.plugin.name,
+ setup: () => {
+ }
+ }
+ };
+ }
+ const checkedFetchFileToInject = path8.join(tmpDirPath, "checked-fetch.js");
+ if (checkFetch && !fs5.existsSync(checkedFetchFileToInject)) {
+ fs5.mkdirSync(tmpDirPath, {
+ recursive: true
+ });
+ fs5.writeFileSync(
+ checkedFetchFileToInject,
+ fs5.readFileSync(path8.resolve(getBasePath(), "templates/checked-fetch.js"))
+ );
+ }
+ const middlewareToLoad = [
+ {
+ name: "scheduled",
+ path: "templates/middleware/middleware-scheduled.ts",
+ active: targetConsumer === "dev" && !!testScheduled
+ },
+ // In Miniflare 3, we bind the user's worker as a service binding in a
+ // special entry worker that handles things like injecting `Request.cf`,
+ // live-reload, and the pretty-error page.
+ //
+ // Unfortunately, due to a bug in `workerd`, errors thrown asynchronously by
+ // native APIs don't have `stack`s. This means Miniflare can't extract the
+ // `stack` trace from dispatching to the user worker service binding by
+ // `try/catch`.
+ //
+ // As a stop-gap solution, if the `MF-Experimental-Error-Stack` header is
+ // truthy on responses, the body will be interpreted as a JSON-error of the
+ // form `{ message?: string, name?: string, stack?: string }`.
+ //
+ // This middleware wraps the user's worker in a `try/catch`, and rewrites
+ // errors in this format so a pretty-error page can be shown.
+ {
+ name: "miniflare3-json-error",
+ path: "templates/middleware/middleware-miniflare3-json-error.ts",
+ active: targetConsumer === "dev" && local
+ },
+ {
+ name: "serve-static-assets",
+ path: "templates/middleware/middleware-serve-static-assets.ts",
+ active: serveAssetsFromWorker,
+ config: {
+ spaMode: typeof assets === "object" ? assets.serve_single_page_app : false,
+ cacheControl: typeof assets === "object" ? {
+ browserTTL: assets.browser_TTL || 172800,
+ bypassCache: assets.bypassCache
+ } : {}
+ }
+ },
+ {
+ name: "multiworker-dev",
+ path: "templates/middleware/middleware-multiworker-dev.ts",
+ active: targetConsumer === "dev" && !!(workerDefinitions && Object.keys(workerDefinitions).length > 0 && services && services.length > 0),
+ config: {
+ workers: Object.fromEntries(
+ (services || []).map((serviceBinding) => [
+ serviceBinding.binding,
+ workerDefinitions?.[serviceBinding.service] || null
+ ])
+ )
+ }
+ }
+ ];
+ let initialBuildResult;
+ const initialBuildResultPromise = new Promise(
+ (resolve18) => initialBuildResult = resolve18
+ );
+ const buildResultPlugin = {
+ name: "Initial build result plugin",
+ setup(build5) {
+ build5.onEnd(initialBuildResult);
+ }
+ };
+ const inject = injectOption ?? [];
+ if (checkFetch)
+ inject.push(checkedFetchFileToInject);
+ const activeMiddleware = middlewareToLoad.filter(
+ // We dynamically filter the middleware depending on where we are bundling for
+ (m) => m.active
+ );
+ let inputEntry = entry;
+ if (activeMiddleware.length > 0 || process.env.EXPERIMENTAL_MIDDLEWARE === "true") {
+ inputEntry = await applyMiddlewareLoaderFacade(
+ entry,
+ tmpDirPath,
+ activeMiddleware,
+ doBindings
+ );
+ if (inputEntry.inject !== void 0)
+ inject.push(...inputEntry.inject);
+ }
+ const buildOptions2 = {
+ entryPoints: [inputEntry.file],
+ bundle,
+ absWorkingDir: entry.directory,
+ outdir: destination,
+ entryNames: entryName || path8.parse(entry.file).name,
+ ...isOutfile ? {
+ outdir: void 0,
+ outfile: destination,
+ entryNames: void 0
+ } : {},
+ inject,
+ external: bundle ? ["__STATIC_CONTENT_MANIFEST"] : void 0,
+ format: entry.format === "modules" ? "esm" : "iife",
+ target: COMMON_ESBUILD_OPTIONS.target,
+ sourcemap: sourcemap ?? true,
+ // Include a reference to the output folder in the sourcemap.
+ // This is omitted by default, but we need it to properly resolve source paths in error output.
+ sourceRoot: destination,
+ minify,
+ metafile: true,
+ conditions: ["workerd", "worker", "browser"],
+ ...{
+ define: {
+ // use process.env["NODE_ENV" + ""] so that esbuild doesn't replace it
+ // when we do a build of wrangler. (re: https://github.com/cloudflare/workers-sdk/issues/1477)
+ "process.env.NODE_ENV": `"${process.env["NODE_ENV"]}"`,
+ ...legacyNodeCompat ? { global: "globalThis" } : {},
+ ...options14.define
+ }
+ },
+ loader: {
+ ...COMMON_ESBUILD_OPTIONS.loader,
+ ...loader || {}
+ },
+ plugins: [
+ moduleCollector.plugin,
+ ...legacyNodeCompat ? [(0, import_node_globals_polyfill.default)({ buffer: true }), (0, import_node_modules_polyfill.default)()] : [],
+ ...nodejsCompat ? [nodejsCompatPlugin] : [],
+ cloudflareInternalPlugin,
+ buildResultPlugin,
+ ...plugins || [],
+ configProviderPlugin(
+ Object.fromEntries(
+ middlewareToLoad.filter((m) => m.config !== void 0).map((m) => [m.name, m.config])
+ )
+ )
+ ],
+ ...jsxFactory && { jsxFactory },
+ ...jsxFragment && { jsxFragment },
+ ...tsconfig && { tsconfig },
+ // The default logLevel is "warning". So that we can rewrite errors before
+ // logging, we disable esbuild's default logging, and log build failures
+ // ourselves.
+ logLevel: "silent"
+ };
+ let result;
+ let stop;
+ try {
+ if (watch6) {
+ const ctx = await esbuild.context(buildOptions2);
+ await ctx.watch();
+ result = await initialBuildResultPromise;
+ if (result.errors.length > 0) {
+ throw new Error("Failed to build");
+ }
+ stop = /* @__PURE__ */ __name(async function() {
+ await ctx.dispose();
+ }, "stop");
+ } else {
+ result = await esbuild.build(buildOptions2);
+ }
+ } catch (e2) {
+ if (!legacyNodeCompat && isBuildFailure(e2))
+ rewriteNodeCompatBuildFailure(e2.errors, forPages);
+ throw e2;
+ }
+ const entryPoint = getEntryPointFromMetafile(entry.file, result.metafile);
+ const bundleType = entryPoint.exports.length > 0 ? "esm" : "commonjs";
+ const sourceMapPath = Object.keys(result.metafile.outputs).filter(
+ (_path) => _path.includes(".map")
+ )[0];
+ const resolvedEntryPointPath = path8.resolve(
+ entry.directory,
+ entryPoint.relativePath
+ );
+ const modules = dedupeModulesByName([
+ ...moduleCollector.modules,
+ ...additionalModules
+ ]);
+ for (const module2 of modules) {
+ const modulePath = path8.join(
+ path8.dirname(resolvedEntryPointPath),
+ module2.name
+ );
+ fs5.mkdirSync(path8.dirname(modulePath), { recursive: true });
+ fs5.writeFileSync(modulePath, module2.content);
+ }
+ return {
+ modules,
+ dependencies: entryPoint.dependencies,
+ resolvedEntryPointPath,
+ bundleType,
+ stop,
+ sourceMapPath,
+ sourceMapMetadata: {
+ tmpDir: tmpDirPath,
+ entryDirectory: entry.directory
+ },
+ moduleCollector
+ };
+}
+__name(bundleWorker, "bundleWorker");
+async function applyMiddlewareLoaderFacade(entry, tmpDirPath, middleware, doBindings) {
+ const middlewareIdentifiers = middleware.map((m, index) => [
+ `__MIDDLEWARE_${index}__`,
+ path8.resolve(getBasePath(), m.path)
+ ]);
+ const dynamicFacadePath = path8.join(
+ tmpDirPath,
+ "middleware-insertion-facade.js"
+ );
+ const imports = middlewareIdentifiers.map(
+ ([id, middlewarePath]) => (
+ /*javascript*/
+ `import * as ${id} from "${prepareFilePath(
+ middlewarePath
+ )}";`
+ )
+ ).join("\n");
+ const middlewareFns = middlewareIdentifiers.map(([m]) => `${m}.default`);
+ if (entry.format === "modules") {
+ const middlewareWrappers = middlewareIdentifiers.map(([m]) => `${m}.wrap`).join(",");
+ const durableObjects = doBindings.filter((b) => !b.script_name).map(
+ (b) => (
+ /*javascript*/
+ `export const ${b.class_name} = maskDurableObjectDefinition(OTHER_EXPORTS.${b.class_name});`
+ )
+ ).join("\n");
+ await fs5.promises.writeFile(
+ dynamicFacadePath,
+ dedent`
+ import worker, * as OTHER_EXPORTS from "${prepareFilePath(entry.file)}";
+ ${imports}
+ const envWrappers = [${middlewareWrappers}].filter(Boolean);
+ const facade = {
+ ...worker,
+ envWrappers,
+ middleware: [
+ ${middlewareFns.join(",")},
+ ...(worker.middleware ? worker.middleware : []),
+ ].filter(Boolean)
+ }
+ export * from "${prepareFilePath(entry.file)}";
+
+ const maskDurableObjectDefinition = (cls) =>
+ class extends cls {
+ constructor(state, env) {
+ let wrappedEnv = env
+ for (const wrapFn of envWrappers) {
+ wrappedEnv = wrapFn(wrappedEnv)
+ }
+ super(state, wrappedEnv);
+ }
+ };
+ ${durableObjects}
+
+ export default facade;
+ `
+ );
+ const targetPathLoader = path8.join(
+ tmpDirPath,
+ "middleware-loader.entry.ts"
+ );
+ const loaderPath = path8.resolve(
+ getBasePath(),
+ "templates/middleware/loader-modules.ts"
+ );
+ const baseLoader = await fs5.promises.readFile(loaderPath, "utf-8");
+ const transformedLoader = baseLoader.replaceAll("__ENTRY_POINT__", prepareFilePath(dynamicFacadePath)).replace(
+ "./common",
+ prepareFilePath(
+ path8.resolve(getBasePath(), "templates/middleware/common.ts")
+ )
+ );
+ await fs5.promises.writeFile(targetPathLoader, transformedLoader);
+ return {
+ ...entry,
+ file: targetPathLoader
+ };
+ } else {
+ const loaderSwPath = path8.resolve(
+ getBasePath(),
+ "templates/middleware/loader-sw.ts"
+ );
+ await fs5.promises.writeFile(
+ dynamicFacadePath,
+ dedent`
+ import { __facade_registerInternal__ } from "${prepareFilePath(loaderSwPath)}";
+ ${imports}
+ __facade_registerInternal__([${middlewareFns}])
+ `
+ );
+ return {
+ ...entry,
+ inject: [dynamicFacadePath]
+ };
+ }
+}
+__name(applyMiddlewareLoaderFacade, "applyMiddlewareLoaderFacade");
+function dedupeModulesByName(modules) {
+ return Object.values(
+ modules.reduce((moduleMap, module2) => {
+ moduleMap[module2.name] = module2;
+ return moduleMap;
+ }, {})
+ );
+}
+__name(dedupeModulesByName, "dedupeModulesByName");
+function prepareFilePath(filePath) {
+ return JSON.stringify(filePath).slice(1, -1);
+}
+__name(prepareFilePath, "prepareFilePath");
+
+// src/deployment-bundle/guess-worker-format.ts
+async function guessWorkerFormat(entryFile, entryWorkingDirectory, hint, tsconfig) {
+ const result = await esbuild2.build({
+ ...COMMON_ESBUILD_OPTIONS,
+ entryPoints: [entryFile],
+ absWorkingDir: entryWorkingDirectory,
+ metafile: true,
+ bundle: false,
+ write: false,
+ ...tsconfig && { tsconfig }
+ });
+ const metafile = result.metafile;
+ const { exports: exports2 } = getEntryPointFromMetafile(entryFile, metafile);
+ let guessedWorkerFormat;
+ if (exports2.length > 0) {
+ if (exports2.includes("default")) {
+ guessedWorkerFormat = "modules";
+ } else {
+ logger.warn(
+ `The entrypoint ${import_node_path9.default.relative(
+ process.cwd(),
+ entryFile
+ )} has exports like an ES Module, but hasn't defined a default export like a module worker normally would. Building the worker using "service-worker" format...`
+ );
+ guessedWorkerFormat = "service-worker";
+ }
+ } else {
+ guessedWorkerFormat = "service-worker";
+ }
+ if (hint) {
+ if (hint !== guessedWorkerFormat) {
+ if (hint === "service-worker") {
+ throw new Error(
+ "You configured this worker to be a 'service-worker', but the file you are trying to build appears to have a `default` export like a module worker. Please pass `--format modules`, or simply remove the configuration."
+ );
+ } else {
+ throw new Error(
+ "You configured this worker to be 'modules', but the file you are trying to build doesn't export a handler. Please pass `--format service-worker`, or simply remove the configuration."
+ );
+ }
+ }
+ }
+ return guessedWorkerFormat;
+}
+__name(guessWorkerFormat, "guessWorkerFormat");
+
+// src/deployment-bundle/run-custom-build.ts
+init_import_meta_url();
+var import_node_fs5 = require("node:fs");
+var import_node_path12 = __toESM(require("node:path"));
+
+// ../../node_modules/.pnpm/execa@6.1.0/node_modules/execa/index.js
+init_import_meta_url();
+var import_node_buffer = require("node:buffer");
+var import_node_path11 = __toESM(require("node:path"), 1);
+var import_node_child_process = __toESM(require("node:child_process"), 1);
+var import_node_process3 = __toESM(require("node:process"), 1);
+var import_cross_spawn = __toESM(require_cross_spawn(), 1);
+
+// ../../node_modules/.pnpm/strip-final-newline@3.0.0/node_modules/strip-final-newline/index.js
+init_import_meta_url();
+function stripFinalNewline(input) {
+ const LF = typeof input === "string" ? "\n" : "\n".charCodeAt();
+ const CR = typeof input === "string" ? "\r" : "\r".charCodeAt();
+ if (input[input.length - 1] === LF) {
+ input = input.slice(0, -1);
+ }
+ if (input[input.length - 1] === CR) {
+ input = input.slice(0, -1);
+ }
+ return input;
+}
+__name(stripFinalNewline, "stripFinalNewline");
+
+// ../../node_modules/.pnpm/npm-run-path@5.1.0/node_modules/npm-run-path/index.js
+init_import_meta_url();
+var import_node_process2 = __toESM(require("node:process"), 1);
+var import_node_path10 = __toESM(require("node:path"), 1);
+var import_node_url5 = __toESM(require("node:url"), 1);
+
+// ../../node_modules/.pnpm/path-key@4.0.0/node_modules/path-key/index.js
+init_import_meta_url();
+function pathKey(options14 = {}) {
+ const {
+ env: env5 = process.env,
+ platform = process.platform
+ } = options14;
+ if (platform !== "win32") {
+ return "PATH";
+ }
+ return Object.keys(env5).reverse().find((key) => key.toUpperCase() === "PATH") || "Path";
+}
+__name(pathKey, "pathKey");
+
+// ../../node_modules/.pnpm/npm-run-path@5.1.0/node_modules/npm-run-path/index.js
+function npmRunPath(options14 = {}) {
+ const {
+ cwd: cwd2 = import_node_process2.default.cwd(),
+ path: path_ = import_node_process2.default.env[pathKey()],
+ execPath = import_node_process2.default.execPath
+ } = options14;
+ let previous;
+ const cwdString = cwd2 instanceof URL ? import_node_url5.default.fileURLToPath(cwd2) : cwd2;
+ let cwdPath = import_node_path10.default.resolve(cwdString);
+ const result = [];
+ while (previous !== cwdPath) {
+ result.push(import_node_path10.default.join(cwdPath, "node_modules/.bin"));
+ previous = cwdPath;
+ cwdPath = import_node_path10.default.resolve(cwdPath, "..");
+ }
+ result.push(import_node_path10.default.resolve(cwdString, execPath, ".."));
+ return [...result, path_].join(import_node_path10.default.delimiter);
+}
+__name(npmRunPath, "npmRunPath");
+function npmRunPathEnv({ env: env5 = import_node_process2.default.env, ...options14 } = {}) {
+ env5 = { ...env5 };
+ const path45 = pathKey({ env: env5 });
+ options14.path = env5[path45];
+ env5[path45] = npmRunPath(options14);
+ return env5;
+}
+__name(npmRunPathEnv, "npmRunPathEnv");
+
+// ../../node_modules/.pnpm/onetime@6.0.0/node_modules/onetime/index.js
+init_import_meta_url();
+
+// ../../node_modules/.pnpm/mimic-fn@4.0.0/node_modules/mimic-fn/index.js
+init_import_meta_url();
+var copyProperty = /* @__PURE__ */ __name((to, from, property, ignoreNonConfigurable) => {
+ if (property === "length" || property === "prototype") {
+ return;
+ }
+ if (property === "arguments" || property === "caller") {
+ return;
+ }
+ const toDescriptor = Object.getOwnPropertyDescriptor(to, property);
+ const fromDescriptor = Object.getOwnPropertyDescriptor(from, property);
+ if (!canCopyProperty(toDescriptor, fromDescriptor) && ignoreNonConfigurable) {
+ return;
+ }
+ Object.defineProperty(to, property, fromDescriptor);
+}, "copyProperty");
+var canCopyProperty = /* @__PURE__ */ __name(function(toDescriptor, fromDescriptor) {
+ return toDescriptor === void 0 || toDescriptor.configurable || toDescriptor.writable === fromDescriptor.writable && toDescriptor.enumerable === fromDescriptor.enumerable && toDescriptor.configurable === fromDescriptor.configurable && (toDescriptor.writable || toDescriptor.value === fromDescriptor.value);
+}, "canCopyProperty");
+var changePrototype = /* @__PURE__ */ __name((to, from) => {
+ const fromPrototype = Object.getPrototypeOf(from);
+ if (fromPrototype === Object.getPrototypeOf(to)) {
+ return;
+ }
+ Object.setPrototypeOf(to, fromPrototype);
+}, "changePrototype");
+var wrappedToString = /* @__PURE__ */ __name((withName, fromBody) => `/* Wrapped ${withName}*/
+${fromBody}`, "wrappedToString");
+var toStringDescriptor = Object.getOwnPropertyDescriptor(Function.prototype, "toString");
+var toStringName = Object.getOwnPropertyDescriptor(Function.prototype.toString, "name");
+var changeToString = /* @__PURE__ */ __name((to, from, name) => {
+ const withName = name === "" ? "" : `with ${name.trim()}() `;
+ const newToString = wrappedToString.bind(null, withName, from.toString());
+ Object.defineProperty(newToString, "name", toStringName);
+ Object.defineProperty(to, "toString", { ...toStringDescriptor, value: newToString });
+}, "changeToString");
+function mimicFunction(to, from, { ignoreNonConfigurable = false } = {}) {
+ const { name } = to;
+ for (const property of Reflect.ownKeys(from)) {
+ copyProperty(to, from, property, ignoreNonConfigurable);
+ }
+ changePrototype(to, from);
+ changeToString(to, from, name);
+ return to;
+}
+__name(mimicFunction, "mimicFunction");
+
+// ../../node_modules/.pnpm/onetime@6.0.0/node_modules/onetime/index.js
+var calledFunctions = /* @__PURE__ */ new WeakMap();
+var onetime = /* @__PURE__ */ __name((function_, options14 = {}) => {
+ if (typeof function_ !== "function") {
+ throw new TypeError("Expected a function");
+ }
+ let returnValue;
+ let callCount = 0;
+ const functionName = function_.displayName || function_.name || "";
+ const onetime2 = /* @__PURE__ */ __name(function(...arguments_) {
+ calledFunctions.set(onetime2, ++callCount);
+ if (callCount === 1) {
+ returnValue = function_.apply(this, arguments_);
+ function_ = null;
+ } else if (options14.throw === true) {
+ throw new Error(`Function \`${functionName}\` can only be called once`);
+ }
+ return returnValue;
+ }, "onetime");
+ mimicFunction(onetime2, function_);
+ calledFunctions.set(onetime2, callCount);
+ return onetime2;
+}, "onetime");
+onetime.callCount = (function_) => {
+ if (!calledFunctions.has(function_)) {
+ throw new Error(`The given function \`${function_.name}\` is not wrapped by the \`onetime\` package`);
+ }
+ return calledFunctions.get(function_);
+};
+var onetime_default = onetime;
+
+// ../../node_modules/.pnpm/execa@6.1.0/node_modules/execa/lib/error.js
+init_import_meta_url();
+
+// ../../node_modules/.pnpm/human-signals@3.0.1/node_modules/human-signals/build/src/main.js
+init_import_meta_url();
+var import_os2 = require("os");
+
+// ../../node_modules/.pnpm/human-signals@3.0.1/node_modules/human-signals/build/src/realtime.js
+init_import_meta_url();
+var getRealtimeSignals = /* @__PURE__ */ __name(function() {
+ const length = SIGRTMAX - SIGRTMIN + 1;
+ return Array.from({ length }, getRealtimeSignal);
+}, "getRealtimeSignals");
+var getRealtimeSignal = /* @__PURE__ */ __name(function(value, index) {
+ return {
+ name: `SIGRT${index + 1}`,
+ number: SIGRTMIN + index,
+ action: "terminate",
+ description: "Application-specific signal (realtime)",
+ standard: "posix"
+ };
+}, "getRealtimeSignal");
+var SIGRTMIN = 34;
+var SIGRTMAX = 64;
+
+// ../../node_modules/.pnpm/human-signals@3.0.1/node_modules/human-signals/build/src/signals.js
+init_import_meta_url();
+var import_os = require("os");
+
+// ../../node_modules/.pnpm/human-signals@3.0.1/node_modules/human-signals/build/src/core.js
+init_import_meta_url();
+var SIGNALS = [
+ {
+ name: "SIGHUP",
+ number: 1,
+ action: "terminate",
+ description: "Terminal closed",
+ standard: "posix"
+ },
+ {
+ name: "SIGINT",
+ number: 2,
+ action: "terminate",
+ description: "User interruption with CTRL-C",
+ standard: "ansi"
+ },
+ {
+ name: "SIGQUIT",
+ number: 3,
+ action: "core",
+ description: "User interruption with CTRL-\\",
+ standard: "posix"
+ },
+ {
+ name: "SIGILL",
+ number: 4,
+ action: "core",
+ description: "Invalid machine instruction",
+ standard: "ansi"
+ },
+ {
+ name: "SIGTRAP",
+ number: 5,
+ action: "core",
+ description: "Debugger breakpoint",
+ standard: "posix"
+ },
+ {
+ name: "SIGABRT",
+ number: 6,
+ action: "core",
+ description: "Aborted",
+ standard: "ansi"
+ },
+ {
+ name: "SIGIOT",
+ number: 6,
+ action: "core",
+ description: "Aborted",
+ standard: "bsd"
+ },
+ {
+ name: "SIGBUS",
+ number: 7,
+ action: "core",
+ description: "Bus error due to misaligned, non-existing address or paging error",
+ standard: "bsd"
+ },
+ {
+ name: "SIGEMT",
+ number: 7,
+ action: "terminate",
+ description: "Command should be emulated but is not implemented",
+ standard: "other"
+ },
+ {
+ name: "SIGFPE",
+ number: 8,
+ action: "core",
+ description: "Floating point arithmetic error",
+ standard: "ansi"
+ },
+ {
+ name: "SIGKILL",
+ number: 9,
+ action: "terminate",
+ description: "Forced termination",
+ standard: "posix",
+ forced: true
+ },
+ {
+ name: "SIGUSR1",
+ number: 10,
+ action: "terminate",
+ description: "Application-specific signal",
+ standard: "posix"
+ },
+ {
+ name: "SIGSEGV",
+ number: 11,
+ action: "core",
+ description: "Segmentation fault",
+ standard: "ansi"
+ },
+ {
+ name: "SIGUSR2",
+ number: 12,
+ action: "terminate",
+ description: "Application-specific signal",
+ standard: "posix"
+ },
+ {
+ name: "SIGPIPE",
+ number: 13,
+ action: "terminate",
+ description: "Broken pipe or socket",
+ standard: "posix"
+ },
+ {
+ name: "SIGALRM",
+ number: 14,
+ action: "terminate",
+ description: "Timeout or timer",
+ standard: "posix"
+ },
+ {
+ name: "SIGTERM",
+ number: 15,
+ action: "terminate",
+ description: "Termination",
+ standard: "ansi"
+ },
+ {
+ name: "SIGSTKFLT",
+ number: 16,
+ action: "terminate",
+ description: "Stack is empty or overflowed",
+ standard: "other"
+ },
+ {
+ name: "SIGCHLD",
+ number: 17,
+ action: "ignore",
+ description: "Child process terminated, paused or unpaused",
+ standard: "posix"
+ },
+ {
+ name: "SIGCLD",
+ number: 17,
+ action: "ignore",
+ description: "Child process terminated, paused or unpaused",
+ standard: "other"
+ },
+ {
+ name: "SIGCONT",
+ number: 18,
+ action: "unpause",
+ description: "Unpaused",
+ standard: "posix",
+ forced: true
+ },
+ {
+ name: "SIGSTOP",
+ number: 19,
+ action: "pause",
+ description: "Paused",
+ standard: "posix",
+ forced: true
+ },
+ {
+ name: "SIGTSTP",
+ number: 20,
+ action: "pause",
+ description: 'Paused using CTRL-Z or "suspend"',
+ standard: "posix"
+ },
+ {
+ name: "SIGTTIN",
+ number: 21,
+ action: "pause",
+ description: "Background process cannot read terminal input",
+ standard: "posix"
+ },
+ {
+ name: "SIGBREAK",
+ number: 21,
+ action: "terminate",
+ description: "User interruption with CTRL-BREAK",
+ standard: "other"
+ },
+ {
+ name: "SIGTTOU",
+ number: 22,
+ action: "pause",
+ description: "Background process cannot write to terminal output",
+ standard: "posix"
+ },
+ {
+ name: "SIGURG",
+ number: 23,
+ action: "ignore",
+ description: "Socket received out-of-band data",
+ standard: "bsd"
+ },
+ {
+ name: "SIGXCPU",
+ number: 24,
+ action: "core",
+ description: "Process timed out",
+ standard: "bsd"
+ },
+ {
+ name: "SIGXFSZ",
+ number: 25,
+ action: "core",
+ description: "File too big",
+ standard: "bsd"
+ },
+ {
+ name: "SIGVTALRM",
+ number: 26,
+ action: "terminate",
+ description: "Timeout or timer",
+ standard: "bsd"
+ },
+ {
+ name: "SIGPROF",
+ number: 27,
+ action: "terminate",
+ description: "Timeout or timer",
+ standard: "bsd"
+ },
+ {
+ name: "SIGWINCH",
+ number: 28,
+ action: "ignore",
+ description: "Terminal window size changed",
+ standard: "bsd"
+ },
+ {
+ name: "SIGIO",
+ number: 29,
+ action: "terminate",
+ description: "I/O is available",
+ standard: "other"
+ },
+ {
+ name: "SIGPOLL",
+ number: 29,
+ action: "terminate",
+ description: "Watched event",
+ standard: "other"
+ },
+ {
+ name: "SIGINFO",
+ number: 29,
+ action: "ignore",
+ description: "Request for process information",
+ standard: "other"
+ },
+ {
+ name: "SIGPWR",
+ number: 30,
+ action: "terminate",
+ description: "Device running out of power",
+ standard: "systemv"
+ },
+ {
+ name: "SIGSYS",
+ number: 31,
+ action: "core",
+ description: "Invalid system call",
+ standard: "other"
+ },
+ {
+ name: "SIGUNUSED",
+ number: 31,
+ action: "terminate",
+ description: "Invalid system call",
+ standard: "other"
+ }
+];
+
+// ../../node_modules/.pnpm/human-signals@3.0.1/node_modules/human-signals/build/src/signals.js
+var getSignals = /* @__PURE__ */ __name(function() {
+ const realtimeSignals = getRealtimeSignals();
+ const signals = [...SIGNALS, ...realtimeSignals].map(normalizeSignal);
+ return signals;
+}, "getSignals");
+var normalizeSignal = /* @__PURE__ */ __name(function({
+ name,
+ number: defaultNumber,
+ description,
+ action,
+ forced = false,
+ standard
+}) {
+ const {
+ signals: { [name]: constantSignal }
+ } = import_os.constants;
+ const supported = constantSignal !== void 0;
+ const number = supported ? constantSignal : defaultNumber;
+ return { name, number, description, supported, action, forced, standard };
+}, "normalizeSignal");
+
+// ../../node_modules/.pnpm/human-signals@3.0.1/node_modules/human-signals/build/src/main.js
+var getSignalsByName = /* @__PURE__ */ __name(function() {
+ const signals = getSignals();
+ return signals.reduce(getSignalByName, {});
+}, "getSignalsByName");
+var getSignalByName = /* @__PURE__ */ __name(function(signalByNameMemo, { name, number, description, supported, action, forced, standard }) {
+ return {
+ ...signalByNameMemo,
+ [name]: { name, number, description, supported, action, forced, standard }
+ };
+}, "getSignalByName");
+var signalsByName = getSignalsByName();
+var getSignalsByNumber = /* @__PURE__ */ __name(function() {
+ const signals = getSignals();
+ const length = SIGRTMAX + 1;
+ const signalsA = Array.from({ length }, (value, number) => getSignalByNumber(number, signals));
+ return Object.assign({}, ...signalsA);
+}, "getSignalsByNumber");
+var getSignalByNumber = /* @__PURE__ */ __name(function(number, signals) {
+ const signal = findSignalByNumber(number, signals);
+ if (signal === void 0) {
+ return {};
+ }
+ const { name, description, supported, action, forced, standard } = signal;
+ return {
+ [number]: {
+ name,
+ number,
+ description,
+ supported,
+ action,
+ forced,
+ standard
+ }
+ };
+}, "getSignalByNumber");
+var findSignalByNumber = /* @__PURE__ */ __name(function(number, signals) {
+ const signal = signals.find(({ name }) => import_os2.constants.signals[name] === number);
+ if (signal !== void 0) {
+ return signal;
+ }
+ return signals.find((signalA) => signalA.number === number);
+}, "findSignalByNumber");
+var signalsByNumber = getSignalsByNumber();
+
+// ../../node_modules/.pnpm/execa@6.1.0/node_modules/execa/lib/error.js
+var getErrorPrefix = /* @__PURE__ */ __name(({ timedOut, timeout, errorCode, signal, signalDescription, exitCode, isCanceled }) => {
+ if (timedOut) {
+ return `timed out after ${timeout} milliseconds`;
+ }
+ if (isCanceled) {
+ return "was canceled";
+ }
+ if (errorCode !== void 0) {
+ return `failed with ${errorCode}`;
+ }
+ if (signal !== void 0) {
+ return `was killed with ${signal} (${signalDescription})`;
+ }
+ if (exitCode !== void 0) {
+ return `failed with exit code ${exitCode}`;
+ }
+ return "failed";
+}, "getErrorPrefix");
+var makeError = /* @__PURE__ */ __name(({
+ stdout,
+ stderr,
+ all: all2,
+ error,
+ signal,
+ exitCode,
+ command: command2,
+ escapedCommand,
+ timedOut,
+ isCanceled,
+ killed,
+ parsed: { options: { timeout } }
+}) => {
+ exitCode = exitCode === null ? void 0 : exitCode;
+ signal = signal === null ? void 0 : signal;
+ const signalDescription = signal === void 0 ? void 0 : signalsByName[signal].description;
+ const errorCode = error && error.code;
+ const prefix = getErrorPrefix({ timedOut, timeout, errorCode, signal, signalDescription, exitCode, isCanceled });
+ const execaMessage = `Command ${prefix}: ${command2}`;
+ const isError = Object.prototype.toString.call(error) === "[object Error]";
+ const shortMessage = isError ? `${execaMessage}
+${error.message}` : execaMessage;
+ const message = [shortMessage, stderr, stdout].filter(Boolean).join("\n");
+ if (isError) {
+ error.originalMessage = error.message;
+ error.message = message;
+ } else {
+ error = new Error(message);
+ }
+ error.shortMessage = shortMessage;
+ error.command = command2;
+ error.escapedCommand = escapedCommand;
+ error.exitCode = exitCode;
+ error.signal = signal;
+ error.signalDescription = signalDescription;
+ error.stdout = stdout;
+ error.stderr = stderr;
+ if (all2 !== void 0) {
+ error.all = all2;
+ }
+ if ("bufferedData" in error) {
+ delete error.bufferedData;
+ }
+ error.failed = true;
+ error.timedOut = Boolean(timedOut);
+ error.isCanceled = isCanceled;
+ error.killed = killed && !timedOut;
+ return error;
+}, "makeError");
+
+// ../../node_modules/.pnpm/execa@6.1.0/node_modules/execa/lib/stdio.js
+init_import_meta_url();
+var aliases = ["stdin", "stdout", "stderr"];
+var hasAlias = /* @__PURE__ */ __name((options14) => aliases.some((alias) => options14[alias] !== void 0), "hasAlias");
+var normalizeStdio = /* @__PURE__ */ __name((options14) => {
+ if (!options14) {
+ return;
+ }
+ const { stdio } = options14;
+ if (stdio === void 0) {
+ return aliases.map((alias) => options14[alias]);
+ }
+ if (hasAlias(options14)) {
+ throw new Error(`It's not possible to provide \`stdio\` in combination with one of ${aliases.map((alias) => `\`${alias}\``).join(", ")}`);
+ }
+ if (typeof stdio === "string") {
+ return stdio;
+ }
+ if (!Array.isArray(stdio)) {
+ throw new TypeError(`Expected \`stdio\` to be of type \`string\` or \`Array\`, got \`${typeof stdio}\``);
+ }
+ const length = Math.max(stdio.length, aliases.length);
+ return Array.from({ length }, (value, index) => stdio[index]);
+}, "normalizeStdio");
+
+// ../../node_modules/.pnpm/execa@6.1.0/node_modules/execa/lib/kill.js
+init_import_meta_url();
+var import_node_os3 = __toESM(require("node:os"), 1);
+var import_signal_exit = __toESM(require_signal_exit(), 1);
+var DEFAULT_FORCE_KILL_TIMEOUT = 1e3 * 5;
+var spawnedKill = /* @__PURE__ */ __name((kill, signal = "SIGTERM", options14 = {}) => {
+ const killResult = kill(signal);
+ setKillTimeout(kill, signal, options14, killResult);
+ return killResult;
+}, "spawnedKill");
+var setKillTimeout = /* @__PURE__ */ __name((kill, signal, options14, killResult) => {
+ if (!shouldForceKill(signal, options14, killResult)) {
+ return;
+ }
+ const timeout = getForceKillAfterTimeout(options14);
+ const t2 = setTimeout(() => {
+ kill("SIGKILL");
+ }, timeout);
+ if (t2.unref) {
+ t2.unref();
+ }
+}, "setKillTimeout");
+var shouldForceKill = /* @__PURE__ */ __name((signal, { forceKillAfterTimeout }, killResult) => isSigterm(signal) && forceKillAfterTimeout !== false && killResult, "shouldForceKill");
+var isSigterm = /* @__PURE__ */ __name((signal) => signal === import_node_os3.default.constants.signals.SIGTERM || typeof signal === "string" && signal.toUpperCase() === "SIGTERM", "isSigterm");
+var getForceKillAfterTimeout = /* @__PURE__ */ __name(({ forceKillAfterTimeout = true }) => {
+ if (forceKillAfterTimeout === true) {
+ return DEFAULT_FORCE_KILL_TIMEOUT;
+ }
+ if (!Number.isFinite(forceKillAfterTimeout) || forceKillAfterTimeout < 0) {
+ throw new TypeError(`Expected the \`forceKillAfterTimeout\` option to be a non-negative integer, got \`${forceKillAfterTimeout}\` (${typeof forceKillAfterTimeout})`);
+ }
+ return forceKillAfterTimeout;
+}, "getForceKillAfterTimeout");
+var spawnedCancel = /* @__PURE__ */ __name((spawned, context2) => {
+ const killResult = spawned.kill();
+ if (killResult) {
+ context2.isCanceled = true;
+ }
+}, "spawnedCancel");
+var timeoutKill = /* @__PURE__ */ __name((spawned, signal, reject) => {
+ spawned.kill(signal);
+ reject(Object.assign(new Error("Timed out"), { timedOut: true, signal }));
+}, "timeoutKill");
+var setupTimeout = /* @__PURE__ */ __name((spawned, { timeout, killSignal = "SIGTERM" }, spawnedPromise) => {
+ if (timeout === 0 || timeout === void 0) {
+ return spawnedPromise;
+ }
+ let timeoutId;
+ const timeoutPromise = new Promise((resolve18, reject) => {
+ timeoutId = setTimeout(() => {
+ timeoutKill(spawned, killSignal, reject);
+ }, timeout);
+ });
+ const safeSpawnedPromise = spawnedPromise.finally(() => {
+ clearTimeout(timeoutId);
+ });
+ return Promise.race([timeoutPromise, safeSpawnedPromise]);
+}, "setupTimeout");
+var validateTimeout = /* @__PURE__ */ __name(({ timeout }) => {
+ if (timeout !== void 0 && (!Number.isFinite(timeout) || timeout < 0)) {
+ throw new TypeError(`Expected the \`timeout\` option to be a non-negative integer, got \`${timeout}\` (${typeof timeout})`);
+ }
+}, "validateTimeout");
+var setExitHandler = /* @__PURE__ */ __name(async (spawned, { cleanup, detached }, timedPromise) => {
+ if (!cleanup || detached) {
+ return timedPromise;
+ }
+ const removeExitHandler = (0, import_signal_exit.default)(() => {
+ spawned.kill();
+ });
+ return timedPromise.finally(() => {
+ removeExitHandler();
+ });
+}, "setExitHandler");
+
+// ../../node_modules/.pnpm/execa@6.1.0/node_modules/execa/lib/stream.js
+init_import_meta_url();
+
+// ../../node_modules/.pnpm/is-stream@3.0.0/node_modules/is-stream/index.js
+init_import_meta_url();
+function isStream(stream2) {
+ return stream2 !== null && typeof stream2 === "object" && typeof stream2.pipe === "function";
+}
+__name(isStream, "isStream");
+
+// ../../node_modules/.pnpm/execa@6.1.0/node_modules/execa/lib/stream.js
+var import_get_stream = __toESM(require_get_stream(), 1);
+var import_merge_stream = __toESM(require_merge_stream(), 1);
+var handleInput = /* @__PURE__ */ __name((spawned, input) => {
+ if (input === void 0 || spawned.stdin === void 0) {
+ return;
+ }
+ if (isStream(input)) {
+ input.pipe(spawned.stdin);
+ } else {
+ spawned.stdin.end(input);
+ }
+}, "handleInput");
+var makeAllStream = /* @__PURE__ */ __name((spawned, { all: all2 }) => {
+ if (!all2 || !spawned.stdout && !spawned.stderr) {
+ return;
+ }
+ const mixed = (0, import_merge_stream.default)();
+ if (spawned.stdout) {
+ mixed.add(spawned.stdout);
+ }
+ if (spawned.stderr) {
+ mixed.add(spawned.stderr);
+ }
+ return mixed;
+}, "makeAllStream");
+var getBufferedData = /* @__PURE__ */ __name(async (stream2, streamPromise) => {
+ if (!stream2) {
+ return;
+ }
+ stream2.destroy();
+ try {
+ return await streamPromise;
+ } catch (error) {
+ return error.bufferedData;
+ }
+}, "getBufferedData");
+var getStreamPromise = /* @__PURE__ */ __name((stream2, { encoding, buffer, maxBuffer }) => {
+ if (!stream2 || !buffer) {
+ return;
+ }
+ if (encoding) {
+ return (0, import_get_stream.default)(stream2, { encoding, maxBuffer });
+ }
+ return import_get_stream.default.buffer(stream2, { maxBuffer });
+}, "getStreamPromise");
+var getSpawnedResult = /* @__PURE__ */ __name(async ({ stdout, stderr, all: all2 }, { encoding, buffer, maxBuffer }, processDone) => {
+ const stdoutPromise = getStreamPromise(stdout, { encoding, buffer, maxBuffer });
+ const stderrPromise = getStreamPromise(stderr, { encoding, buffer, maxBuffer });
+ const allPromise = getStreamPromise(all2, { encoding, buffer, maxBuffer: maxBuffer * 2 });
+ try {
+ return await Promise.all([processDone, stdoutPromise, stderrPromise, allPromise]);
+ } catch (error) {
+ return Promise.all([
+ { error, signal: error.signal, timedOut: error.timedOut },
+ getBufferedData(stdout, stdoutPromise),
+ getBufferedData(stderr, stderrPromise),
+ getBufferedData(all2, allPromise)
+ ]);
+ }
+}, "getSpawnedResult");
+var validateInputSync = /* @__PURE__ */ __name(({ input }) => {
+ if (isStream(input)) {
+ throw new TypeError("The `input` option cannot be a stream in sync mode");
+ }
+}, "validateInputSync");
+
+// ../../node_modules/.pnpm/execa@6.1.0/node_modules/execa/lib/promise.js
+init_import_meta_url();
+var nativePromisePrototype = (async () => {
+})().constructor.prototype;
+var descriptors = ["then", "catch", "finally"].map((property) => [
+ property,
+ Reflect.getOwnPropertyDescriptor(nativePromisePrototype, property)
+]);
+var mergePromise = /* @__PURE__ */ __name((spawned, promise) => {
+ for (const [property, descriptor2] of descriptors) {
+ const value = typeof promise === "function" ? (...args) => Reflect.apply(descriptor2.value, promise(), args) : descriptor2.value.bind(promise);
+ Reflect.defineProperty(spawned, property, { ...descriptor2, value });
+ }
+ return spawned;
+}, "mergePromise");
+var getSpawnedPromise = /* @__PURE__ */ __name((spawned) => new Promise((resolve18, reject) => {
+ spawned.on("exit", (exitCode, signal) => {
+ resolve18({ exitCode, signal });
+ });
+ spawned.on("error", (error) => {
+ reject(error);
+ });
+ if (spawned.stdin) {
+ spawned.stdin.on("error", (error) => {
+ reject(error);
+ });
+ }
+}), "getSpawnedPromise");
+
+// ../../node_modules/.pnpm/execa@6.1.0/node_modules/execa/lib/command.js
+init_import_meta_url();
+var normalizeArgs = /* @__PURE__ */ __name((file, args = []) => {
+ if (!Array.isArray(args)) {
+ return [file];
+ }
+ return [file, ...args];
+}, "normalizeArgs");
+var NO_ESCAPE_REGEXP = /^[\w.-]+$/;
+var DOUBLE_QUOTES_REGEXP = /"/g;
+var escapeArg = /* @__PURE__ */ __name((arg) => {
+ if (typeof arg !== "string" || NO_ESCAPE_REGEXP.test(arg)) {
+ return arg;
+ }
+ return `"${arg.replace(DOUBLE_QUOTES_REGEXP, '\\"')}"`;
+}, "escapeArg");
+var joinCommand = /* @__PURE__ */ __name((file, args) => normalizeArgs(file, args).join(" "), "joinCommand");
+var getEscapedCommand = /* @__PURE__ */ __name((file, args) => normalizeArgs(file, args).map((arg) => escapeArg(arg)).join(" "), "getEscapedCommand");
+var SPACES_REGEXP = / +/g;
+var parseCommand = /* @__PURE__ */ __name((command2) => {
+ const tokens = [];
+ for (const token of command2.trim().split(SPACES_REGEXP)) {
+ const previousToken = tokens[tokens.length - 1];
+ if (previousToken && previousToken.endsWith("\\")) {
+ tokens[tokens.length - 1] = `${previousToken.slice(0, -1)} ${token}`;
+ } else {
+ tokens.push(token);
+ }
+ }
+ return tokens;
+}, "parseCommand");
+
+// ../../node_modules/.pnpm/execa@6.1.0/node_modules/execa/index.js
+var DEFAULT_MAX_BUFFER = 1e3 * 1e3 * 100;
+var getEnv = /* @__PURE__ */ __name(({ env: envOption, extendEnv, preferLocal, localDir, execPath }) => {
+ const env5 = extendEnv ? { ...import_node_process3.default.env, ...envOption } : envOption;
+ if (preferLocal) {
+ return npmRunPathEnv({ env: env5, cwd: localDir, execPath });
+ }
+ return env5;
+}, "getEnv");
+var handleArguments = /* @__PURE__ */ __name((file, args, options14 = {}) => {
+ const parsed = import_cross_spawn.default._parse(file, args, options14);
+ file = parsed.command;
+ args = parsed.args;
+ options14 = parsed.options;
+ options14 = {
+ maxBuffer: DEFAULT_MAX_BUFFER,
+ buffer: true,
+ stripFinalNewline: true,
+ extendEnv: true,
+ preferLocal: false,
+ localDir: options14.cwd || import_node_process3.default.cwd(),
+ execPath: import_node_process3.default.execPath,
+ encoding: "utf8",
+ reject: true,
+ cleanup: true,
+ all: false,
+ windowsHide: true,
+ ...options14
+ };
+ options14.env = getEnv(options14);
+ options14.stdio = normalizeStdio(options14);
+ if (import_node_process3.default.platform === "win32" && import_node_path11.default.basename(file, ".exe") === "cmd") {
+ args.unshift("/q");
+ }
+ return { file, args, options: options14, parsed };
+}, "handleArguments");
+var handleOutput = /* @__PURE__ */ __name((options14, value, error) => {
+ if (typeof value !== "string" && !import_node_buffer.Buffer.isBuffer(value)) {
+ return error === void 0 ? void 0 : "";
+ }
+ if (options14.stripFinalNewline) {
+ return stripFinalNewline(value);
+ }
+ return value;
+}, "handleOutput");
+function execa(file, args, options14) {
+ const parsed = handleArguments(file, args, options14);
+ const command2 = joinCommand(file, args);
+ const escapedCommand = getEscapedCommand(file, args);
+ validateTimeout(parsed.options);
+ let spawned;
+ try {
+ spawned = import_node_child_process.default.spawn(parsed.file, parsed.args, parsed.options);
+ } catch (error) {
+ const dummySpawned = new import_node_child_process.default.ChildProcess();
+ const errorPromise = Promise.reject(makeError({
+ error,
+ stdout: "",
+ stderr: "",
+ all: "",
+ command: command2,
+ escapedCommand,
+ parsed,
+ timedOut: false,
+ isCanceled: false,
+ killed: false
+ }));
+ return mergePromise(dummySpawned, errorPromise);
+ }
+ const spawnedPromise = getSpawnedPromise(spawned);
+ const timedPromise = setupTimeout(spawned, parsed.options, spawnedPromise);
+ const processDone = setExitHandler(spawned, parsed.options, timedPromise);
+ const context2 = { isCanceled: false };
+ spawned.kill = spawnedKill.bind(null, spawned.kill.bind(spawned));
+ spawned.cancel = spawnedCancel.bind(null, spawned, context2);
+ const handlePromise = /* @__PURE__ */ __name(async () => {
+ const [{ error, exitCode, signal, timedOut }, stdoutResult, stderrResult, allResult] = await getSpawnedResult(spawned, parsed.options, processDone);
+ const stdout = handleOutput(parsed.options, stdoutResult);
+ const stderr = handleOutput(parsed.options, stderrResult);
+ const all2 = handleOutput(parsed.options, allResult);
+ if (error || exitCode !== 0 || signal !== null) {
+ const returnedError = makeError({
+ error,
+ exitCode,
+ signal,
+ stdout,
+ stderr,
+ all: all2,
+ command: command2,
+ escapedCommand,
+ parsed,
+ timedOut,
+ isCanceled: context2.isCanceled || (parsed.options.signal ? parsed.options.signal.aborted : false),
+ killed: spawned.killed
+ });
+ if (!parsed.options.reject) {
+ return returnedError;
+ }
+ throw returnedError;
+ }
+ return {
+ command: command2,
+ escapedCommand,
+ exitCode: 0,
+ stdout,
+ stderr,
+ all: all2,
+ failed: false,
+ timedOut: false,
+ isCanceled: false,
+ killed: false
+ };
+ }, "handlePromise");
+ const handlePromiseOnce = onetime_default(handlePromise);
+ handleInput(spawned, parsed.options.input);
+ spawned.all = makeAllStream(spawned, parsed.options);
+ return mergePromise(spawned, handlePromiseOnce);
+}
+__name(execa, "execa");
+function execaSync(file, args, options14) {
+ const parsed = handleArguments(file, args, options14);
+ const command2 = joinCommand(file, args);
+ const escapedCommand = getEscapedCommand(file, args);
+ validateInputSync(parsed.options);
+ let result;
+ try {
+ result = import_node_child_process.default.spawnSync(parsed.file, parsed.args, parsed.options);
+ } catch (error) {
+ throw makeError({
+ error,
+ stdout: "",
+ stderr: "",
+ all: "",
+ command: command2,
+ escapedCommand,
+ parsed,
+ timedOut: false,
+ isCanceled: false,
+ killed: false
+ });
+ }
+ const stdout = handleOutput(parsed.options, result.stdout, result.error);
+ const stderr = handleOutput(parsed.options, result.stderr, result.error);
+ if (result.error || result.status !== 0 || result.signal !== null) {
+ const error = makeError({
+ stdout,
+ stderr,
+ error: result.error,
+ signal: result.signal,
+ exitCode: result.status,
+ command: command2,
+ escapedCommand,
+ parsed,
+ timedOut: result.error && result.error.code === "ETIMEDOUT",
+ isCanceled: false,
+ killed: result.signal !== null
+ });
+ if (!parsed.options.reject) {
+ return error;
+ }
+ throw error;
+ }
+ return {
+ command: command2,
+ escapedCommand,
+ exitCode: 0,
+ stdout,
+ stderr,
+ failed: false,
+ timedOut: false,
+ isCanceled: false,
+ killed: false
+ };
+}
+__name(execaSync, "execaSync");
+function execaCommand(command2, options14) {
+ const [file, ...args] = parseCommand(command2);
+ return execa(file, args, options14);
+}
+__name(execaCommand, "execaCommand");
+function execaCommandSync(command2, options14) {
+ const [file, ...args] = parseCommand(command2);
+ return execaSync(file, args, options14);
+}
+__name(execaCommandSync, "execaCommandSync");
+
+// src/deployment-bundle/run-custom-build.ts
+async function runCustomBuild(expectedEntryAbsolute, expectedEntryRelative, build5) {
+ if (build5.command) {
+ logger.log("Running custom build:", build5.command);
+ await execaCommand(build5.command, {
+ shell: true,
+ // we keep these two as "inherit" so that
+ // logs are still visible.
+ stdout: "inherit",
+ stderr: "inherit",
+ ...build5.cwd && { cwd: build5.cwd }
+ });
+ assertEntryPointExists(
+ expectedEntryAbsolute,
+ expectedEntryRelative,
+ `The expected output file at "${expectedEntryRelative}" was not found after running custom build: ${build5.command}.
+The \`main\` property in wrangler.toml should point to the file generated by the custom build.`
+ );
+ } else {
+ assertEntryPointExists(
+ expectedEntryAbsolute,
+ expectedEntryRelative,
+ `The entry-point file at "${expectedEntryRelative}" was not found.`
+ );
+ }
+}
+__name(runCustomBuild, "runCustomBuild");
+function assertEntryPointExists(expectedEntryAbsolute, expectedEntryRelative, errorMessage) {
+ if (!fileExists(expectedEntryAbsolute)) {
+ throw new Error(
+ getMissingEntryPointMessage(
+ errorMessage,
+ expectedEntryAbsolute,
+ expectedEntryRelative
+ )
+ );
+ }
+}
+__name(assertEntryPointExists, "assertEntryPointExists");
+function getMissingEntryPointMessage(message, absoluteEntryPointPath, relativeEntryPointPath) {
+ if ((0, import_node_fs5.existsSync)(absoluteEntryPointPath) && (0, import_node_fs5.statSync)(absoluteEntryPointPath).isDirectory()) {
+ message += `
+The provided entry-point path, "${relativeEntryPointPath}", points to a directory, rather than a file.
+`;
+ const possiblePaths = [];
+ for (const basenamePath of [
+ "worker",
+ "dist/worker",
+ "index",
+ "dist/index"
+ ]) {
+ for (const extension of [".ts", ".tsx", ".js", ".jsx"]) {
+ const filePath = basenamePath + extension;
+ if (fileExists(import_node_path12.default.resolve(absoluteEntryPointPath, filePath))) {
+ possiblePaths.push(import_node_path12.default.join(relativeEntryPointPath, filePath));
+ }
+ }
+ }
+ if (possiblePaths.length > 0) {
+ message += `
+Did you mean to set the main field to${possiblePaths.length > 1 ? " one of" : ""}:
+\`\`\`
+` + possiblePaths.map((filePath) => `main = "./${filePath}"
+`).join("") + "```";
+ }
+ }
+ return message;
+}
+__name(getMissingEntryPointMessage, "getMissingEntryPointMessage");
+function fileExists(filePath) {
+ const SOURCE_FILE_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx"];
+ if (import_node_path12.default.extname(filePath) !== "") {
+ return (0, import_node_fs5.existsSync)(filePath);
+ }
+ const base = import_node_path12.default.join(import_node_path12.default.dirname(filePath), import_node_path12.default.basename(filePath));
+ for (const ext of SOURCE_FILE_EXTENSIONS) {
+ if ((0, import_node_fs5.existsSync)(base + ext)) {
+ return true;
+ }
+ }
+ return false;
+}
+__name(fileExists, "fileExists");
+
+// src/deployment-bundle/entry.ts
+async function getEntry(args, config, command2) {
+ let file;
+ let directory = process.cwd();
+ if (args.script) {
+ file = import_node_path13.default.resolve(args.script);
+ } else if (config.main === void 0) {
+ if (config.site?.["entry-point"]) {
+ directory = import_node_path13.default.resolve(import_node_path13.default.dirname(config.configPath ?? "."));
+ file = import_node_path13.default.extname(config.site?.["entry-point"]) ? import_node_path13.default.resolve(config.site?.["entry-point"]) : (
+ // site.entry-point could be a directory
+ import_node_path13.default.resolve(config.site?.["entry-point"], "index.js")
+ );
+ } else if (args.assets || config.assets) {
+ file = import_node_path13.default.resolve(getBasePath(), "templates/no-op-worker.js");
+ } else {
+ throw new Error(
+ `Missing entry-point: The entry-point should be specified via the command line (e.g. \`wrangler ${command2} path/to/script\`) or the \`main\` config field.`
+ );
+ }
+ } else {
+ directory = import_node_path13.default.resolve(import_node_path13.default.dirname(config.configPath ?? "."));
+ file = import_node_path13.default.resolve(directory, config.main);
+ }
+ const relativeFile = import_node_path13.default.relative(directory, file) || ".";
+ await runCustomBuild(file, relativeFile, config.build);
+ const format8 = await guessWorkerFormat(
+ file,
+ directory,
+ args.format ?? config.build?.upload?.format,
+ config.tsconfig
+ );
+ const { localBindings, remoteBindings } = partitionDurableObjectBindings(config);
+ if (command2 === "dev" && remoteBindings.length > 0) {
+ logger.warn(
+ "WARNING: You have Durable Object bindings that are not defined locally in the worker being developed.\nBe aware that changes to the data stored in these Durable Objects will be permanent and affect the live instances.\nRemote Durable Objects that are affected:\n" + remoteBindings.map((b) => `- ${JSON.stringify(b)}`).join("\n")
+ );
+ }
+ if (format8 === "service-worker" && localBindings.length > 0) {
+ const errorMessage = "You seem to be trying to use Durable Objects in a Worker written as a service-worker.";
+ const addScriptName = "You can use Durable Objects defined in other Workers by specifying a `script_name` in your wrangler.toml, where `script_name` is the name of the Worker that implements that Durable Object. For example:";
+ const addScriptNameExamples = generateAddScriptNameExamples(localBindings);
+ const migrateText = "Alternatively, migrate your worker to ES Module syntax to implement a Durable Object in this Worker:";
+ const migrateUrl = "https://developers.cloudflare.com/workers/learning/migrating-to-module-workers/";
+ throw new Error(
+ `${errorMessage}
+${addScriptName}
+${addScriptNameExamples}
+${migrateText}
+${migrateUrl}`
+ );
+ }
+ return {
+ file,
+ directory,
+ format: format8,
+ moduleRoot: args.moduleRoot ?? config.base_dir ?? import_node_path13.default.dirname(file),
+ name: config.name ?? "worker"
+ };
+}
+__name(getEntry, "getEntry");
+function partitionDurableObjectBindings(config) {
+ const localBindings = [];
+ const remoteBindings = [];
+ for (const binding of config.durable_objects.bindings) {
+ if (binding.script_name === void 0) {
+ localBindings.push(binding);
+ } else {
+ remoteBindings.push(binding);
+ }
+ }
+ return { localBindings, remoteBindings };
+}
+__name(partitionDurableObjectBindings, "partitionDurableObjectBindings");
+function generateAddScriptNameExamples(localBindings) {
+ function exampleScriptName(binding_name) {
+ return `${binding_name.toLowerCase().replaceAll("_", "-")}-worker`;
+ }
+ __name(exampleScriptName, "exampleScriptName");
+ return localBindings.map(({ name, class_name }) => {
+ const script_name = exampleScriptName(name);
+ const currentBinding = `{ name = ${name}, class_name = ${class_name} }`;
+ const fixedBinding = `{ name = ${name}, class_name = ${class_name}, script_name = ${script_name} }`;
+ return `${currentBinding} ==> ${fixedBinding}`;
+ }).join("\n");
+}
+__name(generateAddScriptNameExamples, "generateAddScriptNameExamples");
+
+// src/dev/dev.tsx
+init_import_meta_url();
+var import_node_child_process6 = require("node:child_process");
+var import_node_fs26 = __toESM(require("node:fs"));
+var path41 = __toESM(require("node:path"));
+var util = __toESM(require("node:util"));
+var import_chokidar4 = require("chokidar");
+
+// ../../node_modules/.pnpm/clipboardy@3.0.0/node_modules/clipboardy/index.js
+init_import_meta_url();
+var import_node_process4 = __toESM(require("node:process"), 1);
+var import_is_wsl = __toESM(require_is_wsl(), 1);
+
+// ../../node_modules/.pnpm/clipboardy@3.0.0/node_modules/clipboardy/lib/termux.js
+init_import_meta_url();
+var import_execa2 = __toESM(require_execa(), 1);
+var handler = /* @__PURE__ */ __name((error) => {
+ if (error.code === "ENOENT") {
+ throw new Error("Couldn't find the termux-api scripts. You can install them with: apt install termux-api");
+ }
+ throw error;
+}, "handler");
+var clipboard = {
+ copy: async (options14) => {
+ try {
+ await (0, import_execa2.default)("termux-clipboard-set", options14);
+ } catch (error) {
+ handler(error);
+ }
+ },
+ paste: async (options14) => {
+ try {
+ const { stdout } = await (0, import_execa2.default)("termux-clipboard-get", options14);
+ return stdout;
+ } catch (error) {
+ handler(error);
+ }
+ },
+ copySync: (options14) => {
+ try {
+ import_execa2.default.sync("termux-clipboard-set", options14);
+ } catch (error) {
+ handler(error);
+ }
+ },
+ pasteSync: (options14) => {
+ try {
+ return import_execa2.default.sync("termux-clipboard-get", options14).stdout;
+ } catch (error) {
+ handler(error);
+ }
+ }
+};
+var termux_default = clipboard;
+
+// ../../node_modules/.pnpm/clipboardy@3.0.0/node_modules/clipboardy/lib/linux.js
+init_import_meta_url();
+var import_node_path14 = __toESM(require("node:path"), 1);
+var import_node_url6 = require("node:url");
+var import_execa3 = __toESM(require_execa(), 1);
+var __dirname3 = import_node_path14.default.dirname((0, import_node_url6.fileURLToPath)(import_meta_url));
+var xsel = "xsel";
+var xselFallback = import_node_path14.default.join(__dirname3, "../fallbacks/linux/xsel");
+var copyArguments = ["--clipboard", "--input"];
+var pasteArguments = ["--clipboard", "--output"];
+var makeError2 = /* @__PURE__ */ __name((xselError, fallbackError) => {
+ let error;
+ if (xselError.code === "ENOENT") {
+ error = new Error("Couldn't find the `xsel` binary and fallback didn't work. On Debian/Ubuntu you can install xsel with: sudo apt install xsel");
+ } else {
+ error = new Error("Both xsel and fallback failed");
+ error.xselError = xselError;
+ }
+ error.fallbackError = fallbackError;
+ return error;
+}, "makeError");
+var xselWithFallback = /* @__PURE__ */ __name(async (argumentList, options14) => {
+ try {
+ const { stdout } = await (0, import_execa3.default)(xsel, argumentList, options14);
+ return stdout;
+ } catch (xselError) {
+ try {
+ const { stdout } = await (0, import_execa3.default)(xselFallback, argumentList, options14);
+ return stdout;
+ } catch (fallbackError) {
+ throw makeError2(xselError, fallbackError);
+ }
+ }
+}, "xselWithFallback");
+var xselWithFallbackSync = /* @__PURE__ */ __name((argumentList, options14) => {
+ try {
+ return import_execa3.default.sync(xsel, argumentList, options14).stdout;
+ } catch (xselError) {
+ try {
+ return import_execa3.default.sync(xselFallback, argumentList, options14).stdout;
+ } catch (fallbackError) {
+ throw makeError2(xselError, fallbackError);
+ }
+ }
+}, "xselWithFallbackSync");
+var clipboard2 = {
+ copy: async (options14) => {
+ await xselWithFallback(copyArguments, options14);
+ },
+ copySync: (options14) => {
+ xselWithFallbackSync(copyArguments, options14);
+ },
+ paste: (options14) => xselWithFallback(pasteArguments, options14),
+ pasteSync: (options14) => xselWithFallbackSync(pasteArguments, options14)
+};
+var linux_default = clipboard2;
+
+// ../../node_modules/.pnpm/clipboardy@3.0.0/node_modules/clipboardy/lib/macos.js
+init_import_meta_url();
+var import_execa4 = __toESM(require_execa(), 1);
+var env2 = {
+ LC_CTYPE: "UTF-8"
+};
+var clipboard3 = {
+ copy: async (options14) => (0, import_execa4.default)("pbcopy", { ...options14, env: env2 }),
+ paste: async (options14) => {
+ const { stdout } = await (0, import_execa4.default)("pbpaste", { ...options14, env: env2 });
+ return stdout;
+ },
+ copySync: (options14) => import_execa4.default.sync("pbcopy", { ...options14, env: env2 }),
+ pasteSync: (options14) => import_execa4.default.sync("pbpaste", { ...options14, env: env2 }).stdout
+};
+var macos_default = clipboard3;
+
+// ../../node_modules/.pnpm/clipboardy@3.0.0/node_modules/clipboardy/lib/windows.js
+init_import_meta_url();
+var import_node_path15 = __toESM(require("node:path"), 1);
+var import_node_url7 = require("node:url");
+var import_execa5 = __toESM(require_execa(), 1);
+var import_arch = __toESM(require_arch(), 1);
+var __dirname4 = import_node_path15.default.dirname((0, import_node_url7.fileURLToPath)(import_meta_url));
+var binarySuffix = (0, import_arch.default)() === "x64" ? "x86_64" : "i686";
+var windowBinaryPath = import_node_path15.default.join(__dirname4, `../fallbacks/windows/clipboard_${binarySuffix}.exe`);
+var clipboard4 = {
+ copy: async (options14) => (0, import_execa5.default)(windowBinaryPath, ["--copy"], options14),
+ paste: async (options14) => {
+ const { stdout } = await (0, import_execa5.default)(windowBinaryPath, ["--paste"], options14);
+ return stdout;
+ },
+ copySync: (options14) => import_execa5.default.sync(windowBinaryPath, ["--copy"], options14),
+ pasteSync: (options14) => import_execa5.default.sync(windowBinaryPath, ["--paste"], options14).stdout
+};
+var windows_default = clipboard4;
+
+// ../../node_modules/.pnpm/clipboardy@3.0.0/node_modules/clipboardy/index.js
+var platformLib = (() => {
+ switch (import_node_process4.default.platform) {
+ case "darwin":
+ return macos_default;
+ case "win32":
+ return windows_default;
+ case "android":
+ if (import_node_process4.default.env.PREFIX !== "/data/data/com.termux/files/usr") {
+ throw new Error("You need to install Termux for this module to work on Android: https://termux.com");
+ }
+ return termux_default;
+ default:
+ if (import_is_wsl.default) {
+ return windows_default;
+ }
+ return linux_default;
+ }
+})();
+var clipboard5 = {};
+clipboard5.write = async (text) => {
+ if (typeof text !== "string") {
+ throw new TypeError(`Expected a string, got ${typeof text}`);
+ }
+ await platformLib.copy({ input: text });
+};
+clipboard5.read = async () => platformLib.paste({ stripFinalNewline: false });
+clipboard5.writeSync = (text) => {
+ if (typeof text !== "string") {
+ throw new TypeError(`Expected a string, got ${typeof text}`);
+ }
+ platformLib.copySync({ input: text });
+};
+clipboard5.readSync = () => platformLib.pasteSync({ stripFinalNewline: false });
+var clipboardy_default = clipboard5;
+
+// src/dev/dev.tsx
+var import_command_exists2 = __toESM(require_command_exists2());
+var import_ink12 = __toESM(require_build2());
+var import_react19 = __toESM(require_react());
+
+// ../../node_modules/.pnpm/react-error-boundary@3.1.4_react@17.0.2/node_modules/react-error-boundary/dist/react-error-boundary.esm.js
+init_import_meta_url();
+
+// ../../node_modules/.pnpm/@babel+runtime@7.22.5/node_modules/@babel/runtime/helpers/esm/inheritsLoose.js
+init_import_meta_url();
+
+// ../../node_modules/.pnpm/@babel+runtime@7.22.5/node_modules/@babel/runtime/helpers/esm/setPrototypeOf.js
+init_import_meta_url();
+function _setPrototypeOf(o, p) {
+ _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : /* @__PURE__ */ __name(function _setPrototypeOf2(o2, p2) {
+ o2.__proto__ = p2;
+ return o2;
+ }, "_setPrototypeOf");
+ return _setPrototypeOf(o, p);
+}
+__name(_setPrototypeOf, "_setPrototypeOf");
+
+// ../../node_modules/.pnpm/@babel+runtime@7.22.5/node_modules/@babel/runtime/helpers/esm/inheritsLoose.js
+function _inheritsLoose(subClass, superClass) {
+ subClass.prototype = Object.create(superClass.prototype);
+ subClass.prototype.constructor = subClass;
+ _setPrototypeOf(subClass, superClass);
+}
+__name(_inheritsLoose, "_inheritsLoose");
+
+// ../../node_modules/.pnpm/react-error-boundary@3.1.4_react@17.0.2/node_modules/react-error-boundary/dist/react-error-boundary.esm.js
+var React = __toESM(require_react());
+var changedArray = /* @__PURE__ */ __name(function changedArray2(a, b) {
+ if (a === void 0) {
+ a = [];
+ }
+ if (b === void 0) {
+ b = [];
+ }
+ return a.length !== b.length || a.some(function(item, index) {
+ return !Object.is(item, b[index]);
+ });
+}, "changedArray");
+var initialState = {
+ error: null
+};
+var ErrorBoundary = /* @__PURE__ */ function(_React$Component) {
+ _inheritsLoose(ErrorBoundary2, _React$Component);
+ function ErrorBoundary2() {
+ var _this;
+ for (var _len = arguments.length, _args = new Array(_len), _key = 0; _key < _len; _key++) {
+ _args[_key] = arguments[_key];
+ }
+ _this = _React$Component.call.apply(_React$Component, [this].concat(_args)) || this;
+ _this.state = initialState;
+ _this.resetErrorBoundary = function() {
+ var _this$props;
+ for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+ args[_key2] = arguments[_key2];
+ }
+ _this.props.onReset == null ? void 0 : (_this$props = _this.props).onReset.apply(_this$props, args);
+ _this.reset();
+ };
+ return _this;
+ }
+ __name(ErrorBoundary2, "ErrorBoundary");
+ ErrorBoundary2.getDerivedStateFromError = /* @__PURE__ */ __name(function getDerivedStateFromError(error) {
+ return {
+ error
+ };
+ }, "getDerivedStateFromError");
+ var _proto = ErrorBoundary2.prototype;
+ _proto.reset = /* @__PURE__ */ __name(function reset() {
+ this.setState(initialState);
+ }, "reset");
+ _proto.componentDidCatch = /* @__PURE__ */ __name(function componentDidCatch(error, info) {
+ var _this$props$onError, _this$props2;
+ (_this$props$onError = (_this$props2 = this.props).onError) == null ? void 0 : _this$props$onError.call(_this$props2, error, info);
+ }, "componentDidCatch");
+ _proto.componentDidUpdate = /* @__PURE__ */ __name(function componentDidUpdate(prevProps, prevState) {
+ var error = this.state.error;
+ var resetKeys = this.props.resetKeys;
+ if (error !== null && prevState.error !== null && changedArray(prevProps.resetKeys, resetKeys)) {
+ var _this$props$onResetKe, _this$props3;
+ (_this$props$onResetKe = (_this$props3 = this.props).onResetKeysChange) == null ? void 0 : _this$props$onResetKe.call(_this$props3, prevProps.resetKeys, resetKeys);
+ this.reset();
+ }
+ }, "componentDidUpdate");
+ _proto.render = /* @__PURE__ */ __name(function render7() {
+ var error = this.state.error;
+ var _this$props4 = this.props, fallbackRender = _this$props4.fallbackRender, FallbackComponent = _this$props4.FallbackComponent, fallback = _this$props4.fallback;
+ if (error !== null) {
+ var _props = {
+ error,
+ resetErrorBoundary: this.resetErrorBoundary
+ };
+ if (/* @__PURE__ */ React.isValidElement(fallback)) {
+ return fallback;
+ } else if (typeof fallbackRender === "function") {
+ return fallbackRender(_props);
+ } else if (FallbackComponent) {
+ return /* @__PURE__ */ React.createElement(FallbackComponent, _props);
+ } else {
+ throw new Error("react-error-boundary requires either a fallback, fallbackRender, or FallbackComponent prop");
+ }
+ }
+ return this.props.children;
+ }, "render");
+ return ErrorBoundary2;
+}(React.Component);
+function withErrorBoundary(Component2, errorBoundaryProps) {
+ var Wrapped = /* @__PURE__ */ __name(function Wrapped2(props) {
+ return /* @__PURE__ */ React.createElement(ErrorBoundary, errorBoundaryProps, /* @__PURE__ */ React.createElement(Component2, props));
+ }, "Wrapped");
+ var name = Component2.displayName || Component2.name || "Unknown";
+ Wrapped.displayName = "withErrorBoundary(" + name + ")";
+ return Wrapped;
+}
+__name(withErrorBoundary, "withErrorBoundary");
+function useErrorHandler(givenError) {
+ var _React$useState = React.useState(null), error = _React$useState[0], setError = _React$useState[1];
+ if (givenError != null)
+ throw givenError;
+ if (error != null)
+ throw error;
+ return setError;
+}
+__name(useErrorHandler, "useErrorHandler");
+
+// src/dev/dev.tsx
+var import_signal_exit5 = __toESM(require_signal_exit());
+var import_tmp_promise3 = __toESM(require_tmp_promise());
+var import_undici17 = __toESM(require_undici());
+
+// src/dev-registry.ts
+init_import_meta_url();
+var import_http = __toESM(require("http"));
+var import_net = __toESM(require("net"));
+var import_body_parser = __toESM(require_body_parser());
+var import_express = __toESM(require_express2());
+var import_http_terminator = __toESM(require_src5());
+var import_undici5 = __toESM(require_undici());
+var DEV_REGISTRY_PORT = "6284";
+var DEV_REGISTRY_HOST = `http://localhost:${DEV_REGISTRY_PORT}`;
+var server;
+var terminator;
+async function isPortAvailable() {
+ return new Promise((resolve18, reject) => {
+ const netServer = import_net.default.createServer().once("error", (err) => {
+ netServer.close();
+ if (err.code === "EADDRINUSE") {
+ resolve18(false);
+ } else {
+ reject(err);
+ }
+ }).once("listening", () => {
+ netServer.close();
+ resolve18(true);
+ });
+ netServer.listen(DEV_REGISTRY_PORT);
+ });
+}
+__name(isPortAvailable, "isPortAvailable");
+var jsonBodyParser = import_body_parser.default.json();
+async function startWorkerRegistry() {
+ if (await isPortAvailable() && !server) {
+ const app = (0, import_express.default)();
+ let workers = {};
+ app.get("/workers", async (req, res) => {
+ res.json(workers);
+ }).post("/workers/:workerId", jsonBodyParser, async (req, res) => {
+ workers[req.params.workerId] = req.body;
+ res.json(null);
+ }).delete(`/workers/:workerId`, async (req, res) => {
+ delete workers[req.params.workerId];
+ res.json(null);
+ }).delete("/workers", async (req, res) => {
+ workers = {};
+ res.json(null);
+ });
+ server = import_http.default.createServer(app);
+ terminator = (0, import_http_terminator.createHttpTerminator)({ server });
+ server.listen(DEV_REGISTRY_PORT);
+ server.once("error", (err) => {
+ if (err.code !== "EADDRINUSE") {
+ throw err;
+ }
+ });
+ server.on("close", () => {
+ server = null;
+ });
+ }
+}
+__name(startWorkerRegistry, "startWorkerRegistry");
+async function stopWorkerRegistry() {
+ await terminator?.terminate();
+ server = null;
+}
+__name(stopWorkerRegistry, "stopWorkerRegistry");
+async function registerWorker(name, definition) {
+ await startWorkerRegistry();
+ try {
+ return await (0, import_undici5.fetch)(`${DEV_REGISTRY_HOST}/workers/${name}`, {
+ method: "POST",
+ headers: {
+ "Content-Type": "application/json"
+ },
+ body: JSON.stringify(definition)
+ });
+ } catch (e2) {
+ if (!["ECONNRESET", "ECONNREFUSED"].includes(
+ e2.cause?.code || "___"
+ )) {
+ logger.error("Failed to register worker in local service registry", e2);
+ } else {
+ logger.debug("Failed to register worker in local service registry", e2);
+ }
+ }
+}
+__name(registerWorker, "registerWorker");
+async function unregisterWorker(name) {
+ try {
+ await (0, import_undici5.fetch)(`${DEV_REGISTRY_HOST}/workers/${name}`, {
+ method: "DELETE"
+ });
+ } catch (e2) {
+ if (!["ECONNRESET", "ECONNREFUSED"].includes(
+ e2.cause?.code || "___"
+ )) {
+ throw e2;
+ }
+ }
+}
+__name(unregisterWorker, "unregisterWorker");
+async function getRegisteredWorkers() {
+ try {
+ const response = await (0, import_undici5.fetch)(`${DEV_REGISTRY_HOST}/workers`);
+ return await response.json();
+ } catch (e2) {
+ if (!["ECONNRESET", "ECONNREFUSED"].includes(
+ e2.cause?.code || "___"
+ )) {
+ throw e2;
+ }
+ }
+}
+__name(getRegisteredWorkers, "getRegisteredWorkers");
+async function getBoundRegisteredWorkers({
+ services,
+ durableObjects
+}) {
+ const serviceNames = (services || []).map(
+ (serviceBinding) => serviceBinding.service
+ );
+ const durableObjectServices = (durableObjects || { bindings: [] }).bindings.map((durableObjectBinding) => durableObjectBinding.script_name);
+ const workerDefinitions = await getRegisteredWorkers();
+ const filteredWorkers = Object.fromEntries(
+ Object.entries(workerDefinitions || {}).filter(
+ ([key, _value]) => serviceNames.includes(key) || durableObjectServices.includes(key)
+ )
+ );
+ return filteredWorkers;
+}
+__name(getBoundRegisteredWorkers, "getBoundRegisteredWorkers");
+
+// src/inspect.ts
+init_import_meta_url();
+var import_fs6 = require("fs");
+var import_node_assert6 = __toESM(require("node:assert"));
+var import_node_crypto4 = __toESM(require("node:crypto"));
+var import_node_http3 = require("node:http");
+var import_node_os6 = __toESM(require("node:os"));
+var import_node_path16 = __toESM(require("node:path"));
+var import_node_url8 = require("node:url");
+var import_open2 = __toESM(require_open());
+var import_react2 = __toESM(require_react());
+
+// ../../node_modules/.pnpm/ws@8.11.0/node_modules/ws/wrapper.mjs
+init_import_meta_url();
+var import_stream2 = __toESM(require_stream3(), 1);
+var import_receiver = __toESM(require_receiver3(), 1);
+var import_sender = __toESM(require_sender2(), 1);
+var import_websocket = __toESM(require_websocket3(), 1);
+var import_websocket_server = __toESM(require_websocket_server2(), 1);
+var wrapper_default = import_websocket.default;
+
+// src/proxy.ts
+init_import_meta_url();
+var import_node_http2 = require("node:http");
+var import_node_http22 = require("node:http2");
+var import_node_https = require("node:https");
+var import_node_https2 = __toESM(require("node:https"));
+var import_node_os5 = require("node:os");
+var import_http_terminator2 = __toESM(require_src5());
+var import_react = __toESM(require_react());
+var import_serve_static = __toESM(require_serve_static());
+
+// src/https-options.ts
+init_import_meta_url();
+var fs6 = __toESM(require("node:fs"));
+var import_node_os4 = __toESM(require("node:os"));
+var path16 = __toESM(require("node:path"));
+var import_node_util3 = require("node:util");
+var CERT_EXPIRY_DAYS = 30;
+var ONE_DAY_IN_MS = 864e5;
+async function getHttpsOptions() {
+ const certDirectory = path16.join(getGlobalWranglerConfigPath(), "local-cert");
+ const keyPath = path16.join(certDirectory, "key.pem");
+ const certPath = path16.join(certDirectory, "cert.pem");
+ const regenerate = !fs6.existsSync(keyPath) || !fs6.existsSync(certPath) || hasCertificateExpired(keyPath, certPath);
+ if (regenerate) {
+ logger.log("Generating new self-signed certificate...");
+ const { key, cert } = await generateCertificate();
+ try {
+ fs6.mkdirSync(certDirectory, { recursive: true });
+ fs6.writeFileSync(keyPath, key, "utf8");
+ fs6.writeFileSync(certPath, cert, "utf8");
+ } catch (e2) {
+ const message = e2 instanceof Error ? e2.message : `${e2}`;
+ logger.warn(
+ `Unable to cache generated self-signed certificate in ${path16.relative(
+ process.cwd(),
+ certDirectory
+ )}.
+${message}`
+ );
+ }
+ return { key, cert };
+ } else {
+ return {
+ key: fs6.readFileSync(keyPath, "utf8"),
+ cert: fs6.readFileSync(certPath, "utf8")
+ };
+ }
+}
+__name(getHttpsOptions, "getHttpsOptions");
+function hasCertificateExpired(keyPath, certPath) {
+ const keyStat = fs6.statSync(keyPath);
+ const certStat = fs6.statSync(certPath);
+ const created = Math.max(keyStat.mtimeMs, certStat.mtimeMs);
+ return Date.now() - created > (CERT_EXPIRY_DAYS - 2) * ONE_DAY_IN_MS;
+}
+__name(hasCertificateExpired, "hasCertificateExpired");
+async function generateCertificate() {
+ const generate = (0, import_node_util3.promisify)(
+ // eslint-disable-next-line @typescript-eslint/no-var-requires
+ require("selfsigned").generate
+ );
+ const certAttrs = [{ name: "commonName", value: "localhost" }];
+ const certOptions = {
+ algorithm: "sha256",
+ days: CERT_EXPIRY_DAYS,
+ keySize: 2048,
+ extensions: [
+ { name: "basicConstraints", cA: true },
+ {
+ name: "keyUsage",
+ keyCertSign: true,
+ digitalSignature: true,
+ nonRepudiation: true,
+ keyEncipherment: true,
+ dataEncipherment: true
+ },
+ {
+ name: "extKeyUsage",
+ serverAuth: true,
+ clientAuth: true,
+ codeSigning: true,
+ timeStamping: true
+ },
+ {
+ name: "subjectAltName",
+ altNames: [
+ { type: 2, value: "localhost" },
+ ...getAccessibleHosts().map((ip2) => ({ type: 7, ip: ip2 }))
+ ]
+ }
+ ]
+ };
+ const { private: key, cert } = await generate(certAttrs, certOptions);
+ return { key, cert };
+}
+__name(generateCertificate, "generateCertificate");
+function getAccessibleHosts(ipv4 = false) {
+ const hosts = [];
+ Object.values(import_node_os4.default.networkInterfaces()).forEach(
+ (net3) => net3?.forEach(({ family, address }) => {
+ if (!ipv4 || family === "IPv4")
+ hosts.push(address);
+ })
+ );
+ return hosts;
+}
+__name(getAccessibleHosts, "getAccessibleHosts");
+
+// src/proxy.ts
+function addCfPreviewTokenHeader(headers, previewTokenValue) {
+ headers["cf-workers-preview-token"] = previewTokenValue;
+}
+__name(addCfPreviewTokenHeader, "addCfPreviewTokenHeader");
+async function addCfAccessToken(headers, domain, accessTokenRef) {
+ if (accessTokenRef.current === null) {
+ return;
+ }
+ if (typeof accessTokenRef.current === "string") {
+ headers["cookie"] = `${headers["cookie"]};CF_Authorization=${accessTokenRef.current}`;
+ return;
+ }
+ const token = await getAccessToken(domain);
+ accessTokenRef.current = token;
+ if (token)
+ headers["cookie"] = `${headers["cookie"]};CF_Authorization=${accessTokenRef.current}`;
+}
+__name(addCfAccessToken, "addCfAccessToken");
+function rewriteRemoteHostToLocalHostInHeaders(headers, remoteHost, localPort, localProtocol) {
+ for (const [name, value] of Object.entries(headers)) {
+ if (typeof value === "string" && value.includes(remoteHost)) {
+ headers[name] = value.replaceAll(
+ `https://${remoteHost}`,
+ `${localProtocol}://localhost:${localPort}`
+ ).replaceAll(remoteHost, `localhost:${localPort}`);
+ }
+ }
+}
+__name(rewriteRemoteHostToLocalHostInHeaders, "rewriteRemoteHostToLocalHostInHeaders");
+function writeHead(socket, res) {
+ socket.write(
+ `HTTP/${res.httpVersion} ${res.statusCode} ${res.statusMessage}\r
+`
+ );
+ for (const [key, values] of Object.entries(res.headers)) {
+ if (Array.isArray(values)) {
+ for (const value of values)
+ socket.write(`${key}: ${value}\r
+`);
+ } else {
+ socket.write(`${key}: ${values}\r
+`);
+ }
+ }
+ socket.write("\r\n");
+}
+__name(writeHead, "writeHead");
+async function startPreviewServer({
+ previewToken,
+ assetDirectory,
+ localProtocol,
+ localPort: port2,
+ ip: ip2,
+ onReady
+}) {
+ try {
+ const abortController = new AbortController();
+ const server2 = await createProxyServer(localProtocol);
+ const proxy2 = {
+ server: server2,
+ terminator: (0, import_http_terminator2.createHttpTerminator)({
+ server: server2,
+ gracefulTerminationTimeout: 0
+ })
+ };
+ const streamBufferRef = { current: [] };
+ const requestResponseBufferRef = { current: [] };
+ const accessTokenRef = { current: void 0 };
+ const cleanupListeners = configureProxyServer({
+ proxy: proxy2,
+ previewToken,
+ streamBufferRef,
+ requestResponseBufferRef,
+ retryServerSetup: () => {
+ },
+ // no-op outside of React
+ assetDirectory,
+ localProtocol,
+ port: port2,
+ accessTokenRef
+ });
+ await waitForPortToBeAvailable(port2, {
+ retryPeriod: 200,
+ timeout: 2e3,
+ abortSignal: abortController.signal
+ });
+ proxy2.server.on("listening", () => {
+ const address = proxy2.server.address();
+ const usedPort = address && typeof address === "object" ? address.port : port2;
+ logger.log(`\u2B23 Listening at ${localProtocol}://${ip2}:${usedPort}`);
+ const accessibleHosts = ip2 !== "0.0.0.0" ? [ip2] : getAccessibleHosts2();
+ for (const accessibleHost of accessibleHosts) {
+ logger.log(`- ${localProtocol}://${accessibleHost}:${usedPort}`);
+ }
+ onReady?.(ip2, usedPort);
+ });
+ proxy2.server.listen(port2, ip2);
+ return {
+ stop: () => {
+ abortController.abort();
+ cleanupListeners?.forEach((cleanup) => cleanup());
+ }
+ };
+ } catch (err) {
+ if (err.code !== "ABORT_ERR") {
+ logger.error(`Failed to start server: ${err}`);
+ }
+ logger.error("Failed to create proxy server:", err);
+ }
+}
+__name(startPreviewServer, "startPreviewServer");
+function usePreviewServer({
+ previewToken,
+ assetDirectory,
+ localProtocol,
+ localPort: port2,
+ ip: ip2
+}) {
+ const [proxy2, setProxy] = (0, import_react.useState)();
+ (0, import_react.useEffect)(() => {
+ if (proxy2 === void 0) {
+ createProxyServer(localProtocol).then((server2) => {
+ setProxy({
+ server: server2,
+ terminator: (0, import_http_terminator2.createHttpTerminator)({
+ server: server2,
+ gracefulTerminationTimeout: 0
+ })
+ });
+ }).catch(async (err) => {
+ logger.error("Failed to create proxy server:", err);
+ });
+ }
+ }, [proxy2, localProtocol]);
+ const streamBufferRef = (0, import_react.useRef)([]);
+ const requestResponseBufferRef = (0, import_react.useRef)([]);
+ const accessTokenRef = (0, import_react.useRef)(void 0);
+ const [retryServerSetupSigil, setRetryServerSetupSigil] = (0, import_react.useState)(0);
+ function retryServerSetup() {
+ setRetryServerSetupSigil((x) => x + 1);
+ }
+ __name(retryServerSetup, "retryServerSetup");
+ (0, import_react.useEffect)(() => {
+ const cleanupListeners = configureProxyServer({
+ proxy: proxy2,
+ previewToken,
+ streamBufferRef,
+ requestResponseBufferRef,
+ retryServerSetup,
+ assetDirectory,
+ localProtocol,
+ port: port2,
+ accessTokenRef
+ });
+ return () => {
+ cleanupListeners?.forEach((cleanup) => cleanup());
+ };
+ }, [
+ previewToken,
+ assetDirectory,
+ port2,
+ localProtocol,
+ proxy2,
+ // We use a state value as a sigil to trigger reconnecting the server.
+ // It's not used inside the effect, so react-hooks/exhaustive-deps
+ // doesn't complain if it's not included in the dependency array.
+ // But its presence is critical, so Do NOT remove it from the dependency list.
+ retryServerSetupSigil
+ ]);
+ (0, import_react.useEffect)(() => {
+ const abortController = new AbortController();
+ if (proxy2 === void 0) {
+ return;
+ }
+ waitForPortToBeAvailable(port2, {
+ retryPeriod: 200,
+ timeout: 2e3,
+ abortSignal: abortController.signal
+ }).then(() => {
+ proxy2.server.on("listening", () => {
+ const address = proxy2.server.address();
+ const usedPort = address && typeof address === "object" ? address.port : port2;
+ logger.log(`\u2B23 Listening at ${localProtocol}://${ip2}:${usedPort}`);
+ const accessibleHosts = ip2 !== "0.0.0.0" ? [ip2] : getAccessibleHosts2();
+ for (const accessibleHost of accessibleHosts) {
+ logger.log(`- ${localProtocol}://${accessibleHost}:${usedPort}`);
+ }
+ });
+ proxy2.server.listen(port2, ip2);
+ }).catch((err) => {
+ if (err.code !== "ABORT_ERR") {
+ logger.error(`Failed to start server: ${err}`);
+ }
+ });
+ return () => {
+ abortController.abort();
+ proxy2.terminator.terminate().catch(() => logger.error("Failed to terminate the proxy server."));
+ };
+ }, [port2, ip2, proxy2, localProtocol]);
+}
+__name(usePreviewServer, "usePreviewServer");
+function configureProxyServer({
+ proxy: proxy2,
+ previewToken,
+ streamBufferRef,
+ requestResponseBufferRef,
+ retryServerSetup,
+ port: port2,
+ localProtocol,
+ assetDirectory,
+ accessTokenRef
+}) {
+ if (proxy2 === void 0) {
+ return;
+ }
+ if (!previewToken) {
+ const cleanupListeners2 = [];
+ const bufferStream = /* @__PURE__ */ __name((stream2, headers) => {
+ streamBufferRef.current.push({ stream: stream2, headers });
+ }, "bufferStream");
+ proxy2.server.on("stream", bufferStream);
+ cleanupListeners2.push(() => proxy2.server.off("stream", bufferStream));
+ const bufferRequestResponse = /* @__PURE__ */ __name((request, response) => {
+ requestResponseBufferRef.current.push({ request, response });
+ }, "bufferRequestResponse");
+ proxy2.server.on("request", bufferRequestResponse);
+ cleanupListeners2.push(
+ () => proxy2.server.off("request", bufferRequestResponse)
+ );
+ return cleanupListeners2;
+ }
+ const cleanupListeners = [];
+ logger.debug("PREVIEW URL:", `https://${previewToken.host}`);
+ const remote = (0, import_node_http22.connect)(`https://${previewToken.host}`);
+ cleanupListeners.push(() => remote.destroy());
+ remote.on("close", retryServerSetup);
+ cleanupListeners.push(() => remote.off("close", retryServerSetup));
+ const handleStream = createStreamHandler(
+ previewToken,
+ remote,
+ port2,
+ localProtocol,
+ accessTokenRef
+ );
+ proxy2.server.on("stream", handleStream);
+ cleanupListeners.push(() => proxy2.server.off("stream", handleStream));
+ streamBufferRef.current.forEach(
+ (buffer) => handleStream(buffer.stream, buffer.headers)
+ );
+ streamBufferRef.current = [];
+ const handleRequest = /* @__PURE__ */ __name(async (message, response) => {
+ const { httpVersionMajor, headers, method, url: url3 } = message;
+ if (httpVersionMajor >= 2) {
+ return;
+ }
+ await addCfAccessToken(headers, previewToken.host, accessTokenRef);
+ addCfPreviewTokenHeader(headers, previewToken.value);
+ headers[":method"] = method;
+ headers[":path"] = url3;
+ headers[":authority"] = previewToken.host;
+ headers[":scheme"] = "https";
+ for (const name of Object.keys(headers)) {
+ if (HTTP1_HEADERS.has(name.toLowerCase())) {
+ delete headers[name];
+ }
+ }
+ const request = message.pipe(remote.request(headers));
+ logger.debug(
+ "WORKER REQUEST",
+ (/* @__PURE__ */ new Date()).toLocaleTimeString(),
+ method,
+ url3
+ );
+ logger.debug("HEADERS", JSON.stringify(headers, null, 2));
+ logger.debug("PREVIEW TOKEN", previewToken);
+ request.on("response", (responseHeaders) => {
+ const status = responseHeaders[":status"] ?? 500;
+ logger.log((/* @__PURE__ */ new Date()).toLocaleTimeString(), method, url3, status);
+ rewriteRemoteHostToLocalHostInHeaders(
+ responseHeaders,
+ previewToken.host,
+ port2,
+ localProtocol
+ );
+ for (const name of Object.keys(responseHeaders)) {
+ if (name.startsWith(":")) {
+ delete responseHeaders[name];
+ }
+ }
+ response.writeHead(status, responseHeaders);
+ request.pipe(response, { end: true });
+ });
+ }, "handleRequest");
+ const actualHandleRequest = assetDirectory ? createHandleAssetsRequest(assetDirectory, handleRequest) : handleRequest;
+ proxy2.server.on("request", actualHandleRequest);
+ cleanupListeners.push(() => proxy2.server.off("request", actualHandleRequest));
+ requestResponseBufferRef.current.forEach(
+ ({
+ request,
+ response
+ }) => actualHandleRequest(request, response)
+ );
+ requestResponseBufferRef.current = [];
+ const handleUpgrade = /* @__PURE__ */ __name(async (originalMessage, originalSocket, originalHead) => {
+ const { headers, method, url: url3 } = originalMessage;
+ await addCfAccessToken(headers, previewToken.host, accessTokenRef);
+ addCfPreviewTokenHeader(headers, previewToken.value);
+ headers["host"] = previewToken.host;
+ if (originalHead?.byteLength)
+ originalSocket.unshift(originalHead);
+ const runtimeRequest = import_node_https2.default.request(
+ {
+ hostname: previewToken.host,
+ path: url3,
+ method,
+ headers
+ },
+ (runtimeResponse) => {
+ if (!runtimeResponse.upgrade) {
+ writeHead(originalSocket, runtimeResponse);
+ runtimeResponse.pipe(originalSocket);
+ }
+ }
+ );
+ runtimeRequest.on(
+ "upgrade",
+ (runtimeResponse, runtimeSocket, runtimeHead) => {
+ if (runtimeHead?.byteLength)
+ runtimeSocket.unshift(runtimeHead);
+ writeHead(originalSocket, {
+ httpVersion: "1.1",
+ statusCode: 101,
+ statusMessage: "Switching Protocols",
+ headers: runtimeResponse.headers
+ });
+ runtimeSocket.pipe(originalSocket).pipe(runtimeSocket);
+ }
+ );
+ originalMessage.pipe(runtimeRequest);
+ }, "handleUpgrade");
+ proxy2.server.on("upgrade", handleUpgrade);
+ cleanupListeners.push(() => proxy2.server.off("upgrade", handleUpgrade));
+ return cleanupListeners;
+}
+__name(configureProxyServer, "configureProxyServer");
+function createHandleAssetsRequest(assetDirectory, handleRequest) {
+ const handleAsset = (0, import_serve_static.default)(assetDirectory, {
+ cacheControl: false
+ });
+ return (request, response) => {
+ handleAsset(request, response, () => {
+ handleRequest(request, response);
+ });
+ };
+}
+__name(createHandleAssetsRequest, "createHandleAssetsRequest");
+var HTTP1_HEADERS = /* @__PURE__ */ new Set([
+ "host",
+ "connection",
+ "upgrade",
+ "keep-alive",
+ "proxy-connection",
+ "transfer-encoding",
+ "http2-settings"
+]);
+async function createProxyServer(localProtocol) {
+ const server2 = localProtocol === "https" ? (0, import_node_https.createServer)(await getHttpsOptions()) : (0, import_node_http2.createServer)();
+ return server2.on("upgrade", (req) => {
+ logger.log(
+ (/* @__PURE__ */ new Date()).toLocaleTimeString(),
+ req.method,
+ req.url,
+ 101,
+ "(WebSocket)"
+ );
+ }).on("error", (err) => {
+ logger.error((/* @__PURE__ */ new Date()).toLocaleTimeString(), err);
+ });
+}
+__name(createProxyServer, "createProxyServer");
+function createStreamHandler(previewToken, remote, localPort, localProtocol, accessTokenRef) {
+ return /* @__PURE__ */ __name(async function handleStream(stream2, headers) {
+ await addCfAccessToken(headers, previewToken.host, accessTokenRef);
+ addCfPreviewTokenHeader(headers, previewToken.value);
+ headers[":authority"] = previewToken.host;
+ const request = stream2.pipe(remote.request(headers));
+ request.on("response", (responseHeaders) => {
+ rewriteRemoteHostToLocalHostInHeaders(
+ responseHeaders,
+ previewToken.host,
+ localPort,
+ localProtocol
+ );
+ stream2.respond(responseHeaders);
+ request.pipe(stream2, { end: true });
+ });
+ }, "handleStream");
+}
+__name(createStreamHandler, "createStreamHandler");
+async function waitForPortToBeAvailable(port2, options14) {
+ return new Promise((resolve18, reject) => {
+ options14.abortSignal.addEventListener("abort", () => {
+ const abortError = new Error("waitForPortToBeAvailable() aborted");
+ abortError.code = "ABORT_ERR";
+ doReject(abortError);
+ });
+ const timeout = setTimeout(() => {
+ doReject(new Error(`Timed out waiting for port ${port2}`));
+ }, options14.timeout);
+ const interval2 = setInterval(checkPort, options14.retryPeriod);
+ checkPort();
+ function doResolve() {
+ clearTimeout(timeout);
+ clearInterval(interval2);
+ resolve18();
+ }
+ __name(doResolve, "doResolve");
+ function doReject(err) {
+ clearInterval(interval2);
+ clearTimeout(timeout);
+ reject(err);
+ }
+ __name(doReject, "doReject");
+ function checkPort() {
+ if (port2 === 0) {
+ doResolve();
+ return;
+ }
+ const server2 = (0, import_node_http2.createServer)();
+ const terminator2 = (0, import_http_terminator2.createHttpTerminator)({
+ server: server2,
+ gracefulTerminationTimeout: 0
+ // default 1000
+ });
+ server2.on("error", (err) => {
+ if (err.code !== "EADDRINUSE") {
+ doReject(err);
+ }
+ });
+ server2.listen(
+ port2,
+ () => terminator2.terminate().then(
+ doResolve,
+ () => logger.error("Failed to terminate the port checker.")
+ )
+ );
+ }
+ __name(checkPort, "checkPort");
+ });
+}
+__name(waitForPortToBeAvailable, "waitForPortToBeAvailable");
+function getAccessibleHosts2() {
+ const hosts = [];
+ Object.values((0, import_node_os5.networkInterfaces)()).forEach((net3) => {
+ net3?.forEach(({ family, address }) => {
+ if (family === "IPv4" || family === 4)
+ hosts.push(address);
+ });
+ });
+ return hosts;
+}
+__name(getAccessibleHosts2, "getAccessibleHosts");
+
+// src/sourcemap.ts
+init_import_meta_url();
+var import_node_assert5 = __toESM(require("node:assert"));
+var sourceMappingPrepareStackTrace;
+function getSourceMappedStack(details) {
+ const description = details.exception?.description ?? "";
+ const callFrames = details.stackTrace?.callFrames;
+ if (callFrames === void 0)
+ return description;
+ if (sourceMappingPrepareStackTrace === void 0) {
+ const originalSupport = require.cache["source-map-support"];
+ delete require.cache["source-map-support"];
+ const support = require_source_map_support();
+ require.cache["source-map-support"] = originalSupport;
+ const originalPrepareStackTrace = Error.prepareStackTrace;
+ support.install({
+ environment: "node",
+ // Don't add Node `uncaughtException` handler
+ handleUncaughtExceptions: false,
+ // Don't hook Node `require` function
+ hookRequire: false,
+ // Make sure we're using fresh copies of files each time we source map
+ emptyCacheBetweenOperations: true
+ });
+ sourceMappingPrepareStackTrace = Error.prepareStackTrace;
+ (0, import_node_assert5.default)(sourceMappingPrepareStackTrace !== void 0);
+ Error.prepareStackTrace = originalPrepareStackTrace;
+ }
+ const nameMessage = details.exception?.description?.split("\n")[0] ?? "";
+ const colonIndex = nameMessage.indexOf(":");
+ const error = new Error(nameMessage.substring(colonIndex + 2));
+ error.name = nameMessage.substring(0, colonIndex);
+ const callSites = callFrames.map((frame) => new CallSite(frame));
+ return sourceMappingPrepareStackTrace(error, callSites);
+}
+__name(getSourceMappedStack, "getSourceMappedStack");
+var CallSite = class {
+ constructor(frame) {
+ this.frame = frame;
+ }
+ getThis() {
+ return null;
+ }
+ getTypeName() {
+ return null;
+ }
+ // eslint-disable-next-line @typescript-eslint/ban-types
+ getFunction() {
+ return void 0;
+ }
+ getFunctionName() {
+ return this.frame.functionName;
+ }
+ getMethodName() {
+ return null;
+ }
+ getFileName() {
+ return this.frame.url;
+ }
+ getScriptNameOrSourceURL() {
+ return this.frame.url;
+ }
+ getLineNumber() {
+ return this.frame.lineNumber;
+ }
+ getColumnNumber() {
+ return this.frame.columnNumber;
+ }
+ getEvalOrigin() {
+ return void 0;
+ }
+ isToplevel() {
+ return false;
+ }
+ isEval() {
+ return false;
+ }
+ isNative() {
+ return false;
+ }
+ isConstructor() {
+ return false;
+ }
+ isAsync() {
+ return false;
+ }
+ isPromiseAll() {
+ return false;
+ }
+ isPromiseAny() {
+ return false;
+ }
+ getPromiseIndex() {
+ return null;
+ }
+};
+__name(CallSite, "CallSite");
+
+// src/inspect.ts
+function useInspector(props) {
+ const inspectorIdRef = (0, import_react2.useRef)(import_node_crypto4.default.randomUUID());
+ const [localWebSocket, setLocalWebSocket] = (0, import_react2.useState)();
+ const [remoteWebSocket, setRemoteWebSocket] = (0, import_react2.useState)();
+ const sourceMaps = (0, import_react2.useRef)();
+ sourceMaps.current ??= /* @__PURE__ */ new Map();
+ const allowedSourcePaths = (0, import_react2.useRef)();
+ allowedSourcePaths.current ??= /* @__PURE__ */ new Set();
+ const serverRef = (0, import_react2.useRef)();
+ if (serverRef.current === void 0) {
+ serverRef.current = (0, import_node_http3.createServer)(
+ (req, res) => {
+ switch (req.url) {
+ case "/json/version":
+ res.setHeader("Content-Type", "application/json");
+ res.end(
+ JSON.stringify({
+ Browser: `wrangler/v${version}`,
+ // TODO: (someday): The DevTools protocol should match that of Edge Worker.
+ // This could be exposed by the preview API.
+ "Protocol-Version": "1.3"
+ })
+ );
+ return;
+ case "/json":
+ case "/json/list":
+ {
+ res.setHeader("Content-Type", "application/json");
+ const localHost = `localhost:${props.port}/ws`;
+ const devtoolsFrontendUrl = `devtools://devtools/bundled/js_app.html?experiments=true&v8only=true&ws=${localHost}`;
+ const devtoolsFrontendUrlCompat = `devtools://devtools/bundled/inspector.html?experiments=true&v8only=true&ws=${localHost}`;
+ res.end(
+ JSON.stringify([
+ {
+ id: inspectorIdRef.current,
+ type: "node",
+ description: "workers",
+ webSocketDebuggerUrl: `ws://${localHost}`,
+ devtoolsFrontendUrl,
+ devtoolsFrontendUrlCompat,
+ // Below are fields that are visible in the DevTools UI.
+ title: "Cloudflare Worker",
+ faviconUrl: "https://workers.cloudflare.com/favicon.ico",
+ url: "https://" + (remoteWebSocket ? new import_node_url8.URL(remoteWebSocket.url).host : "workers.dev")
+ }
+ ])
+ );
+ }
+ return;
+ default:
+ break;
+ }
+ }
+ );
+ }
+ const server2 = serverRef.current;
+ const wsServerRef = (0, import_react2.useRef)();
+ if (wsServerRef.current === void 0) {
+ wsServerRef.current = new import_websocket_server.default({
+ server: server2,
+ clientTracking: true
+ });
+ }
+ const wsServer = wsServerRef.current;
+ wsServer.on("connection", (ws, req) => {
+ if (wsServer.clients.size > 1) {
+ logger.error(
+ "Tried to open a new devtools window when a previous one was already open."
+ );
+ ws.close(1013, "Too many clients; only one can be connected at a time");
+ } else {
+ remoteWebSocket?.send(
+ JSON.stringify({
+ // This number is arbitrary, and is chosen to be high so as not to conflict with messages that DevTools might actually send.
+ // For completeness, these options don't work: 0, -1, or Number.MAX_SAFE_INTEGER
+ id: 1e8,
+ method: "Debugger.disable"
+ })
+ );
+ const localWs = ws;
+ localWs.isDevTools = /mozilla/i.test(req.headers["user-agent"] ?? "");
+ setLocalWebSocket(localWs);
+ ws.addEventListener("close", () => {
+ setLocalWebSocket(void 0);
+ });
+ }
+ });
+ (0, import_react2.useEffect)(() => {
+ const abortController = new AbortController();
+ async function startInspectorProxy() {
+ await waitForPortToBeAvailable(props.port, {
+ retryPeriod: 200,
+ timeout: 2e3,
+ abortSignal: abortController.signal
+ });
+ server2.listen(props.port);
+ }
+ __name(startInspectorProxy, "startInspectorProxy");
+ startInspectorProxy().catch((err) => {
+ if (err.code !== "ABORT_ERR") {
+ logger.error("Failed to start inspector:", err);
+ }
+ });
+ return () => {
+ server2.close();
+ wsServer.clients.forEach((ws) => ws.close());
+ wsServer.close();
+ abortController.abort();
+ };
+ }, [props.port, server2, wsServer]);
+ const [
+ retryRemoteWebSocketConnectionSigil,
+ setRetryRemoteWebSocketConnectionSigil
+ ] = (0, import_react2.useState)(0);
+ function retryRemoteWebSocketConnection() {
+ setRetryRemoteWebSocketConnectionSigil((x) => x + 1);
+ }
+ __name(retryRemoteWebSocketConnection, "retryRemoteWebSocketConnection");
+ const messageCounterRef = (0, import_react2.useRef)(1);
+ const cfAccessRef = (0, import_react2.useRef)();
+ (0, import_react2.useEffect)(() => {
+ const run = /* @__PURE__ */ __name(async () => {
+ if (props.host && !cfAccessRef.current) {
+ const token = await getAccessToken(props.host);
+ cfAccessRef.current = token;
+ }
+ }, "run");
+ if (props.host)
+ void run();
+ }, [props.host]);
+ (0, import_react2.useEffect)(() => {
+ if (!props.inspectorUrl) {
+ return;
+ }
+ const ws = new wrapper_default(props.inspectorUrl, {
+ headers: {
+ cookie: `CF_Authorization=${cfAccessRef.current}`
+ }
+ });
+ setRemoteWebSocket(ws);
+ let keepAliveInterval;
+ function isClosed() {
+ return ws.readyState === wrapper_default.CLOSED || ws.readyState === wrapper_default.CLOSING;
+ }
+ __name(isClosed, "isClosed");
+ function send(event) {
+ if (!isClosed()) {
+ ws.send(JSON.stringify(event));
+ }
+ }
+ __name(send, "send");
+ function close() {
+ if (!isClosed()) {
+ try {
+ ws.close();
+ } catch (err) {
+ }
+ }
+ }
+ __name(close, "close");
+ if (props.logToTerminal) {
+ ws.addEventListener("message", async (event) => {
+ if (typeof event.data === "string") {
+ const evt = JSON.parse(event.data);
+ if (evt.method === "Runtime.exceptionThrown") {
+ const params = evt.params;
+ const stack = getSourceMappedStack(params.exceptionDetails);
+ logger.error(params.exceptionDetails.text, stack);
+ }
+ if (evt.method === "Runtime.consoleAPICalled") {
+ logConsoleMessage(
+ evt.params
+ );
+ }
+ } else {
+ logger.error("Unrecognised devtools event:", event);
+ }
+ });
+ }
+ ws.addEventListener("open", () => {
+ send({ method: "Runtime.enable", id: messageCounterRef.current });
+ send({ method: "Network.enable", id: messageCounterRef.current++ });
+ keepAliveInterval = setInterval(() => {
+ send({
+ method: "Runtime.getIsolateId",
+ id: messageCounterRef.current++
+ });
+ }, 1e4);
+ });
+ ws.on("unexpected-response", () => {
+ logger.log("Waiting for connection...");
+ retryRemoteWebSocketConnection();
+ });
+ ws.addEventListener("close", () => {
+ clearInterval(keepAliveInterval);
+ });
+ return () => {
+ clearInterval(keepAliveInterval);
+ wsServer.clients.forEach((client) => {
+ client.send(
+ JSON.stringify({
+ // TODO: This doesn't actually work. Must fix.
+ method: "Log.clear",
+ // we can disable the next eslint warning since
+ // we're referencing a ref that stays alive
+ // eslint-disable-next-line react-hooks/exhaustive-deps
+ id: messageCounterRef.current++,
+ params: {}
+ })
+ );
+ });
+ close();
+ setRemoteWebSocket(void 0);
+ };
+ }, [
+ props.inspectorUrl,
+ props.logToTerminal,
+ props.sourceMapPath,
+ wsServer,
+ // We use a state value as a sigil to trigger a retry of the
+ // remote websocket connection. It's not used inside the effect,
+ // so react-hooks/exhaustive-deps doesn't complain if it's not
+ // included in the dependency array. But its presence is critical,
+ // so do NOT remove it from the dependency list.
+ retryRemoteWebSocketConnectionSigil
+ ]);
+ const messageBufferRef = (0, import_react2.useRef)([]);
+ (0, import_react2.useEffect)(() => {
+ function bufferMessageFromRemoteSocket(event) {
+ messageBufferRef.current.push(event);
+ }
+ __name(bufferMessageFromRemoteSocket, "bufferMessageFromRemoteSocket");
+ if (remoteWebSocket && !localWebSocket) {
+ remoteWebSocket.addEventListener(
+ "message",
+ bufferMessageFromRemoteSocket
+ );
+ }
+ function sendMessageToRemoteWebSocket(event) {
+ try {
+ const message = JSON.parse(event.data);
+ if (message.method === "Network.loadNetworkResource") {
+ (0, import_node_assert6.default)(sourceMaps.current !== void 0);
+ (0, import_node_assert6.default)(allowedSourcePaths.current !== void 0);
+ const maybeText = maybeHandleNetworkLoadResource(
+ message.params.url,
+ sourceMaps.current,
+ allowedSourcePaths.current,
+ props.sourceMapMetadata?.tmpDir
+ );
+ if (maybeText !== void 0) {
+ sendMessageToLocalWebSocket({
+ data: JSON.stringify({
+ id: message.id,
+ result: { resource: { success: true, text: maybeText } }
+ })
+ });
+ return;
+ }
+ }
+ } catch (e2) {
+ logger.debug(e2);
+ }
+ try {
+ (0, import_node_assert6.default)(
+ remoteWebSocket,
+ "Trying to send a message to an undefined `remoteWebSocket`"
+ );
+ remoteWebSocket.send(event.data);
+ } catch (e2) {
+ if (e2.message !== "WebSocket is not open: readyState 0 (CONNECTING)") {
+ logger.error(e2);
+ }
+ }
+ }
+ __name(sendMessageToRemoteWebSocket, "sendMessageToRemoteWebSocket");
+ function sendMessageToLocalWebSocket(event) {
+ (0, import_node_assert6.default)(
+ localWebSocket,
+ "Trying to send a message to an undefined `localWebSocket`"
+ );
+ try {
+ if (localWebSocket.isDevTools) {
+ const message = JSON.parse(event.data);
+ if (message.method === "Debugger.scriptParsed") {
+ if (message.params.sourceMapURL) {
+ const url3 = new import_node_url8.URL(
+ message.params.sourceMapURL,
+ message.params.url
+ );
+ if (url3.protocol === "file:") {
+ (0, import_node_assert6.default)(sourceMaps.current !== void 0);
+ const name = props.name ?? "worker";
+ const id = import_node_crypto4.default.randomUUID();
+ sourceMaps.current.set(id, (0, import_node_url8.fileURLToPath)(url3));
+ message.params.sourceMapURL = `worker://${name}/${id}`;
+ localWebSocket.send(JSON.stringify(message));
+ return;
+ }
+ }
+ }
+ }
+ } catch (e2) {
+ logger.debug(e2);
+ }
+ localWebSocket.send(event.data);
+ }
+ __name(sendMessageToLocalWebSocket, "sendMessageToLocalWebSocket");
+ if (localWebSocket && remoteWebSocket) {
+ localWebSocket.addEventListener("message", sendMessageToRemoteWebSocket);
+ remoteWebSocket.addEventListener("message", sendMessageToLocalWebSocket);
+ messageBufferRef.current.forEach(sendMessageToLocalWebSocket);
+ messageBufferRef.current = [];
+ }
+ return () => {
+ if (remoteWebSocket) {
+ remoteWebSocket.removeEventListener(
+ "message",
+ bufferMessageFromRemoteSocket
+ );
+ remoteWebSocket.removeEventListener(
+ "message",
+ sendMessageToLocalWebSocket
+ );
+ }
+ if (localWebSocket) {
+ localWebSocket.removeEventListener(
+ "message",
+ sendMessageToRemoteWebSocket
+ );
+ }
+ };
+ }, [
+ localWebSocket,
+ remoteWebSocket,
+ props.name,
+ props.sourceMapMetadata,
+ props.sourceMapPath
+ ]);
+}
+__name(useInspector, "useInspector");
+var mapConsoleAPIMessageTypeToConsoleMethod = {
+ log: "log",
+ debug: "debug",
+ info: "info",
+ warning: "warn",
+ error: "error",
+ dir: "dir",
+ dirxml: "dirxml",
+ table: "table",
+ trace: "trace",
+ clear: "clear",
+ count: "count",
+ assert: "assert",
+ profile: "profile",
+ profileEnd: "profileEnd",
+ timeEnd: "timeEnd",
+ startGroup: "group",
+ startGroupCollapsed: "groupCollapsed",
+ endGroup: "groupEnd"
+};
+function logConsoleMessage(evt) {
+ const args = [];
+ for (const ro2 of evt.args) {
+ switch (ro2.type) {
+ case "string":
+ case "number":
+ case "boolean":
+ case "undefined":
+ case "symbol":
+ case "bigint":
+ args.push(ro2.value);
+ break;
+ case "function":
+ args.push(`[Function: ${ro2.description ?? ""}]`);
+ break;
+ case "object":
+ if (!ro2.preview) {
+ args.push(
+ ro2.subtype === "null" ? "null" : ro2.description ?? ""
+ );
+ } else {
+ args.push(ro2.preview.description ?? "");
+ switch (ro2.preview.subtype) {
+ case "array":
+ args.push(
+ "[ " + ro2.preview.properties.map(({ value }) => {
+ return value;
+ }).join(", ") + (ro2.preview.overflow ? "..." : "") + " ]"
+ );
+ break;
+ case "weakmap":
+ case "map":
+ ro2.preview.entries === void 0 ? args.push("{}") : args.push(
+ "{\n" + ro2.preview.entries.map(({ key, value }) => {
+ return ` ${key?.description ?? ""} => ${value.description}`;
+ }).join(",\n") + (ro2.preview.overflow ? "\n ..." : "") + "\n}"
+ );
+ break;
+ case "weakset":
+ case "set":
+ ro2.preview.entries === void 0 ? args.push("{}") : args.push(
+ "{ " + ro2.preview.entries.map(({ value }) => {
+ return `${value.description}`;
+ }).join(", ") + (ro2.preview.overflow ? ", ..." : "") + " }"
+ );
+ break;
+ case "regexp":
+ break;
+ case "date":
+ break;
+ case "generator":
+ args.push(ro2.preview.properties[0].value || "");
+ break;
+ case "promise":
+ if (ro2.preview.properties[0].value === "pending") {
+ args.push(`{<${ro2.preview.properties[0].value}>}`);
+ } else {
+ args.push(
+ `{<${ro2.preview.properties[0].value}>: ${ro2.preview.properties[1].value}}`
+ );
+ }
+ break;
+ case "node":
+ case "iterator":
+ case "proxy":
+ case "typedarray":
+ case "arraybuffer":
+ case "dataview":
+ case "webassemblymemory":
+ case "wasmvalue":
+ break;
+ case "error":
+ default:
+ args.push(
+ "{\n" + ro2.preview.properties.map(({ name, value }) => {
+ return ` ${name}: ${value}`;
+ }).join(",\n") + (ro2.preview.overflow ? "\n ..." : "") + "\n}"
+ );
+ }
+ }
+ break;
+ default:
+ args.push(ro2.description || ro2.unserializableValue || "\u{1F98B}");
+ break;
+ }
+ }
+ const method = mapConsoleAPIMessageTypeToConsoleMethod[evt.type];
+ if (method in console) {
+ switch (method) {
+ case "dir":
+ console.dir(args);
+ break;
+ case "table":
+ console.table(args);
+ break;
+ default:
+ console[method].apply(console, args);
+ break;
+ }
+ } else {
+ logger.warn(`Unsupported console method: ${method}`);
+ logger.warn("console event:", evt);
+ }
+}
+__name(logConsoleMessage, "logConsoleMessage");
+function maybeHandleNetworkLoadResource(url3, sourceMaps, allowedSourcePaths, tmpDir) {
+ if (typeof url3 === "string")
+ url3 = new import_node_url8.URL(url3);
+ if (url3.protocol !== "worker:")
+ return;
+ const id = url3.pathname.substring(1);
+ const maybeSourceMapFilePath = sourceMaps.get(id);
+ if (maybeSourceMapFilePath !== void 0) {
+ sourceMaps.delete(id);
+ const sourceMap = JSON.parse((0, import_fs6.readFileSync)(maybeSourceMapFilePath, "utf-8"));
+ sourceMap.x_google_ignoreList = sourceMap.sources.map((source, i) => {
+ if (tmpDir !== void 0 && source.includes(tmpDir))
+ return i;
+ if (source.includes("wrangler/templates"))
+ return i;
+ }).filter((i) => i !== void 0);
+ if (!sourceMap.sourcesContent) {
+ const fileURL = (0, import_node_url8.pathToFileURL)(maybeSourceMapFilePath);
+ for (const source of sourceMap.sources) {
+ const sourcePath = (0, import_node_url8.fileURLToPath)(new import_node_url8.URL(source, fileURL));
+ allowedSourcePaths.add(sourcePath);
+ }
+ }
+ return JSON.stringify(sourceMap);
+ }
+ const filePath = import_node_path16.default.resolve(id);
+ if (allowedSourcePaths.has(filePath)) {
+ allowedSourcePaths.delete(filePath);
+ return (0, import_fs6.readFileSync)(filePath, "utf-8");
+ }
+}
+__name(maybeHandleNetworkLoadResource, "maybeHandleNetworkLoadResource");
+var openInspector = /* @__PURE__ */ __name(async (inspectorPort, worker) => {
+ const query = new URLSearchParams();
+ query.set("theme", "systemPreferred");
+ query.set("ws", `localhost:${inspectorPort}/ws`);
+ if (worker)
+ query.set("domain", worker);
+ query.set("debugger", "true");
+ const url3 = `https://devtools.devprod.cloudflare.dev/js_app?${query.toString()}`;
+ const errorMessage = "Failed to open inspector.\nInspector depends on having a Chromium-based browser installed, maybe you need to install one?";
+ let braveBrowser;
+ switch (import_node_os6.default.platform()) {
+ case "darwin":
+ case "win32":
+ braveBrowser = "Brave";
+ break;
+ default:
+ braveBrowser = "brave";
+ }
+ const childProcess2 = await (0, import_open2.default)(url3, {
+ app: [
+ {
+ name: import_open2.default.apps.chrome
+ },
+ {
+ name: braveBrowser
+ },
+ {
+ name: import_open2.default.apps.edge
+ },
+ {
+ name: import_open2.default.apps.firefox
+ }
+ ]
+ });
+ childProcess2.on("error", () => {
+ logger.warn(errorMessage);
+ });
+}, "openInspector");
+
+// src/dev/local.tsx
+init_import_meta_url();
+var import_node_assert8 = __toESM(require("node:assert"));
+var import_chalk4 = __toESM(require_chalk());
+var import_react3 = __toESM(require_react());
+var import_signal_exit2 = __toESM(require_signal_exit());
+var import_undici6 = __toESM(require_undici());
+
+// src/dev/miniflare.ts
+init_import_meta_url();
+var import_node_assert7 = __toESM(require("node:assert"));
+var import_node_fs6 = require("node:fs");
+var import_promises2 = require("node:fs/promises");
+var import_node_path17 = __toESM(require("node:path"));
+var import_miniflare = require("miniflare");
+var EXTERNAL_DURABLE_OBJECTS_WORKER_NAME = "__WRANGLER_EXTERNAL_DURABLE_OBJECTS_WORKER";
+var EXTERNAL_DURABLE_OBJECTS_WORKER_SCRIPT = `
+const HEADER_URL = "X-Miniflare-Durable-Object-URL";
+const HEADER_NAME = "X-Miniflare-Durable-Object-Name";
+const HEADER_ID = "X-Miniflare-Durable-Object-Id";
+
+function createClass({ className, proxyUrl }) {
+ return class {
+ constructor(state) {
+ this.id = state.id.toString();
+ }
+ fetch(request) {
+ if (proxyUrl === undefined) {
+ return new Response(\`[wrangler] Couldn't find \\\`wrangler dev\\\` session for class "\${className}" to proxy to\`, { status: 503 });
+ }
+ const proxyRequest = new Request(proxyUrl, request);
+ proxyRequest.headers.set(HEADER_URL, request.url);
+ proxyRequest.headers.set(HEADER_NAME, className);
+ proxyRequest.headers.set(HEADER_ID, this.id);
+ return fetch(proxyRequest);
+ }
+ }
+}
+
+export default {
+ async fetch(request, env) {
+ const originalUrl = request.headers.get(HEADER_URL);
+ const className = request.headers.get(HEADER_NAME);
+ const idString = request.headers.get(HEADER_ID);
+ if (originalUrl === null || className === null || idString === null) {
+ return new Response("[wrangler] Received Durable Object proxy request with missing headers", { status: 400 });
+ }
+ request = new Request(originalUrl, request);
+ request.headers.delete(HEADER_URL);
+ request.headers.delete(HEADER_NAME);
+ request.headers.delete(HEADER_ID);
+ const ns = env[className];
+ const id = ns.idFromString(idString);
+ const stub = ns.get(id);
+ return stub.fetch(request);
+ }
+}
+`;
+var WranglerLog = class extends import_miniflare.Log {
+ #warnedCompatibilityDateFallback = false;
+ info(message) {
+ if (message.includes(EXTERNAL_DURABLE_OBJECTS_WORKER_NAME))
+ return;
+ super.info(message);
+ }
+ warn(message) {
+ if (message.startsWith("The latest compatibility date supported by")) {
+ if (this.#warnedCompatibilityDateFallback)
+ return;
+ this.#warnedCompatibilityDateFallback = true;
+ }
+ super.warn(message);
+ }
+};
+__name(WranglerLog, "WranglerLog");
+function getName(config) {
+ return config.name ?? "worker";
+}
+__name(getName, "getName");
+var IDENTIFIER_UNSAFE_REGEXP = /[^a-zA-Z0-9_$]/g;
+function getIdentifier(name) {
+ return name.replace(IDENTIFIER_UNSAFE_REGEXP, "_");
+}
+__name(getIdentifier, "getIdentifier");
+function buildLog() {
+ let level = logger.loggerLevel.toUpperCase();
+ if (level === "LOG")
+ level = "INFO";
+ const logLevel = import_miniflare.LogLevel[level];
+ return logLevel === import_miniflare.LogLevel.NONE ? new import_miniflare.NoOpLog() : new WranglerLog(logLevel);
+}
+__name(buildLog, "buildLog");
+async function buildSourceOptions(config) {
+ const scriptPath = (0, import_node_fs6.realpathSync)(config.bundle.path);
+ if (config.format === "modules") {
+ const modulesRoot = import_node_path17.default.dirname(scriptPath);
+ return {
+ modulesRoot,
+ modules: [
+ // Entrypoint
+ {
+ type: "ESModule",
+ path: scriptPath,
+ contents: await (0, import_promises2.readFile)(scriptPath, "utf-8")
+ },
+ // Misc (WebAssembly, etc, ...)
+ ...config.bundle.modules.map((module2) => ({
+ type: ModuleTypeToRuleType[module2.type ?? "esm"],
+ path: import_node_path17.default.resolve(modulesRoot, module2.name),
+ contents: module2.content
+ }))
+ ]
+ };
+ } else {
+ return { scriptPath };
+ }
+}
+__name(buildSourceOptions, "buildSourceOptions");
+function kvNamespaceEntry({ binding, id }) {
+ return [binding, id];
+}
+__name(kvNamespaceEntry, "kvNamespaceEntry");
+function r2BucketEntry({ binding, bucket_name }) {
+ return [binding, bucket_name];
+}
+__name(r2BucketEntry, "r2BucketEntry");
+function d1DatabaseEntry(db) {
+ return [db.binding, db.preview_database_id ?? db.database_id];
+}
+__name(d1DatabaseEntry, "d1DatabaseEntry");
+function queueProducerEntry(queue) {
+ return [queue.binding, queue.queue_name];
+}
+__name(queueProducerEntry, "queueProducerEntry");
+function queueConsumerEntry(consumer) {
+ const options14 = {
+ maxBatchSize: consumer.max_batch_size,
+ maxBatchTimeout: consumer.max_batch_timeout,
+ maxRetires: consumer.max_retries,
+ deadLetterQueue: consumer.dead_letter_queue
+ };
+ return [consumer.queue, options14];
+}
+__name(queueConsumerEntry, "queueConsumerEntry");
+function buildBindingOptions(config) {
+ const bindings = config.bindings;
+ const textBlobBindings = { ...bindings.text_blobs };
+ const dataBlobBindings = { ...bindings.data_blobs };
+ const wasmBindings = { ...bindings.wasm_modules };
+ if (config.format === "service-worker") {
+ const scriptPath = (0, import_node_fs6.realpathSync)(config.bundle.path);
+ const modulesRoot = import_node_path17.default.dirname(scriptPath);
+ for (const { type, name } of config.bundle.modules) {
+ if (type === "text") {
+ textBlobBindings[getIdentifier(name)] = import_node_path17.default.resolve(modulesRoot, name);
+ } else if (type === "buffer") {
+ dataBlobBindings[getIdentifier(name)] = import_node_path17.default.resolve(modulesRoot, name);
+ } else if (type === "compiled-wasm") {
+ wasmBindings[getIdentifier(name)] = import_node_path17.default.resolve(modulesRoot, name);
+ }
+ }
+ }
+ const internalObjects = [];
+ const externalObjects = [];
+ for (const binding of bindings.durable_objects?.bindings ?? []) {
+ const internal = binding.script_name === void 0 || binding.script_name === config.name;
+ (internal ? internalObjects : externalObjects).push(binding);
+ }
+ const externalDurableObjectWorker = {
+ name: EXTERNAL_DURABLE_OBJECTS_WORKER_NAME,
+ // Bind all internal objects, so they're accessible by all other sessions
+ // that proxy requests for our objects to this worker
+ durableObjects: Object.fromEntries(
+ internalObjects.map(({ class_name }) => [
+ class_name,
+ { className: class_name, scriptName: getName(config) }
+ ])
+ ),
+ // Use this worker instead of the user worker if the pathname is
+ // `/${EXTERNAL_DURABLE_OBJECTS_WORKER_NAME}`
+ routes: [`*/${EXTERNAL_DURABLE_OBJECTS_WORKER_NAME}`],
+ // Use in-memory storage for the stub object classes *declared* by this
+ // script. They don't need to persist anything, and would end up using the
+ // incorrect unsafe unique key.
+ unsafeEphemeralDurableObjects: true,
+ modules: true,
+ script: EXTERNAL_DURABLE_OBJECTS_WORKER_SCRIPT + // Add stub object classes that proxy requests to the correct session
+ externalObjects.map(({ class_name, script_name }) => {
+ (0, import_node_assert7.default)(script_name !== void 0);
+ const target = config.workerDefinitions?.[script_name];
+ const targetHasClass = target?.durableObjects.some(
+ ({ className }) => className === class_name
+ );
+ const identifier = getIdentifier(`${script_name}_${class_name}`);
+ const classNameJson = JSON.stringify(class_name);
+ if (target?.host === void 0 || target.port === void 0 || !targetHasClass) {
+ return `export const ${identifier} = createClass({ className: ${classNameJson} });`;
+ } else {
+ const proxyUrl = `http://${target.host}:${target.port}/${EXTERNAL_DURABLE_OBJECTS_WORKER_NAME}`;
+ const proxyUrlJson = JSON.stringify(proxyUrl);
+ return `export const ${identifier} = createClass({ className: ${classNameJson}, proxyUrl: ${proxyUrlJson} });`;
+ }
+ }).join("\n")
+ };
+ const bindingOptions = {
+ bindings: bindings.vars,
+ textBlobBindings,
+ dataBlobBindings,
+ wasmBindings,
+ kvNamespaces: Object.fromEntries(
+ bindings.kv_namespaces?.map(kvNamespaceEntry) ?? []
+ ),
+ r2Buckets: Object.fromEntries(
+ bindings.r2_buckets?.map(r2BucketEntry) ?? []
+ ),
+ d1Databases: Object.fromEntries(
+ bindings.d1_databases?.map(d1DatabaseEntry) ?? []
+ ),
+ queueProducers: Object.fromEntries(
+ bindings.queues?.map(queueProducerEntry) ?? []
+ ),
+ queueConsumers: Object.fromEntries(
+ config.queueConsumers?.map(queueConsumerEntry) ?? []
+ ),
+ durableObjects: Object.fromEntries([
+ ...internalObjects.map(({ name, class_name }) => [name, class_name]),
+ ...externalObjects.map(({ name, class_name, script_name }) => {
+ const identifier = getIdentifier(`${script_name}_${class_name}`);
+ return [
+ name,
+ {
+ className: identifier,
+ scriptName: EXTERNAL_DURABLE_OBJECTS_WORKER_NAME,
+ // Matches the unique key Miniflare will generate for this object in
+ // the target session. We need to do this so workerd generates the
+ // same IDs it would if this were part of the same process. workerd
+ // doesn't allow IDs from Durable Objects with different unique keys
+ // to be used with each other.
+ unsafeUniqueKey: `${script_name}-${class_name}`
+ }
+ ];
+ })
+ ]),
+ serviceBindings: config.serviceBindings
+ // TODO: check multi worker service bindings also supported
+ };
+ return {
+ bindingOptions,
+ internalObjects,
+ externalDurableObjectWorker
+ };
+}
+__name(buildBindingOptions, "buildBindingOptions");
+function buildPersistOptions(localPersistencePath) {
+ if (localPersistencePath !== null) {
+ const v3Path = import_node_path17.default.join(localPersistencePath, "v3");
+ return {
+ cachePersist: import_node_path17.default.join(v3Path, "cache"),
+ durableObjectsPersist: import_node_path17.default.join(v3Path, "do"),
+ kvPersist: import_node_path17.default.join(v3Path, "kv"),
+ r2Persist: import_node_path17.default.join(v3Path, "r2"),
+ d1Persist: import_node_path17.default.join(v3Path, "d1")
+ };
+ }
+}
+__name(buildPersistOptions, "buildPersistOptions");
+function buildSitesOptions({ assetPaths }) {
+ if (assetPaths !== void 0) {
+ const { baseDirectory, assetDirectory, includePatterns, excludePatterns } = assetPaths;
+ return {
+ sitePath: import_node_path17.default.join(baseDirectory, assetDirectory),
+ siteInclude: includePatterns.length > 0 ? includePatterns : void 0,
+ siteExclude: excludePatterns.length > 0 ? excludePatterns : void 0
+ };
+ }
+}
+__name(buildSitesOptions, "buildSitesOptions");
+async function buildMiniflareOptions(log, config) {
+ if (config.crons.length > 0) {
+ logger.warn("Miniflare 3 does not support CRON triggers yet, ignoring...");
+ }
+ const upstream = typeof config.localUpstream === "string" ? `${config.localProtocol}://${config.localUpstream}` : void 0;
+ const sourceOptions = await buildSourceOptions(config);
+ const { bindingOptions, internalObjects, externalDurableObjectWorker } = buildBindingOptions(config);
+ const sitesOptions = buildSitesOptions(config);
+ const persistOptions = buildPersistOptions(config.localPersistencePath);
+ let httpsOptions;
+ if (config.localProtocol === "https") {
+ const cert = await getHttpsOptions();
+ httpsOptions = {
+ httpsKey: cert.key,
+ httpsCert: cert.cert
+ };
+ }
+ const options14 = {
+ host: config.initialIp,
+ port: config.initialPort,
+ inspectorPort: config.inspect ? config.inspectorPort : void 0,
+ liveReload: config.liveReload,
+ upstream,
+ log,
+ verbose: logger.loggerLevel === "debug",
+ ...httpsOptions,
+ ...persistOptions,
+ workers: [
+ {
+ name: getName(config),
+ compatibilityDate: config.compatibilityDate,
+ compatibilityFlags: config.compatibilityFlags,
+ ...sourceOptions,
+ ...bindingOptions,
+ ...sitesOptions
+ },
+ externalDurableObjectWorker
+ ]
+ };
+ return { options: options14, internalObjects };
+}
+__name(buildMiniflareOptions, "buildMiniflareOptions");
+var ReloadedEvent = class extends Event {
+ url;
+ internalDurableObjects;
+ constructor(type, options14) {
+ super(type);
+ this.url = options14.url;
+ this.internalDurableObjects = options14.internalDurableObjects;
+ }
+};
+__name(ReloadedEvent, "ReloadedEvent");
+var ErrorEvent = class extends Event {
+ error;
+ constructor(type, options14) {
+ super(type);
+ this.error = options14.error;
+ }
+};
+__name(ErrorEvent, "ErrorEvent");
+var MiniflareServer = class extends import_miniflare.TypedEventTarget {
+ #log = buildLog();
+ #mf;
+ // `buildMiniflareOptions()` is asynchronous, meaning if multiple bundle
+ // updates were submitted, the second may apply before the first. Therefore,
+ // wrap updates in a mutex, so they're always applied in invocation order.
+ #mutex = new import_miniflare.Mutex();
+ async #onBundleUpdate(config, opts) {
+ if (opts?.signal?.aborted)
+ return;
+ try {
+ const { options: options14, internalObjects } = await buildMiniflareOptions(
+ this.#log,
+ config
+ );
+ if (opts?.signal?.aborted)
+ return;
+ if (this.#mf === void 0) {
+ this.#mf = new import_miniflare.Miniflare(options14);
+ } else {
+ await this.#mf.setOptions(options14);
+ }
+ const url3 = await this.#mf.ready;
+ if (opts?.signal?.aborted)
+ return;
+ const event = new ReloadedEvent("reloaded", {
+ url: url3,
+ internalDurableObjects: internalObjects
+ });
+ this.dispatchEvent(event);
+ } catch (error) {
+ this.dispatchEvent(new ErrorEvent("error", { error }));
+ }
+ }
+ onBundleUpdate(config, opts) {
+ return this.#mutex.runWith(() => this.#onBundleUpdate(config, opts));
+ }
+ #onDispose = async () => {
+ await this.#mf?.dispose();
+ this.#mf = void 0;
+ };
+ onDispose() {
+ return this.#mutex.runWith(this.#onDispose);
+ }
+};
+__name(MiniflareServer, "MiniflareServer");
+
+// src/dev/local.tsx
+async function localPropsToConfigBundle(props) {
+ (0, import_node_assert8.default)(props.bundle !== void 0);
+ const serviceBindings = {};
+ if (props.enablePagesAssetsServiceBinding !== void 0) {
+ const generateASSETSBinding2 = (init_assets(), __toCommonJS(assets_exports)).default;
+ serviceBindings.ASSETS = await generateASSETSBinding2({
+ log: logger,
+ ...props.enablePagesAssetsServiceBinding
+ });
+ }
+ return {
+ name: props.name,
+ bundle: props.bundle,
+ format: props.format,
+ compatibilityDate: props.compatibilityDate,
+ compatibilityFlags: props.compatibilityFlags,
+ inspectorPort: props.runtimeInspectorPort,
+ usageModel: props.usageModel,
+ bindings: props.bindings,
+ workerDefinitions: props.workerDefinitions,
+ assetPaths: props.assetPaths,
+ initialPort: props.initialPort,
+ initialIp: props.initialIp,
+ rules: props.rules,
+ localPersistencePath: props.localPersistencePath,
+ liveReload: props.liveReload,
+ crons: props.crons,
+ queueConsumers: props.queueConsumers,
+ localProtocol: props.localProtocol,
+ localUpstream: props.localUpstream,
+ inspect: props.inspect,
+ serviceBindings
+ };
+}
+__name(localPropsToConfigBundle, "localPropsToConfigBundle");
+function maybeRegisterLocalWorker(event, name) {
+ if (name === void 0)
+ return;
+ let protocol = event.url.protocol;
+ protocol = protocol.substring(0, event.url.protocol.length - 1);
+ if (protocol !== "http" && protocol !== "https")
+ return;
+ const port2 = parseInt(event.url.port);
+ return registerWorker(name, {
+ protocol,
+ mode: "local",
+ port: port2,
+ host: event.url.hostname,
+ durableObjects: event.internalDurableObjects.map((binding) => ({
+ name: binding.name,
+ className: binding.class_name
+ })),
+ durableObjectsHost: event.url.hostname,
+ durableObjectsPort: port2
+ });
+}
+__name(maybeRegisterLocalWorker, "maybeRegisterLocalWorker");
+function Local(props) {
+ const { inspectorUrl } = useLocalWorker(props);
+ useInspector({
+ inspectorUrl,
+ port: props.inspectorPort,
+ logToTerminal: true,
+ sourceMapPath: props.sourceMapPath,
+ name: props.name,
+ sourceMapMetadata: props.bundle?.sourceMapMetadata
+ });
+ return null;
+}
+__name(Local, "Local");
+function useLocalWorker(props) {
+ const miniflareServerRef = (0, import_react3.useRef)();
+ const removeMiniflareServerExitListenerRef = (0, import_react3.useRef)();
+ const [inspectorUrl, setInspectorUrl] = (0, import_react3.useState)();
+ (0, import_react3.useEffect)(() => {
+ if (props.bindings.services && props.bindings.services.length > 0) {
+ logger.warn(
+ "\u2394 Support for service bindings in local mode is experimental and may change."
+ );
+ }
+ }, [props.bindings.services]);
+ (0, import_react3.useEffect)(() => {
+ const externalDurableObjects = (props.bindings.durable_objects?.bindings || []).filter((binding) => binding.script_name);
+ if (externalDurableObjects.length > 0) {
+ logger.warn(
+ "\u2394 Support for external Durable Objects in local mode is experimental and may change."
+ );
+ }
+ }, [props.bindings.durable_objects?.bindings]);
+ (0, import_react3.useEffect)(() => {
+ const abortController = new AbortController();
+ if (!props.bundle || !props.format)
+ return;
+ let server2 = miniflareServerRef.current;
+ if (server2 === void 0) {
+ logger.log(import_chalk4.default.dim("\u2394 Starting local server..."));
+ const newServer = new MiniflareServer();
+ miniflareServerRef.current = server2 = newServer;
+ server2.addEventListener("reloaded", async (event) => {
+ await maybeRegisterLocalWorker(event, props.name);
+ props.onReady?.(event.url.hostname, parseInt(event.url.port));
+ try {
+ const jsonUrl = `http://127.0.0.1:${props.runtimeInspectorPort}/json`;
+ const res = await (0, import_undici6.fetch)(jsonUrl);
+ const body = await res.json();
+ const debuggerUrl = body?.find(
+ ({ id }) => id.startsWith("core:user")
+ )?.webSocketDebuggerUrl;
+ if (debuggerUrl === void 0) {
+ setInspectorUrl(void 0);
+ } else {
+ const url3 = new URL(debuggerUrl);
+ url3.username = `${Date.now()}-${Math.floor(
+ Math.random() * Number.MAX_SAFE_INTEGER
+ )}`;
+ setInspectorUrl(url3.toString());
+ }
+ } catch (error) {
+ logger.error("Error attempting to retrieve debugger URL:", error);
+ }
+ });
+ server2.addEventListener("error", ({ error }) => {
+ if (typeof error === "object" && error !== null && "code" in error && error.code === "ERR_RUNTIME_FAILURE") {
+ logger.error(String(error));
+ } else {
+ logger.error("Error reloading local server:", error);
+ }
+ });
+ removeMiniflareServerExitListenerRef.current = (0, import_signal_exit2.default)(() => {
+ logger.log(import_chalk4.default.dim("\u2394 Shutting down local server..."));
+ void newServer.onDispose();
+ miniflareServerRef.current = void 0;
+ });
+ } else {
+ logger.log(import_chalk4.default.dim("\u2394 Reloading local server..."));
+ }
+ const currentServer = server2;
+ void localPropsToConfigBundle(props).then(
+ (config) => currentServer.onBundleUpdate(config, { signal: abortController.signal })
+ );
+ return () => abortController.abort();
+ }, [props]);
+ (0, import_react3.useEffect)(
+ () => () => {
+ if (miniflareServerRef.current) {
+ logger.log(import_chalk4.default.dim("\u2394 Shutting down local server..."));
+ void miniflareServerRef.current.onDispose().catch(() => {
+ });
+ miniflareServerRef.current = void 0;
+ }
+ removeMiniflareServerExitListenerRef.current?.();
+ removeMiniflareServerExitListenerRef.current = void 0;
+ },
+ []
+ );
+ return { inspectorUrl };
+}
+__name(useLocalWorker, "useLocalWorker");
+
+// src/dev/remote.tsx
+init_import_meta_url();
+var import_promises15 = require("node:fs/promises");
+var import_node_path45 = __toESM(require("node:path"));
+var import_url3 = require("url");
+var import_ink10 = __toESM(require_build2());
+var import_ink_select_input3 = __toESM(require_build3());
+var import_react17 = __toESM(require_react());
+
+// src/create-worker-preview.ts
+init_import_meta_url();
+var import_node_url9 = require("node:url");
+var import_undici8 = __toESM(require_undici());
+
+// src/deployment-bundle/create-worker-upload-form.ts
+init_import_meta_url();
+var import_node_fs10 = require("node:fs");
+var import_undici7 = __toESM(require_undici());
+
+// src/deployment-bundle/capnp.ts
+init_import_meta_url();
+var import_node_child_process2 = require("node:child_process");
+var import_node_fs9 = require("node:fs");
+var import_node_path20 = require("node:path");
+var import_command_exists = __toESM(require_command_exists2());
+function handleUnsafeCapnp(capnp) {
+ if (capnp.compiled_schema) {
+ return (0, import_node_fs9.readFileSync)((0, import_node_path20.resolve)(capnp.compiled_schema));
+ }
+ const { base_path, source_schemas } = capnp;
+ const capnpSchemas = (source_schemas ?? []).map(
+ (x) => (0, import_node_path20.resolve)(base_path, x)
+ );
+ if (!(0, import_command_exists.sync)("capnp")) {
+ throw new Error(
+ "The capnp compiler is required to upload capnp schemas, but is not present."
+ );
+ }
+ const srcPrefix = (0, import_node_path20.resolve)(base_path ?? ".");
+ const capnpProcess = (0, import_node_child_process2.spawnSync)("capnp", [
+ "compile",
+ "-o-",
+ `--src-prefix=${srcPrefix}`,
+ ...capnpSchemas
+ ]);
+ if (capnpProcess.error)
+ throw capnpProcess.error;
+ if (capnpProcess.stderr.length)
+ throw new Error(capnpProcess.stderr.toString());
+ return capnpProcess.stdout;
+}
+__name(handleUnsafeCapnp, "handleUnsafeCapnp");
+
+// src/deployment-bundle/create-worker-upload-form.ts
+function toMimeType(type) {
+ switch (type) {
+ case "esm":
+ return "application/javascript+module";
+ case "commonjs":
+ return "application/javascript";
+ case "compiled-wasm":
+ return "application/wasm";
+ case "buffer":
+ return "application/octet-stream";
+ case "text":
+ return "text/plain";
+ default:
+ throw new TypeError("Unsupported module: " + type);
+ }
+}
+__name(toMimeType, "toMimeType");
+function createWorkerUploadForm(worker) {
+ const formData = new import_undici7.FormData();
+ const {
+ main: main2,
+ bindings,
+ migrations,
+ usage_model,
+ compatibility_date,
+ compatibility_flags,
+ keepVars,
+ logpush,
+ placement,
+ tail_consumers
+ } = worker;
+ let { modules } = worker;
+ const metadataBindings = [];
+ Object.entries(bindings.vars || {})?.forEach(([key, value]) => {
+ if (typeof value === "string") {
+ metadataBindings.push({ name: key, type: "plain_text", text: value });
+ } else {
+ metadataBindings.push({ name: key, type: "json", json: value });
+ }
+ });
+ bindings.kv_namespaces?.forEach(({ id, binding }) => {
+ metadataBindings.push({
+ name: binding,
+ type: "kv_namespace",
+ namespace_id: id
+ });
+ });
+ bindings.send_email?.forEach(
+ ({ name, destination_address, allowed_destination_addresses }) => {
+ metadataBindings.push({
+ name,
+ type: "send_email",
+ destination_address,
+ allowed_destination_addresses
+ });
+ }
+ );
+ bindings.durable_objects?.bindings.forEach(
+ ({ name, class_name, script_name, environment }) => {
+ metadataBindings.push({
+ name,
+ type: "durable_object_namespace",
+ class_name,
+ ...script_name && { script_name },
+ ...environment && { environment }
+ });
+ }
+ );
+ bindings.queues?.forEach(({ binding, queue_name }) => {
+ metadataBindings.push({
+ type: "queue",
+ name: binding,
+ queue_name
+ });
+ });
+ bindings.r2_buckets?.forEach(({ binding, bucket_name, jurisdiction }) => {
+ metadataBindings.push({
+ name: binding,
+ type: "r2_bucket",
+ bucket_name,
+ jurisdiction
+ });
+ });
+ bindings.d1_databases?.forEach(
+ ({ binding, database_id, database_internal_env }) => {
+ metadataBindings.push({
+ name: binding,
+ type: "d1",
+ id: database_id,
+ internalEnv: database_internal_env
+ });
+ }
+ );
+ bindings.constellation?.forEach(({ binding, project_id }) => {
+ metadataBindings.push({
+ name: binding,
+ type: "constellation",
+ project: project_id
+ });
+ });
+ bindings.services?.forEach(({ binding, service, environment }) => {
+ metadataBindings.push({
+ name: binding,
+ type: "service",
+ service,
+ ...environment && { environment }
+ });
+ });
+ bindings.analytics_engine_datasets?.forEach(({ binding, dataset }) => {
+ metadataBindings.push({
+ name: binding,
+ type: "analytics_engine",
+ dataset
+ });
+ });
+ bindings.dispatch_namespaces?.forEach(({ binding, namespace, outbound }) => {
+ metadataBindings.push({
+ name: binding,
+ type: "dispatch_namespace",
+ namespace,
+ ...outbound && {
+ outbound: {
+ worker: {
+ service: outbound.service,
+ environment: outbound.environment
+ },
+ params: outbound.parameters?.map((p) => ({ name: p }))
+ }
+ }
+ });
+ });
+ bindings.mtls_certificates?.forEach(({ binding, certificate_id }) => {
+ metadataBindings.push({
+ name: binding,
+ type: "mtls_certificate",
+ certificate_id
+ });
+ });
+ bindings.logfwdr?.bindings.forEach(({ name, destination }) => {
+ metadataBindings.push({
+ name,
+ type: "logfwdr",
+ destination
+ });
+ });
+ for (const [name, filePath] of Object.entries(bindings.wasm_modules || {})) {
+ metadataBindings.push({
+ name,
+ type: "wasm_module",
+ part: name
+ });
+ formData.set(
+ name,
+ new import_undici7.File([(0, import_node_fs10.readFileSync)(filePath)], filePath, {
+ type: "application/wasm"
+ })
+ );
+ }
+ if (bindings.browser !== void 0) {
+ metadataBindings.push({
+ name: bindings.browser.binding,
+ type: "browser"
+ });
+ }
+ for (const [name, filePath] of Object.entries(bindings.text_blobs || {})) {
+ metadataBindings.push({
+ name,
+ type: "text_blob",
+ part: name
+ });
+ if (name !== "__STATIC_CONTENT_MANIFEST") {
+ formData.set(
+ name,
+ new import_undici7.File([(0, import_node_fs10.readFileSync)(filePath)], filePath, {
+ type: "text/plain"
+ })
+ );
+ }
+ }
+ for (const [name, filePath] of Object.entries(bindings.data_blobs || {})) {
+ metadataBindings.push({
+ name,
+ type: "data_blob",
+ part: name
+ });
+ formData.set(
+ name,
+ new import_undici7.File([(0, import_node_fs10.readFileSync)(filePath)], filePath, {
+ type: "application/octet-stream"
+ })
+ );
+ }
+ if (main2.type === "commonjs") {
+ for (const module2 of Object.values([...modules || []])) {
+ if (module2.name === "__STATIC_CONTENT_MANIFEST") {
+ formData.set(
+ module2.name,
+ new import_undici7.File([module2.content], module2.name, {
+ type: "text/plain"
+ })
+ );
+ modules = modules?.filter((m) => m !== module2);
+ } else if (module2.type === "compiled-wasm" || module2.type === "text" || module2.type === "buffer") {
+ const name = module2.name.replace(/[^a-zA-Z0-9_$]/g, "_");
+ metadataBindings.push({
+ name,
+ type: module2.type === "compiled-wasm" ? "wasm_module" : module2.type === "text" ? "text_blob" : "data_blob",
+ part: name
+ });
+ formData.set(
+ name,
+ new import_undici7.File([module2.content], module2.name, {
+ type: module2.type === "compiled-wasm" ? "application/wasm" : module2.type === "text" ? "text/plain" : "application/octet-stream"
+ })
+ );
+ modules = modules?.filter((m) => m !== module2);
+ }
+ }
+ }
+ if (bindings.unsafe?.bindings) {
+ metadataBindings.push(...bindings.unsafe.bindings);
+ }
+ let capnpSchemaOutputFile;
+ if (bindings.unsafe?.capnp) {
+ const capnpOutput = handleUnsafeCapnp(bindings.unsafe.capnp);
+ capnpSchemaOutputFile = `./capnp-${Date.now()}.compiled`;
+ formData.set(
+ capnpSchemaOutputFile,
+ new import_undici7.File([capnpOutput], capnpSchemaOutputFile, {
+ type: "application/octet-stream"
+ })
+ );
+ }
+ const metadata = {
+ ...main2.type !== "commonjs" ? { main_module: main2.name } : { body_part: main2.name },
+ bindings: metadataBindings,
+ ...compatibility_date && { compatibility_date },
+ ...compatibility_flags && { compatibility_flags },
+ ...usage_model && { usage_model },
+ ...migrations && { migrations },
+ capnp_schema: capnpSchemaOutputFile,
+ ...keepVars && { keep_bindings: ["plain_text", "json"] },
+ ...logpush !== void 0 && { logpush },
+ ...placement && { placement },
+ ...tail_consumers && { tail_consumers }
+ };
+ if (bindings.unsafe?.metadata !== void 0) {
+ for (const key of Object.keys(bindings.unsafe.metadata)) {
+ metadata[key] = bindings.unsafe.metadata[key];
+ }
+ }
+ formData.set("metadata", JSON.stringify(metadata));
+ if (main2.type === "commonjs" && modules && modules.length > 0) {
+ throw new TypeError(
+ "More than one module can only be specified when type = 'esm'"
+ );
+ }
+ for (const module2 of [main2].concat(modules || [])) {
+ formData.set(
+ module2.name,
+ new import_undici7.File([module2.content], module2.name, {
+ type: toMimeType(module2.type ?? main2.type ?? "esm")
+ })
+ );
+ }
+ return formData;
+}
+__name(createWorkerUploadForm, "createWorkerUploadForm");
+
+// src/create-worker-preview.ts
+function randomId() {
+ return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function(c) {
+ const r = Math.random() * 16 | 0, v = c == "x" ? r : r & 3 | 8;
+ return v.toString(16);
+ });
+}
+__name(randomId, "randomId");
+function switchHost(originalUrl, host) {
+ const url3 = new import_node_url9.URL(originalUrl);
+ url3.hostname = host ?? url3.hostname;
+ return url3;
+}
+__name(switchHost, "switchHost");
+async function createPreviewSession(account, ctx, abortSignal) {
+ const { accountId } = account;
+ const initUrl = ctx.zone ? `/zones/${ctx.zone}/workers/edge-preview` : `/accounts/${accountId}/workers/subdomain/edge-preview`;
+ const { exchange_url } = await fetchResult(
+ initUrl,
+ void 0,
+ void 0,
+ abortSignal
+ );
+ const switchedExchangeUrl = switchHost(exchange_url, ctx.host).toString();
+ logger.debug(`-- START EXCHANGE API REQUEST: GET ${switchedExchangeUrl}`);
+ logger.debug("-- END EXCHANGE API REQUEST");
+ const exchangeResponse = await (0, import_undici8.fetch)(switchedExchangeUrl, {
+ signal: abortSignal
+ });
+ const bodyText = await exchangeResponse.text();
+ logger.debug(
+ "-- START EXCHANGE API RESPONSE:",
+ exchangeResponse.statusText,
+ exchangeResponse.status
+ );
+ logger.debug("HEADERS:", JSON.stringify(exchangeResponse.headers, null, 2));
+ logger.debug("RESPONSE:", bodyText);
+ logger.debug("-- END EXCHANGE API RESPONSE");
+ const { inspector_websocket, prewarm, token } = parseJSON(bodyText);
+ const inspector = new import_node_url9.URL(inspector_websocket);
+ inspector.searchParams.append("cf_workers_preview_token", token);
+ return {
+ id: randomId(),
+ value: token,
+ host: ctx.host ?? inspector.host,
+ inspectorUrl: switchHost(inspector.href, ctx.host),
+ prewarmUrl: switchHost(prewarm, ctx.host)
+ };
+}
+__name(createPreviewSession, "createPreviewSession");
+async function createPreviewToken(account, worker, ctx, session, abortSignal) {
+ const { value, host, inspectorUrl, prewarmUrl } = session;
+ const { accountId } = account;
+ const scriptId = worker.name || (ctx.zone ? session.id : host.split(".")[0]);
+ const url3 = ctx.env && !ctx.legacyEnv ? `/accounts/${accountId}/workers/services/${scriptId}/environments/${ctx.env}/edge-preview` : `/accounts/${accountId}/workers/scripts/${scriptId}/edge-preview`;
+ const mode = ctx.zone ? {
+ routes: ctx.routes ? (
+ // extract all the route patterns
+ ctx.routes.map((route2) => {
+ if (typeof route2 === "string") {
+ return route2;
+ }
+ if (route2.custom_domain) {
+ return `${route2.pattern}/*`;
+ }
+ return route2.pattern;
+ })
+ ) : (
+ // if there aren't any patterns, then just match on all routes
+ ["*/*"]
+ )
+ } : { workers_dev: true };
+ const formData = createWorkerUploadForm(worker);
+ formData.set("wrangler-session-config", JSON.stringify(mode));
+ const { preview_token } = await fetchResult(
+ url3,
+ {
+ method: "POST",
+ body: formData,
+ headers: {
+ "cf-preview-upload-config-token": value
+ }
+ },
+ void 0,
+ abortSignal
+ );
+ return {
+ value: preview_token,
+ host: ctx.host ?? (worker.name ? `${worker.name}.${host.split(".").slice(1).join(".")}` : host),
+ inspectorUrl,
+ prewarmUrl
+ };
+}
+__name(createPreviewToken, "createPreviewToken");
+async function createWorkerPreview(init, account, ctx, session, abortSignal) {
+ const token = await createPreviewToken(
+ account,
+ init,
+ ctx,
+ session,
+ abortSignal
+ );
+ const accessToken = await getAccessToken(token.prewarmUrl.hostname);
+ const headers = { "cf-workers-preview-token": token.value };
+ if (accessToken) {
+ headers.cookie = `CF_Authorization=${accessToken}`;
+ }
+ (0, import_undici8.fetch)(token.prewarmUrl.href, {
+ method: "POST",
+ signal: abortSignal,
+ headers
+ }).then(
+ (response) => {
+ if (!response.ok) {
+ logger.warn("worker failed to prewarm: ", response.statusText);
+ }
+ },
+ (err) => {
+ if (err.code !== "ABORT_ERR") {
+ logger.warn("worker failed to prewarm: ", err);
+ }
+ }
+ );
+ return token;
+}
+__name(createWorkerPreview, "createWorkerPreview");
+
+// src/deploy/deploy.ts
+init_import_meta_url();
+var import_node_assert14 = __toESM(require("node:assert"));
+var import_node_fs25 = require("node:fs");
+var import_node_path44 = __toESM(require("node:path"));
+var import_node_url11 = require("node:url");
+var import_chalk14 = __toESM(require_chalk());
+var import_tmp_promise2 = __toESM(require_tmp_promise());
+
+// src/deployment-bundle/bundle-reporter.ts
+init_import_meta_url();
+var import_node_buffer2 = require("node:buffer");
+var import_node_zlib = require("node:zlib");
+var import_chalk5 = __toESM(require_chalk());
+var ONE_KIB_BYTES = 1024;
+var ALLOWED_INITIAL_MAX = ONE_KIB_BYTES * 1024;
+async function getSize(modules) {
+ const gzipSize = (0, import_node_zlib.gzipSync)(
+ await new import_node_buffer2.Blob(modules.map((file) => file.content)).arrayBuffer()
+ ).byteLength;
+ const aggregateSize = new import_node_buffer2.Blob(modules.map((file) => file.content)).size;
+ return { size: aggregateSize, gzipSize };
+}
+__name(getSize, "getSize");
+async function printBundleSize(main2, modules) {
+ const { size, gzipSize } = await getSize([...modules, main2]);
+ const bundleReport = `${(size / ONE_KIB_BYTES).toFixed(2)} KiB / gzip: ${(gzipSize / ONE_KIB_BYTES).toFixed(2)} KiB`;
+ const percentage = gzipSize / ALLOWED_INITIAL_MAX * 100;
+ const colorizedReport = percentage > 90 ? import_chalk5.default.red(bundleReport) : percentage > 70 ? import_chalk5.default.yellow(bundleReport) : import_chalk5.default.green(bundleReport);
+ logger.log(`Total Upload: ${colorizedReport}`);
+ if (gzipSize > ALLOWED_INITIAL_MAX && !process.env.NO_SCRIPT_SIZE_WARNING) {
+ logger.warn(
+ "We recommend keeping your script less than 1MiB (1024 KiB) after gzip. Exceeding past this can affect cold start time"
+ );
+ }
+}
+__name(printBundleSize, "printBundleSize");
+function printOffendingDependencies(dependencies) {
+ const warning = [];
+ const dependenciesSorted = Object.entries(dependencies);
+ dependenciesSorted.sort(
+ ([_adep, aData], [_bdep, bData]) => bData.bytesInOutput - aData.bytesInOutput
+ );
+ const topLargest = dependenciesSorted.slice(0, 5);
+ if (topLargest.length > 0) {
+ warning.push(
+ `Here are the ${topLargest.length} largest dependencies included in your script:`
+ );
+ for (const [dep, data] of topLargest) {
+ warning.push(
+ `- ${dep} - ${(data.bytesInOutput / ONE_KIB_BYTES).toFixed(2)} KiB`
+ );
+ }
+ warning.push("If these are unnecessary, consider removing them");
+ logger.warn(warning.join("\n"));
+ }
+}
+__name(printOffendingDependencies, "printOffendingDependencies");
+
+// src/deployment-bundle/traverse-module-graph.ts
+init_import_meta_url();
+var import_promises3 = require("node:fs/promises");
+var import_node_path21 = __toESM(require("node:path"));
+var import_chalk6 = __toESM(require_chalk());
+async function getFiles(root, relativeTo) {
+ const files = [];
+ for (const file of await (0, import_promises3.readdir)(root, { withFileTypes: true })) {
+ if (file.isDirectory()) {
+ files.push(...await getFiles(import_node_path21.default.join(root, file.name), relativeTo));
+ } else {
+ files.push(
+ import_node_path21.default.relative(relativeTo, import_node_path21.default.join(root, file.name)).replaceAll("\\", "/")
+ );
+ }
+ }
+ return files;
+}
+__name(getFiles, "getFiles");
+async function traverseModuleGraph(entry, rules) {
+ const files = await getFiles(entry.moduleRoot, entry.moduleRoot);
+ const relativeEntryPoint = import_node_path21.default.relative(entry.moduleRoot, entry.file).replaceAll("\\", "/");
+ const modules = (await matchFiles(files, entry.moduleRoot, parseRules(rules))).filter((m) => m.name !== relativeEntryPoint).map((m) => ({
+ ...m,
+ name: m.name
+ }));
+ const bundleType = entry.format === "modules" ? "esm" : "commonjs";
+ if (modules.length > 0) {
+ logger.info(`Attaching additional modules:`);
+ modules.forEach(({ name, type }) => {
+ logger.info(`- ${import_chalk6.default.blue(name)} (${import_chalk6.default.green(type ?? "")})`);
+ });
+ }
+ return {
+ modules,
+ dependencies: {},
+ resolvedEntryPointPath: entry.file,
+ bundleType,
+ stop: void 0,
+ sourceMapPath: void 0,
+ sourceMapMetadata: void 0,
+ moduleCollector: void 0
+ };
+}
+__name(traverseModuleGraph, "traverseModuleGraph");
+
+// src/deployments.ts
+init_import_meta_url();
+var import_url2 = require("url");
+var import_toml6 = __toESM(require_toml());
+var import_chalk12 = __toESM(require_chalk());
+var import_undici16 = __toESM(require_undici());
+
+// src/init.ts
+init_import_meta_url();
+var fs17 = __toESM(require("node:fs"));
+var import_promises14 = require("node:fs/promises");
+var import_node_path43 = __toESM(require("node:path"));
+var import_toml5 = __toESM(require_toml());
+
+// src/git-client.ts
+init_import_meta_url();
+var import_node_fs11 = __toESM(require("node:fs"));
+var import_node_os7 = __toESM(require("node:os"));
+var import_node_path22 = __toESM(require("node:path"));
+
+// ../../node_modules/.pnpm/semiver@1.1.0/node_modules/semiver/dist/semiver.mjs
+init_import_meta_url();
+var fn = new Intl.Collator(0, { numeric: 1 }).compare;
+function semiver_default(a, b, bool) {
+ a = a.split(".");
+ b = b.split(".");
+ return fn(a[0], b[0]) || fn(a[1], b[1]) || (b[2] = b.slice(2).join("."), bool = /[.-]/.test(a[2] = a.slice(2).join(".")), bool == /[.-]/.test(b[2]) ? fn(a[2], b[2]) : bool ? -1 : 1);
+}
+__name(semiver_default, "default");
+
+// src/git-client.ts
+async function isInsideGitRepo(cwd2) {
+ const res = await findUp(".git", { cwd: cwd2, type: "directory" });
+ return res !== void 0;
+}
+__name(isInsideGitRepo, "isInsideGitRepo");
+async function getGitVersioon() {
+ try {
+ const gitVersionExecutionResult = await execa("git", ["--version"]);
+ if (gitVersionExecutionResult.exitCode !== 0) {
+ return null;
+ }
+ const [gitVersion] = /\d+.\d+.\d+/.exec(gitVersionExecutionResult.stdout) || [];
+ return gitVersion ?? null;
+ } catch (err) {
+ return null;
+ }
+}
+__name(getGitVersioon, "getGitVersioon");
+async function initializeGit(cwd2) {
+ try {
+ const { stdout: defaultBranchName } = await execa("git", [
+ "config",
+ "--get",
+ "init.defaultBranch"
+ ]);
+ await execa(
+ "git",
+ ["init", "--initial-branch", defaultBranchName.trim() ?? "main"],
+ {
+ cwd: cwd2
+ }
+ );
+ } catch {
+ await execa("git", ["init"], {
+ cwd: cwd2
+ });
+ }
+}
+__name(initializeGit, "initializeGit");
+async function cloneIntoDirectory(remote, targetDirectory, subdirectory) {
+ const args = ["clone", "--depth", "1"];
+ const gitVersion = await getGitVersioon();
+ if (!gitVersion) {
+ throw new Error("Failed to find git installation");
+ }
+ const useSparseCheckout = subdirectory && semiver_default(gitVersion, "2.26.0") > -1;
+ if (useSparseCheckout) {
+ args.push("--filter=blob:none", "--sparse");
+ }
+ const tagIndex = remote.lastIndexOf("#");
+ if (tagIndex === -1) {
+ args.push(remote);
+ } else {
+ args.push("-b", remote.substring(tagIndex + 1));
+ args.push(remote.substring(0, tagIndex));
+ }
+ const tempDir = import_node_fs11.default.mkdtempSync(
+ import_node_path22.default.join(import_node_os7.default.tmpdir(), `wrangler-generate-repo-`)
+ );
+ args.push(tempDir);
+ await execa("git", args);
+ if (useSparseCheckout) {
+ await execa("git", [`sparse-checkout`, `set`, subdirectory], {
+ cwd: tempDir
+ });
+ }
+ const templatePath = subdirectory !== void 0 ? import_node_path22.default.join(tempDir, subdirectory) : tempDir;
+ try {
+ import_node_fs11.default.renameSync(templatePath, targetDirectory);
+ } catch (err) {
+ if (err.code !== "EXDEV") {
+ logger.debug(err);
+ throw new Error(`Failed to find "${subdirectory}" in ${remote}`);
+ }
+ try {
+ import_node_fs11.default.cpSync(templatePath, targetDirectory, { recursive: true });
+ import_node_fs11.default.rmSync(templatePath, {
+ recursive: true,
+ force: true
+ });
+ } catch (moveErr) {
+ logger.debug(moveErr);
+ throw new Error(`Failed to find "${subdirectory}" in ${remote}`);
+ }
+ }
+ import_node_fs11.default.rmSync(import_node_path22.default.join(targetDirectory, ".git"), {
+ recursive: true,
+ force: true
+ });
+}
+__name(cloneIntoDirectory, "cloneIntoDirectory");
+
+// src/package-manager.ts
+init_import_meta_url();
+var import_node_fs12 = require("node:fs");
+var import_node_path23 = require("node:path");
+var import_node_process5 = require("node:process");
+async function getPackageManager(cwd2) {
+ const [hasYarn, hasNpm, hasPnpm] = await Promise.all([
+ supportsYarn(),
+ supportsNpm(),
+ supportsPnpm()
+ ]);
+ const hasYarnLock = (0, import_node_fs12.existsSync)((0, import_node_path23.join)(cwd2, "yarn.lock"));
+ const hasNpmLock = (0, import_node_fs12.existsSync)((0, import_node_path23.join)(cwd2, "package-lock.json"));
+ const hasPnpmLock = (0, import_node_fs12.existsSync)((0, import_node_path23.join)(cwd2, "pnpm-lock.yaml"));
+ const userAgent = sniffUserAgent();
+ if (hasNpmLock) {
+ if (hasNpm) {
+ logger.log(
+ "Using npm as package manager, as there is already a package-lock.json file."
+ );
+ return { ...NpmPackageManager, cwd: cwd2 };
+ } else if (hasYarn) {
+ logger.log("Using yarn as package manager.");
+ logger.warn(
+ "There is already a package-lock.json file but could not find npm on the PATH."
+ );
+ return { ...YarnPackageManager, cwd: cwd2 };
+ }
+ } else if (hasPnpmLock) {
+ if (hasPnpm) {
+ logger.log(
+ "Using pnpm as package manager, as there is already a pnpm-lock.yaml file."
+ );
+ return { ...PnpmPackageManager, cwd: cwd2 };
+ } else {
+ logger.warn(
+ "There is already a pnpm-lock.yaml file but could not find pnpm on the PATH."
+ );
+ }
+ } else if (hasYarnLock) {
+ if (hasYarn) {
+ logger.log(
+ "Using yarn as package manager, as there is already a yarn.lock file."
+ );
+ return { ...YarnPackageManager, cwd: cwd2 };
+ } else if (hasNpm) {
+ logger.log("Using npm as package manager.");
+ logger.warn(
+ "There is already a yarn.lock file but could not find yarn on the PATH."
+ );
+ return { ...NpmPackageManager, cwd: cwd2 };
+ }
+ }
+ if (userAgent === "npm" && hasNpm) {
+ logger.log("Using npm as package manager.");
+ return { ...NpmPackageManager, cwd: cwd2 };
+ } else if (userAgent === "pnpm" && hasPnpm) {
+ logger.log("Using pnpm as package manager.");
+ return { ...PnpmPackageManager, cwd: cwd2 };
+ } else if (userAgent === "yarn" && hasYarn) {
+ logger.log("Using yarn as package manager.");
+ return { ...YarnPackageManager, cwd: cwd2 };
+ }
+ if (hasNpm) {
+ logger.log("Using npm as package manager.");
+ return { ...NpmPackageManager, cwd: cwd2 };
+ } else if (hasYarn) {
+ logger.log("Using yarn as package manager.");
+ return { ...YarnPackageManager, cwd: cwd2 };
+ } else if (hasPnpm) {
+ logger.log("Using pnpm as package manager.");
+ return { ...PnpmPackageManager, cwd: cwd2 };
+ } else {
+ throw new Error(
+ "Unable to find a package manager. Supported managers are: npm, yarn, and pnpm."
+ );
+ }
+}
+__name(getPackageManager, "getPackageManager");
+var NpmPackageManager = {
+ cwd: process.cwd(),
+ type: "npm",
+ /** Add and install a new devDependency into the local package.json. */
+ async addDevDeps(...packages) {
+ await execa("npm", ["install", ...packages, "--save-dev"], {
+ stdio: "inherit",
+ cwd: this.cwd
+ });
+ },
+ /** Install all the dependencies in the local package.json. */
+ async install() {
+ await execa("npm", ["install"], {
+ stdio: "inherit",
+ cwd: this.cwd
+ });
+ }
+};
+var PnpmPackageManager = {
+ cwd: process.cwd(),
+ type: "pnpm",
+ /** Add and install a new devDependency into the local package.json. */
+ async addDevDeps(...packages) {
+ await execa("pnpm", ["install", ...packages, "--save-dev"], {
+ stdio: "inherit",
+ cwd: this.cwd
+ });
+ },
+ /** Install all the dependencies in the local package.json. */
+ async install() {
+ await execa("pnpm", ["install"], {
+ stdio: "inherit",
+ cwd: this.cwd
+ });
+ }
+};
+var YarnPackageManager = {
+ cwd: process.cwd(),
+ type: "yarn",
+ /** Add and install a new devDependency into the local package.json. */
+ async addDevDeps(...packages) {
+ await execa("yarn", ["add", ...packages, "--dev"], {
+ stdio: "inherit",
+ cwd: this.cwd
+ });
+ },
+ /** Install all the dependencies in the local package.json. */
+ async install() {
+ await execa("yarn", ["install"], {
+ stdio: "inherit",
+ cwd: this.cwd
+ });
+ }
+};
+async function supports(name) {
+ try {
+ execaCommandSync(`${name} --version`, { stdio: "ignore" });
+ return true;
+ } catch {
+ return false;
+ }
+}
+__name(supports, "supports");
+function supportsYarn() {
+ return supports("yarn");
+}
+__name(supportsYarn, "supportsYarn");
+function supportsNpm() {
+ return supports("npm");
+}
+__name(supportsNpm, "supportsNpm");
+function supportsPnpm() {
+ return supports("pnpm");
+}
+__name(supportsPnpm, "supportsPnpm");
+function sniffUserAgent() {
+ const userAgent = import_node_process5.env.npm_config_user_agent;
+ if (userAgent === void 0) {
+ return void 0;
+ }
+ if (userAgent.includes("yarn")) {
+ return "yarn";
+ }
+ if (userAgent.includes("pnpm")) {
+ return "pnpm";
+ }
+ if (userAgent.includes("npm")) {
+ return "npm";
+ }
+}
+__name(sniffUserAgent, "sniffUserAgent");
+
+// src/index.ts
+init_import_meta_url();
+var import_node_os13 = __toESM(require("node:os"));
+var import_toml4 = __toESM(require_toml());
+var import_chalk11 = __toESM(require_chalk());
+
+// ../../node_modules/.pnpm/supports-color@9.2.2/node_modules/supports-color/index.js
+init_import_meta_url();
+var import_node_process6 = __toESM(require("node:process"), 1);
+var import_node_os8 = __toESM(require("node:os"), 1);
+var import_node_tty = __toESM(require("node:tty"), 1);
+function hasFlag(flag, argv = import_node_process6.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);
+}
+__name(hasFlag, "hasFlag");
+var { env: env4 } = import_node_process6.default;
+var flagForceColor;
+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;
+}
+function envForceColor() {
+ if ("FORCE_COLOR" in env4) {
+ if (env4.FORCE_COLOR === "true") {
+ return 1;
+ }
+ if (env4.FORCE_COLOR === "false") {
+ return 0;
+ }
+ return env4.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env4.FORCE_COLOR, 10), 3);
+ }
+}
+__name(envForceColor, "envForceColor");
+function translateLevel(level) {
+ if (level === 0) {
+ return false;
+ }
+ return {
+ level,
+ hasBasic: true,
+ has256: level >= 2,
+ has16m: level >= 3
+ };
+}
+__name(translateLevel, "translateLevel");
+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 (haveStream && !streamIsTTY && forceColor === void 0) {
+ return 0;
+ }
+ const min = forceColor || 0;
+ if (env4.TERM === "dumb") {
+ return min;
+ }
+ if (import_node_process6.default.platform === "win32") {
+ const osRelease = import_node_os8.default.release().split(".");
+ if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
+ return Number(osRelease[2]) >= 14931 ? 3 : 2;
+ }
+ return 1;
+ }
+ if ("CI" in env4) {
+ if (["TRAVIS", "CIRCLECI", "APPVEYOR", "GITLAB_CI", "GITHUB_ACTIONS", "BUILDKITE", "DRONE"].some((sign) => sign in env4) || env4.CI_NAME === "codeship") {
+ return 1;
+ }
+ return min;
+ }
+ if ("TEAMCITY_VERSION" in env4) {
+ return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env4.TEAMCITY_VERSION) ? 1 : 0;
+ }
+ if ("TF_BUILD" in env4 && "AGENT_NAME" in env4) {
+ return 1;
+ }
+ if (env4.COLORTERM === "truecolor") {
+ return 3;
+ }
+ if ("TERM_PROGRAM" in env4) {
+ const version2 = Number.parseInt((env4.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+ switch (env4.TERM_PROGRAM) {
+ case "iTerm.app":
+ return version2 >= 3 ? 3 : 2;
+ case "Apple_Terminal":
+ return 2;
+ }
+ }
+ if (/-256(color)?$/i.test(env4.TERM)) {
+ return 2;
+ }
+ if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env4.TERM)) {
+ return 1;
+ }
+ if ("COLORTERM" in env4) {
+ return 1;
+ }
+ return min;
+}
+__name(_supportsColor, "_supportsColor");
+function createSupportsColor(stream2, options14 = {}) {
+ const level = _supportsColor(stream2, {
+ streamIsTTY: stream2 && stream2.isTTY,
+ ...options14
+ });
+ return translateLevel(level);
+}
+__name(createSupportsColor, "createSupportsColor");
+var supportsColor = {
+ stdout: createSupportsColor({ isTTY: import_node_tty.default.isatty(1) }),
+ stderr: createSupportsColor({ isTTY: import_node_tty.default.isatty(2) })
+};
+var supports_color_default = supportsColor;
+
+// src/index.ts
+var import_undici15 = __toESM(require_undici());
+
+// ../../node_modules/.pnpm/yargs@17.7.1/node_modules/yargs/index.mjs
+init_import_meta_url();
+
+// ../../node_modules/.pnpm/yargs@17.7.1/node_modules/yargs/build/lib/yargs-factory.js
+init_import_meta_url();
+
+// ../../node_modules/.pnpm/yargs@17.7.1/node_modules/yargs/build/lib/command.js
+init_import_meta_url();
+
+// ../../node_modules/.pnpm/yargs@17.7.1/node_modules/yargs/build/lib/typings/common-types.js
+init_import_meta_url();
+function assertNotStrictEqual(actual, expected, shim3, message) {
+ shim3.assert.notStrictEqual(actual, expected, message);
+}
+__name(assertNotStrictEqual, "assertNotStrictEqual");
+function assertSingleKey(actual, shim3) {
+ shim3.assert.strictEqual(typeof actual, "string");
+}
+__name(assertSingleKey, "assertSingleKey");
+function objectKeys(object) {
+ return Object.keys(object);
+}
+__name(objectKeys, "objectKeys");
+
+// ../../node_modules/.pnpm/yargs@17.7.1/node_modules/yargs/build/lib/utils/is-promise.js
+init_import_meta_url();
+function isPromise(maybePromise) {
+ return !!maybePromise && !!maybePromise.then && typeof maybePromise.then === "function";
+}
+__name(isPromise, "isPromise");
+
+// ../../node_modules/.pnpm/yargs@17.7.1/node_modules/yargs/build/lib/middleware.js
+init_import_meta_url();
+
+// ../../node_modules/.pnpm/yargs@17.7.1/node_modules/yargs/build/lib/argsert.js
+init_import_meta_url();
+
+// ../../node_modules/.pnpm/yargs@17.7.1/node_modules/yargs/build/lib/parse-command.js
+init_import_meta_url();
+function parseCommand2(cmd) {
+ const extraSpacesStrippedCommand = cmd.replace(/\s{2,}/g, " ");
+ const splitCommand = extraSpacesStrippedCommand.split(/\s+(?![^[]*]|[^<]*>)/);
+ const bregex = /\.*[\][<>]/g;
+ const firstCommand = splitCommand.shift();
+ if (!firstCommand)
+ throw new Error(`No command found in: ${cmd}`);
+ const parsedCommand = {
+ cmd: firstCommand.replace(bregex, ""),
+ demanded: [],
+ optional: []
+ };
+ splitCommand.forEach((cmd2, i) => {
+ let variadic = false;
+ cmd2 = cmd2.replace(/\s/g, "");
+ if (/\.+[\]>]/.test(cmd2) && i === splitCommand.length - 1)
+ variadic = true;
+ if (/^\[/.test(cmd2)) {
+ parsedCommand.optional.push({
+ cmd: cmd2.replace(bregex, "").split("|"),
+ variadic
+ });
+ } else {
+ parsedCommand.demanded.push({
+ cmd: cmd2.replace(bregex, "").split("|"),
+ variadic
+ });
+ }
+ });
+ return parsedCommand;
+}
+__name(parseCommand2, "parseCommand");
+
+// ../../node_modules/.pnpm/yargs@17.7.1/node_modules/yargs/build/lib/argsert.js
+var positionName = ["first", "second", "third", "fourth", "fifth", "sixth"];
+function argsert(arg1, arg2, arg3) {
+ function parseArgs() {
+ return typeof arg1 === "object" ? [{ demanded: [], optional: [] }, arg1, arg2] : [
+ parseCommand2(`cmd ${arg1}`),
+ arg2,
+ arg3
+ ];
+ }
+ __name(parseArgs, "parseArgs");
+ try {
+ let position = 0;
+ const [parsed, callerArguments, _length] = parseArgs();
+ const args = [].slice.call(callerArguments);
+ while (args.length && args[args.length - 1] === void 0)
+ args.pop();
+ const length = _length || args.length;
+ if (length < parsed.demanded.length) {
+ throw new YError(`Not enough arguments provided. Expected ${parsed.demanded.length} but received ${args.length}.`);
+ }
+ const totalCommands = parsed.demanded.length + parsed.optional.length;
+ if (length > totalCommands) {
+ throw new YError(`Too many arguments provided. Expected max ${totalCommands} but received ${length}.`);
+ }
+ parsed.demanded.forEach((demanded) => {
+ const arg = args.shift();
+ const observedType = guessType(arg);
+ const matchingTypes = demanded.cmd.filter((type) => type === observedType || type === "*");
+ if (matchingTypes.length === 0)
+ argumentTypeError(observedType, demanded.cmd, position);
+ position += 1;
+ });
+ parsed.optional.forEach((optional) => {
+ if (args.length === 0)
+ return;
+ const arg = args.shift();
+ const observedType = guessType(arg);
+ const matchingTypes = optional.cmd.filter((type) => type === observedType || type === "*");
+ if (matchingTypes.length === 0)
+ argumentTypeError(observedType, optional.cmd, position);
+ position += 1;
+ });
+ } catch (err) {
+ console.warn(err.stack);
+ }
+}
+__name(argsert, "argsert");
+function guessType(arg) {
+ if (Array.isArray(arg)) {
+ return "array";
+ } else if (arg === null) {
+ return "null";
+ }
+ return typeof arg;
+}
+__name(guessType, "guessType");
+function argumentTypeError(observedType, allowedTypes, position) {
+ throw new YError(`Invalid ${positionName[position] || "manyith"} argument. Expected ${allowedTypes.join(" or ")} but received ${observedType}.`);
+}
+__name(argumentTypeError, "argumentTypeError");
+
+// ../../node_modules/.pnpm/yargs@17.7.1/node_modules/yargs/build/lib/middleware.js
+var GlobalMiddleware = class {
+ constructor(yargs) {
+ this.globalMiddleware = [];
+ this.frozens = [];
+ this.yargs = yargs;
+ }
+ addMiddleware(callback, applyBeforeValidation, global2 = true, mutates = false) {
+ argsert(" [boolean] [boolean] [boolean]", [callback, applyBeforeValidation, global2], arguments.length);
+ if (Array.isArray(callback)) {
+ for (let i = 0; i < callback.length; i++) {
+ if (typeof callback[i] !== "function") {
+ throw Error("middleware must be a function");
+ }
+ const m = callback[i];
+ m.applyBeforeValidation = applyBeforeValidation;
+ m.global = global2;
+ }
+ Array.prototype.push.apply(this.globalMiddleware, callback);
+ } else if (typeof callback === "function") {
+ const m = callback;
+ m.applyBeforeValidation = applyBeforeValidation;
+ m.global = global2;
+ m.mutates = mutates;
+ this.globalMiddleware.push(callback);
+ }
+ return this.yargs;
+ }
+ addCoerceMiddleware(callback, option) {
+ const aliases2 = this.yargs.getAliases();
+ this.globalMiddleware = this.globalMiddleware.filter((m) => {
+ const toCheck = [...aliases2[option] || [], option];
+ if (!m.option)
+ return true;
+ else
+ return !toCheck.includes(m.option);
+ });
+ callback.option = option;
+ return this.addMiddleware(callback, true, true, true);
+ }
+ getMiddleware() {
+ return this.globalMiddleware;
+ }
+ freeze() {
+ this.frozens.push([...this.globalMiddleware]);
+ }
+ unfreeze() {
+ const frozen = this.frozens.pop();
+ if (frozen !== void 0)
+ this.globalMiddleware = frozen;
+ }
+ reset() {
+ this.globalMiddleware = this.globalMiddleware.filter((m) => m.global);
+ }
+};
+__name(GlobalMiddleware, "GlobalMiddleware");
+function commandMiddlewareFactory(commandMiddleware) {
+ if (!commandMiddleware)
+ return [];
+ return commandMiddleware.map((middleware) => {
+ middleware.applyBeforeValidation = false;
+ return middleware;
+ });
+}
+__name(commandMiddlewareFactory, "commandMiddlewareFactory");
+function applyMiddleware(argv, yargs, middlewares, beforeValidation) {
+ return middlewares.reduce((acc, middleware) => {
+ if (middleware.applyBeforeValidation !== beforeValidation) {
+ return acc;
+ }
+ if (middleware.mutates) {
+ if (middleware.applied)
+ return acc;
+ middleware.applied = true;
+ }
+ if (isPromise(acc)) {
+ return acc.then((initialObj) => Promise.all([initialObj, middleware(initialObj, yargs)])).then(([initialObj, middlewareObj]) => Object.assign(initialObj, middlewareObj));
+ } else {
+ const result = middleware(acc, yargs);
+ return isPromise(result) ? result.then((middlewareObj) => Object.assign(acc, middlewareObj)) : Object.assign(acc, result);
+ }
+ }, argv);
+}
+__name(applyMiddleware, "applyMiddleware");
+
+// ../../node_modules/.pnpm/yargs@17.7.1/node_modules/yargs/build/lib/utils/maybe-async-result.js
+init_import_meta_url();
+function maybeAsyncResult(getResult, resultHandler, errorHandler = (err) => {
+ throw err;
+}) {
+ try {
+ const result = isFunction(getResult) ? getResult() : getResult;
+ return isPromise(result) ? result.then((result2) => resultHandler(result2)) : resultHandler(result);
+ } catch (err) {
+ return errorHandler(err);
+ }
+}
+__name(maybeAsyncResult, "maybeAsyncResult");
+function isFunction(arg) {
+ return typeof arg === "function";
+}
+__name(isFunction, "isFunction");
+
+// ../../node_modules/.pnpm/yargs@17.7.1/node_modules/yargs/build/lib/utils/which-module.js
+init_import_meta_url();
+function whichModule(exported) {
+ if (typeof require === "undefined")
+ return null;
+ for (let i = 0, files = Object.keys(require.cache), mod; i < files.length; i++) {
+ mod = require.cache[files[i]];
+ if (mod.exports === exported)
+ return mod;
+ }
+ return null;
+}
+__name(whichModule, "whichModule");
+
+// ../../node_modules/.pnpm/yargs@17.7.1/node_modules/yargs/build/lib/command.js
+var DEFAULT_MARKER = /(^\*)|(^\$0)/;
+var CommandInstance = class {
+ constructor(usage2, validation2, globalMiddleware, shim3) {
+ this.requireCache = /* @__PURE__ */ new Set();
+ this.handlers = {};
+ this.aliasMap = {};
+ this.frozens = [];
+ this.shim = shim3;
+ this.usage = usage2;
+ this.globalMiddleware = globalMiddleware;
+ this.validation = validation2;
+ }
+ addDirectory(dir, req, callerFile, opts) {
+ opts = opts || {};
+ if (typeof opts.recurse !== "boolean")
+ opts.recurse = false;
+ if (!Array.isArray(opts.extensions))
+ opts.extensions = ["js"];
+ const parentVisit = typeof opts.visit === "function" ? opts.visit : (o) => o;
+ opts.visit = (obj, joined, filename) => {
+ const visited = parentVisit(obj, joined, filename);
+ if (visited) {
+ if (this.requireCache.has(joined))
+ return visited;
+ else
+ this.requireCache.add(joined);
+ this.addHandler(visited);
+ }
+ return visited;
+ };
+ this.shim.requireDirectory({ require: req, filename: callerFile }, dir, opts);
+ }
+ addHandler(cmd, description, builder, handler15, commandMiddleware, deprecated2) {
+ let aliases2 = [];
+ const middlewares = commandMiddlewareFactory(commandMiddleware);
+ handler15 = handler15 || (() => {
+ });
+ if (Array.isArray(cmd)) {
+ if (isCommandAndAliases(cmd)) {
+ [cmd, ...aliases2] = cmd;
+ } else {
+ for (const command2 of cmd) {
+ this.addHandler(command2);
+ }
+ }
+ } else if (isCommandHandlerDefinition(cmd)) {
+ let command2 = Array.isArray(cmd.command) || typeof cmd.command === "string" ? cmd.command : this.moduleName(cmd);
+ if (cmd.aliases)
+ command2 = [].concat(command2).concat(cmd.aliases);
+ this.addHandler(command2, this.extractDesc(cmd), cmd.builder, cmd.handler, cmd.middlewares, cmd.deprecated);
+ return;
+ } else if (isCommandBuilderDefinition(builder)) {
+ this.addHandler([cmd].concat(aliases2), description, builder.builder, builder.handler, builder.middlewares, builder.deprecated);
+ return;
+ }
+ if (typeof cmd === "string") {
+ const parsedCommand = parseCommand2(cmd);
+ aliases2 = aliases2.map((alias) => parseCommand2(alias).cmd);
+ let isDefault = false;
+ const parsedAliases = [parsedCommand.cmd].concat(aliases2).filter((c) => {
+ if (DEFAULT_MARKER.test(c)) {
+ isDefault = true;
+ return false;
+ }
+ return true;
+ });
+ if (parsedAliases.length === 0 && isDefault)
+ parsedAliases.push("$0");
+ if (isDefault) {
+ parsedCommand.cmd = parsedAliases[0];
+ aliases2 = parsedAliases.slice(1);
+ cmd = cmd.replace(DEFAULT_MARKER, parsedCommand.cmd);
+ }
+ aliases2.forEach((alias) => {
+ this.aliasMap[alias] = parsedCommand.cmd;
+ });
+ if (description !== false) {
+ this.usage.command(cmd, description, isDefault, aliases2, deprecated2);
+ }
+ this.handlers[parsedCommand.cmd] = {
+ original: cmd,
+ description,
+ handler: handler15,
+ builder: builder || {},
+ middlewares,
+ deprecated: deprecated2,
+ demanded: parsedCommand.demanded,
+ optional: parsedCommand.optional
+ };
+ if (isDefault)
+ this.defaultCommand = this.handlers[parsedCommand.cmd];
+ }
+ }
+ getCommandHandlers() {
+ return this.handlers;
+ }
+ getCommands() {
+ return Object.keys(this.handlers).concat(Object.keys(this.aliasMap));
+ }
+ hasDefaultCommand() {
+ return !!this.defaultCommand;
+ }
+ runCommand(command2, yargs, parsed, commandIndex, helpOnly, helpOrVersionSet) {
+ const commandHandler = this.handlers[command2] || this.handlers[this.aliasMap[command2]] || this.defaultCommand;
+ const currentContext = yargs.getInternalMethods().getContext();
+ const parentCommands = currentContext.commands.slice();
+ const isDefaultCommand = !command2;
+ if (command2) {
+ currentContext.commands.push(command2);
+ currentContext.fullCommands.push(commandHandler.original);
+ }
+ const builderResult = this.applyBuilderUpdateUsageAndParse(isDefaultCommand, commandHandler, yargs, parsed.aliases, parentCommands, commandIndex, helpOnly, helpOrVersionSet);
+ return isPromise(builderResult) ? builderResult.then((result) => this.applyMiddlewareAndGetResult(isDefaultCommand, commandHandler, result.innerArgv, currentContext, helpOnly, result.aliases, yargs)) : this.applyMiddlewareAndGetResult(isDefaultCommand, commandHandler, builderResult.innerArgv, currentContext, helpOnly, builderResult.aliases, yargs);
+ }
+ applyBuilderUpdateUsageAndParse(isDefaultCommand, commandHandler, yargs, aliases2, parentCommands, commandIndex, helpOnly, helpOrVersionSet) {
+ const builder = commandHandler.builder;
+ let innerYargs = yargs;
+ if (isCommandBuilderCallback(builder)) {
+ yargs.getInternalMethods().getUsageInstance().freeze();
+ const builderOutput = builder(yargs.getInternalMethods().reset(aliases2), helpOrVersionSet);
+ if (isPromise(builderOutput)) {
+ return builderOutput.then((output) => {
+ innerYargs = isYargsInstance(output) ? output : yargs;
+ return this.parseAndUpdateUsage(isDefaultCommand, commandHandler, innerYargs, parentCommands, commandIndex, helpOnly);
+ });
+ }
+ } else if (isCommandBuilderOptionDefinitions(builder)) {
+ yargs.getInternalMethods().getUsageInstance().freeze();
+ innerYargs = yargs.getInternalMethods().reset(aliases2);
+ Object.keys(commandHandler.builder).forEach((key) => {
+ innerYargs.option(key, builder[key]);
+ });
+ }
+ return this.parseAndUpdateUsage(isDefaultCommand, commandHandler, innerYargs, parentCommands, commandIndex, helpOnly);
+ }
+ parseAndUpdateUsage(isDefaultCommand, commandHandler, innerYargs, parentCommands, commandIndex, helpOnly) {
+ if (isDefaultCommand)
+ innerYargs.getInternalMethods().getUsageInstance().unfreeze(true);
+ if (this.shouldUpdateUsage(innerYargs)) {
+ innerYargs.getInternalMethods().getUsageInstance().usage(this.usageFromParentCommandsCommandHandler(parentCommands, commandHandler), commandHandler.description);
+ }
+ const innerArgv = innerYargs.getInternalMethods().runYargsParserAndExecuteCommands(null, void 0, true, commandIndex, helpOnly);
+ return isPromise(innerArgv) ? innerArgv.then((argv) => ({
+ aliases: innerYargs.parsed.aliases,
+ innerArgv: argv
+ })) : {
+ aliases: innerYargs.parsed.aliases,
+ innerArgv
+ };
+ }
+ shouldUpdateUsage(yargs) {
+ return !yargs.getInternalMethods().getUsageInstance().getUsageDisabled() && yargs.getInternalMethods().getUsageInstance().getUsage().length === 0;
+ }
+ usageFromParentCommandsCommandHandler(parentCommands, commandHandler) {
+ const c = DEFAULT_MARKER.test(commandHandler.original) ? commandHandler.original.replace(DEFAULT_MARKER, "").trim() : commandHandler.original;
+ const pc = parentCommands.filter((c2) => {
+ return !DEFAULT_MARKER.test(c2);
+ });
+ pc.push(c);
+ return `$0 ${pc.join(" ")}`;
+ }
+ handleValidationAndGetResult(isDefaultCommand, commandHandler, innerArgv, currentContext, aliases2, yargs, middlewares, positionalMap) {
+ if (!yargs.getInternalMethods().getHasOutput()) {
+ const validation2 = yargs.getInternalMethods().runValidation(aliases2, positionalMap, yargs.parsed.error, isDefaultCommand);
+ innerArgv = maybeAsyncResult(innerArgv, (result) => {
+ validation2(result);
+ return result;
+ });
+ }
+ if (commandHandler.handler && !yargs.getInternalMethods().getHasOutput()) {
+ yargs.getInternalMethods().setHasOutput();
+ const populateDoubleDash = !!yargs.getOptions().configuration["populate--"];
+ yargs.getInternalMethods().postProcess(innerArgv, populateDoubleDash, false, false);
+ innerArgv = applyMiddleware(innerArgv, yargs, middlewares, false);
+ innerArgv = maybeAsyncResult(innerArgv, (result) => {
+ const handlerResult = commandHandler.handler(result);
+ return isPromise(handlerResult) ? handlerResult.then(() => result) : result;
+ });
+ if (!isDefaultCommand) {
+ yargs.getInternalMethods().getUsageInstance().cacheHelpMessage();
+ }
+ if (isPromise(innerArgv) && !yargs.getInternalMethods().hasParseCallback()) {
+ innerArgv.catch((error) => {
+ try {
+ yargs.getInternalMethods().getUsageInstance().fail(null, error);
+ } catch (_err) {
+ }
+ });
+ }
+ }
+ if (!isDefaultCommand) {
+ currentContext.commands.pop();
+ currentContext.fullCommands.pop();
+ }
+ return innerArgv;
+ }
+ applyMiddlewareAndGetResult(isDefaultCommand, commandHandler, innerArgv, currentContext, helpOnly, aliases2, yargs) {
+ let positionalMap = {};
+ if (helpOnly)
+ return innerArgv;
+ if (!yargs.getInternalMethods().getHasOutput()) {
+ positionalMap = this.populatePositionals(commandHandler, innerArgv, currentContext, yargs);
+ }
+ const middlewares = this.globalMiddleware.getMiddleware().slice(0).concat(commandHandler.middlewares);
+ const maybePromiseArgv = applyMiddleware(innerArgv, yargs, middlewares, true);
+ return isPromise(maybePromiseArgv) ? maybePromiseArgv.then((resolvedInnerArgv) => this.handleValidationAndGetResult(isDefaultCommand, commandHandler, resolvedInnerArgv, currentContext, aliases2, yargs, middlewares, positionalMap)) : this.handleValidationAndGetResult(isDefaultCommand, commandHandler, maybePromiseArgv, currentContext, aliases2, yargs, middlewares, positionalMap);
+ }
+ populatePositionals(commandHandler, argv, context2, yargs) {
+ argv._ = argv._.slice(context2.commands.length);
+ const demanded = commandHandler.demanded.slice(0);
+ const optional = commandHandler.optional.slice(0);
+ const positionalMap = {};
+ this.validation.positionalCount(demanded.length, argv._.length);
+ while (demanded.length) {
+ const demand = demanded.shift();
+ this.populatePositional(demand, argv, positionalMap);
+ }
+ while (optional.length) {
+ const maybe = optional.shift();
+ this.populatePositional(maybe, argv, positionalMap);
+ }
+ argv._ = context2.commands.concat(argv._.map((a) => "" + a));
+ this.postProcessPositionals(argv, positionalMap, this.cmdToParseOptions(commandHandler.original), yargs);
+ return positionalMap;
+ }
+ populatePositional(positional, argv, positionalMap) {
+ const cmd = positional.cmd[0];
+ if (positional.variadic) {
+ positionalMap[cmd] = argv._.splice(0).map(String);
+ } else {
+ if (argv._.length)
+ positionalMap[cmd] = [String(argv._.shift())];
+ }
+ }
+ cmdToParseOptions(cmdString) {
+ const parseOptions = {
+ array: [],
+ default: {},
+ alias: {},
+ demand: {}
+ };
+ const parsed = parseCommand2(cmdString);
+ parsed.demanded.forEach((d) => {
+ const [cmd, ...aliases2] = d.cmd;
+ if (d.variadic) {
+ parseOptions.array.push(cmd);
+ parseOptions.default[cmd] = [];
+ }
+ parseOptions.alias[cmd] = aliases2;
+ parseOptions.demand[cmd] = true;
+ });
+ parsed.optional.forEach((o) => {
+ const [cmd, ...aliases2] = o.cmd;
+ if (o.variadic) {
+ parseOptions.array.push(cmd);
+ parseOptions.default[cmd] = [];
+ }
+ parseOptions.alias[cmd] = aliases2;
+ });
+ return parseOptions;
+ }
+ postProcessPositionals(argv, positionalMap, parseOptions, yargs) {
+ const options14 = Object.assign({}, yargs.getOptions());
+ options14.default = Object.assign(parseOptions.default, options14.default);
+ for (const key of Object.keys(parseOptions.alias)) {
+ options14.alias[key] = (options14.alias[key] || []).concat(parseOptions.alias[key]);
+ }
+ options14.array = options14.array.concat(parseOptions.array);
+ options14.config = {};
+ const unparsed = [];
+ Object.keys(positionalMap).forEach((key) => {
+ positionalMap[key].map((value) => {
+ if (options14.configuration["unknown-options-as-args"])
+ options14.key[key] = true;
+ unparsed.push(`--${key}`);
+ unparsed.push(value);
+ });
+ });
+ if (!unparsed.length)
+ return;
+ const config = Object.assign({}, options14.configuration, {
+ "populate--": false
+ });
+ const parsed = this.shim.Parser.detailed(unparsed, Object.assign({}, options14, {
+ configuration: config
+ }));
+ if (parsed.error) {
+ yargs.getInternalMethods().getUsageInstance().fail(parsed.error.message, parsed.error);
+ } else {
+ const positionalKeys = Object.keys(positionalMap);
+ Object.keys(positionalMap).forEach((key) => {
+ positionalKeys.push(...parsed.aliases[key]);
+ });
+ Object.keys(parsed.argv).forEach((key) => {
+ if (positionalKeys.includes(key)) {
+ if (!positionalMap[key])
+ positionalMap[key] = parsed.argv[key];
+ if (!this.isInConfigs(yargs, key) && !this.isDefaulted(yargs, key) && Object.prototype.hasOwnProperty.call(argv, key) && Object.prototype.hasOwnProperty.call(parsed.argv, key) && (Array.isArray(argv[key]) || Array.isArray(parsed.argv[key]))) {
+ argv[key] = [].concat(argv[key], parsed.argv[key]);
+ } else {
+ argv[key] = parsed.argv[key];
+ }
+ }
+ });
+ }
+ }
+ isDefaulted(yargs, key) {
+ const { default: defaults } = yargs.getOptions();
+ return Object.prototype.hasOwnProperty.call(defaults, key) || Object.prototype.hasOwnProperty.call(defaults, this.shim.Parser.camelCase(key));
+ }
+ isInConfigs(yargs, key) {
+ const { configObjects } = yargs.getOptions();
+ return configObjects.some((c) => Object.prototype.hasOwnProperty.call(c, key)) || configObjects.some((c) => Object.prototype.hasOwnProperty.call(c, this.shim.Parser.camelCase(key)));
+ }
+ runDefaultBuilderOn(yargs) {
+ if (!this.defaultCommand)
+ return;
+ if (this.shouldUpdateUsage(yargs)) {
+ const commandString = DEFAULT_MARKER.test(this.defaultCommand.original) ? this.defaultCommand.original : this.defaultCommand.original.replace(/^[^[\]<>]*/, "$0 ");
+ yargs.getInternalMethods().getUsageInstance().usage(commandString, this.defaultCommand.description);
+ }
+ const builder = this.defaultCommand.builder;
+ if (isCommandBuilderCallback(builder)) {
+ return builder(yargs, true);
+ } else if (!isCommandBuilderDefinition(builder)) {
+ Object.keys(builder).forEach((key) => {
+ yargs.option(key, builder[key]);
+ });
+ }
+ return void 0;
+ }
+ moduleName(obj) {
+ const mod = whichModule(obj);
+ if (!mod)
+ throw new Error(`No command name given for module: ${this.shim.inspect(obj)}`);
+ return this.commandFromFilename(mod.filename);
+ }
+ commandFromFilename(filename) {
+ return this.shim.path.basename(filename, this.shim.path.extname(filename));
+ }
+ extractDesc({ describe, description, desc }) {
+ for (const test of [describe, description, desc]) {
+ if (typeof test === "string" || test === false)
+ return test;
+ assertNotStrictEqual(test, true, this.shim);
+ }
+ return false;
+ }
+ freeze() {
+ this.frozens.push({
+ handlers: this.handlers,
+ aliasMap: this.aliasMap,
+ defaultCommand: this.defaultCommand
+ });
+ }
+ unfreeze() {
+ const frozen = this.frozens.pop();
+ assertNotStrictEqual(frozen, void 0, this.shim);
+ ({
+ handlers: this.handlers,
+ aliasMap: this.aliasMap,
+ defaultCommand: this.defaultCommand
+ } = frozen);
+ }
+ reset() {
+ this.handlers = {};
+ this.aliasMap = {};
+ this.defaultCommand = void 0;
+ this.requireCache = /* @__PURE__ */ new Set();
+ return this;
+ }
+};
+__name(CommandInstance, "CommandInstance");
+function command(usage2, validation2, globalMiddleware, shim3) {
+ return new CommandInstance(usage2, validation2, globalMiddleware, shim3);
+}
+__name(command, "command");
+function isCommandBuilderDefinition(builder) {
+ return typeof builder === "object" && !!builder.builder && typeof builder.handler === "function";
+}
+__name(isCommandBuilderDefinition, "isCommandBuilderDefinition");
+function isCommandAndAliases(cmd) {
+ return cmd.every((c) => typeof c === "string");
+}
+__name(isCommandAndAliases, "isCommandAndAliases");
+function isCommandBuilderCallback(builder) {
+ return typeof builder === "function";
+}
+__name(isCommandBuilderCallback, "isCommandBuilderCallback");
+function isCommandBuilderOptionDefinitions(builder) {
+ return typeof builder === "object";
+}
+__name(isCommandBuilderOptionDefinitions, "isCommandBuilderOptionDefinitions");
+function isCommandHandlerDefinition(cmd) {
+ return typeof cmd === "object" && !Array.isArray(cmd);
+}
+__name(isCommandHandlerDefinition, "isCommandHandlerDefinition");
+
+// ../../node_modules/.pnpm/yargs@17.7.1/node_modules/yargs/build/lib/usage.js
+init_import_meta_url();
+
+// ../../node_modules/.pnpm/yargs@17.7.1/node_modules/yargs/build/lib/utils/obj-filter.js
+init_import_meta_url();
+function objFilter(original = {}, filter = () => true) {
+ const obj = {};
+ objectKeys(original).forEach((key) => {
+ if (filter(key, original[key])) {
+ obj[key] = original[key];
+ }
+ });
+ return obj;
+}
+__name(objFilter, "objFilter");
+
+// ../../node_modules/.pnpm/yargs@17.7.1/node_modules/yargs/build/lib/utils/set-blocking.js
+init_import_meta_url();
+function setBlocking(blocking) {
+ if (typeof process === "undefined")
+ return;
+ [process.stdout, process.stderr].forEach((_stream) => {
+ const stream2 = _stream;
+ if (stream2._handle && stream2.isTTY && typeof stream2._handle.setBlocking === "function") {
+ stream2._handle.setBlocking(blocking);
+ }
+ });
+}
+__name(setBlocking, "setBlocking");
+
+// ../../node_modules/.pnpm/yargs@17.7.1/node_modules/yargs/build/lib/usage.js
+function isBoolean2(fail) {
+ return typeof fail === "boolean";
+}
+__name(isBoolean2, "isBoolean");
+function usage(yargs, shim3) {
+ const __ = shim3.y18n.__;
+ const self2 = {};
+ const fails = [];
+ self2.failFn = /* @__PURE__ */ __name(function failFn(f) {
+ fails.push(f);
+ }, "failFn");
+ let failMessage = null;
+ let globalFailMessage = null;
+ let showHelpOnFail = true;
+ self2.showHelpOnFail = /* @__PURE__ */ __name(function showHelpOnFailFn(arg1 = true, arg2) {
+ const [enabled, message] = typeof arg1 === "string" ? [true, arg1] : [arg1, arg2];
+ if (yargs.getInternalMethods().isGlobalContext()) {
+ globalFailMessage = message;
+ }
+ failMessage = message;
+ showHelpOnFail = enabled;
+ return self2;
+ }, "showHelpOnFailFn");
+ let failureOutput = false;
+ self2.fail = /* @__PURE__ */ __name(function fail(msg, err) {
+ const logger2 = yargs.getInternalMethods().getLoggerInstance();
+ if (fails.length) {
+ for (let i = fails.length - 1; i >= 0; --i) {
+ const fail2 = fails[i];
+ if (isBoolean2(fail2)) {
+ if (err)
+ throw err;
+ else if (msg)
+ throw Error(msg);
+ } else {
+ fail2(msg, err, self2);
+ }
+ }
+ } else {
+ if (yargs.getExitProcess())
+ setBlocking(true);
+ if (!failureOutput) {
+ failureOutput = true;
+ if (showHelpOnFail) {
+ yargs.showHelp("error");
+ logger2.error();
+ }
+ if (msg || err)
+ logger2.error(msg || err);
+ const globalOrCommandFailMessage = failMessage || globalFailMessage;
+ if (globalOrCommandFailMessage) {
+ if (msg || err)
+ logger2.error("");
+ logger2.error(globalOrCommandFailMessage);
+ }
+ }
+ err = err || new YError(msg);
+ if (yargs.getExitProcess()) {
+ return yargs.exit(1);
+ } else if (yargs.getInternalMethods().hasParseCallback()) {
+ return yargs.exit(1, err);
+ } else {
+ throw err;
+ }
+ }
+ }, "fail");
+ let usages = [];
+ let usageDisabled = false;
+ self2.usage = (msg, description) => {
+ if (msg === null) {
+ usageDisabled = true;
+ usages = [];
+ return self2;
+ }
+ usageDisabled = false;
+ usages.push([msg, description || ""]);
+ return self2;
+ };
+ self2.getUsage = () => {
+ return usages;
+ };
+ self2.getUsageDisabled = () => {
+ return usageDisabled;
+ };
+ self2.getPositionalGroupName = () => {
+ return __("Positionals:");
+ };
+ let examples = [];
+ self2.example = (cmd, description) => {
+ examples.push([cmd, description || ""]);
+ };
+ let commands = [];
+ self2.command = /* @__PURE__ */ __name(function command2(cmd, description, isDefault, aliases2, deprecated2 = false) {
+ if (isDefault) {
+ commands = commands.map((cmdArray) => {
+ cmdArray[2] = false;
+ return cmdArray;
+ });
+ }
+ commands.push([cmd, description || "", isDefault, aliases2, deprecated2]);
+ }, "command");
+ self2.getCommands = () => commands;
+ let descriptions = {};
+ self2.describe = /* @__PURE__ */ __name(function describe(keyOrKeys, desc) {
+ if (Array.isArray(keyOrKeys)) {
+ keyOrKeys.forEach((k) => {
+ self2.describe(k, desc);
+ });
+ } else if (typeof keyOrKeys === "object") {
+ Object.keys(keyOrKeys).forEach((k) => {
+ self2.describe(k, keyOrKeys[k]);
+ });
+ } else {
+ descriptions[keyOrKeys] = desc;
+ }
+ }, "describe");
+ self2.getDescriptions = () => descriptions;
+ let epilogs = [];
+ self2.epilog = (msg) => {
+ epilogs.push(msg);
+ };
+ let wrapSet = false;
+ let wrap2;
+ self2.wrap = (cols) => {
+ wrapSet = true;
+ wrap2 = cols;
+ };
+ self2.getWrap = () => {
+ if (shim3.getEnv("YARGS_DISABLE_WRAP")) {
+ return null;
+ }
+ if (!wrapSet) {
+ wrap2 = windowWidth();
+ wrapSet = true;
+ }
+ return wrap2;
+ };
+ const deferY18nLookupPrefix = "__yargsString__:";
+ self2.deferY18nLookup = (str) => deferY18nLookupPrefix + str;
+ self2.help = /* @__PURE__ */ __name(function help() {
+ if (cachedHelpMessage)
+ return cachedHelpMessage;
+ normalizeAliases();
+ const base$0 = yargs.customScriptName ? yargs.$0 : shim3.path.basename(yargs.$0);
+ const demandedOptions = yargs.getDemandedOptions();
+ const demandedCommands = yargs.getDemandedCommands();
+ const deprecatedOptions = yargs.getDeprecatedOptions();
+ const groups = yargs.getGroups();
+ const options14 = yargs.getOptions();
+ let keys = [];
+ keys = keys.concat(Object.keys(descriptions));
+ keys = keys.concat(Object.keys(demandedOptions));
+ keys = keys.concat(Object.keys(demandedCommands));
+ keys = keys.concat(Object.keys(options14.default));
+ keys = keys.filter(filterHiddenOptions);
+ keys = Object.keys(keys.reduce((acc, key) => {
+ if (key !== "_")
+ acc[key] = true;
+ return acc;
+ }, {}));
+ const theWrap = self2.getWrap();
+ const ui2 = shim3.cliui({
+ width: theWrap,
+ wrap: !!theWrap
+ });
+ if (!usageDisabled) {
+ if (usages.length) {
+ usages.forEach((usage2) => {
+ ui2.div({ text: `${usage2[0].replace(/\$0/g, base$0)}` });
+ if (usage2[1]) {
+ ui2.div({ text: `${usage2[1]}`, padding: [1, 0, 0, 0] });
+ }
+ });
+ ui2.div();
+ } else if (commands.length) {
+ let u = null;
+ if (demandedCommands._) {
+ u = `${base$0} <${__("command")}>
+`;
+ } else {
+ u = `${base$0} [${__("command")}]
+`;
+ }
+ ui2.div(`${u}`);
+ }
+ }
+ if (commands.length > 1 || commands.length === 1 && !commands[0][2]) {
+ ui2.div(__("Commands:"));
+ const context2 = yargs.getInternalMethods().getContext();
+ const parentCommands = context2.commands.length ? `${context2.commands.join(" ")} ` : "";
+ if (yargs.getInternalMethods().getParserConfiguration()["sort-commands"] === true) {
+ commands = commands.sort((a, b) => a[0].localeCompare(b[0]));
+ }
+ const prefix = base$0 ? `${base$0} ` : "";
+ commands.forEach((command2) => {
+ const commandString = `${prefix}${parentCommands}${command2[0].replace(/^\$0 ?/, "")}`;
+ ui2.span({
+ text: commandString,
+ padding: [0, 2, 0, 2],
+ width: maxWidth(commands, theWrap, `${base$0}${parentCommands}`) + 4
+ }, { text: command2[1] });
+ const hints = [];
+ if (command2[2])
+ hints.push(`[${__("default")}]`);
+ if (command2[3] && command2[3].length) {
+ hints.push(`[${__("aliases:")} ${command2[3].join(", ")}]`);
+ }
+ if (command2[4]) {
+ if (typeof command2[4] === "string") {
+ hints.push(`[${__("deprecated: %s", command2[4])}]`);
+ } else {
+ hints.push(`[${__("deprecated")}]`);
+ }
+ }
+ if (hints.length) {
+ ui2.div({
+ text: hints.join(" "),
+ padding: [0, 0, 0, 2],
+ align: "right"
+ });
+ } else {
+ ui2.div();
+ }
+ });
+ ui2.div();
+ }
+ const aliasKeys = (Object.keys(options14.alias) || []).concat(Object.keys(yargs.parsed.newAliases) || []);
+ keys = keys.filter((key) => !yargs.parsed.newAliases[key] && aliasKeys.every((alias) => (options14.alias[alias] || []).indexOf(key) === -1));
+ const defaultGroup = __("Options:");
+ if (!groups[defaultGroup])
+ groups[defaultGroup] = [];
+ addUngroupedKeys(keys, options14.alias, groups, defaultGroup);
+ const isLongSwitch = /* @__PURE__ */ __name((sw) => /^--/.test(getText(sw)), "isLongSwitch");
+ const displayedGroups = Object.keys(groups).filter((groupName) => groups[groupName].length > 0).map((groupName) => {
+ const normalizedKeys = groups[groupName].filter(filterHiddenOptions).map((key) => {
+ if (aliasKeys.includes(key))
+ return key;
+ for (let i = 0, aliasKey; (aliasKey = aliasKeys[i]) !== void 0; i++) {
+ if ((options14.alias[aliasKey] || []).includes(key))
+ return aliasKey;
+ }
+ return key;
+ });
+ return { groupName, normalizedKeys };
+ }).filter(({ normalizedKeys }) => normalizedKeys.length > 0).map(({ groupName, normalizedKeys }) => {
+ const switches = normalizedKeys.reduce((acc, key) => {
+ acc[key] = [key].concat(options14.alias[key] || []).map((sw) => {
+ if (groupName === self2.getPositionalGroupName())
+ return sw;
+ else {
+ return (/^[0-9]$/.test(sw) ? options14.boolean.includes(key) ? "-" : "--" : sw.length > 1 ? "--" : "-") + sw;
+ }
+ }).sort((sw1, sw2) => isLongSwitch(sw1) === isLongSwitch(sw2) ? 0 : isLongSwitch(sw1) ? 1 : -1).join(", ");
+ return acc;
+ }, {});
+ return { groupName, normalizedKeys, switches };
+ });
+ const shortSwitchesUsed = displayedGroups.filter(({ groupName }) => groupName !== self2.getPositionalGroupName()).some(({ normalizedKeys, switches }) => !normalizedKeys.every((key) => isLongSwitch(switches[key])));
+ if (shortSwitchesUsed) {
+ displayedGroups.filter(({ groupName }) => groupName !== self2.getPositionalGroupName()).forEach(({ normalizedKeys, switches }) => {
+ normalizedKeys.forEach((key) => {
+ if (isLongSwitch(switches[key])) {
+ switches[key] = addIndentation(switches[key], "-x, ".length);
+ }
+ });
+ });
+ }
+ displayedGroups.forEach(({ groupName, normalizedKeys, switches }) => {
+ ui2.div(groupName);
+ normalizedKeys.forEach((key) => {
+ const kswitch = switches[key];
+ let desc = descriptions[key] || "";
+ let type = null;
+ if (desc.includes(deferY18nLookupPrefix))
+ desc = __(desc.substring(deferY18nLookupPrefix.length));
+ if (options14.boolean.includes(key))
+ type = `[${__("boolean")}]`;
+ if (options14.count.includes(key))
+ type = `[${__("count")}]`;
+ if (options14.string.includes(key))
+ type = `[${__("string")}]`;
+ if (options14.normalize.includes(key))
+ type = `[${__("string")}]`;
+ if (options14.array.includes(key))
+ type = `[${__("array")}]`;
+ if (options14.number.includes(key))
+ type = `[${__("number")}]`;
+ const deprecatedExtra = /* @__PURE__ */ __name((deprecated2) => typeof deprecated2 === "string" ? `[${__("deprecated: %s", deprecated2)}]` : `[${__("deprecated")}]`, "deprecatedExtra");
+ const extra = [
+ key in deprecatedOptions ? deprecatedExtra(deprecatedOptions[key]) : null,
+ type,
+ key in demandedOptions ? `[${__("required")}]` : null,
+ options14.choices && options14.choices[key] ? `[${__("choices:")} ${self2.stringifiedValues(options14.choices[key])}]` : null,
+ defaultString(options14.default[key], options14.defaultDescription[key])
+ ].filter(Boolean).join(" ");
+ ui2.span({
+ text: getText(kswitch),
+ padding: [0, 2, 0, 2 + getIndentation(kswitch)],
+ width: maxWidth(switches, theWrap) + 4
+ }, desc);
+ const shouldHideOptionExtras = yargs.getInternalMethods().getUsageConfiguration()["hide-types"] === true;
+ if (extra && !shouldHideOptionExtras)
+ ui2.div({ text: extra, padding: [0, 0, 0, 2], align: "right" });
+ else
+ ui2.div();
+ });
+ ui2.div();
+ });
+ if (examples.length) {
+ ui2.div(__("Examples:"));
+ examples.forEach((example) => {
+ example[0] = example[0].replace(/\$0/g, base$0);
+ });
+ examples.forEach((example) => {
+ if (example[1] === "") {
+ ui2.div({
+ text: example[0],
+ padding: [0, 2, 0, 2]
+ });
+ } else {
+ ui2.div({
+ text: example[0],
+ padding: [0, 2, 0, 2],
+ width: maxWidth(examples, theWrap) + 4
+ }, {
+ text: example[1]
+ });
+ }
+ });
+ ui2.div();
+ }
+ if (epilogs.length > 0) {
+ const e2 = epilogs.map((epilog) => epilog.replace(/\$0/g, base$0)).join("\n");
+ ui2.div(`${e2}
+`);
+ }
+ return ui2.toString().replace(/\s*$/, "");
+ }, "help");
+ function maxWidth(table, theWrap, modifier) {
+ let width = 0;
+ if (!Array.isArray(table)) {
+ table = Object.values(table).map((v) => [v]);
+ }
+ table.forEach((v) => {
+ width = Math.max(shim3.stringWidth(modifier ? `${modifier} ${getText(v[0])}` : getText(v[0])) + getIndentation(v[0]), width);
+ });
+ if (theWrap)
+ width = Math.min(width, parseInt((theWrap * 0.5).toString(), 10));
+ return width;
+ }
+ __name(maxWidth, "maxWidth");
+ function normalizeAliases() {
+ const demandedOptions = yargs.getDemandedOptions();
+ const options14 = yargs.getOptions();
+ (Object.keys(options14.alias) || []).forEach((key) => {
+ options14.alias[key].forEach((alias) => {
+ if (descriptions[alias])
+ self2.describe(key, descriptions[alias]);
+ if (alias in demandedOptions)
+ yargs.demandOption(key, demandedOptions[alias]);
+ if (options14.boolean.includes(alias))
+ yargs.boolean(key);
+ if (options14.count.includes(alias))
+ yargs.count(key);
+ if (options14.string.includes(alias))
+ yargs.string(key);
+ if (options14.normalize.includes(alias))
+ yargs.normalize(key);
+ if (options14.array.includes(alias))
+ yargs.array(key);
+ if (options14.number.includes(alias))
+ yargs.number(key);
+ });
+ });
+ }
+ __name(normalizeAliases, "normalizeAliases");
+ let cachedHelpMessage;
+ self2.cacheHelpMessage = function() {
+ cachedHelpMessage = this.help();
+ };
+ self2.clearCachedHelpMessage = function() {
+ cachedHelpMessage = void 0;
+ };
+ self2.hasCachedHelpMessage = function() {
+ return !!cachedHelpMessage;
+ };
+ function addUngroupedKeys(keys, aliases2, groups, defaultGroup) {
+ let groupedKeys = [];
+ let toCheck = null;
+ Object.keys(groups).forEach((group) => {
+ groupedKeys = groupedKeys.concat(groups[group]);
+ });
+ keys.forEach((key) => {
+ toCheck = [key].concat(aliases2[key]);
+ if (!toCheck.some((k) => groupedKeys.indexOf(k) !== -1)) {
+ groups[defaultGroup].push(key);
+ }
+ });
+ return groupedKeys;
+ }
+ __name(addUngroupedKeys, "addUngroupedKeys");
+ function filterHiddenOptions(key) {
+ return yargs.getOptions().hiddenOptions.indexOf(key) < 0 || yargs.parsed.argv[yargs.getOptions().showHiddenOpt];
+ }
+ __name(filterHiddenOptions, "filterHiddenOptions");
+ self2.showHelp = (level) => {
+ const logger2 = yargs.getInternalMethods().getLoggerInstance();
+ if (!level)
+ level = "error";
+ const emit = typeof level === "function" ? level : logger2[level];
+ emit(self2.help());
+ };
+ self2.functionDescription = (fn2) => {
+ const description = fn2.name ? shim3.Parser.decamelize(fn2.name, "-") : __("generated-value");
+ return ["(", description, ")"].join("");
+ };
+ self2.stringifiedValues = /* @__PURE__ */ __name(function stringifiedValues(values, separator) {
+ let string = "";
+ const sep2 = separator || ", ";
+ const array = [].concat(values);
+ if (!values || !array.length)
+ return string;
+ array.forEach((value) => {
+ if (string.length)
+ string += sep2;
+ string += JSON.stringify(value);
+ });
+ return string;
+ }, "stringifiedValues");
+ function defaultString(value, defaultDescription) {
+ let string = `[${__("default:")} `;
+ if (value === void 0 && !defaultDescription)
+ return null;
+ if (defaultDescription) {
+ string += defaultDescription;
+ } else {
+ switch (typeof value) {
+ case "string":
+ string += `"${value}"`;
+ break;
+ case "object":
+ string += JSON.stringify(value);
+ break;
+ default:
+ string += value;
+ }
+ }
+ return `${string}]`;
+ }
+ __name(defaultString, "defaultString");
+ function windowWidth() {
+ const maxWidth2 = 80;
+ if (shim3.process.stdColumns) {
+ return Math.min(maxWidth2, shim3.process.stdColumns);
+ } else {
+ return maxWidth2;
+ }
+ }
+ __name(windowWidth, "windowWidth");
+ let version2 = null;
+ self2.version = (ver) => {
+ version2 = ver;
+ };
+ self2.showVersion = (level) => {
+ const logger2 = yargs.getInternalMethods().getLoggerInstance();
+ if (!level)
+ level = "error";
+ const emit = typeof level === "function" ? level : logger2[level];
+ emit(version2);
+ };
+ self2.reset = /* @__PURE__ */ __name(function reset(localLookup) {
+ failMessage = null;
+ failureOutput = false;
+ usages = [];
+ usageDisabled = false;
+ epilogs = [];
+ examples = [];
+ commands = [];
+ descriptions = objFilter(descriptions, (k) => !localLookup[k]);
+ return self2;
+ }, "reset");
+ const frozens = [];
+ self2.freeze = /* @__PURE__ */ __name(function freeze() {
+ frozens.push({
+ failMessage,
+ failureOutput,
+ usages,
+ usageDisabled,
+ epilogs,
+ examples,
+ commands,
+ descriptions
+ });
+ }, "freeze");
+ self2.unfreeze = /* @__PURE__ */ __name(function unfreeze(defaultCommand = false) {
+ const frozen = frozens.pop();
+ if (!frozen)
+ return;
+ if (defaultCommand) {
+ descriptions = { ...frozen.descriptions, ...descriptions };
+ commands = [...frozen.commands, ...commands];
+ usages = [...frozen.usages, ...usages];
+ examples = [...frozen.examples, ...examples];
+ epilogs = [...frozen.epilogs, ...epilogs];
+ } else {
+ ({
+ failMessage,
+ failureOutput,
+ usages,
+ usageDisabled,
+ epilogs,
+ examples,
+ commands,
+ descriptions
+ } = frozen);
+ }
+ }, "unfreeze");
+ return self2;
+}
+__name(usage, "usage");
+function isIndentedText(text) {
+ return typeof text === "object";
+}
+__name(isIndentedText, "isIndentedText");
+function addIndentation(text, indent) {
+ return isIndentedText(text) ? { text: text.text, indentation: text.indentation + indent } : { text, indentation: indent };
+}
+__name(addIndentation, "addIndentation");
+function getIndentation(text) {
+ return isIndentedText(text) ? text.indentation : 0;
+}
+__name(getIndentation, "getIndentation");
+function getText(text) {
+ return isIndentedText(text) ? text.text : text;
+}
+__name(getText, "getText");
+
+// ../../node_modules/.pnpm/yargs@17.7.1/node_modules/yargs/build/lib/completion.js
+init_import_meta_url();
+
+// ../../node_modules/.pnpm/yargs@17.7.1/node_modules/yargs/build/lib/completion-templates.js
+init_import_meta_url();
+var completionShTemplate = `###-begin-{{app_name}}-completions-###
+#
+# yargs command completion script
+#
+# Installation: {{app_path}} {{completion_command}} >> ~/.bashrc
+# or {{app_path}} {{completion_command}} >> ~/.bash_profile on OSX.
+#
+_{{app_name}}_yargs_completions()
+{
+ local cur_word args type_list
+
+ cur_word="\${COMP_WORDS[COMP_CWORD]}"
+ args=("\${COMP_WORDS[@]}")
+
+ # ask yargs to generate completions.
+ type_list=$({{app_path}} --get-yargs-completions "\${args[@]}")
+
+ COMPREPLY=( $(compgen -W "\${type_list}" -- \${cur_word}) )
+
+ # if no match was found, fall back to filename completion
+ if [ \${#COMPREPLY[@]} -eq 0 ]; then
+ COMPREPLY=()
+ fi
+
+ return 0
+}
+complete -o bashdefault -o default -F _{{app_name}}_yargs_completions {{app_name}}
+###-end-{{app_name}}-completions-###
+`;
+var completionZshTemplate = `#compdef {{app_name}}
+###-begin-{{app_name}}-completions-###
+#
+# yargs command completion script
+#
+# Installation: {{app_path}} {{completion_command}} >> ~/.zshrc
+# or {{app_path}} {{completion_command}} >> ~/.zprofile on OSX.
+#
+_{{app_name}}_yargs_completions()
+{
+ local reply
+ local si=$IFS
+ IFS=$'
+' reply=($(COMP_CWORD="$((CURRENT-1))" COMP_LINE="$BUFFER" COMP_POINT="$CURSOR" {{app_path}} --get-yargs-completions "\${words[@]}"))
+ IFS=$si
+ _describe 'values' reply
+}
+compdef _{{app_name}}_yargs_completions {{app_name}}
+###-end-{{app_name}}-completions-###
+`;
+
+// ../../node_modules/.pnpm/yargs@17.7.1/node_modules/yargs/build/lib/completion.js
+var Completion = class {
+ constructor(yargs, usage2, command2, shim3) {
+ var _a2, _b2, _c2;
+ this.yargs = yargs;
+ this.usage = usage2;
+ this.command = command2;
+ this.shim = shim3;
+ this.completionKey = "get-yargs-completions";
+ this.aliases = null;
+ this.customCompletionFunction = null;
+ this.indexAfterLastReset = 0;
+ this.zshShell = (_c2 = ((_a2 = this.shim.getEnv("SHELL")) === null || _a2 === void 0 ? void 0 : _a2.includes("zsh")) || ((_b2 = this.shim.getEnv("ZSH_NAME")) === null || _b2 === void 0 ? void 0 : _b2.includes("zsh"))) !== null && _c2 !== void 0 ? _c2 : false;
+ }
+ defaultCompletion(args, argv, current, done) {
+ const handlers = this.command.getCommandHandlers();
+ for (let i = 0, ii = args.length; i < ii; ++i) {
+ if (handlers[args[i]] && handlers[args[i]].builder) {
+ const builder = handlers[args[i]].builder;
+ if (isCommandBuilderCallback(builder)) {
+ this.indexAfterLastReset = i + 1;
+ const y = this.yargs.getInternalMethods().reset();
+ builder(y, true);
+ return y.argv;
+ }
+ }
+ }
+ const completions = [];
+ this.commandCompletions(completions, args, current);
+ this.optionCompletions(completions, args, argv, current);
+ this.choicesFromOptionsCompletions(completions, args, argv, current);
+ this.choicesFromPositionalsCompletions(completions, args, argv, current);
+ done(null, completions);
+ }
+ commandCompletions(completions, args, current) {
+ const parentCommands = this.yargs.getInternalMethods().getContext().commands;
+ if (!current.match(/^-/) && parentCommands[parentCommands.length - 1] !== current && !this.previousArgHasChoices(args)) {
+ this.usage.getCommands().forEach((usageCommand) => {
+ const commandName = parseCommand2(usageCommand[0]).cmd;
+ if (args.indexOf(commandName) === -1) {
+ if (!this.zshShell) {
+ completions.push(commandName);
+ } else {
+ const desc = usageCommand[1] || "";
+ completions.push(commandName.replace(/:/g, "\\:") + ":" + desc);
+ }
+ }
+ });
+ }
+ }
+ optionCompletions(completions, args, argv, current) {
+ if ((current.match(/^-/) || current === "" && completions.length === 0) && !this.previousArgHasChoices(args)) {
+ const options14 = this.yargs.getOptions();
+ const positionalKeys = this.yargs.getGroups()[this.usage.getPositionalGroupName()] || [];
+ Object.keys(options14.key).forEach((key) => {
+ const negable = !!options14.configuration["boolean-negation"] && options14.boolean.includes(key);
+ const isPositionalKey = positionalKeys.includes(key);
+ if (!isPositionalKey && !options14.hiddenOptions.includes(key) && !this.argsContainKey(args, key, negable)) {
+ this.completeOptionKey(key, completions, current);
+ if (negable && !!options14.default[key])
+ this.completeOptionKey(`no-${key}`, completions, current);
+ }
+ });
+ }
+ }
+ choicesFromOptionsCompletions(completions, args, argv, current) {
+ if (this.previousArgHasChoices(args)) {
+ const choices = this.getPreviousArgChoices(args);
+ if (choices && choices.length > 0) {
+ completions.push(...choices.map((c) => c.replace(/:/g, "\\:")));
+ }
+ }
+ }
+ choicesFromPositionalsCompletions(completions, args, argv, current) {
+ if (current === "" && completions.length > 0 && this.previousArgHasChoices(args)) {
+ return;
+ }
+ const positionalKeys = this.yargs.getGroups()[this.usage.getPositionalGroupName()] || [];
+ const offset = Math.max(this.indexAfterLastReset, this.yargs.getInternalMethods().getContext().commands.length + 1);
+ const positionalKey = positionalKeys[argv._.length - offset - 1];
+ if (!positionalKey) {
+ return;
+ }
+ const choices = this.yargs.getOptions().choices[positionalKey] || [];
+ for (const choice of choices) {
+ if (choice.startsWith(current)) {
+ completions.push(choice.replace(/:/g, "\\:"));
+ }
+ }
+ }
+ getPreviousArgChoices(args) {
+ if (args.length < 1)
+ return;
+ let previousArg = args[args.length - 1];
+ let filter = "";
+ if (!previousArg.startsWith("-") && args.length > 1) {
+ filter = previousArg;
+ previousArg = args[args.length - 2];
+ }
+ if (!previousArg.startsWith("-"))
+ return;
+ const previousArgKey = previousArg.replace(/^-+/, "");
+ const options14 = this.yargs.getOptions();
+ const possibleAliases = [
+ previousArgKey,
+ ...this.yargs.getAliases()[previousArgKey] || []
+ ];
+ let choices;
+ for (const possibleAlias of possibleAliases) {
+ if (Object.prototype.hasOwnProperty.call(options14.key, possibleAlias) && Array.isArray(options14.choices[possibleAlias])) {
+ choices = options14.choices[possibleAlias];
+ break;
+ }
+ }
+ if (choices) {
+ return choices.filter((choice) => !filter || choice.startsWith(filter));
+ }
+ }
+ previousArgHasChoices(args) {
+ const choices = this.getPreviousArgChoices(args);
+ return choices !== void 0 && choices.length > 0;
+ }
+ argsContainKey(args, key, negable) {
+ const argsContains = /* @__PURE__ */ __name((s) => args.indexOf((/^[^0-9]$/.test(s) ? "-" : "--") + s) !== -1, "argsContains");
+ if (argsContains(key))
+ return true;
+ if (negable && argsContains(`no-${key}`))
+ return true;
+ if (this.aliases) {
+ for (const alias of this.aliases[key]) {
+ if (argsContains(alias))
+ return true;
+ }
+ }
+ return false;
+ }
+ completeOptionKey(key, completions, current) {
+ var _a2, _b2, _c2;
+ const descs = this.usage.getDescriptions();
+ const startsByTwoDashes = /* @__PURE__ */ __name((s) => /^--/.test(s), "startsByTwoDashes");
+ const isShortOption = /* @__PURE__ */ __name((s) => /^[^0-9]$/.test(s), "isShortOption");
+ const dashes = !startsByTwoDashes(current) && isShortOption(key) ? "-" : "--";
+ if (!this.zshShell) {
+ completions.push(dashes + key);
+ } else {
+ const aliasKey = (_a2 = this === null || this === void 0 ? void 0 : this.aliases) === null || _a2 === void 0 ? void 0 : _a2[key].find((alias) => {
+ const desc2 = descs[alias];
+ return typeof desc2 === "string" && desc2.length > 0;
+ });
+ const descFromAlias = aliasKey ? descs[aliasKey] : void 0;
+ const desc = (_c2 = (_b2 = descs[key]) !== null && _b2 !== void 0 ? _b2 : descFromAlias) !== null && _c2 !== void 0 ? _c2 : "";
+ completions.push(dashes + `${key.replace(/:/g, "\\:")}:${desc.replace("__yargsString__:", "").replace(/(\r\n|\n|\r)/gm, " ")}`);
+ }
+ }
+ customCompletion(args, argv, current, done) {
+ assertNotStrictEqual(this.customCompletionFunction, null, this.shim);
+ if (isSyncCompletionFunction(this.customCompletionFunction)) {
+ const result = this.customCompletionFunction(current, argv);
+ if (isPromise(result)) {
+ return result.then((list) => {
+ this.shim.process.nextTick(() => {
+ done(null, list);
+ });
+ }).catch((err) => {
+ this.shim.process.nextTick(() => {
+ done(err, void 0);
+ });
+ });
+ }
+ return done(null, result);
+ } else if (isFallbackCompletionFunction(this.customCompletionFunction)) {
+ return this.customCompletionFunction(current, argv, (onCompleted = done) => this.defaultCompletion(args, argv, current, onCompleted), (completions) => {
+ done(null, completions);
+ });
+ } else {
+ return this.customCompletionFunction(current, argv, (completions) => {
+ done(null, completions);
+ });
+ }
+ }
+ getCompletion(args, done) {
+ const current = args.length ? args[args.length - 1] : "";
+ const argv = this.yargs.parse(args, true);
+ const completionFunction = this.customCompletionFunction ? (argv2) => this.customCompletion(args, argv2, current, done) : (argv2) => this.defaultCompletion(args, argv2, current, done);
+ return isPromise(argv) ? argv.then(completionFunction) : completionFunction(argv);
+ }
+ generateCompletionScript($0, cmd) {
+ let script = this.zshShell ? completionZshTemplate : completionShTemplate;
+ const name = this.shim.path.basename($0);
+ if ($0.match(/\.js$/))
+ $0 = `./${$0}`;
+ script = script.replace(/{{app_name}}/g, name);
+ script = script.replace(/{{completion_command}}/g, cmd);
+ return script.replace(/{{app_path}}/g, $0);
+ }
+ registerFunction(fn2) {
+ this.customCompletionFunction = fn2;
+ }
+ setParsed(parsed) {
+ this.aliases = parsed.aliases;
+ }
+};
+__name(Completion, "Completion");
+function completion(yargs, usage2, command2, shim3) {
+ return new Completion(yargs, usage2, command2, shim3);
+}
+__name(completion, "completion");
+function isSyncCompletionFunction(completionFunction) {
+ return completionFunction.length < 3;
+}
+__name(isSyncCompletionFunction, "isSyncCompletionFunction");
+function isFallbackCompletionFunction(completionFunction) {
+ return completionFunction.length > 3;
+}
+__name(isFallbackCompletionFunction, "isFallbackCompletionFunction");
+
+// ../../node_modules/.pnpm/yargs@17.7.1/node_modules/yargs/build/lib/validation.js
+init_import_meta_url();
+
+// ../../node_modules/.pnpm/yargs@17.7.1/node_modules/yargs/build/lib/utils/levenshtein.js
+init_import_meta_url();
+function levenshtein(a, b) {
+ if (a.length === 0)
+ return b.length;
+ if (b.length === 0)
+ return a.length;
+ const matrix = [];
+ let i;
+ for (i = 0; i <= b.length; i++) {
+ matrix[i] = [i];
+ }
+ let j;
+ for (j = 0; j <= a.length; j++) {
+ matrix[0][j] = j;
+ }
+ for (i = 1; i <= b.length; i++) {
+ for (j = 1; j <= a.length; j++) {
+ if (b.charAt(i - 1) === a.charAt(j - 1)) {
+ matrix[i][j] = matrix[i - 1][j - 1];
+ } else {
+ if (i > 1 && j > 1 && b.charAt(i - 2) === a.charAt(j - 1) && b.charAt(i - 1) === a.charAt(j - 2)) {
+ matrix[i][j] = matrix[i - 2][j - 2] + 1;
+ } else {
+ matrix[i][j] = Math.min(matrix[i - 1][j - 1] + 1, Math.min(matrix[i][j - 1] + 1, matrix[i - 1][j] + 1));
+ }
+ }
+ }
+ }
+ return matrix[b.length][a.length];
+}
+__name(levenshtein, "levenshtein");
+
+// ../../node_modules/.pnpm/yargs@17.7.1/node_modules/yargs/build/lib/validation.js
+var specialKeys = ["$0", "--", "_"];
+function validation(yargs, usage2, shim3) {
+ const __ = shim3.y18n.__;
+ const __n = shim3.y18n.__n;
+ const self2 = {};
+ self2.nonOptionCount = /* @__PURE__ */ __name(function nonOptionCount(argv) {
+ const demandedCommands = yargs.getDemandedCommands();
+ const positionalCount = argv._.length + (argv["--"] ? argv["--"].length : 0);
+ const _s = positionalCount - yargs.getInternalMethods().getContext().commands.length;
+ if (demandedCommands._ && (_s < demandedCommands._.min || _s > demandedCommands._.max)) {
+ if (_s < demandedCommands._.min) {
+ if (demandedCommands._.minMsg !== void 0) {
+ usage2.fail(demandedCommands._.minMsg ? demandedCommands._.minMsg.replace(/\$0/g, _s.toString()).replace(/\$1/, demandedCommands._.min.toString()) : null);
+ } else {
+ usage2.fail(__n("Not enough non-option arguments: got %s, need at least %s", "Not enough non-option arguments: got %s, need at least %s", _s, _s.toString(), demandedCommands._.min.toString()));
+ }
+ } else if (_s > demandedCommands._.max) {
+ if (demandedCommands._.maxMsg !== void 0) {
+ usage2.fail(demandedCommands._.maxMsg ? demandedCommands._.maxMsg.replace(/\$0/g, _s.toString()).replace(/\$1/, demandedCommands._.max.toString()) : null);
+ } else {
+ usage2.fail(__n("Too many non-option arguments: got %s, maximum of %s", "Too many non-option arguments: got %s, maximum of %s", _s, _s.toString(), demandedCommands._.max.toString()));
+ }
+ }
+ }
+ }, "nonOptionCount");
+ self2.positionalCount = /* @__PURE__ */ __name(function positionalCount(required, observed) {
+ if (observed < required) {
+ usage2.fail(__n("Not enough non-option arguments: got %s, need at least %s", "Not enough non-option arguments: got %s, need at least %s", observed, observed + "", required + ""));
+ }
+ }, "positionalCount");
+ self2.requiredArguments = /* @__PURE__ */ __name(function requiredArguments(argv, demandedOptions) {
+ let missing = null;
+ for (const key of Object.keys(demandedOptions)) {
+ if (!Object.prototype.hasOwnProperty.call(argv, key) || typeof argv[key] === "undefined") {
+ missing = missing || {};
+ missing[key] = demandedOptions[key];
+ }
+ }
+ if (missing) {
+ const customMsgs = [];
+ for (const key of Object.keys(missing)) {
+ const msg = missing[key];
+ if (msg && customMsgs.indexOf(msg) < 0) {
+ customMsgs.push(msg);
+ }
+ }
+ const customMsg = customMsgs.length ? `
+${customMsgs.join("\n")}` : "";
+ usage2.fail(__n("Missing required argument: %s", "Missing required arguments: %s", Object.keys(missing).length, Object.keys(missing).join(", ") + customMsg));
+ }
+ }, "requiredArguments");
+ self2.unknownArguments = /* @__PURE__ */ __name(function unknownArguments(argv, aliases2, positionalMap, isDefaultCommand, checkPositionals = true) {
+ var _a2;
+ const commandKeys = yargs.getInternalMethods().getCommandInstance().getCommands();
+ const unknown = [];
+ const currentContext = yargs.getInternalMethods().getContext();
+ Object.keys(argv).forEach((key) => {
+ if (!specialKeys.includes(key) && !Object.prototype.hasOwnProperty.call(positionalMap, key) && !Object.prototype.hasOwnProperty.call(yargs.getInternalMethods().getParseContext(), key) && !self2.isValidAndSomeAliasIsNotNew(key, aliases2)) {
+ unknown.push(key);
+ }
+ });
+ if (checkPositionals && (currentContext.commands.length > 0 || commandKeys.length > 0 || isDefaultCommand)) {
+ argv._.slice(currentContext.commands.length).forEach((key) => {
+ if (!commandKeys.includes("" + key)) {
+ unknown.push("" + key);
+ }
+ });
+ }
+ if (checkPositionals) {
+ const demandedCommands = yargs.getDemandedCommands();
+ const maxNonOptDemanded = ((_a2 = demandedCommands._) === null || _a2 === void 0 ? void 0 : _a2.max) || 0;
+ const expected = currentContext.commands.length + maxNonOptDemanded;
+ if (expected < argv._.length) {
+ argv._.slice(expected).forEach((key) => {
+ key = String(key);
+ if (!currentContext.commands.includes(key) && !unknown.includes(key)) {
+ unknown.push(key);
+ }
+ });
+ }
+ }
+ if (unknown.length) {
+ usage2.fail(__n("Unknown argument: %s", "Unknown arguments: %s", unknown.length, unknown.map((s) => s.trim() ? s : `"${s}"`).join(", ")));
+ }
+ }, "unknownArguments");
+ self2.unknownCommands = /* @__PURE__ */ __name(function unknownCommands(argv) {
+ const commandKeys = yargs.getInternalMethods().getCommandInstance().getCommands();
+ const unknown = [];
+ const currentContext = yargs.getInternalMethods().getContext();
+ if (currentContext.commands.length > 0 || commandKeys.length > 0) {
+ argv._.slice(currentContext.commands.length).forEach((key) => {
+ if (!commandKeys.includes("" + key)) {
+ unknown.push("" + key);
+ }
+ });
+ }
+ if (unknown.length > 0) {
+ usage2.fail(__n("Unknown command: %s", "Unknown commands: %s", unknown.length, unknown.join(", ")));
+ return true;
+ } else {
+ return false;
+ }
+ }, "unknownCommands");
+ self2.isValidAndSomeAliasIsNotNew = /* @__PURE__ */ __name(function isValidAndSomeAliasIsNotNew(key, aliases2) {
+ if (!Object.prototype.hasOwnProperty.call(aliases2, key)) {
+ return false;
+ }
+ const newAliases = yargs.parsed.newAliases;
+ return [key, ...aliases2[key]].some((a) => !Object.prototype.hasOwnProperty.call(newAliases, a) || !newAliases[key]);
+ }, "isValidAndSomeAliasIsNotNew");
+ self2.limitedChoices = /* @__PURE__ */ __name(function limitedChoices(argv) {
+ const options14 = yargs.getOptions();
+ const invalid = {};
+ if (!Object.keys(options14.choices).length)
+ return;
+ Object.keys(argv).forEach((key) => {
+ if (specialKeys.indexOf(key) === -1 && Object.prototype.hasOwnProperty.call(options14.choices, key)) {
+ [].concat(argv[key]).forEach((value) => {
+ if (options14.choices[key].indexOf(value) === -1 && value !== void 0) {
+ invalid[key] = (invalid[key] || []).concat(value);
+ }
+ });
+ }
+ });
+ const invalidKeys = Object.keys(invalid);
+ if (!invalidKeys.length)
+ return;
+ let msg = __("Invalid values:");
+ invalidKeys.forEach((key) => {
+ msg += `
+ ${__("Argument: %s, Given: %s, Choices: %s", key, usage2.stringifiedValues(invalid[key]), usage2.stringifiedValues(options14.choices[key]))}`;
+ });
+ usage2.fail(msg);
+ }, "limitedChoices");
+ let implied = {};
+ self2.implies = /* @__PURE__ */ __name(function implies(key, value) {
+ argsert(" [array|number|string]", [key, value], arguments.length);
+ if (typeof key === "object") {
+ Object.keys(key).forEach((k) => {
+ self2.implies(k, key[k]);
+ });
+ } else {
+ yargs.global(key);
+ if (!implied[key]) {
+ implied[key] = [];
+ }
+ if (Array.isArray(value)) {
+ value.forEach((i) => self2.implies(key, i));
+ } else {
+ assertNotStrictEqual(value, void 0, shim3);
+ implied[key].push(value);
+ }
+ }
+ }, "implies");
+ self2.getImplied = /* @__PURE__ */ __name(function getImplied() {
+ return implied;
+ }, "getImplied");
+ function keyExists(argv, val) {
+ const num = Number(val);
+ val = isNaN(num) ? val : num;
+ if (typeof val === "number") {
+ val = argv._.length >= val;
+ } else if (val.match(/^--no-.+/)) {
+ val = val.match(/^--no-(.+)/)[1];
+ val = !Object.prototype.hasOwnProperty.call(argv, val);
+ } else {
+ val = Object.prototype.hasOwnProperty.call(argv, val);
+ }
+ return val;
+ }
+ __name(keyExists, "keyExists");
+ self2.implications = /* @__PURE__ */ __name(function implications(argv) {
+ const implyFail = [];
+ Object.keys(implied).forEach((key) => {
+ const origKey = key;
+ (implied[key] || []).forEach((value) => {
+ let key2 = origKey;
+ const origValue = value;
+ key2 = keyExists(argv, key2);
+ value = keyExists(argv, value);
+ if (key2 && !value) {
+ implyFail.push(` ${origKey} -> ${origValue}`);
+ }
+ });
+ });
+ if (implyFail.length) {
+ let msg = `${__("Implications failed:")}
+`;
+ implyFail.forEach((value) => {
+ msg += value;
+ });
+ usage2.fail(msg);
+ }
+ }, "implications");
+ let conflicting = {};
+ self2.conflicts = /* @__PURE__ */ __name(function conflicts(key, value) {
+ argsert(" [array|string]", [key, value], arguments.length);
+ if (typeof key === "object") {
+ Object.keys(key).forEach((k) => {
+ self2.conflicts(k, key[k]);
+ });
+ } else {
+ yargs.global(key);
+ if (!conflicting[key]) {
+ conflicting[key] = [];
+ }
+ if (Array.isArray(value)) {
+ value.forEach((i) => self2.conflicts(key, i));
+ } else {
+ conflicting[key].push(value);
+ }
+ }
+ }, "conflicts");
+ self2.getConflicting = () => conflicting;
+ self2.conflicting = /* @__PURE__ */ __name(function conflictingFn(argv) {
+ Object.keys(argv).forEach((key) => {
+ if (conflicting[key]) {
+ conflicting[key].forEach((value) => {
+ if (value && argv[key] !== void 0 && argv[value] !== void 0) {
+ usage2.fail(__("Arguments %s and %s are mutually exclusive", key, value));
+ }
+ });
+ }
+ });
+ if (yargs.getInternalMethods().getParserConfiguration()["strip-dashed"]) {
+ Object.keys(conflicting).forEach((key) => {
+ conflicting[key].forEach((value) => {
+ if (value && argv[shim3.Parser.camelCase(key)] !== void 0 && argv[shim3.Parser.camelCase(value)] !== void 0) {
+ usage2.fail(__("Arguments %s and %s are mutually exclusive", key, value));
+ }
+ });
+ });
+ }
+ }, "conflictingFn");
+ self2.recommendCommands = /* @__PURE__ */ __name(function recommendCommands(cmd, potentialCommands) {
+ const threshold = 3;
+ potentialCommands = potentialCommands.sort((a, b) => b.length - a.length);
+ let recommended = null;
+ let bestDistance = Infinity;
+ for (let i = 0, candidate; (candidate = potentialCommands[i]) !== void 0; i++) {
+ const d = levenshtein(cmd, candidate);
+ if (d <= threshold && d < bestDistance) {
+ bestDistance = d;
+ recommended = candidate;
+ }
+ }
+ if (recommended)
+ usage2.fail(__("Did you mean %s?", recommended));
+ }, "recommendCommands");
+ self2.reset = /* @__PURE__ */ __name(function reset(localLookup) {
+ implied = objFilter(implied, (k) => !localLookup[k]);
+ conflicting = objFilter(conflicting, (k) => !localLookup[k]);
+ return self2;
+ }, "reset");
+ const frozens = [];
+ self2.freeze = /* @__PURE__ */ __name(function freeze() {
+ frozens.push({
+ implied,
+ conflicting
+ });
+ }, "freeze");
+ self2.unfreeze = /* @__PURE__ */ __name(function unfreeze() {
+ const frozen = frozens.pop();
+ assertNotStrictEqual(frozen, void 0, shim3);
+ ({ implied, conflicting } = frozen);
+ }, "unfreeze");
+ return self2;
+}
+__name(validation, "validation");
+
+// ../../node_modules/.pnpm/yargs@17.7.1/node_modules/yargs/build/lib/yargs-factory.js
+var __classPrivateFieldSet = function(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 __classPrivateFieldGet = function(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);
+};
+var _YargsInstance_command;
+var _YargsInstance_cwd;
+var _YargsInstance_context;
+var _YargsInstance_completion;
+var _YargsInstance_completionCommand;
+var _YargsInstance_defaultShowHiddenOpt;
+var _YargsInstance_exitError;
+var _YargsInstance_detectLocale;
+var _YargsInstance_emittedWarnings;
+var _YargsInstance_exitProcess;
+var _YargsInstance_frozens;
+var _YargsInstance_globalMiddleware;
+var _YargsInstance_groups;
+var _YargsInstance_hasOutput;
+var _YargsInstance_helpOpt;
+var _YargsInstance_isGlobalContext;
+var _YargsInstance_logger;
+var _YargsInstance_output;
+var _YargsInstance_options;
+var _YargsInstance_parentRequire;
+var _YargsInstance_parserConfig;
+var _YargsInstance_parseFn;
+var _YargsInstance_parseContext;
+var _YargsInstance_pkgs;
+var _YargsInstance_preservedGroups;
+var _YargsInstance_processArgs;
+var _YargsInstance_recommendCommands;
+var _YargsInstance_shim;
+var _YargsInstance_strict;
+var _YargsInstance_strictCommands;
+var _YargsInstance_strictOptions;
+var _YargsInstance_usage;
+var _YargsInstance_usageConfig;
+var _YargsInstance_versionOpt;
+var _YargsInstance_validation;
+function YargsFactory(_shim) {
+ return (processArgs = [], cwd2 = _shim.process.cwd(), parentRequire) => {
+ const yargs = new YargsInstance(processArgs, cwd2, parentRequire, _shim);
+ Object.defineProperty(yargs, "argv", {
+ get: () => {
+ return yargs.parse();
+ },
+ enumerable: true
+ });
+ yargs.help();
+ yargs.version();
+ return yargs;
+ };
+}
+__name(YargsFactory, "YargsFactory");
+var kCopyDoubleDash = Symbol("copyDoubleDash");
+var kCreateLogger = Symbol("copyDoubleDash");
+var kDeleteFromParserHintObject = Symbol("deleteFromParserHintObject");
+var kEmitWarning = Symbol("emitWarning");
+var kFreeze = Symbol("freeze");
+var kGetDollarZero = Symbol("getDollarZero");
+var kGetParserConfiguration = Symbol("getParserConfiguration");
+var kGetUsageConfiguration = Symbol("getUsageConfiguration");
+var kGuessLocale = Symbol("guessLocale");
+var kGuessVersion = Symbol("guessVersion");
+var kParsePositionalNumbers = Symbol("parsePositionalNumbers");
+var kPkgUp = Symbol("pkgUp");
+var kPopulateParserHintArray = Symbol("populateParserHintArray");
+var kPopulateParserHintSingleValueDictionary = Symbol("populateParserHintSingleValueDictionary");
+var kPopulateParserHintArrayDictionary = Symbol("populateParserHintArrayDictionary");
+var kPopulateParserHintDictionary = Symbol("populateParserHintDictionary");
+var kSanitizeKey = Symbol("sanitizeKey");
+var kSetKey = Symbol("setKey");
+var kUnfreeze = Symbol("unfreeze");
+var kValidateAsync = Symbol("validateAsync");
+var kGetCommandInstance = Symbol("getCommandInstance");
+var kGetContext = Symbol("getContext");
+var kGetHasOutput = Symbol("getHasOutput");
+var kGetLoggerInstance = Symbol("getLoggerInstance");
+var kGetParseContext = Symbol("getParseContext");
+var kGetUsageInstance = Symbol("getUsageInstance");
+var kGetValidationInstance = Symbol("getValidationInstance");
+var kHasParseCallback = Symbol("hasParseCallback");
+var kIsGlobalContext = Symbol("isGlobalContext");
+var kPostProcess = Symbol("postProcess");
+var kRebase = Symbol("rebase");
+var kReset = Symbol("reset");
+var kRunYargsParserAndExecuteCommands = Symbol("runYargsParserAndExecuteCommands");
+var kRunValidation = Symbol("runValidation");
+var kSetHasOutput = Symbol("setHasOutput");
+var kTrackManuallySetKeys = Symbol("kTrackManuallySetKeys");
+var YargsInstance = class {
+ constructor(processArgs = [], cwd2, parentRequire, shim3) {
+ this.customScriptName = false;
+ this.parsed = false;
+ _YargsInstance_command.set(this, void 0);
+ _YargsInstance_cwd.set(this, void 0);
+ _YargsInstance_context.set(this, { commands: [], fullCommands: [] });
+ _YargsInstance_completion.set(this, null);
+ _YargsInstance_completionCommand.set(this, null);
+ _YargsInstance_defaultShowHiddenOpt.set(this, "show-hidden");
+ _YargsInstance_exitError.set(this, null);
+ _YargsInstance_detectLocale.set(this, true);
+ _YargsInstance_emittedWarnings.set(this, {});
+ _YargsInstance_exitProcess.set(this, true);
+ _YargsInstance_frozens.set(this, []);
+ _YargsInstance_globalMiddleware.set(this, void 0);
+ _YargsInstance_groups.set(this, {});
+ _YargsInstance_hasOutput.set(this, false);
+ _YargsInstance_helpOpt.set(this, null);
+ _YargsInstance_isGlobalContext.set(this, true);
+ _YargsInstance_logger.set(this, void 0);
+ _YargsInstance_output.set(this, "");
+ _YargsInstance_options.set(this, void 0);
+ _YargsInstance_parentRequire.set(this, void 0);
+ _YargsInstance_parserConfig.set(this, {});
+ _YargsInstance_parseFn.set(this, null);
+ _YargsInstance_parseContext.set(this, null);
+ _YargsInstance_pkgs.set(this, {});
+ _YargsInstance_preservedGroups.set(this, {});
+ _YargsInstance_processArgs.set(this, void 0);
+ _YargsInstance_recommendCommands.set(this, false);
+ _YargsInstance_shim.set(this, void 0);
+ _YargsInstance_strict.set(this, false);
+ _YargsInstance_strictCommands.set(this, false);
+ _YargsInstance_strictOptions.set(this, false);
+ _YargsInstance_usage.set(this, void 0);
+ _YargsInstance_usageConfig.set(this, {});
+ _YargsInstance_versionOpt.set(this, null);
+ _YargsInstance_validation.set(this, void 0);
+ __classPrivateFieldSet(this, _YargsInstance_shim, shim3, "f");
+ __classPrivateFieldSet(this, _YargsInstance_processArgs, processArgs, "f");
+ __classPrivateFieldSet(this, _YargsInstance_cwd, cwd2, "f");
+ __classPrivateFieldSet(this, _YargsInstance_parentRequire, parentRequire, "f");
+ __classPrivateFieldSet(this, _YargsInstance_globalMiddleware, new GlobalMiddleware(this), "f");
+ this.$0 = this[kGetDollarZero]();
+ this[kReset]();
+ __classPrivateFieldSet(this, _YargsInstance_command, __classPrivateFieldGet(this, _YargsInstance_command, "f"), "f");
+ __classPrivateFieldSet(this, _YargsInstance_usage, __classPrivateFieldGet(this, _YargsInstance_usage, "f"), "f");
+ __classPrivateFieldSet(this, _YargsInstance_validation, __classPrivateFieldGet(this, _YargsInstance_validation, "f"), "f");
+ __classPrivateFieldSet(this, _YargsInstance_options, __classPrivateFieldGet(this, _YargsInstance_options, "f"), "f");
+ __classPrivateFieldGet(this, _YargsInstance_options, "f").showHiddenOpt = __classPrivateFieldGet(this, _YargsInstance_defaultShowHiddenOpt, "f");
+ __classPrivateFieldSet(this, _YargsInstance_logger, this[kCreateLogger](), "f");
+ }
+ addHelpOpt(opt, msg) {
+ const defaultHelpOpt = "help";
+ argsert("[string|boolean] [string]", [opt, msg], arguments.length);
+ if (__classPrivateFieldGet(this, _YargsInstance_helpOpt, "f")) {
+ this[kDeleteFromParserHintObject](__classPrivateFieldGet(this, _YargsInstance_helpOpt, "f"));
+ __classPrivateFieldSet(this, _YargsInstance_helpOpt, null, "f");
+ }
+ if (opt === false && msg === void 0)
+ return this;
+ __classPrivateFieldSet(this, _YargsInstance_helpOpt, typeof opt === "string" ? opt : defaultHelpOpt, "f");
+ this.boolean(__classPrivateFieldGet(this, _YargsInstance_helpOpt, "f"));
+ this.describe(__classPrivateFieldGet(this, _YargsInstance_helpOpt, "f"), msg || __classPrivateFieldGet(this, _YargsInstance_usage, "f").deferY18nLookup("Show help"));
+ return this;
+ }
+ help(opt, msg) {
+ return this.addHelpOpt(opt, msg);
+ }
+ addShowHiddenOpt(opt, msg) {
+ argsert("[string|boolean] [string]", [opt, msg], arguments.length);
+ if (opt === false && msg === void 0)
+ return this;
+ const showHiddenOpt = typeof opt === "string" ? opt : __classPrivateFieldGet(this, _YargsInstance_defaultShowHiddenOpt, "f");
+ this.boolean(showHiddenOpt);
+ this.describe(showHiddenOpt, msg || __classPrivateFieldGet(this, _YargsInstance_usage, "f").deferY18nLookup("Show hidden options"));
+ __classPrivateFieldGet(this, _YargsInstance_options, "f").showHiddenOpt = showHiddenOpt;
+ return this;
+ }
+ showHidden(opt, msg) {
+ return this.addShowHiddenOpt(opt, msg);
+ }
+ alias(key, value) {
+ argsert(" [string|array]", [key, value], arguments.length);
+ this[kPopulateParserHintArrayDictionary](this.alias.bind(this), "alias", key, value);
+ return this;
+ }
+ array(keys) {
+ argsert("", [keys], arguments.length);
+ this[kPopulateParserHintArray]("array", keys);
+ this[kTrackManuallySetKeys](keys);
+ return this;
+ }
+ boolean(keys) {
+ argsert("", [keys], arguments.length);
+ this[kPopulateParserHintArray]("boolean", keys);
+ this[kTrackManuallySetKeys](keys);
+ return this;
+ }
+ check(f, global2) {
+ argsert(" [boolean]", [f, global2], arguments.length);
+ this.middleware((argv, _yargs) => {
+ return maybeAsyncResult(() => {
+ return f(argv, _yargs.getOptions());
+ }, (result) => {
+ if (!result) {
+ __classPrivateFieldGet(this, _YargsInstance_usage, "f").fail(__classPrivateFieldGet(this, _YargsInstance_shim, "f").y18n.__("Argument check failed: %s", f.toString()));
+ } else if (typeof result === "string" || result instanceof Error) {
+ __classPrivateFieldGet(this, _YargsInstance_usage, "f").fail(result.toString(), result);
+ }
+ return argv;
+ }, (err) => {
+ __classPrivateFieldGet(this, _YargsInstance_usage, "f").fail(err.message ? err.message : err.toString(), err);
+ return argv;
+ });
+ }, false, global2);
+ return this;
+ }
+ choices(key, value) {
+ argsert(" [string|array]", [key, value], arguments.length);
+ this[kPopulateParserHintArrayDictionary](this.choices.bind(this), "choices", key, value);
+ return this;
+ }
+ coerce(keys, value) {
+ argsert(" [function]", [keys, value], arguments.length);
+ if (Array.isArray(keys)) {
+ if (!value) {
+ throw new YError("coerce callback must be provided");
+ }
+ for (const key of keys) {
+ this.coerce(key, value);
+ }
+ return this;
+ } else if (typeof keys === "object") {
+ for (const key of Object.keys(keys)) {
+ this.coerce(key, keys[key]);
+ }
+ return this;
+ }
+ if (!value) {
+ throw new YError("coerce callback must be provided");
+ }
+ __classPrivateFieldGet(this, _YargsInstance_options, "f").key[keys] = true;
+ __classPrivateFieldGet(this, _YargsInstance_globalMiddleware, "f").addCoerceMiddleware((argv, yargs) => {
+ let aliases2;
+ const shouldCoerce = Object.prototype.hasOwnProperty.call(argv, keys);
+ if (!shouldCoerce) {
+ return argv;
+ }
+ return maybeAsyncResult(() => {
+ aliases2 = yargs.getAliases();
+ return value(argv[keys]);
+ }, (result) => {
+ argv[keys] = result;
+ const stripAliased = yargs.getInternalMethods().getParserConfiguration()["strip-aliased"];
+ if (aliases2[keys] && stripAliased !== true) {
+ for (const alias of aliases2[keys]) {
+ argv[alias] = result;
+ }
+ }
+ return argv;
+ }, (err) => {
+ throw new YError(err.message);
+ });
+ }, keys);
+ return this;
+ }
+ conflicts(key1, key2) {
+ argsert(" [string|array]", [key1, key2], arguments.length);
+ __classPrivateFieldGet(this, _YargsInstance_validation, "f").conflicts(key1, key2);
+ return this;
+ }
+ config(key = "config", msg, parseFn) {
+ argsert("[object|string] [string|function] [function]", [key, msg, parseFn], arguments.length);
+ if (typeof key === "object" && !Array.isArray(key)) {
+ key = applyExtends(key, __classPrivateFieldGet(this, _YargsInstance_cwd, "f"), this[kGetParserConfiguration]()["deep-merge-config"] || false, __classPrivateFieldGet(this, _YargsInstance_shim, "f"));
+ __classPrivateFieldGet(this, _YargsInstance_options, "f").configObjects = (__classPrivateFieldGet(this, _YargsInstance_options, "f").configObjects || []).concat(key);
+ return this;
+ }
+ if (typeof msg === "function") {
+ parseFn = msg;
+ msg = void 0;
+ }
+ this.describe(key, msg || __classPrivateFieldGet(this, _YargsInstance_usage, "f").deferY18nLookup("Path to JSON config file"));
+ (Array.isArray(key) ? key : [key]).forEach((k) => {
+ __classPrivateFieldGet(this, _YargsInstance_options, "f").config[k] = parseFn || true;
+ });
+ return this;
+ }
+ completion(cmd, desc, fn2) {
+ argsert("[string] [string|boolean|function] [function]", [cmd, desc, fn2], arguments.length);
+ if (typeof desc === "function") {
+ fn2 = desc;
+ desc = void 0;
+ }
+ __classPrivateFieldSet(this, _YargsInstance_completionCommand, cmd || __classPrivateFieldGet(this, _YargsInstance_completionCommand, "f") || "completion", "f");
+ if (!desc && desc !== false) {
+ desc = "generate completion script";
+ }
+ this.command(__classPrivateFieldGet(this, _YargsInstance_completionCommand, "f"), desc);
+ if (fn2)
+ __classPrivateFieldGet(this, _YargsInstance_completion, "f").registerFunction(fn2);
+ return this;
+ }
+ command(cmd, description, builder, handler15, middlewares, deprecated2) {
+ argsert(" [string|boolean] [function|object] [function] [array] [boolean|string]", [cmd, description, builder, handler15, middlewares, deprecated2], arguments.length);
+ __classPrivateFieldGet(this, _YargsInstance_command, "f").addHandler(cmd, description, builder, handler15, middlewares, deprecated2);
+ return this;
+ }
+ commands(cmd, description, builder, handler15, middlewares, deprecated2) {
+ return this.command(cmd, description, builder, handler15, middlewares, deprecated2);
+ }
+ commandDir(dir, opts) {
+ argsert(" [object]", [dir, opts], arguments.length);
+ const req = __classPrivateFieldGet(this, _YargsInstance_parentRequire, "f") || __classPrivateFieldGet(this, _YargsInstance_shim, "f").require;
+ __classPrivateFieldGet(this, _YargsInstance_command, "f").addDirectory(dir, req, __classPrivateFieldGet(this, _YargsInstance_shim, "f").getCallerFile(), opts);
+ return this;
+ }
+ count(keys) {
+ argsert("", [keys], arguments.length);
+ this[kPopulateParserHintArray]("count", keys);
+ this[kTrackManuallySetKeys](keys);
+ return this;
+ }
+ default(key, value, defaultDescription) {
+ argsert(" [*] [string]", [key, value, defaultDescription], arguments.length);
+ if (defaultDescription) {
+ assertSingleKey(key, __classPrivateFieldGet(this, _YargsInstance_shim, "f"));
+ __classPrivateFieldGet(this, _YargsInstance_options, "f").defaultDescription[key] = defaultDescription;
+ }
+ if (typeof value === "function") {
+ assertSingleKey(key, __classPrivateFieldGet(this, _YargsInstance_shim, "f"));
+ if (!__classPrivateFieldGet(this, _YargsInstance_options, "f").defaultDescription[key])
+ __classPrivateFieldGet(this, _YargsInstance_options, "f").defaultDescription[key] = __classPrivateFieldGet(this, _YargsInstance_usage, "f").functionDescription(value);
+ value = value.call();
+ }
+ this[kPopulateParserHintSingleValueDictionary](this.default.bind(this), "default", key, value);
+ return this;
+ }
+ defaults(key, value, defaultDescription) {
+ return this.default(key, value, defaultDescription);
+ }
+ demandCommand(min = 1, max, minMsg, maxMsg) {
+ argsert("[number] [number|string] [string|null|undefined] [string|null|undefined]", [min, max, minMsg, maxMsg], arguments.length);
+ if (typeof max !== "number") {
+ minMsg = max;
+ max = Infinity;
+ }
+ this.global("_", false);
+ __classPrivateFieldGet(this, _YargsInstance_options, "f").demandedCommands._ = {
+ min,
+ max,
+ minMsg,
+ maxMsg
+ };
+ return this;
+ }
+ demand(keys, max, msg) {
+ if (Array.isArray(max)) {
+ max.forEach((key) => {
+ assertNotStrictEqual(msg, true, __classPrivateFieldGet(this, _YargsInstance_shim, "f"));
+ this.demandOption(key, msg);
+ });
+ max = Infinity;
+ } else if (typeof max !== "number") {
+ msg = max;
+ max = Infinity;
+ }
+ if (typeof keys === "number") {
+ assertNotStrictEqual(msg, true, __classPrivateFieldGet(this, _YargsInstance_shim, "f"));
+ this.demandCommand(keys, max, msg, msg);
+ } else if (Array.isArray(keys)) {
+ keys.forEach((key) => {
+ assertNotStrictEqual(msg, true, __classPrivateFieldGet(this, _YargsInstance_shim, "f"));
+ this.demandOption(key, msg);
+ });
+ } else {
+ if (typeof msg === "string") {
+ this.demandOption(keys, msg);
+ } else if (msg === true || typeof msg === "undefined") {
+ this.demandOption(keys);
+ }
+ }
+ return this;
+ }
+ demandOption(keys, msg) {
+ argsert(" [string]", [keys, msg], arguments.length);
+ this[kPopulateParserHintSingleValueDictionary](this.demandOption.bind(this), "demandedOptions", keys, msg);
+ return this;
+ }
+ deprecateOption(option, message) {
+ argsert(" [string|boolean]", [option, message], arguments.length);
+ __classPrivateFieldGet(this, _YargsInstance_options, "f").deprecatedOptions[option] = message;
+ return this;
+ }
+ describe(keys, description) {
+ argsert(" [string]", [keys, description], arguments.length);
+ this[kSetKey](keys, true);
+ __classPrivateFieldGet(this, _YargsInstance_usage, "f").describe(keys, description);
+ return this;
+ }
+ detectLocale(detect) {
+ argsert("", [detect], arguments.length);
+ __classPrivateFieldSet(this, _YargsInstance_detectLocale, detect, "f");
+ return this;
+ }
+ env(prefix) {
+ argsert("[string|boolean]", [prefix], arguments.length);
+ if (prefix === false)
+ delete __classPrivateFieldGet(this, _YargsInstance_options, "f").envPrefix;
+ else
+ __classPrivateFieldGet(this, _YargsInstance_options, "f").envPrefix = prefix || "";
+ return this;
+ }
+ epilogue(msg) {
+ argsert("", [msg], arguments.length);
+ __classPrivateFieldGet(this, _YargsInstance_usage, "f").epilog(msg);
+ return this;
+ }
+ epilog(msg) {
+ return this.epilogue(msg);
+ }
+ example(cmd, description) {
+ argsert(" [string]", [cmd, description], arguments.length);
+ if (Array.isArray(cmd)) {
+ cmd.forEach((exampleParams) => this.example(...exampleParams));
+ } else {
+ __classPrivateFieldGet(this, _YargsInstance_usage, "f").example(cmd, description);
+ }
+ return this;
+ }
+ exit(code, err) {
+ __classPrivateFieldSet(this, _YargsInstance_hasOutput, true, "f");
+ __classPrivateFieldSet(this, _YargsInstance_exitError, err, "f");
+ if (__classPrivateFieldGet(this, _YargsInstance_exitProcess, "f"))
+ __classPrivateFieldGet(this, _YargsInstance_shim, "f").process.exit(code);
+ }
+ exitProcess(enabled = true) {
+ argsert("[boolean]", [enabled], arguments.length);
+ __classPrivateFieldSet(this, _YargsInstance_exitProcess, enabled, "f");
+ return this;
+ }
+ fail(f) {
+ argsert("", [f], arguments.length);
+ if (typeof f === "boolean" && f !== false) {
+ throw new YError("Invalid first argument. Expected function or boolean 'false'");
+ }
+ __classPrivateFieldGet(this, _YargsInstance_usage, "f").failFn(f);
+ return this;
+ }
+ getAliases() {
+ return this.parsed ? this.parsed.aliases : {};
+ }
+ async getCompletion(args, done) {
+ argsert(" [function]", [args, done], arguments.length);
+ if (!done) {
+ return new Promise((resolve18, reject) => {
+ __classPrivateFieldGet(this, _YargsInstance_completion, "f").getCompletion(args, (err, completions) => {
+ if (err)
+ reject(err);
+ else
+ resolve18(completions);
+ });
+ });
+ } else {
+ return __classPrivateFieldGet(this, _YargsInstance_completion, "f").getCompletion(args, done);
+ }
+ }
+ getDemandedOptions() {
+ argsert([], 0);
+ return __classPrivateFieldGet(this, _YargsInstance_options, "f").demandedOptions;
+ }
+ getDemandedCommands() {
+ argsert([], 0);
+ return __classPrivateFieldGet(this, _YargsInstance_options, "f").demandedCommands;
+ }
+ getDeprecatedOptions() {
+ argsert([], 0);
+ return __classPrivateFieldGet(this, _YargsInstance_options, "f").deprecatedOptions;
+ }
+ getDetectLocale() {
+ return __classPrivateFieldGet(this, _YargsInstance_detectLocale, "f");
+ }
+ getExitProcess() {
+ return __classPrivateFieldGet(this, _YargsInstance_exitProcess, "f");
+ }
+ getGroups() {
+ return Object.assign({}, __classPrivateFieldGet(this, _YargsInstance_groups, "f"), __classPrivateFieldGet(this, _YargsInstance_preservedGroups, "f"));
+ }
+ getHelp() {
+ __classPrivateFieldSet(this, _YargsInstance_hasOutput, true, "f");
+ if (!__classPrivateFieldGet(this, _YargsInstance_usage, "f").hasCachedHelpMessage()) {
+ if (!this.parsed) {
+ const parse4 = this[kRunYargsParserAndExecuteCommands](__classPrivateFieldGet(this, _YargsInstance_processArgs, "f"), void 0, void 0, 0, true);
+ if (isPromise(parse4)) {
+ return parse4.then(() => {
+ return __classPrivateFieldGet(this, _YargsInstance_usage, "f").help();
+ });
+ }
+ }
+ const builderResponse = __classPrivateFieldGet(this, _YargsInstance_command, "f").runDefaultBuilderOn(this);
+ if (isPromise(builderResponse)) {
+ return builderResponse.then(() => {
+ return __classPrivateFieldGet(this, _YargsInstance_usage, "f").help();
+ });
+ }
+ }
+ return Promise.resolve(__classPrivateFieldGet(this, _YargsInstance_usage, "f").help());
+ }
+ getOptions() {
+ return __classPrivateFieldGet(this, _YargsInstance_options, "f");
+ }
+ getStrict() {
+ return __classPrivateFieldGet(this, _YargsInstance_strict, "f");
+ }
+ getStrictCommands() {
+ return __classPrivateFieldGet(this, _YargsInstance_strictCommands, "f");
+ }
+ getStrictOptions() {
+ return __classPrivateFieldGet(this, _YargsInstance_strictOptions, "f");
+ }
+ global(globals, global2) {
+ argsert(" [boolean]", [globals, global2], arguments.length);
+ globals = [].concat(globals);
+ if (global2 !== false) {
+ __classPrivateFieldGet(this, _YargsInstance_options, "f").local = __classPrivateFieldGet(this, _YargsInstance_options, "f").local.filter((l) => globals.indexOf(l) === -1);
+ } else {
+ globals.forEach((g) => {
+ if (!__classPrivateFieldGet(this, _YargsInstance_options, "f").local.includes(g))
+ __classPrivateFieldGet(this, _YargsInstance_options, "f").local.push(g);
+ });
+ }
+ return this;
+ }
+ group(opts, groupName) {
+ argsert(" ", [opts, groupName], arguments.length);
+ const existing = __classPrivateFieldGet(this, _YargsInstance_preservedGroups, "f")[groupName] || __classPrivateFieldGet(this, _YargsInstance_groups, "f")[groupName];
+ if (__classPrivateFieldGet(this, _YargsInstance_preservedGroups, "f")[groupName]) {
+ delete __classPrivateFieldGet(this, _YargsInstance_preservedGroups, "f")[groupName];
+ }
+ const seen = {};
+ __classPrivateFieldGet(this, _YargsInstance_groups, "f")[groupName] = (existing || []).concat(opts).filter((key) => {
+ if (seen[key])
+ return false;
+ return seen[key] = true;
+ });
+ return this;
+ }
+ hide(key) {
+ argsert("", [key], arguments.length);
+ __classPrivateFieldGet(this, _YargsInstance_options, "f").hiddenOptions.push(key);
+ return this;
+ }
+ implies(key, value) {
+ argsert(" [number|string|array]", [key, value], arguments.length);
+ __classPrivateFieldGet(this, _YargsInstance_validation, "f").implies(key, value);
+ return this;
+ }
+ locale(locale) {
+ argsert("[string]", [locale], arguments.length);
+ if (locale === void 0) {
+ this[kGuessLocale]();
+ return __classPrivateFieldGet(this, _YargsInstance_shim, "f").y18n.getLocale();
+ }
+ __classPrivateFieldSet(this, _YargsInstance_detectLocale, false, "f");
+ __classPrivateFieldGet(this, _YargsInstance_shim, "f").y18n.setLocale(locale);
+ return this;
+ }
+ middleware(callback, applyBeforeValidation, global2) {
+ return __classPrivateFieldGet(this, _YargsInstance_globalMiddleware, "f").addMiddleware(callback, !!applyBeforeValidation, global2);
+ }
+ nargs(key, value) {
+ argsert(" [number]", [key, value], arguments.length);
+ this[kPopulateParserHintSingleValueDictionary](this.nargs.bind(this), "narg", key, value);
+ return this;
+ }
+ normalize(keys) {
+ argsert("", [keys], arguments.length);
+ this[kPopulateParserHintArray]("normalize", keys);
+ return this;
+ }
+ number(keys) {
+ argsert("", [keys], arguments.length);
+ this[kPopulateParserHintArray]("number", keys);
+ this[kTrackManuallySetKeys](keys);
+ return this;
+ }
+ option(key, opt) {
+ argsert(" [object]", [key, opt], arguments.length);
+ if (typeof key === "object") {
+ Object.keys(key).forEach((k) => {
+ this.options(k, key[k]);
+ });
+ } else {
+ if (typeof opt !== "object") {
+ opt = {};
+ }
+ this[kTrackManuallySetKeys](key);
+ if (__classPrivateFieldGet(this, _YargsInstance_versionOpt, "f") && (key === "version" || (opt === null || opt === void 0 ? void 0 : opt.alias) === "version")) {
+ this[kEmitWarning]([
+ '"version" is a reserved word.',
+ "Please do one of the following:",
+ '- Disable version with `yargs.version(false)` if using "version" as an option',
+ "- Use the built-in `yargs.version` method instead (if applicable)",
+ "- Use a different option key",
+ "https://yargs.js.org/docs/#api-reference-version"
+ ].join("\n"), void 0, "versionWarning");
+ }
+ __classPrivateFieldGet(this, _YargsInstance_options, "f").key[key] = true;
+ if (opt.alias)
+ this.alias(key, opt.alias);
+ const deprecate = opt.deprecate || opt.deprecated;
+ if (deprecate) {
+ this.deprecateOption(key, deprecate);
+ }
+ const demand = opt.demand || opt.required || opt.require;
+ if (demand) {
+ this.demand(key, demand);
+ }
+ if (opt.demandOption) {
+ this.demandOption(key, typeof opt.demandOption === "string" ? opt.demandOption : void 0);
+ }
+ if (opt.conflicts) {
+ this.conflicts(key, opt.conflicts);
+ }
+ if ("default" in opt) {
+ this.default(key, opt.default);
+ }
+ if (opt.implies !== void 0) {
+ this.implies(key, opt.implies);
+ }
+ if (opt.nargs !== void 0) {
+ this.nargs(key, opt.nargs);
+ }
+ if (opt.config) {
+ this.config(key, opt.configParser);
+ }
+ if (opt.normalize) {
+ this.normalize(key);
+ }
+ if (opt.choices) {
+ this.choices(key, opt.choices);
+ }
+ if (opt.coerce) {
+ this.coerce(key, opt.coerce);
+ }
+ if (opt.group) {
+ this.group(key, opt.group);
+ }
+ if (opt.boolean || opt.type === "boolean") {
+ this.boolean(key);
+ if (opt.alias)
+ this.boolean(opt.alias);
+ }
+ if (opt.array || opt.type === "array") {
+ this.array(key);
+ if (opt.alias)
+ this.array(opt.alias);
+ }
+ if (opt.number || opt.type === "number") {
+ this.number(key);
+ if (opt.alias)
+ this.number(opt.alias);
+ }
+ if (opt.string || opt.type === "string") {
+ this.string(key);
+ if (opt.alias)
+ this.string(opt.alias);
+ }
+ if (opt.count || opt.type === "count") {
+ this.count(key);
+ }
+ if (typeof opt.global === "boolean") {
+ this.global(key, opt.global);
+ }
+ if (opt.defaultDescription) {
+ __classPrivateFieldGet(this, _YargsInstance_options, "f").defaultDescription[key] = opt.defaultDescription;
+ }
+ if (opt.skipValidation) {
+ this.skipValidation(key);
+ }
+ const desc = opt.describe || opt.description || opt.desc;
+ const descriptions = __classPrivateFieldGet(this, _YargsInstance_usage, "f").getDescriptions();
+ if (!Object.prototype.hasOwnProperty.call(descriptions, key) || typeof desc === "string") {
+ this.describe(key, desc);
+ }
+ if (opt.hidden) {
+ this.hide(key);
+ }
+ if (opt.requiresArg) {
+ this.requiresArg(key);
+ }
+ }
+ return this;
+ }
+ options(key, opt) {
+ return this.option(key, opt);
+ }
+ parse(args, shortCircuit, _parseFn) {
+ argsert("[string|array] [function|boolean|object] [function]", [args, shortCircuit, _parseFn], arguments.length);
+ this[kFreeze]();
+ if (typeof args === "undefined") {
+ args = __classPrivateFieldGet(this, _YargsInstance_processArgs, "f");
+ }
+ if (typeof shortCircuit === "object") {
+ __classPrivateFieldSet(this, _YargsInstance_parseContext, shortCircuit, "f");
+ shortCircuit = _parseFn;
+ }
+ if (typeof shortCircuit === "function") {
+ __classPrivateFieldSet(this, _YargsInstance_parseFn, shortCircuit, "f");
+ shortCircuit = false;
+ }
+ if (!shortCircuit)
+ __classPrivateFieldSet(this, _YargsInstance_processArgs, args, "f");
+ if (__classPrivateFieldGet(this, _YargsInstance_parseFn, "f"))
+ __classPrivateFieldSet(this, _YargsInstance_exitProcess, false, "f");
+ const parsed = this[kRunYargsParserAndExecuteCommands](args, !!shortCircuit);
+ const tmpParsed = this.parsed;
+ __classPrivateFieldGet(this, _YargsInstance_completion, "f").setParsed(this.parsed);
+ if (isPromise(parsed)) {
+ return parsed.then((argv) => {
+ if (__classPrivateFieldGet(this, _YargsInstance_parseFn, "f"))
+ __classPrivateFieldGet(this, _YargsInstance_parseFn, "f").call(this, __classPrivateFieldGet(this, _YargsInstance_exitError, "f"), argv, __classPrivateFieldGet(this, _YargsInstance_output, "f"));
+ return argv;
+ }).catch((err) => {
+ if (__classPrivateFieldGet(this, _YargsInstance_parseFn, "f")) {
+ __classPrivateFieldGet(this, _YargsInstance_parseFn, "f")(err, this.parsed.argv, __classPrivateFieldGet(this, _YargsInstance_output, "f"));
+ }
+ throw err;
+ }).finally(() => {
+ this[kUnfreeze]();
+ this.parsed = tmpParsed;
+ });
+ } else {
+ if (__classPrivateFieldGet(this, _YargsInstance_parseFn, "f"))
+ __classPrivateFieldGet(this, _YargsInstance_parseFn, "f").call(this, __classPrivateFieldGet(this, _YargsInstance_exitError, "f"), parsed, __classPrivateFieldGet(this, _YargsInstance_output, "f"));
+ this[kUnfreeze]();
+ this.parsed = tmpParsed;
+ }
+ return parsed;
+ }
+ parseAsync(args, shortCircuit, _parseFn) {
+ const maybePromise = this.parse(args, shortCircuit, _parseFn);
+ return !isPromise(maybePromise) ? Promise.resolve(maybePromise) : maybePromise;
+ }
+ parseSync(args, shortCircuit, _parseFn) {
+ const maybePromise = this.parse(args, shortCircuit, _parseFn);
+ if (isPromise(maybePromise)) {
+ throw new YError(".parseSync() must not be used with asynchronous builders, handlers, or middleware");
+ }
+ return maybePromise;
+ }
+ parserConfiguration(config) {
+ argsert("
+
+
+
+