diff --git a/.claude/memory/feedback_no_chrome_devtools.md b/.claude/memory/feedback_no_chrome_devtools.md new file mode 100644 index 0000000000000000000000000000000000000000..4966d1a7e94b80a49061664700a014a524cd10d6 --- /dev/null +++ b/.claude/memory/feedback_no_chrome_devtools.md @@ -0,0 +1,11 @@ +--- +name: No usar Chrome DevTools para verificar UI +description: El usuario prefiere verificar los cambios de UI él mismo, sin que Claude use Chrome DevTools +type: feedback +--- + +No usar Chrome DevTools MCP para tomar screenshots o interactuar con el navegador después de hacer cambios de UI. El usuario prefiere revisar los cambios visualmente por su cuenta. + +**Why:** El usuario lo indicó explícitamente cuando se usaban las herramientas de Chrome para verificar cambios CSS/JS. + +**How to apply:** Después de hacer cambios de CSS o JS en la UI, describir los cambios realizados y dejar que el usuario los verifique en el navegador. diff --git a/.gitattributes b/.gitattributes index a6344aac8c09253b3b630fb776ae94478aa0275b..7fde19b1875e82de950502fd36197c4e2ba8284a 100644 --- a/.gitattributes +++ b/.gitattributes @@ -33,3 +33,10 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text *.zip filter=lfs diff=lfs merge=lfs -text *.zst filter=lfs diff=lfs merge=lfs -text *tfevents* filter=lfs diff=lfs merge=lfs -text +backend/node_modules/prisma/libquery_engine-darwin-arm64.dylib.node filter=lfs diff=lfs merge=lfs -text +backend/node_modules/@prisma/engines/libquery_engine-darwin-arm64.dylib.node filter=lfs diff=lfs merge=lfs -text +backend/node_modules/@prisma/engines/schema-engine-darwin-arm64 filter=lfs diff=lfs merge=lfs -text +backend/node_modules/.prisma/client/libquery_engine-darwin-arm64.dylib.node filter=lfs diff=lfs merge=lfs -text +backend/node_modules/prisma/build/public/icon-1024.png filter=lfs diff=lfs merge=lfs -text +backend/node_modules/prisma/build/public/assets/inter-all-400-normal.4c1f8a0d.woff filter=lfs diff=lfs merge=lfs -text +backend/node_modules/prisma/build/public/assets/inter-all-600-normal.d0a7c8a9.woff filter=lfs diff=lfs merge=lfs -text diff --git a/backend/node_modules/.prisma/client/libquery_engine-darwin-arm64.dylib.node b/backend/node_modules/.prisma/client/libquery_engine-darwin-arm64.dylib.node new file mode 100644 index 0000000000000000000000000000000000000000..3cc7e60a82903bbfb9233dc286fe550921c9f40f --- /dev/null +++ b/backend/node_modules/.prisma/client/libquery_engine-darwin-arm64.dylib.node @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:afb9cb5a12ea42caa6f6498e40e9cb75059cae17098aadcc1001c99bb262e1ee +size 19356128 diff --git a/backend/node_modules/.prisma/client/query_engine_bg.wasm b/backend/node_modules/.prisma/client/query_engine_bg.wasm new file mode 100644 index 0000000000000000000000000000000000000000..2b38eca3f2068106f4c2c44440862409c830be25 --- /dev/null +++ b/backend/node_modules/.prisma/client/query_engine_bg.wasm @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7ec8cd57e69e5e061c71accb0ae4ea5a258b074e51da112c6d871d398e259eba +size 2171299 diff --git a/backend/node_modules/@prisma/engines/libquery_engine-darwin-arm64.dylib.node b/backend/node_modules/@prisma/engines/libquery_engine-darwin-arm64.dylib.node new file mode 100644 index 0000000000000000000000000000000000000000..3cc7e60a82903bbfb9233dc286fe550921c9f40f --- /dev/null +++ b/backend/node_modules/@prisma/engines/libquery_engine-darwin-arm64.dylib.node @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:afb9cb5a12ea42caa6f6498e40e9cb75059cae17098aadcc1001c99bb262e1ee +size 19356128 diff --git a/backend/node_modules/@prisma/engines/schema-engine-darwin-arm64 b/backend/node_modules/@prisma/engines/schema-engine-darwin-arm64 new file mode 100644 index 0000000000000000000000000000000000000000..95d1a32136f9cfdb60bada84cc8b6b2d986cf263 --- /dev/null +++ b/backend/node_modules/@prisma/engines/schema-engine-darwin-arm64 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:caa2cf90d5b2cfe6cc06e47974f7e3275dd395b4d35cf140d5d4b2362c3b5bb1 +size 21686160 diff --git a/backend/node_modules/c12/dist/index.d.mts b/backend/node_modules/c12/dist/index.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..e31028e217ec3af7850f3db2afeddc5aa3b51eb5 --- /dev/null +++ b/backend/node_modules/c12/dist/index.d.mts @@ -0,0 +1,157 @@ +import { Jiti, JitiOptions } from 'jiti'; +import { DownloadTemplateOptions } from 'giget'; +import { ChokidarOptions } from 'chokidar'; +import { diff } from 'ohash/utils'; + +interface DotenvOptions { + /** + * The project root directory (either absolute or relative to the current working directory). + */ + cwd: string; + /** + * What file to look in for environment variables (either absolute or relative + * to the current working directory). For example, `.env`. + */ + fileName?: string; + /** + * Whether to interpolate variables within .env. + * + * @example + * ```env + * BASE_DIR="/test" + * # resolves to "/test/further" + * ANOTHER_DIR="${BASE_DIR}/further" + * ``` + */ + interpolate?: boolean; + /** + * An object describing environment variables (key, value pairs). + */ + env?: NodeJS.ProcessEnv; +} +type Env = typeof process.env; +/** + * Load and interpolate environment variables into `process.env`. + * If you need more control (or access to the values), consider using `loadDotenv` instead + * + */ +declare function setupDotenv(options: DotenvOptions): Promise; +/** Load environment variables into an object. */ +declare function loadDotenv(options: DotenvOptions): Promise; +declare global { + var __c12_dotenv_vars__: Map, Set>; +} + +interface ConfigLayerMeta { + name?: string; + [key: string]: any; +} +type UserInputConfig = Record; +interface C12InputConfig { + $test?: T; + $development?: T; + $production?: T; + $env?: Record; + $meta?: MT; +} +type InputConfig = C12InputConfig & T; +interface SourceOptions { + /** Custom meta for layer */ + meta?: MT; + /** Layer config overrides */ + overrides?: T; + [key: string]: any; + /** + * Options for cloning remote sources + * + * @see https://giget.unjs.io + */ + giget?: DownloadTemplateOptions; + /** + * Install dependencies after cloning + * + * @see https://nypm.unjs.io + */ + install?: boolean; + /** + * Token for cloning private sources + * + * @see https://giget.unjs.io#providing-token-for-private-repositories + */ + auth?: string; +} +interface ConfigLayer { + config: T | null; + source?: string; + sourceOptions?: SourceOptions; + meta?: MT; + cwd?: string; + configFile?: string; +} +interface ResolvedConfig extends ConfigLayer { + config: T; + layers?: ConfigLayer[]; + cwd?: string; +} +type ConfigSource = "overrides" | "main" | "rc" | "packageJson" | "defaultConfig"; +interface ResolvableConfigContext { + configs: Record; + rawConfigs: Record | null | undefined>; +} +type MaybePromise = T | Promise; +type ResolvableConfig = MaybePromise | ((ctx: ResolvableConfigContext) => MaybePromise); +interface LoadConfigOptions { + name?: string; + cwd?: string; + configFile?: string; + rcFile?: false | string; + globalRc?: boolean; + dotenv?: boolean | DotenvOptions; + envName?: string | false; + packageJson?: boolean | string | string[]; + defaults?: T; + defaultConfig?: ResolvableConfig; + overrides?: ResolvableConfig; + omit$Keys?: boolean; + resolve?: (id: string, options: LoadConfigOptions) => null | undefined | ResolvedConfig | Promise | undefined | null>; + jiti?: Jiti; + jitiOptions?: JitiOptions; + giget?: false | DownloadTemplateOptions; + merger?: (...sources: Array) => T; + extend?: false | { + extendKey?: string | string[]; + }; +} +type DefineConfig = (input: InputConfig) => InputConfig; +declare function createDefineConfig(): DefineConfig; + +declare const SUPPORTED_EXTENSIONS: string[]; +declare function loadConfig(options: LoadConfigOptions): Promise>; + +type DiffEntries = ReturnType; +type ConfigWatcher = ResolvedConfig & { + watchingFiles: string[]; + unwatch: () => Promise; +}; +interface WatchConfigOptions extends LoadConfigOptions { + chokidarOptions?: ChokidarOptions; + debounce?: false | number; + onWatch?: (event: { + type: "created" | "updated" | "removed"; + path: string; + }) => void | Promise; + acceptHMR?: (context: { + getDiff: () => DiffEntries; + newConfig: ResolvedConfig; + oldConfig: ResolvedConfig; + }) => void | boolean | Promise; + onUpdate?: (context: { + getDiff: () => ReturnType; + newConfig: ResolvedConfig; + oldConfig: ResolvedConfig; + }) => void | Promise; +} +declare function watchConfig(options: WatchConfigOptions): Promise>; + +export { SUPPORTED_EXTENSIONS, createDefineConfig, loadConfig, loadDotenv, setupDotenv, watchConfig }; +export type { C12InputConfig, ConfigLayer, ConfigLayerMeta, ConfigSource, ConfigWatcher, DefineConfig, DotenvOptions, Env, InputConfig, LoadConfigOptions, ResolvableConfig, ResolvableConfigContext, ResolvedConfig, SourceOptions, UserInputConfig, WatchConfigOptions }; diff --git a/backend/node_modules/c12/dist/index.mjs b/backend/node_modules/c12/dist/index.mjs new file mode 100644 index 0000000000000000000000000000000000000000..9f06c8345762d9df9114b9ab98fa6967fd5121cd --- /dev/null +++ b/backend/node_modules/c12/dist/index.mjs @@ -0,0 +1,112 @@ +import { l as loadConfig, S as SUPPORTED_EXTENSIONS } from './shared/c12.BXpNC6YI.mjs'; +export { a as loadDotenv, s as setupDotenv } from './shared/c12.BXpNC6YI.mjs'; +import { debounce } from 'perfect-debounce'; +import { resolve } from 'pathe'; +import 'node:fs'; +import 'node:fs/promises'; +import 'node:url'; +import 'node:os'; +import 'exsolve'; +import 'jiti'; +import 'rc9'; +import 'defu'; +import 'pkg-types'; +import 'dotenv'; + +function createDefineConfig() { + return (input) => input; +} + +const eventMap = { + add: "created", + change: "updated", + unlink: "removed" +}; +async function watchConfig(options) { + let config = await loadConfig(options); + const configName = options.name || "config"; + const configFileName = options.configFile ?? (options.name === "config" ? "config" : `${options.name}.config`); + const watchingFiles = [ + ...new Set( + (config.layers || []).filter((l) => l.cwd).flatMap((l) => [ + ...SUPPORTED_EXTENSIONS.flatMap((ext) => [ + resolve(l.cwd, configFileName + ext), + resolve(l.cwd, ".config", configFileName + ext), + resolve( + l.cwd, + ".config", + configFileName.replace(/\.config$/, "") + ext + ) + ]), + l.source && resolve(l.cwd, l.source), + // TODO: Support watching rc from home and workspace + options.rcFile && resolve( + l.cwd, + typeof options.rcFile === "string" ? options.rcFile : `.${configName}rc` + ), + options.packageJson && resolve(l.cwd, "package.json") + ]).filter(Boolean) + ) + ]; + const watch = await import('chokidar').then((r) => r.watch || r.default || r); + const { diff } = await import('ohash/utils'); + const _fswatcher = watch(watchingFiles, { + ignoreInitial: true, + ...options.chokidarOptions + }); + const onChange = async (event, path) => { + const type = eventMap[event]; + if (!type) { + return; + } + if (options.onWatch) { + await options.onWatch({ + type, + path + }); + } + const oldConfig = config; + try { + config = await loadConfig(options); + } catch (error) { + console.warn(`Failed to load config ${path} +${error}`); + return; + } + const changeCtx = { + newConfig: config, + oldConfig, + getDiff: () => diff(oldConfig.config, config.config) + }; + if (options.acceptHMR) { + const changeHandled = await options.acceptHMR(changeCtx); + if (changeHandled) { + return; + } + } + if (options.onUpdate) { + await options.onUpdate(changeCtx); + } + }; + if (options.debounce === false) { + _fswatcher.on("all", onChange); + } else { + _fswatcher.on("all", debounce(onChange, options.debounce ?? 100)); + } + const utils = { + watchingFiles, + unwatch: async () => { + await _fswatcher.close(); + } + }; + return new Proxy(utils, { + get(_, prop) { + if (prop in utils) { + return utils[prop]; + } + return config[prop]; + } + }); +} + +export { SUPPORTED_EXTENSIONS, createDefineConfig, loadConfig, watchConfig }; diff --git a/backend/node_modules/c12/dist/shared/c12.BXpNC6YI.mjs b/backend/node_modules/c12/dist/shared/c12.BXpNC6YI.mjs new file mode 100644 index 0000000000000000000000000000000000000000..da1749e81adf2a199d37544a4c53fc6371954661 --- /dev/null +++ b/backend/node_modules/c12/dist/shared/c12.BXpNC6YI.mjs @@ -0,0 +1,401 @@ +import { statSync, promises, existsSync } from 'node:fs'; +import { rm, readFile } from 'node:fs/promises'; +import { pathToFileURL } from 'node:url'; +import { homedir } from 'node:os'; +import { resolve, join, dirname, basename, extname, normalize } from 'pathe'; +import { resolveModulePath } from 'exsolve'; +import { createJiti } from 'jiti'; +import * as rc9 from 'rc9'; +import { defu } from 'defu'; +import { findWorkspaceDir, readPackageJSON } from 'pkg-types'; +import * as dotenv from 'dotenv'; + +async function setupDotenv(options) { + const targetEnvironment = options.env ?? process.env; + const environment = await loadDotenv({ + cwd: options.cwd, + fileName: options.fileName ?? ".env", + env: targetEnvironment, + interpolate: options.interpolate ?? true + }); + const dotenvVars = getDotEnvVars(targetEnvironment); + for (const key in environment) { + if (key.startsWith("_")) { + continue; + } + if (targetEnvironment[key] === void 0 || dotenvVars.has(key)) { + targetEnvironment[key] = environment[key]; + } + } + return environment; +} +async function loadDotenv(options) { + const environment = /* @__PURE__ */ Object.create(null); + const dotenvFile = resolve(options.cwd, options.fileName); + const dotenvVars = getDotEnvVars(options.env || {}); + Object.assign(environment, options.env); + if (statSync(dotenvFile, { throwIfNoEntry: false })?.isFile()) { + const parsed = dotenv.parse(await promises.readFile(dotenvFile, "utf8")); + for (const key in parsed) { + if (key in environment && !dotenvVars.has(key)) { + continue; + } + environment[key] = parsed[key]; + dotenvVars.add(key); + } + } + if (options.interpolate) { + interpolate(environment); + } + return environment; +} +function interpolate(target, source = {}, parse = (v) => v) { + function getValue(key) { + return source[key] === void 0 ? target[key] : source[key]; + } + function interpolate2(value, parents = []) { + if (typeof value !== "string") { + return value; + } + const matches = value.match(/(.?\${?(?:[\w:]+)?}?)/g) || []; + return parse( + // eslint-disable-next-line unicorn/no-array-reduce + matches.reduce((newValue, match) => { + const parts = /(.?)\${?([\w:]+)?}?/g.exec(match) || []; + const prefix = parts[1]; + let value2, replacePart; + if (prefix === "\\") { + replacePart = parts[0] || ""; + value2 = replacePart.replace(String.raw`\$`, "$"); + } else { + const key = parts[2]; + replacePart = (parts[0] || "").slice(prefix.length); + if (parents.includes(key)) { + console.warn( + `Please avoid recursive environment variables ( loop: ${parents.join( + " > " + )} > ${key} )` + ); + return ""; + } + value2 = getValue(key); + value2 = interpolate2(value2, [...parents, key]); + } + return value2 === void 0 ? newValue : newValue.replace(replacePart, value2); + }, value) + ); + } + for (const key in target) { + target[key] = interpolate2(getValue(key)); + } +} +function getDotEnvVars(targetEnvironment) { + const globalRegistry = globalThis.__c12_dotenv_vars__ ||= /* @__PURE__ */ new Map(); + if (!globalRegistry.has(targetEnvironment)) { + globalRegistry.set(targetEnvironment, /* @__PURE__ */ new Set()); + } + return globalRegistry.get(targetEnvironment); +} + +const _normalize = (p) => p?.replace(/\\/g, "/"); +const ASYNC_LOADERS = { + ".yaml": () => import('confbox/yaml').then((r) => r.parseYAML), + ".yml": () => import('confbox/yaml').then((r) => r.parseYAML), + ".jsonc": () => import('confbox/jsonc').then((r) => r.parseJSONC), + ".json5": () => import('confbox/json5').then((r) => r.parseJSON5), + ".toml": () => import('confbox/toml').then((r) => r.parseTOML) +}; +const SUPPORTED_EXTENSIONS = Object.freeze([ + // with jiti + ".js", + ".ts", + ".mjs", + ".cjs", + ".mts", + ".cts", + ".json", + // with confbox + ".jsonc", + ".json5", + ".yaml", + ".yml", + ".toml" +]); +async function loadConfig(options) { + options.cwd = resolve(process.cwd(), options.cwd || "."); + options.name = options.name || "config"; + options.envName = options.envName ?? process.env.NODE_ENV; + options.configFile = options.configFile ?? (options.name === "config" ? "config" : `${options.name}.config`); + options.rcFile = options.rcFile ?? `.${options.name}rc`; + if (options.extend !== false) { + options.extend = { + extendKey: "extends", + ...options.extend + }; + } + const _merger = options.merger || defu; + options.jiti = options.jiti || createJiti(join(options.cwd, options.configFile), { + interopDefault: true, + moduleCache: false, + extensions: [...SUPPORTED_EXTENSIONS], + ...options.jitiOptions + }); + const r = { + config: {}, + cwd: options.cwd, + configFile: resolve(options.cwd, options.configFile), + layers: [] + }; + const rawConfigs = { + overrides: options.overrides, + main: void 0, + rc: void 0, + packageJson: void 0, + defaultConfig: options.defaultConfig + }; + if (options.dotenv) { + await setupDotenv({ + cwd: options.cwd, + ...options.dotenv === true ? {} : options.dotenv + }); + } + const _mainConfig = await resolveConfig(".", options); + if (_mainConfig.configFile) { + rawConfigs.main = _mainConfig.config; + r.configFile = _mainConfig.configFile; + } + if (_mainConfig.meta) { + r.meta = _mainConfig.meta; + } + if (options.rcFile) { + const rcSources = []; + rcSources.push(rc9.read({ name: options.rcFile, dir: options.cwd })); + if (options.globalRc) { + const workspaceDir = await findWorkspaceDir(options.cwd).catch(() => { + }); + if (workspaceDir) { + rcSources.push(rc9.read({ name: options.rcFile, dir: workspaceDir })); + } + rcSources.push(rc9.readUser({ name: options.rcFile, dir: options.cwd })); + } + rawConfigs.rc = _merger({}, ...rcSources); + } + if (options.packageJson) { + const keys = (Array.isArray(options.packageJson) ? options.packageJson : [ + typeof options.packageJson === "string" ? options.packageJson : options.name + ]).filter((t) => t && typeof t === "string"); + const pkgJsonFile = await readPackageJSON(options.cwd).catch(() => { + }); + const values = keys.map((key) => pkgJsonFile?.[key]); + rawConfigs.packageJson = _merger({}, ...values); + } + const configs = {}; + for (const key in rawConfigs) { + const value = rawConfigs[key]; + configs[key] = await (typeof value === "function" ? value({ configs, rawConfigs }) : value); + } + r.config = _merger( + configs.overrides, + configs.main, + configs.rc, + configs.packageJson, + configs.defaultConfig + ); + if (options.extend) { + await extendConfig(r.config, options); + r.layers = r.config._layers; + delete r.config._layers; + r.config = _merger(r.config, ...r.layers.map((e) => e.config)); + } + const baseLayers = [ + configs.overrides && { + config: configs.overrides, + configFile: void 0, + cwd: void 0 + }, + { config: configs.main, configFile: options.configFile, cwd: options.cwd }, + configs.rc && { config: configs.rc, configFile: options.rcFile }, + configs.packageJson && { + config: configs.packageJson, + configFile: "package.json" + } + ].filter((l) => l && l.config); + r.layers = [...baseLayers, ...r.layers]; + if (options.defaults) { + r.config = _merger(r.config, options.defaults); + } + if (options.omit$Keys) { + for (const key in r.config) { + if (key.startsWith("$")) { + delete r.config[key]; + } + } + } + return r; +} +async function extendConfig(config, options) { + config._layers = config._layers || []; + if (!options.extend) { + return; + } + let keys = options.extend.extendKey; + if (typeof keys === "string") { + keys = [keys]; + } + const extendSources = []; + for (const key of keys) { + extendSources.push( + ...(Array.isArray(config[key]) ? config[key] : [config[key]]).filter( + Boolean + ) + ); + delete config[key]; + } + for (let extendSource of extendSources) { + const originalExtendSource = extendSource; + let sourceOptions = {}; + if (extendSource.source) { + sourceOptions = extendSource.options || {}; + extendSource = extendSource.source; + } + if (Array.isArray(extendSource)) { + sourceOptions = extendSource[1] || {}; + extendSource = extendSource[0]; + } + if (typeof extendSource !== "string") { + console.warn( + `Cannot extend config from \`${JSON.stringify( + originalExtendSource + )}\` in ${options.cwd}` + ); + continue; + } + const _config = await resolveConfig(extendSource, options, sourceOptions); + if (!_config.config) { + console.warn( + `Cannot extend config from \`${extendSource}\` in ${options.cwd}` + ); + continue; + } + await extendConfig(_config.config, { ...options, cwd: _config.cwd }); + config._layers.push(_config); + if (_config.config._layers) { + config._layers.push(..._config.config._layers); + delete _config.config._layers; + } + } +} +const GIGET_PREFIXES = [ + "gh:", + "github:", + "gitlab:", + "bitbucket:", + "https://", + "http://" +]; +const NPM_PACKAGE_RE = /^(@[\da-z~-][\d._a-z~-]*\/)?[\da-z~-][\d._a-z~-]*($|\/.*)/; +async function resolveConfig(source, options, sourceOptions = {}) { + if (options.resolve) { + const res2 = await options.resolve(source, options); + if (res2) { + return res2; + } + } + const _merger = options.merger || defu; + const customProviderKeys = Object.keys( + sourceOptions.giget?.providers || {} + ).map((key) => `${key}:`); + const gigetPrefixes = customProviderKeys.length > 0 ? [.../* @__PURE__ */ new Set([...customProviderKeys, ...GIGET_PREFIXES])] : GIGET_PREFIXES; + if (options.giget !== false && gigetPrefixes.some((prefix) => source.startsWith(prefix))) { + const { downloadTemplate } = await import('giget'); + const { digest } = await import('ohash'); + const cloneName = source.replace(/\W+/g, "_").split("_").splice(0, 3).join("_") + "_" + digest(source).slice(0, 10).replace(/[-_]/g, ""); + let cloneDir; + const localNodeModules = resolve(options.cwd, "node_modules"); + const parentDir = dirname(options.cwd); + if (basename(parentDir) === ".c12") { + cloneDir = join(parentDir, cloneName); + } else if (existsSync(localNodeModules)) { + cloneDir = join(localNodeModules, ".c12", cloneName); + } else { + cloneDir = process.env.XDG_CACHE_HOME ? resolve(process.env.XDG_CACHE_HOME, "c12", cloneName) : resolve(homedir(), ".cache/c12", cloneName); + } + if (existsSync(cloneDir) && !sourceOptions.install) { + await rm(cloneDir, { recursive: true }); + } + const cloned = await downloadTemplate(source, { + dir: cloneDir, + install: sourceOptions.install, + force: sourceOptions.install, + auth: sourceOptions.auth, + ...options.giget, + ...sourceOptions.giget + }); + source = cloned.dir; + } + if (NPM_PACKAGE_RE.test(source)) { + source = tryResolve(source, options) || source; + } + const ext = extname(source); + const isDir = !ext || ext === basename(source); + const cwd = resolve(options.cwd, isDir ? source : dirname(source)); + if (isDir) { + source = options.configFile; + } + const res = { + config: void 0, + configFile: void 0, + cwd, + source, + sourceOptions + }; + res.configFile = tryResolve(resolve(cwd, source), options) || tryResolve( + resolve(cwd, ".config", source.replace(/\.config$/, "")), + options + ) || tryResolve(resolve(cwd, ".config", source), options) || source; + if (!existsSync(res.configFile)) { + return res; + } + const configFileExt = extname(res.configFile) || ""; + if (configFileExt in ASYNC_LOADERS) { + const asyncLoader = await ASYNC_LOADERS[configFileExt](); + const contents = await readFile(res.configFile, "utf8"); + res.config = asyncLoader(contents); + } else { + res.config = await options.jiti.import(res.configFile, { + default: true + }); + } + if (typeof res.config === "function") { + res.config = await res.config(); + } + if (options.envName) { + const envConfig = { + ...res.config["$" + options.envName], + ...res.config.$env?.[options.envName] + }; + if (Object.keys(envConfig).length > 0) { + res.config = _merger(envConfig, res.config); + } + } + res.meta = defu(res.sourceOptions.meta, res.config.$meta); + delete res.config.$meta; + if (res.sourceOptions.overrides) { + res.config = _merger(res.sourceOptions.overrides, res.config); + } + res.configFile = _normalize(res.configFile); + res.source = _normalize(res.source); + return res; +} +function tryResolve(id, options) { + const res = resolveModulePath(id, { + try: true, + from: pathToFileURL(join(options.cwd || ".", options.configFile || "/")), + suffixes: ["", "/index"], + extensions: SUPPORTED_EXTENSIONS, + cache: false + }); + return res ? normalize(res) : void 0; +} + +export { SUPPORTED_EXTENSIONS as S, loadDotenv as a, loadConfig as l, setupDotenv as s }; diff --git a/backend/node_modules/c12/dist/update.d.mts b/backend/node_modules/c12/dist/update.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..677038a38dce8218a7cc98c26c46d09c68ffc344 --- /dev/null +++ b/backend/node_modules/c12/dist/update.d.mts @@ -0,0 +1,53 @@ +import * as magicast from 'magicast'; + +/** + * @experimental Update a config file or create a new one. + */ +declare function updateConfig(opts: UpdateConfigOptions): Promise; +interface UpdateConfigResult { + configFile?: string; + created?: boolean; +} +type MaybePromise = T | Promise; +type MagicAstOptions = Exclude[1], undefined>; +interface UpdateConfigOptions { + /** + * Current working directory + */ + cwd: string; + /** + * Config file name + */ + configFile: string; + /** + * Extension used for new config file. + */ + createExtension?: string; + /** + * Magicast options + */ + magicast?: MagicAstOptions; + /** + * Update function. + */ + onUpdate?: (config: any) => MaybePromise; + /** + * Handle default config creation. + * + * Tip: you can use this option as a hook to prompt users about config creation. + * + * Context object: + * - path: determined full path to the config file + * + * Returns types: + * - string: custom config template + * - true: write the template + * - false: abort the operation + */ + onCreate?: (ctx: { + configFile: string; + }) => MaybePromise; +} + +export { updateConfig }; +export type { UpdateConfigOptions, UpdateConfigResult }; diff --git a/backend/node_modules/c12/dist/update.mjs b/backend/node_modules/c12/dist/update.mjs new file mode 100644 index 0000000000000000000000000000000000000000..ba201c050e012290594e08885ae91a8576ee2b4a --- /dev/null +++ b/backend/node_modules/c12/dist/update.mjs @@ -0,0 +1,74 @@ +import { resolveModulePath } from 'exsolve'; +import { S as SUPPORTED_EXTENSIONS } from './shared/c12.BXpNC6YI.mjs'; +import { join, normalize } from 'pathe'; +import { mkdir, writeFile, readFile } from 'node:fs/promises'; +import { dirname, extname } from 'node:path'; +import 'node:fs'; +import 'node:url'; +import 'node:os'; +import 'jiti'; +import 'rc9'; +import 'defu'; +import 'pkg-types'; +import 'dotenv'; + +const UPDATABLE_EXTS = [".js", ".ts", ".mjs", ".cjs", ".mts", ".cts"]; +async function updateConfig(opts) { + const { parseModule } = await import('magicast'); + let configFile = tryResolve(`./${opts.configFile}`, opts.cwd, SUPPORTED_EXTENSIONS) || tryResolve( + `./.config/${opts.configFile}`, + opts.cwd, + SUPPORTED_EXTENSIONS + ) || tryResolve( + `./.config/${opts.configFile.split(".")[0]}`, + opts.cwd, + SUPPORTED_EXTENSIONS + ); + let created = false; + if (!configFile) { + configFile = join( + opts.cwd, + opts.configFile + (opts.createExtension || ".ts") + ); + const createResult = await opts.onCreate?.({ configFile }) ?? true; + if (!createResult) { + throw new Error("Config file creation aborted."); + } + const content = typeof createResult === "string" ? createResult : `export default {} +`; + await mkdir(dirname(configFile), { recursive: true }); + await writeFile(configFile, content, "utf8"); + created = true; + } + const ext = extname(configFile); + if (!UPDATABLE_EXTS.includes(ext)) { + throw new Error( + `Unsupported config file extension: ${ext} (${configFile}) (supported: ${UPDATABLE_EXTS.join(", ")})` + ); + } + const contents = await readFile(configFile, "utf8"); + const _module = parseModule(contents, opts.magicast); + const defaultExport = _module.exports.default; + if (!defaultExport) { + throw new Error("Default export is missing in the config file!"); + } + const configObj = defaultExport.$type === "function-call" ? defaultExport.$args[0] : defaultExport; + await opts.onUpdate?.(configObj); + await writeFile(configFile, _module.generate().code); + return { + configFile, + created + }; +} +function tryResolve(path, cwd, extensions) { + const res = resolveModulePath(path, { + try: true, + from: join(cwd, "/"), + extensions, + suffixes: ["", "/index"], + cache: false + }); + return res ? normalize(res) : void 0; +} + +export { updateConfig }; diff --git a/backend/node_modules/chokidar/esm/handler.d.ts b/backend/node_modules/chokidar/esm/handler.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..ea777d0003d037e3f2a96e7613b92b515a01b19e --- /dev/null +++ b/backend/node_modules/chokidar/esm/handler.d.ts @@ -0,0 +1,90 @@ +import type { WatchEventType, Stats, FSWatcher as NativeFsWatcher } from 'fs'; +import type { FSWatcher, WatchHelper, Throttler } from './index.js'; +import type { EntryInfo } from 'readdirp'; +export type Path = string; +export declare const STR_DATA = "data"; +export declare const STR_END = "end"; +export declare const STR_CLOSE = "close"; +export declare const EMPTY_FN: () => void; +export declare const IDENTITY_FN: (val: unknown) => unknown; +export declare const isWindows: boolean; +export declare const isMacos: boolean; +export declare const isLinux: boolean; +export declare const isFreeBSD: boolean; +export declare const isIBMi: boolean; +export declare const EVENTS: { + readonly ALL: "all"; + readonly READY: "ready"; + readonly ADD: "add"; + readonly CHANGE: "change"; + readonly ADD_DIR: "addDir"; + readonly UNLINK: "unlink"; + readonly UNLINK_DIR: "unlinkDir"; + readonly RAW: "raw"; + readonly ERROR: "error"; +}; +export type EventName = (typeof EVENTS)[keyof typeof EVENTS]; +export type FsWatchContainer = { + listeners: (path: string) => void | Set; + errHandlers: (err: unknown) => void | Set; + rawEmitters: (ev: WatchEventType, path: string, opts: unknown) => void | Set; + watcher: NativeFsWatcher; + watcherUnusable?: boolean; +}; +export interface WatchHandlers { + listener: (path: string) => void; + errHandler: (err: unknown) => void; + rawEmitter: (ev: WatchEventType, path: string, opts: unknown) => void; +} +/** + * @mixin + */ +export declare class NodeFsHandler { + fsw: FSWatcher; + _boundHandleError: (error: unknown) => void; + constructor(fsW: FSWatcher); + /** + * Watch file for changes with fs_watchFile or fs_watch. + * @param path to file or dir + * @param listener on fs change + * @returns closer for the watcher instance + */ + _watchWithNodeFs(path: string, listener: (path: string, newStats?: any) => void | Promise): (() => void) | undefined; + /** + * Watch a file and emit add event if warranted. + * @returns closer for the watcher instance + */ + _handleFile(file: Path, stats: Stats, initialAdd: boolean): (() => void) | undefined; + /** + * Handle symlinks encountered while reading a dir. + * @param entry returned by readdirp + * @param directory path of dir being read + * @param path of this item + * @param item basename of this item + * @returns true if no more processing is needed for this entry. + */ + _handleSymlink(entry: EntryInfo, directory: string, path: Path, item: string): Promise; + _handleRead(directory: string, initialAdd: boolean, wh: WatchHelper, target: Path, dir: Path, depth: number, throttler: Throttler): Promise | undefined; + /** + * Read directory to add / remove files from `@watched` list and re-read it on change. + * @param dir fs path + * @param stats + * @param initialAdd + * @param depth relative to user-supplied path + * @param target child path targeted for watch + * @param wh Common watch helpers for this path + * @param realpath + * @returns closer for the watcher instance. + */ + _handleDir(dir: string, stats: Stats, initialAdd: boolean, depth: number, target: string, wh: WatchHelper, realpath: string): Promise<(() => void) | undefined>; + /** + * Handle added file, directory, or glob pattern. + * Delegates call to _handleFile / _handleDir after checks. + * @param path to file or ir + * @param initialAdd was the file added at watch instantiation? + * @param priorWh depth relative to user-supplied path + * @param depth Child path actually targeted for watch + * @param target Child path actually targeted for watch + */ + _addToNodeFs(path: string, initialAdd: boolean, priorWh: WatchHelper | undefined, depth: number, target?: string): Promise; +} diff --git a/backend/node_modules/chokidar/esm/handler.js b/backend/node_modules/chokidar/esm/handler.js new file mode 100644 index 0000000000000000000000000000000000000000..bbda010174650be45dd52668df88a19fc197e08b --- /dev/null +++ b/backend/node_modules/chokidar/esm/handler.js @@ -0,0 +1,629 @@ +import { watchFile, unwatchFile, watch as fs_watch } from 'fs'; +import { open, stat, lstat, realpath as fsrealpath } from 'fs/promises'; +import * as sysPath from 'path'; +import { type as osType } from 'os'; +export const STR_DATA = 'data'; +export const STR_END = 'end'; +export const STR_CLOSE = 'close'; +export const EMPTY_FN = () => { }; +export const IDENTITY_FN = (val) => val; +const pl = process.platform; +export const isWindows = pl === 'win32'; +export const isMacos = pl === 'darwin'; +export const isLinux = pl === 'linux'; +export const isFreeBSD = pl === 'freebsd'; +export const isIBMi = osType() === 'OS400'; +export const EVENTS = { + ALL: 'all', + READY: 'ready', + ADD: 'add', + CHANGE: 'change', + ADD_DIR: 'addDir', + UNLINK: 'unlink', + UNLINK_DIR: 'unlinkDir', + RAW: 'raw', + ERROR: 'error', +}; +const EV = EVENTS; +const THROTTLE_MODE_WATCH = 'watch'; +const statMethods = { lstat, stat }; +const KEY_LISTENERS = 'listeners'; +const KEY_ERR = 'errHandlers'; +const KEY_RAW = 'rawEmitters'; +const HANDLER_KEYS = [KEY_LISTENERS, KEY_ERR, KEY_RAW]; +// prettier-ignore +const binaryExtensions = new Set([ + '3dm', '3ds', '3g2', '3gp', '7z', 'a', 'aac', 'adp', 'afdesign', 'afphoto', 'afpub', 'ai', + 'aif', 'aiff', 'alz', 'ape', 'apk', 'appimage', 'ar', 'arj', 'asf', 'au', 'avi', + 'bak', 'baml', 'bh', 'bin', 'bk', 'bmp', 'btif', 'bz2', 'bzip2', + 'cab', 'caf', 'cgm', 'class', 'cmx', 'cpio', 'cr2', 'cur', 'dat', 'dcm', 'deb', 'dex', 'djvu', + 'dll', 'dmg', 'dng', 'doc', 'docm', 'docx', 'dot', 'dotm', 'dra', 'DS_Store', 'dsk', 'dts', + 'dtshd', 'dvb', 'dwg', 'dxf', + 'ecelp4800', 'ecelp7470', 'ecelp9600', 'egg', 'eol', 'eot', 'epub', 'exe', + 'f4v', 'fbs', 'fh', 'fla', 'flac', 'flatpak', 'fli', 'flv', 'fpx', 'fst', 'fvt', + 'g3', 'gh', 'gif', 'graffle', 'gz', 'gzip', + 'h261', 'h263', 'h264', 'icns', 'ico', 'ief', 'img', 'ipa', 'iso', + 'jar', 'jpeg', 'jpg', 'jpgv', 'jpm', 'jxr', 'key', 'ktx', + 'lha', 'lib', 'lvp', 'lz', 'lzh', 'lzma', 'lzo', + 'm3u', 'm4a', 'm4v', 'mar', 'mdi', 'mht', 'mid', 'midi', 'mj2', 'mka', 'mkv', 'mmr', 'mng', + 'mobi', 'mov', 'movie', 'mp3', + 'mp4', 'mp4a', 'mpeg', 'mpg', 'mpga', 'mxu', + 'nef', 'npx', 'numbers', 'nupkg', + 'o', 'odp', 'ods', 'odt', 'oga', 'ogg', 'ogv', 'otf', 'ott', + 'pages', 'pbm', 'pcx', 'pdb', 'pdf', 'pea', 'pgm', 'pic', 'png', 'pnm', 'pot', 'potm', + 'potx', 'ppa', 'ppam', + 'ppm', 'pps', 'ppsm', 'ppsx', 'ppt', 'pptm', 'pptx', 'psd', 'pya', 'pyc', 'pyo', 'pyv', + 'qt', + 'rar', 'ras', 'raw', 'resources', 'rgb', 'rip', 'rlc', 'rmf', 'rmvb', 'rpm', 'rtf', 'rz', + 's3m', 's7z', 'scpt', 'sgi', 'shar', 'snap', 'sil', 'sketch', 'slk', 'smv', 'snk', 'so', + 'stl', 'suo', 'sub', 'swf', + 'tar', 'tbz', 'tbz2', 'tga', 'tgz', 'thmx', 'tif', 'tiff', 'tlz', 'ttc', 'ttf', 'txz', + 'udf', 'uvh', 'uvi', 'uvm', 'uvp', 'uvs', 'uvu', + 'viv', 'vob', + 'war', 'wav', 'wax', 'wbmp', 'wdp', 'weba', 'webm', 'webp', 'whl', 'wim', 'wm', 'wma', + 'wmv', 'wmx', 'woff', 'woff2', 'wrm', 'wvx', + 'xbm', 'xif', 'xla', 'xlam', 'xls', 'xlsb', 'xlsm', 'xlsx', 'xlt', 'xltm', 'xltx', 'xm', + 'xmind', 'xpi', 'xpm', 'xwd', 'xz', + 'z', 'zip', 'zipx', +]); +const isBinaryPath = (filePath) => binaryExtensions.has(sysPath.extname(filePath).slice(1).toLowerCase()); +// TODO: emit errors properly. Example: EMFILE on Macos. +const foreach = (val, fn) => { + if (val instanceof Set) { + val.forEach(fn); + } + else { + fn(val); + } +}; +const addAndConvert = (main, prop, item) => { + let container = main[prop]; + if (!(container instanceof Set)) { + main[prop] = container = new Set([container]); + } + container.add(item); +}; +const clearItem = (cont) => (key) => { + const set = cont[key]; + if (set instanceof Set) { + set.clear(); + } + else { + delete cont[key]; + } +}; +const delFromSet = (main, prop, item) => { + const container = main[prop]; + if (container instanceof Set) { + container.delete(item); + } + else if (container === item) { + delete main[prop]; + } +}; +const isEmptySet = (val) => (val instanceof Set ? val.size === 0 : !val); +const FsWatchInstances = new Map(); +/** + * Instantiates the fs_watch interface + * @param path to be watched + * @param options to be passed to fs_watch + * @param listener main event handler + * @param errHandler emits info about errors + * @param emitRaw emits raw event data + * @returns {NativeFsWatcher} + */ +function createFsWatchInstance(path, options, listener, errHandler, emitRaw) { + const handleEvent = (rawEvent, evPath) => { + listener(path); + emitRaw(rawEvent, evPath, { watchedPath: path }); + // emit based on events occurring for files from a directory's watcher in + // case the file's watcher misses it (and rely on throttling to de-dupe) + if (evPath && path !== evPath) { + fsWatchBroadcast(sysPath.resolve(path, evPath), KEY_LISTENERS, sysPath.join(path, evPath)); + } + }; + try { + return fs_watch(path, { + persistent: options.persistent, + }, handleEvent); + } + catch (error) { + errHandler(error); + return undefined; + } +} +/** + * Helper for passing fs_watch event data to a collection of listeners + * @param fullPath absolute path bound to fs_watch instance + */ +const fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => { + const cont = FsWatchInstances.get(fullPath); + if (!cont) + return; + foreach(cont[listenerType], (listener) => { + listener(val1, val2, val3); + }); +}; +/** + * Instantiates the fs_watch interface or binds listeners + * to an existing one covering the same file system entry + * @param path + * @param fullPath absolute path + * @param options to be passed to fs_watch + * @param handlers container for event listener functions + */ +const setFsWatchListener = (path, fullPath, options, handlers) => { + const { listener, errHandler, rawEmitter } = handlers; + let cont = FsWatchInstances.get(fullPath); + let watcher; + if (!options.persistent) { + watcher = createFsWatchInstance(path, options, listener, errHandler, rawEmitter); + if (!watcher) + return; + return watcher.close.bind(watcher); + } + if (cont) { + addAndConvert(cont, KEY_LISTENERS, listener); + addAndConvert(cont, KEY_ERR, errHandler); + addAndConvert(cont, KEY_RAW, rawEmitter); + } + else { + watcher = createFsWatchInstance(path, options, fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS), errHandler, // no need to use broadcast here + fsWatchBroadcast.bind(null, fullPath, KEY_RAW)); + if (!watcher) + return; + watcher.on(EV.ERROR, async (error) => { + const broadcastErr = fsWatchBroadcast.bind(null, fullPath, KEY_ERR); + if (cont) + cont.watcherUnusable = true; // documented since Node 10.4.1 + // Workaround for https://github.com/joyent/node/issues/4337 + if (isWindows && error.code === 'EPERM') { + try { + const fd = await open(path, 'r'); + await fd.close(); + broadcastErr(error); + } + catch (err) { + // do nothing + } + } + else { + broadcastErr(error); + } + }); + cont = { + listeners: listener, + errHandlers: errHandler, + rawEmitters: rawEmitter, + watcher, + }; + FsWatchInstances.set(fullPath, cont); + } + // const index = cont.listeners.indexOf(listener); + // removes this instance's listeners and closes the underlying fs_watch + // instance if there are no more listeners left + return () => { + delFromSet(cont, KEY_LISTENERS, listener); + delFromSet(cont, KEY_ERR, errHandler); + delFromSet(cont, KEY_RAW, rawEmitter); + if (isEmptySet(cont.listeners)) { + // Check to protect against issue gh-730. + // if (cont.watcherUnusable) { + cont.watcher.close(); + // } + FsWatchInstances.delete(fullPath); + HANDLER_KEYS.forEach(clearItem(cont)); + // @ts-ignore + cont.watcher = undefined; + Object.freeze(cont); + } + }; +}; +// fs_watchFile helpers +// object to hold per-process fs_watchFile instances +// (may be shared across chokidar FSWatcher instances) +const FsWatchFileInstances = new Map(); +/** + * Instantiates the fs_watchFile interface or binds listeners + * to an existing one covering the same file system entry + * @param path to be watched + * @param fullPath absolute path + * @param options options to be passed to fs_watchFile + * @param handlers container for event listener functions + * @returns closer + */ +const setFsWatchFileListener = (path, fullPath, options, handlers) => { + const { listener, rawEmitter } = handlers; + let cont = FsWatchFileInstances.get(fullPath); + // let listeners = new Set(); + // let rawEmitters = new Set(); + const copts = cont && cont.options; + if (copts && (copts.persistent < options.persistent || copts.interval > options.interval)) { + // "Upgrade" the watcher to persistence or a quicker interval. + // This creates some unlikely edge case issues if the user mixes + // settings in a very weird way, but solving for those cases + // doesn't seem worthwhile for the added complexity. + // listeners = cont.listeners; + // rawEmitters = cont.rawEmitters; + unwatchFile(fullPath); + cont = undefined; + } + if (cont) { + addAndConvert(cont, KEY_LISTENERS, listener); + addAndConvert(cont, KEY_RAW, rawEmitter); + } + else { + // TODO + // listeners.add(listener); + // rawEmitters.add(rawEmitter); + cont = { + listeners: listener, + rawEmitters: rawEmitter, + options, + watcher: watchFile(fullPath, options, (curr, prev) => { + foreach(cont.rawEmitters, (rawEmitter) => { + rawEmitter(EV.CHANGE, fullPath, { curr, prev }); + }); + const currmtime = curr.mtimeMs; + if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) { + foreach(cont.listeners, (listener) => listener(path, curr)); + } + }), + }; + FsWatchFileInstances.set(fullPath, cont); + } + // const index = cont.listeners.indexOf(listener); + // Removes this instance's listeners and closes the underlying fs_watchFile + // instance if there are no more listeners left. + return () => { + delFromSet(cont, KEY_LISTENERS, listener); + delFromSet(cont, KEY_RAW, rawEmitter); + if (isEmptySet(cont.listeners)) { + FsWatchFileInstances.delete(fullPath); + unwatchFile(fullPath); + cont.options = cont.watcher = undefined; + Object.freeze(cont); + } + }; +}; +/** + * @mixin + */ +export class NodeFsHandler { + constructor(fsW) { + this.fsw = fsW; + this._boundHandleError = (error) => fsW._handleError(error); + } + /** + * Watch file for changes with fs_watchFile or fs_watch. + * @param path to file or dir + * @param listener on fs change + * @returns closer for the watcher instance + */ + _watchWithNodeFs(path, listener) { + const opts = this.fsw.options; + const directory = sysPath.dirname(path); + const basename = sysPath.basename(path); + const parent = this.fsw._getWatchedDir(directory); + parent.add(basename); + const absolutePath = sysPath.resolve(path); + const options = { + persistent: opts.persistent, + }; + if (!listener) + listener = EMPTY_FN; + let closer; + if (opts.usePolling) { + const enableBin = opts.interval !== opts.binaryInterval; + options.interval = enableBin && isBinaryPath(basename) ? opts.binaryInterval : opts.interval; + closer = setFsWatchFileListener(path, absolutePath, options, { + listener, + rawEmitter: this.fsw._emitRaw, + }); + } + else { + closer = setFsWatchListener(path, absolutePath, options, { + listener, + errHandler: this._boundHandleError, + rawEmitter: this.fsw._emitRaw, + }); + } + return closer; + } + /** + * Watch a file and emit add event if warranted. + * @returns closer for the watcher instance + */ + _handleFile(file, stats, initialAdd) { + if (this.fsw.closed) { + return; + } + const dirname = sysPath.dirname(file); + const basename = sysPath.basename(file); + const parent = this.fsw._getWatchedDir(dirname); + // stats is always present + let prevStats = stats; + // if the file is already being watched, do nothing + if (parent.has(basename)) + return; + const listener = async (path, newStats) => { + if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5)) + return; + if (!newStats || newStats.mtimeMs === 0) { + try { + const newStats = await stat(file); + if (this.fsw.closed) + return; + // Check that change event was not fired because of changed only accessTime. + const at = newStats.atimeMs; + const mt = newStats.mtimeMs; + if (!at || at <= mt || mt !== prevStats.mtimeMs) { + this.fsw._emit(EV.CHANGE, file, newStats); + } + if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats.ino) { + this.fsw._closeFile(path); + prevStats = newStats; + const closer = this._watchWithNodeFs(file, listener); + if (closer) + this.fsw._addPathCloser(path, closer); + } + else { + prevStats = newStats; + } + } + catch (error) { + // Fix issues where mtime is null but file is still present + this.fsw._remove(dirname, basename); + } + // add is about to be emitted if file not already tracked in parent + } + else if (parent.has(basename)) { + // Check that change event was not fired because of changed only accessTime. + const at = newStats.atimeMs; + const mt = newStats.mtimeMs; + if (!at || at <= mt || mt !== prevStats.mtimeMs) { + this.fsw._emit(EV.CHANGE, file, newStats); + } + prevStats = newStats; + } + }; + // kick off the watcher + const closer = this._watchWithNodeFs(file, listener); + // emit an add event if we're supposed to + if (!(initialAdd && this.fsw.options.ignoreInitial) && this.fsw._isntIgnored(file)) { + if (!this.fsw._throttle(EV.ADD, file, 0)) + return; + this.fsw._emit(EV.ADD, file, stats); + } + return closer; + } + /** + * Handle symlinks encountered while reading a dir. + * @param entry returned by readdirp + * @param directory path of dir being read + * @param path of this item + * @param item basename of this item + * @returns true if no more processing is needed for this entry. + */ + async _handleSymlink(entry, directory, path, item) { + if (this.fsw.closed) { + return; + } + const full = entry.fullPath; + const dir = this.fsw._getWatchedDir(directory); + if (!this.fsw.options.followSymlinks) { + // watch symlink directly (don't follow) and detect changes + this.fsw._incrReadyCount(); + let linkPath; + try { + linkPath = await fsrealpath(path); + } + catch (e) { + this.fsw._emitReady(); + return true; + } + if (this.fsw.closed) + return; + if (dir.has(item)) { + if (this.fsw._symlinkPaths.get(full) !== linkPath) { + this.fsw._symlinkPaths.set(full, linkPath); + this.fsw._emit(EV.CHANGE, path, entry.stats); + } + } + else { + dir.add(item); + this.fsw._symlinkPaths.set(full, linkPath); + this.fsw._emit(EV.ADD, path, entry.stats); + } + this.fsw._emitReady(); + return true; + } + // don't follow the same symlink more than once + if (this.fsw._symlinkPaths.has(full)) { + return true; + } + this.fsw._symlinkPaths.set(full, true); + } + _handleRead(directory, initialAdd, wh, target, dir, depth, throttler) { + // Normalize the directory name on Windows + directory = sysPath.join(directory, ''); + throttler = this.fsw._throttle('readdir', directory, 1000); + if (!throttler) + return; + const previous = this.fsw._getWatchedDir(wh.path); + const current = new Set(); + let stream = this.fsw._readdirp(directory, { + fileFilter: (entry) => wh.filterPath(entry), + directoryFilter: (entry) => wh.filterDir(entry), + }); + if (!stream) + return; + stream + .on(STR_DATA, async (entry) => { + if (this.fsw.closed) { + stream = undefined; + return; + } + const item = entry.path; + let path = sysPath.join(directory, item); + current.add(item); + if (entry.stats.isSymbolicLink() && + (await this._handleSymlink(entry, directory, path, item))) { + return; + } + if (this.fsw.closed) { + stream = undefined; + return; + } + // Files that present in current directory snapshot + // but absent in previous are added to watch list and + // emit `add` event. + if (item === target || (!target && !previous.has(item))) { + this.fsw._incrReadyCount(); + // ensure relativeness of path is preserved in case of watcher reuse + path = sysPath.join(dir, sysPath.relative(dir, path)); + this._addToNodeFs(path, initialAdd, wh, depth + 1); + } + }) + .on(EV.ERROR, this._boundHandleError); + return new Promise((resolve, reject) => { + if (!stream) + return reject(); + stream.once(STR_END, () => { + if (this.fsw.closed) { + stream = undefined; + return; + } + const wasThrottled = throttler ? throttler.clear() : false; + resolve(undefined); + // Files that absent in current directory snapshot + // but present in previous emit `remove` event + // and are removed from @watched[directory]. + previous + .getChildren() + .filter((item) => { + return item !== directory && !current.has(item); + }) + .forEach((item) => { + this.fsw._remove(directory, item); + }); + stream = undefined; + // one more time for any missed in case changes came in extremely quickly + if (wasThrottled) + this._handleRead(directory, false, wh, target, dir, depth, throttler); + }); + }); + } + /** + * Read directory to add / remove files from `@watched` list and re-read it on change. + * @param dir fs path + * @param stats + * @param initialAdd + * @param depth relative to user-supplied path + * @param target child path targeted for watch + * @param wh Common watch helpers for this path + * @param realpath + * @returns closer for the watcher instance. + */ + async _handleDir(dir, stats, initialAdd, depth, target, wh, realpath) { + const parentDir = this.fsw._getWatchedDir(sysPath.dirname(dir)); + const tracked = parentDir.has(sysPath.basename(dir)); + if (!(initialAdd && this.fsw.options.ignoreInitial) && !target && !tracked) { + this.fsw._emit(EV.ADD_DIR, dir, stats); + } + // ensure dir is tracked (harmless if redundant) + parentDir.add(sysPath.basename(dir)); + this.fsw._getWatchedDir(dir); + let throttler; + let closer; + const oDepth = this.fsw.options.depth; + if ((oDepth == null || depth <= oDepth) && !this.fsw._symlinkPaths.has(realpath)) { + if (!target) { + await this._handleRead(dir, initialAdd, wh, target, dir, depth, throttler); + if (this.fsw.closed) + return; + } + closer = this._watchWithNodeFs(dir, (dirPath, stats) => { + // if current directory is removed, do nothing + if (stats && stats.mtimeMs === 0) + return; + this._handleRead(dirPath, false, wh, target, dir, depth, throttler); + }); + } + return closer; + } + /** + * Handle added file, directory, or glob pattern. + * Delegates call to _handleFile / _handleDir after checks. + * @param path to file or ir + * @param initialAdd was the file added at watch instantiation? + * @param priorWh depth relative to user-supplied path + * @param depth Child path actually targeted for watch + * @param target Child path actually targeted for watch + */ + async _addToNodeFs(path, initialAdd, priorWh, depth, target) { + const ready = this.fsw._emitReady; + if (this.fsw._isIgnored(path) || this.fsw.closed) { + ready(); + return false; + } + const wh = this.fsw._getWatchHelpers(path); + if (priorWh) { + wh.filterPath = (entry) => priorWh.filterPath(entry); + wh.filterDir = (entry) => priorWh.filterDir(entry); + } + // evaluate what is at the path we're being asked to watch + try { + const stats = await statMethods[wh.statMethod](wh.watchPath); + if (this.fsw.closed) + return; + if (this.fsw._isIgnored(wh.watchPath, stats)) { + ready(); + return false; + } + const follow = this.fsw.options.followSymlinks; + let closer; + if (stats.isDirectory()) { + const absPath = sysPath.resolve(path); + const targetPath = follow ? await fsrealpath(path) : path; + if (this.fsw.closed) + return; + closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath); + if (this.fsw.closed) + return; + // preserve this symlink's target path + if (absPath !== targetPath && targetPath !== undefined) { + this.fsw._symlinkPaths.set(absPath, targetPath); + } + } + else if (stats.isSymbolicLink()) { + const targetPath = follow ? await fsrealpath(path) : path; + if (this.fsw.closed) + return; + const parent = sysPath.dirname(wh.watchPath); + this.fsw._getWatchedDir(parent).add(wh.watchPath); + this.fsw._emit(EV.ADD, wh.watchPath, stats); + closer = await this._handleDir(parent, stats, initialAdd, depth, path, wh, targetPath); + if (this.fsw.closed) + return; + // preserve this symlink's target path + if (targetPath !== undefined) { + this.fsw._symlinkPaths.set(sysPath.resolve(path), targetPath); + } + } + else { + closer = this._handleFile(wh.watchPath, stats, initialAdd); + } + ready(); + if (closer) + this.fsw._addPathCloser(path, closer); + return false; + } + catch (error) { + if (this.fsw._handleError(error)) { + ready(); + return path; + } + } + } +} diff --git a/backend/node_modules/chokidar/esm/index.d.ts b/backend/node_modules/chokidar/esm/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..ffeb1e728cdfd6cf1866b67d9c682b19075d9e5f --- /dev/null +++ b/backend/node_modules/chokidar/esm/index.d.ts @@ -0,0 +1,215 @@ +/*! chokidar - MIT License (c) 2012 Paul Miller (paulmillr.com) */ +import { Stats } from 'fs'; +import { EventEmitter } from 'events'; +import { ReaddirpStream, ReaddirpOptions, EntryInfo } from 'readdirp'; +import { NodeFsHandler, EventName, Path, EVENTS as EV, WatchHandlers } from './handler.js'; +type AWF = { + stabilityThreshold: number; + pollInterval: number; +}; +type BasicOpts = { + persistent: boolean; + ignoreInitial: boolean; + followSymlinks: boolean; + cwd?: string; + usePolling: boolean; + interval: number; + binaryInterval: number; + alwaysStat?: boolean; + depth?: number; + ignorePermissionErrors: boolean; + atomic: boolean | number; +}; +export type Throttler = { + timeoutObject: NodeJS.Timeout; + clear: () => void; + count: number; +}; +export type ChokidarOptions = Partial; +}>; +export type FSWInstanceOptions = BasicOpts & { + ignored: Matcher[]; + awaitWriteFinish: false | AWF; +}; +export type ThrottleType = 'readdir' | 'watch' | 'add' | 'remove' | 'change'; +export type EmitArgs = [path: Path, stats?: Stats]; +export type EmitErrorArgs = [error: Error, stats?: Stats]; +export type EmitArgsWithName = [event: EventName, ...EmitArgs]; +export type MatchFunction = (val: string, stats?: Stats) => boolean; +export interface MatcherObject { + path: string; + recursive?: boolean; +} +export type Matcher = string | RegExp | MatchFunction | MatcherObject; +/** + * Directory entry. + */ +declare class DirEntry { + path: Path; + _removeWatcher: (dir: string, base: string) => void; + items: Set; + constructor(dir: Path, removeWatcher: (dir: string, base: string) => void); + add(item: string): void; + remove(item: string): Promise; + has(item: string): boolean | undefined; + getChildren(): string[]; + dispose(): void; +} +export declare class WatchHelper { + fsw: FSWatcher; + path: string; + watchPath: string; + fullWatchPath: string; + dirParts: string[][]; + followSymlinks: boolean; + statMethod: 'stat' | 'lstat'; + constructor(path: string, follow: boolean, fsw: FSWatcher); + entryPath(entry: EntryInfo): Path; + filterPath(entry: EntryInfo): boolean; + filterDir(entry: EntryInfo): boolean; +} +export interface FSWatcherKnownEventMap { + [EV.READY]: []; + [EV.RAW]: Parameters; + [EV.ERROR]: Parameters; + [EV.ALL]: [event: EventName, ...EmitArgs]; +} +export type FSWatcherEventMap = FSWatcherKnownEventMap & { + [k in Exclude]: EmitArgs; +}; +/** + * Watches files & directories for changes. Emitted events: + * `add`, `addDir`, `change`, `unlink`, `unlinkDir`, `all`, `error` + * + * new FSWatcher() + * .add(directories) + * .on('add', path => log('File', path, 'was added')) + */ +export declare class FSWatcher extends EventEmitter { + closed: boolean; + options: FSWInstanceOptions; + _closers: Map>; + _ignoredPaths: Set; + _throttled: Map>; + _streams: Set; + _symlinkPaths: Map; + _watched: Map; + _pendingWrites: Map; + _pendingUnlinks: Map; + _readyCount: number; + _emitReady: () => void; + _closePromise?: Promise; + _userIgnored?: MatchFunction; + _readyEmitted: boolean; + _emitRaw: WatchHandlers['rawEmitter']; + _boundRemove: (dir: string, item: string) => void; + _nodeFsHandler: NodeFsHandler; + constructor(_opts?: ChokidarOptions); + _addIgnoredPath(matcher: Matcher): void; + _removeIgnoredPath(matcher: Matcher): void; + /** + * Adds paths to be watched on an existing FSWatcher instance. + * @param paths_ file or file list. Other arguments are unused + */ + add(paths_: Path | Path[], _origAdd?: string, _internal?: boolean): FSWatcher; + /** + * Close watchers or start ignoring events from specified paths. + */ + unwatch(paths_: Path | Path[]): FSWatcher; + /** + * Close watchers and remove all listeners from watched paths. + */ + close(): Promise; + /** + * Expose list of watched paths + * @returns for chaining + */ + getWatched(): Record; + emitWithAll(event: EventName, args: EmitArgs): void; + /** + * Normalize and emit events. + * Calling _emit DOES NOT MEAN emit() would be called! + * @param event Type of event + * @param path File or directory path + * @param stats arguments to be passed with event + * @returns the error if defined, otherwise the value of the FSWatcher instance's `closed` flag + */ + _emit(event: EventName, path: Path, stats?: Stats): Promise; + /** + * Common handler for errors + * @returns The error if defined, otherwise the value of the FSWatcher instance's `closed` flag + */ + _handleError(error: Error): Error | boolean; + /** + * Helper utility for throttling + * @param actionType type being throttled + * @param path being acted upon + * @param timeout duration of time to suppress duplicate actions + * @returns tracking object or false if action should be suppressed + */ + _throttle(actionType: ThrottleType, path: Path, timeout: number): Throttler | false; + _incrReadyCount(): number; + /** + * Awaits write operation to finish. + * Polls a newly created file for size variations. When files size does not change for 'threshold' milliseconds calls callback. + * @param path being acted upon + * @param threshold Time in milliseconds a file size must be fixed before acknowledging write OP is finished + * @param event + * @param awfEmit Callback to be called when ready for event to be emitted. + */ + _awaitWriteFinish(path: Path, threshold: number, event: EventName, awfEmit: (err?: Error, stat?: Stats) => void): void; + /** + * Determines whether user has asked to ignore this path. + */ + _isIgnored(path: Path, stats?: Stats): boolean; + _isntIgnored(path: Path, stat?: Stats): boolean; + /** + * Provides a set of common helpers and properties relating to symlink handling. + * @param path file or directory pattern being watched + */ + _getWatchHelpers(path: Path): WatchHelper; + /** + * Provides directory tracking objects + * @param directory path of the directory + */ + _getWatchedDir(directory: string): DirEntry; + /** + * Check for read permissions: https://stackoverflow.com/a/11781404/1358405 + */ + _hasReadPermissions(stats: Stats): boolean; + /** + * Handles emitting unlink events for + * files and directories, and via recursion, for + * files and directories within directories that are unlinked + * @param directory within which the following item is located + * @param item base path of item/directory + */ + _remove(directory: string, item: string, isDirectory?: boolean): void; + /** + * Closes all watchers for a path + */ + _closePath(path: Path): void; + /** + * Closes only file-specific watchers + */ + _closeFile(path: Path): void; + _addPathCloser(path: Path, closer: () => void): void; + _readdirp(root: Path, opts?: Partial): ReaddirpStream | undefined; +} +/** + * Instantiates watcher with paths to be tracked. + * @param paths file / directory paths + * @param options opts, such as `atomic`, `awaitWriteFinish`, `ignored`, and others + * @returns an instance of FSWatcher for chaining. + * @example + * const watcher = watch('.').on('all', (event, path) => { console.log(event, path); }); + * watch('.', { atomic: true, awaitWriteFinish: true, ignored: (f, stats) => stats?.isFile() && !f.endsWith('.js') }) + */ +export declare function watch(paths: string | string[], options?: ChokidarOptions): FSWatcher; +declare const _default: { + watch: typeof watch; + FSWatcher: typeof FSWatcher; +}; +export default _default; diff --git a/backend/node_modules/chokidar/esm/index.js b/backend/node_modules/chokidar/esm/index.js new file mode 100644 index 0000000000000000000000000000000000000000..1c80a40ce79329e991b60fd6c70d1d797600d8d7 --- /dev/null +++ b/backend/node_modules/chokidar/esm/index.js @@ -0,0 +1,798 @@ +/*! chokidar - MIT License (c) 2012 Paul Miller (paulmillr.com) */ +import { stat as statcb } from 'fs'; +import { stat, readdir } from 'fs/promises'; +import { EventEmitter } from 'events'; +import * as sysPath from 'path'; +import { readdirp } from 'readdirp'; +import { NodeFsHandler, EVENTS as EV, isWindows, isIBMi, EMPTY_FN, STR_CLOSE, STR_END, } from './handler.js'; +const SLASH = '/'; +const SLASH_SLASH = '//'; +const ONE_DOT = '.'; +const TWO_DOTS = '..'; +const STRING_TYPE = 'string'; +const BACK_SLASH_RE = /\\/g; +const DOUBLE_SLASH_RE = /\/\//; +const DOT_RE = /\..*\.(sw[px])$|~$|\.subl.*\.tmp/; +const REPLACER_RE = /^\.[/\\]/; +function arrify(item) { + return Array.isArray(item) ? item : [item]; +} +const isMatcherObject = (matcher) => typeof matcher === 'object' && matcher !== null && !(matcher instanceof RegExp); +function createPattern(matcher) { + if (typeof matcher === 'function') + return matcher; + if (typeof matcher === 'string') + return (string) => matcher === string; + if (matcher instanceof RegExp) + return (string) => matcher.test(string); + if (typeof matcher === 'object' && matcher !== null) { + return (string) => { + if (matcher.path === string) + return true; + if (matcher.recursive) { + const relative = sysPath.relative(matcher.path, string); + if (!relative) { + return false; + } + return !relative.startsWith('..') && !sysPath.isAbsolute(relative); + } + return false; + }; + } + return () => false; +} +function normalizePath(path) { + if (typeof path !== 'string') + throw new Error('string expected'); + path = sysPath.normalize(path); + path = path.replace(/\\/g, '/'); + let prepend = false; + if (path.startsWith('//')) + prepend = true; + const DOUBLE_SLASH_RE = /\/\//; + while (path.match(DOUBLE_SLASH_RE)) + path = path.replace(DOUBLE_SLASH_RE, '/'); + if (prepend) + path = '/' + path; + return path; +} +function matchPatterns(patterns, testString, stats) { + const path = normalizePath(testString); + for (let index = 0; index < patterns.length; index++) { + const pattern = patterns[index]; + if (pattern(path, stats)) { + return true; + } + } + return false; +} +function anymatch(matchers, testString) { + if (matchers == null) { + throw new TypeError('anymatch: specify first argument'); + } + // Early cache for matchers. + const matchersArray = arrify(matchers); + const patterns = matchersArray.map((matcher) => createPattern(matcher)); + if (testString == null) { + return (testString, stats) => { + return matchPatterns(patterns, testString, stats); + }; + } + return matchPatterns(patterns, testString); +} +const unifyPaths = (paths_) => { + const paths = arrify(paths_).flat(); + if (!paths.every((p) => typeof p === STRING_TYPE)) { + throw new TypeError(`Non-string provided as watch path: ${paths}`); + } + return paths.map(normalizePathToUnix); +}; +// If SLASH_SLASH occurs at the beginning of path, it is not replaced +// because "//StoragePC/DrivePool/Movies" is a valid network path +const toUnix = (string) => { + let str = string.replace(BACK_SLASH_RE, SLASH); + let prepend = false; + if (str.startsWith(SLASH_SLASH)) { + prepend = true; + } + while (str.match(DOUBLE_SLASH_RE)) { + str = str.replace(DOUBLE_SLASH_RE, SLASH); + } + if (prepend) { + str = SLASH + str; + } + return str; +}; +// Our version of upath.normalize +// TODO: this is not equal to path-normalize module - investigate why +const normalizePathToUnix = (path) => toUnix(sysPath.normalize(toUnix(path))); +// TODO: refactor +const normalizeIgnored = (cwd = '') => (path) => { + if (typeof path === 'string') { + return normalizePathToUnix(sysPath.isAbsolute(path) ? path : sysPath.join(cwd, path)); + } + else { + return path; + } +}; +const getAbsolutePath = (path, cwd) => { + if (sysPath.isAbsolute(path)) { + return path; + } + return sysPath.join(cwd, path); +}; +const EMPTY_SET = Object.freeze(new Set()); +/** + * Directory entry. + */ +class DirEntry { + constructor(dir, removeWatcher) { + this.path = dir; + this._removeWatcher = removeWatcher; + this.items = new Set(); + } + add(item) { + const { items } = this; + if (!items) + return; + if (item !== ONE_DOT && item !== TWO_DOTS) + items.add(item); + } + async remove(item) { + const { items } = this; + if (!items) + return; + items.delete(item); + if (items.size > 0) + return; + const dir = this.path; + try { + await readdir(dir); + } + catch (err) { + if (this._removeWatcher) { + this._removeWatcher(sysPath.dirname(dir), sysPath.basename(dir)); + } + } + } + has(item) { + const { items } = this; + if (!items) + return; + return items.has(item); + } + getChildren() { + const { items } = this; + if (!items) + return []; + return [...items.values()]; + } + dispose() { + this.items.clear(); + this.path = ''; + this._removeWatcher = EMPTY_FN; + this.items = EMPTY_SET; + Object.freeze(this); + } +} +const STAT_METHOD_F = 'stat'; +const STAT_METHOD_L = 'lstat'; +export class WatchHelper { + constructor(path, follow, fsw) { + this.fsw = fsw; + const watchPath = path; + this.path = path = path.replace(REPLACER_RE, ''); + this.watchPath = watchPath; + this.fullWatchPath = sysPath.resolve(watchPath); + this.dirParts = []; + this.dirParts.forEach((parts) => { + if (parts.length > 1) + parts.pop(); + }); + this.followSymlinks = follow; + this.statMethod = follow ? STAT_METHOD_F : STAT_METHOD_L; + } + entryPath(entry) { + return sysPath.join(this.watchPath, sysPath.relative(this.watchPath, entry.fullPath)); + } + filterPath(entry) { + const { stats } = entry; + if (stats && stats.isSymbolicLink()) + return this.filterDir(entry); + const resolvedPath = this.entryPath(entry); + // TODO: what if stats is undefined? remove ! + return this.fsw._isntIgnored(resolvedPath, stats) && this.fsw._hasReadPermissions(stats); + } + filterDir(entry) { + return this.fsw._isntIgnored(this.entryPath(entry), entry.stats); + } +} +/** + * Watches files & directories for changes. Emitted events: + * `add`, `addDir`, `change`, `unlink`, `unlinkDir`, `all`, `error` + * + * new FSWatcher() + * .add(directories) + * .on('add', path => log('File', path, 'was added')) + */ +export class FSWatcher extends EventEmitter { + // Not indenting methods for history sake; for now. + constructor(_opts = {}) { + super(); + this.closed = false; + this._closers = new Map(); + this._ignoredPaths = new Set(); + this._throttled = new Map(); + this._streams = new Set(); + this._symlinkPaths = new Map(); + this._watched = new Map(); + this._pendingWrites = new Map(); + this._pendingUnlinks = new Map(); + this._readyCount = 0; + this._readyEmitted = false; + const awf = _opts.awaitWriteFinish; + const DEF_AWF = { stabilityThreshold: 2000, pollInterval: 100 }; + const opts = { + // Defaults + persistent: true, + ignoreInitial: false, + ignorePermissionErrors: false, + interval: 100, + binaryInterval: 300, + followSymlinks: true, + usePolling: false, + // useAsync: false, + atomic: true, // NOTE: overwritten later (depends on usePolling) + ..._opts, + // Change format + ignored: _opts.ignored ? arrify(_opts.ignored) : arrify([]), + awaitWriteFinish: awf === true ? DEF_AWF : typeof awf === 'object' ? { ...DEF_AWF, ...awf } : false, + }; + // Always default to polling on IBM i because fs.watch() is not available on IBM i. + if (isIBMi) + opts.usePolling = true; + // Editor atomic write normalization enabled by default with fs.watch + if (opts.atomic === undefined) + opts.atomic = !opts.usePolling; + // opts.atomic = typeof _opts.atomic === 'number' ? _opts.atomic : 100; + // Global override. Useful for developers, who need to force polling for all + // instances of chokidar, regardless of usage / dependency depth + const envPoll = process.env.CHOKIDAR_USEPOLLING; + if (envPoll !== undefined) { + const envLower = envPoll.toLowerCase(); + if (envLower === 'false' || envLower === '0') + opts.usePolling = false; + else if (envLower === 'true' || envLower === '1') + opts.usePolling = true; + else + opts.usePolling = !!envLower; + } + const envInterval = process.env.CHOKIDAR_INTERVAL; + if (envInterval) + opts.interval = Number.parseInt(envInterval, 10); + // This is done to emit ready only once, but each 'add' will increase that? + let readyCalls = 0; + this._emitReady = () => { + readyCalls++; + if (readyCalls >= this._readyCount) { + this._emitReady = EMPTY_FN; + this._readyEmitted = true; + // use process.nextTick to allow time for listener to be bound + process.nextTick(() => this.emit(EV.READY)); + } + }; + this._emitRaw = (...args) => this.emit(EV.RAW, ...args); + this._boundRemove = this._remove.bind(this); + this.options = opts; + this._nodeFsHandler = new NodeFsHandler(this); + // You’re frozen when your heart’s not open. + Object.freeze(opts); + } + _addIgnoredPath(matcher) { + if (isMatcherObject(matcher)) { + // return early if we already have a deeply equal matcher object + for (const ignored of this._ignoredPaths) { + if (isMatcherObject(ignored) && + ignored.path === matcher.path && + ignored.recursive === matcher.recursive) { + return; + } + } + } + this._ignoredPaths.add(matcher); + } + _removeIgnoredPath(matcher) { + this._ignoredPaths.delete(matcher); + // now find any matcher objects with the matcher as path + if (typeof matcher === 'string') { + for (const ignored of this._ignoredPaths) { + // TODO (43081j): make this more efficient. + // probably just make a `this._ignoredDirectories` or some + // such thing. + if (isMatcherObject(ignored) && ignored.path === matcher) { + this._ignoredPaths.delete(ignored); + } + } + } + } + // Public methods + /** + * Adds paths to be watched on an existing FSWatcher instance. + * @param paths_ file or file list. Other arguments are unused + */ + add(paths_, _origAdd, _internal) { + const { cwd } = this.options; + this.closed = false; + this._closePromise = undefined; + let paths = unifyPaths(paths_); + if (cwd) { + paths = paths.map((path) => { + const absPath = getAbsolutePath(path, cwd); + // Check `path` instead of `absPath` because the cwd portion can't be a glob + return absPath; + }); + } + paths.forEach((path) => { + this._removeIgnoredPath(path); + }); + this._userIgnored = undefined; + if (!this._readyCount) + this._readyCount = 0; + this._readyCount += paths.length; + Promise.all(paths.map(async (path) => { + const res = await this._nodeFsHandler._addToNodeFs(path, !_internal, undefined, 0, _origAdd); + if (res) + this._emitReady(); + return res; + })).then((results) => { + if (this.closed) + return; + results.forEach((item) => { + if (item) + this.add(sysPath.dirname(item), sysPath.basename(_origAdd || item)); + }); + }); + return this; + } + /** + * Close watchers or start ignoring events from specified paths. + */ + unwatch(paths_) { + if (this.closed) + return this; + const paths = unifyPaths(paths_); + const { cwd } = this.options; + paths.forEach((path) => { + // convert to absolute path unless relative path already matches + if (!sysPath.isAbsolute(path) && !this._closers.has(path)) { + if (cwd) + path = sysPath.join(cwd, path); + path = sysPath.resolve(path); + } + this._closePath(path); + this._addIgnoredPath(path); + if (this._watched.has(path)) { + this._addIgnoredPath({ + path, + recursive: true, + }); + } + // reset the cached userIgnored anymatch fn + // to make ignoredPaths changes effective + this._userIgnored = undefined; + }); + return this; + } + /** + * Close watchers and remove all listeners from watched paths. + */ + close() { + if (this._closePromise) { + return this._closePromise; + } + this.closed = true; + // Memory management. + this.removeAllListeners(); + const closers = []; + this._closers.forEach((closerList) => closerList.forEach((closer) => { + const promise = closer(); + if (promise instanceof Promise) + closers.push(promise); + })); + this._streams.forEach((stream) => stream.destroy()); + this._userIgnored = undefined; + this._readyCount = 0; + this._readyEmitted = false; + this._watched.forEach((dirent) => dirent.dispose()); + this._closers.clear(); + this._watched.clear(); + this._streams.clear(); + this._symlinkPaths.clear(); + this._throttled.clear(); + this._closePromise = closers.length + ? Promise.all(closers).then(() => undefined) + : Promise.resolve(); + return this._closePromise; + } + /** + * Expose list of watched paths + * @returns for chaining + */ + getWatched() { + const watchList = {}; + this._watched.forEach((entry, dir) => { + const key = this.options.cwd ? sysPath.relative(this.options.cwd, dir) : dir; + const index = key || ONE_DOT; + watchList[index] = entry.getChildren().sort(); + }); + return watchList; + } + emitWithAll(event, args) { + this.emit(event, ...args); + if (event !== EV.ERROR) + this.emit(EV.ALL, event, ...args); + } + // Common helpers + // -------------- + /** + * Normalize and emit events. + * Calling _emit DOES NOT MEAN emit() would be called! + * @param event Type of event + * @param path File or directory path + * @param stats arguments to be passed with event + * @returns the error if defined, otherwise the value of the FSWatcher instance's `closed` flag + */ + async _emit(event, path, stats) { + if (this.closed) + return; + const opts = this.options; + if (isWindows) + path = sysPath.normalize(path); + if (opts.cwd) + path = sysPath.relative(opts.cwd, path); + const args = [path]; + if (stats != null) + args.push(stats); + const awf = opts.awaitWriteFinish; + let pw; + if (awf && (pw = this._pendingWrites.get(path))) { + pw.lastChange = new Date(); + return this; + } + if (opts.atomic) { + if (event === EV.UNLINK) { + this._pendingUnlinks.set(path, [event, ...args]); + setTimeout(() => { + this._pendingUnlinks.forEach((entry, path) => { + this.emit(...entry); + this.emit(EV.ALL, ...entry); + this._pendingUnlinks.delete(path); + }); + }, typeof opts.atomic === 'number' ? opts.atomic : 100); + return this; + } + if (event === EV.ADD && this._pendingUnlinks.has(path)) { + event = EV.CHANGE; + this._pendingUnlinks.delete(path); + } + } + if (awf && (event === EV.ADD || event === EV.CHANGE) && this._readyEmitted) { + const awfEmit = (err, stats) => { + if (err) { + event = EV.ERROR; + args[0] = err; + this.emitWithAll(event, args); + } + else if (stats) { + // if stats doesn't exist the file must have been deleted + if (args.length > 1) { + args[1] = stats; + } + else { + args.push(stats); + } + this.emitWithAll(event, args); + } + }; + this._awaitWriteFinish(path, awf.stabilityThreshold, event, awfEmit); + return this; + } + if (event === EV.CHANGE) { + const isThrottled = !this._throttle(EV.CHANGE, path, 50); + if (isThrottled) + return this; + } + if (opts.alwaysStat && + stats === undefined && + (event === EV.ADD || event === EV.ADD_DIR || event === EV.CHANGE)) { + const fullPath = opts.cwd ? sysPath.join(opts.cwd, path) : path; + let stats; + try { + stats = await stat(fullPath); + } + catch (err) { + // do nothing + } + // Suppress event when fs_stat fails, to avoid sending undefined 'stat' + if (!stats || this.closed) + return; + args.push(stats); + } + this.emitWithAll(event, args); + return this; + } + /** + * Common handler for errors + * @returns The error if defined, otherwise the value of the FSWatcher instance's `closed` flag + */ + _handleError(error) { + const code = error && error.code; + if (error && + code !== 'ENOENT' && + code !== 'ENOTDIR' && + (!this.options.ignorePermissionErrors || (code !== 'EPERM' && code !== 'EACCES'))) { + this.emit(EV.ERROR, error); + } + return error || this.closed; + } + /** + * Helper utility for throttling + * @param actionType type being throttled + * @param path being acted upon + * @param timeout duration of time to suppress duplicate actions + * @returns tracking object or false if action should be suppressed + */ + _throttle(actionType, path, timeout) { + if (!this._throttled.has(actionType)) { + this._throttled.set(actionType, new Map()); + } + const action = this._throttled.get(actionType); + if (!action) + throw new Error('invalid throttle'); + const actionPath = action.get(path); + if (actionPath) { + actionPath.count++; + return false; + } + // eslint-disable-next-line prefer-const + let timeoutObject; + const clear = () => { + const item = action.get(path); + const count = item ? item.count : 0; + action.delete(path); + clearTimeout(timeoutObject); + if (item) + clearTimeout(item.timeoutObject); + return count; + }; + timeoutObject = setTimeout(clear, timeout); + const thr = { timeoutObject, clear, count: 0 }; + action.set(path, thr); + return thr; + } + _incrReadyCount() { + return this._readyCount++; + } + /** + * Awaits write operation to finish. + * Polls a newly created file for size variations. When files size does not change for 'threshold' milliseconds calls callback. + * @param path being acted upon + * @param threshold Time in milliseconds a file size must be fixed before acknowledging write OP is finished + * @param event + * @param awfEmit Callback to be called when ready for event to be emitted. + */ + _awaitWriteFinish(path, threshold, event, awfEmit) { + const awf = this.options.awaitWriteFinish; + if (typeof awf !== 'object') + return; + const pollInterval = awf.pollInterval; + let timeoutHandler; + let fullPath = path; + if (this.options.cwd && !sysPath.isAbsolute(path)) { + fullPath = sysPath.join(this.options.cwd, path); + } + const now = new Date(); + const writes = this._pendingWrites; + function awaitWriteFinishFn(prevStat) { + statcb(fullPath, (err, curStat) => { + if (err || !writes.has(path)) { + if (err && err.code !== 'ENOENT') + awfEmit(err); + return; + } + const now = Number(new Date()); + if (prevStat && curStat.size !== prevStat.size) { + writes.get(path).lastChange = now; + } + const pw = writes.get(path); + const df = now - pw.lastChange; + if (df >= threshold) { + writes.delete(path); + awfEmit(undefined, curStat); + } + else { + timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat); + } + }); + } + if (!writes.has(path)) { + writes.set(path, { + lastChange: now, + cancelWait: () => { + writes.delete(path); + clearTimeout(timeoutHandler); + return event; + }, + }); + timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval); + } + } + /** + * Determines whether user has asked to ignore this path. + */ + _isIgnored(path, stats) { + if (this.options.atomic && DOT_RE.test(path)) + return true; + if (!this._userIgnored) { + const { cwd } = this.options; + const ign = this.options.ignored; + const ignored = (ign || []).map(normalizeIgnored(cwd)); + const ignoredPaths = [...this._ignoredPaths]; + const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored]; + this._userIgnored = anymatch(list, undefined); + } + return this._userIgnored(path, stats); + } + _isntIgnored(path, stat) { + return !this._isIgnored(path, stat); + } + /** + * Provides a set of common helpers and properties relating to symlink handling. + * @param path file or directory pattern being watched + */ + _getWatchHelpers(path) { + return new WatchHelper(path, this.options.followSymlinks, this); + } + // Directory helpers + // ----------------- + /** + * Provides directory tracking objects + * @param directory path of the directory + */ + _getWatchedDir(directory) { + const dir = sysPath.resolve(directory); + if (!this._watched.has(dir)) + this._watched.set(dir, new DirEntry(dir, this._boundRemove)); + return this._watched.get(dir); + } + // File helpers + // ------------ + /** + * Check for read permissions: https://stackoverflow.com/a/11781404/1358405 + */ + _hasReadPermissions(stats) { + if (this.options.ignorePermissionErrors) + return true; + return Boolean(Number(stats.mode) & 0o400); + } + /** + * Handles emitting unlink events for + * files and directories, and via recursion, for + * files and directories within directories that are unlinked + * @param directory within which the following item is located + * @param item base path of item/directory + */ + _remove(directory, item, isDirectory) { + // if what is being deleted is a directory, get that directory's paths + // for recursive deleting and cleaning of watched object + // if it is not a directory, nestedDirectoryChildren will be empty array + const path = sysPath.join(directory, item); + const fullPath = sysPath.resolve(path); + isDirectory = + isDirectory != null ? isDirectory : this._watched.has(path) || this._watched.has(fullPath); + // prevent duplicate handling in case of arriving here nearly simultaneously + // via multiple paths (such as _handleFile and _handleDir) + if (!this._throttle('remove', path, 100)) + return; + // if the only watched file is removed, watch for its return + if (!isDirectory && this._watched.size === 1) { + this.add(directory, item, true); + } + // This will create a new entry in the watched object in either case + // so we got to do the directory check beforehand + const wp = this._getWatchedDir(path); + const nestedDirectoryChildren = wp.getChildren(); + // Recursively remove children directories / files. + nestedDirectoryChildren.forEach((nested) => this._remove(path, nested)); + // Check if item was on the watched list and remove it + const parent = this._getWatchedDir(directory); + const wasTracked = parent.has(item); + parent.remove(item); + // Fixes issue #1042 -> Relative paths were detected and added as symlinks + // (https://github.com/paulmillr/chokidar/blob/e1753ddbc9571bdc33b4a4af172d52cb6e611c10/lib/nodefs-handler.js#L612), + // but never removed from the map in case the path was deleted. + // This leads to an incorrect state if the path was recreated: + // https://github.com/paulmillr/chokidar/blob/e1753ddbc9571bdc33b4a4af172d52cb6e611c10/lib/nodefs-handler.js#L553 + if (this._symlinkPaths.has(fullPath)) { + this._symlinkPaths.delete(fullPath); + } + // If we wait for this file to be fully written, cancel the wait. + let relPath = path; + if (this.options.cwd) + relPath = sysPath.relative(this.options.cwd, path); + if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) { + const event = this._pendingWrites.get(relPath).cancelWait(); + if (event === EV.ADD) + return; + } + // The Entry will either be a directory that just got removed + // or a bogus entry to a file, in either case we have to remove it + this._watched.delete(path); + this._watched.delete(fullPath); + const eventName = isDirectory ? EV.UNLINK_DIR : EV.UNLINK; + if (wasTracked && !this._isIgnored(path)) + this._emit(eventName, path); + // Avoid conflicts if we later create another file with the same name + this._closePath(path); + } + /** + * Closes all watchers for a path + */ + _closePath(path) { + this._closeFile(path); + const dir = sysPath.dirname(path); + this._getWatchedDir(dir).remove(sysPath.basename(path)); + } + /** + * Closes only file-specific watchers + */ + _closeFile(path) { + const closers = this._closers.get(path); + if (!closers) + return; + closers.forEach((closer) => closer()); + this._closers.delete(path); + } + _addPathCloser(path, closer) { + if (!closer) + return; + let list = this._closers.get(path); + if (!list) { + list = []; + this._closers.set(path, list); + } + list.push(closer); + } + _readdirp(root, opts) { + if (this.closed) + return; + const options = { type: EV.ALL, alwaysStat: true, lstat: true, ...opts, depth: 0 }; + let stream = readdirp(root, options); + this._streams.add(stream); + stream.once(STR_CLOSE, () => { + stream = undefined; + }); + stream.once(STR_END, () => { + if (stream) { + this._streams.delete(stream); + stream = undefined; + } + }); + return stream; + } +} +/** + * Instantiates watcher with paths to be tracked. + * @param paths file / directory paths + * @param options opts, such as `atomic`, `awaitWriteFinish`, `ignored`, and others + * @returns an instance of FSWatcher for chaining. + * @example + * const watcher = watch('.').on('all', (event, path) => { console.log(event, path); }); + * watch('.', { atomic: true, awaitWriteFinish: true, ignored: (f, stats) => stats?.isFile() && !f.endsWith('.js') }) + */ +export function watch(paths, options = {}) { + const watcher = new FSWatcher(options); + watcher.add(paths); + return watcher; +} +export default { watch, FSWatcher }; diff --git a/backend/node_modules/chokidar/esm/package.json b/backend/node_modules/chokidar/esm/package.json new file mode 100644 index 0000000000000000000000000000000000000000..876964185fee0ed0caaf9038f647c8f54411f688 --- /dev/null +++ b/backend/node_modules/chokidar/esm/package.json @@ -0,0 +1 @@ +{ "type": "module", "sideEffects": false } diff --git a/backend/node_modules/dotenv/lib/cli-options.js b/backend/node_modules/dotenv/lib/cli-options.js new file mode 100644 index 0000000000000000000000000000000000000000..b6e40db083c8678184b3814c33ea84db2bc8e29e --- /dev/null +++ b/backend/node_modules/dotenv/lib/cli-options.js @@ -0,0 +1,17 @@ +const re = /^dotenv_config_(encoding|path|quiet|debug|override|DOTENV_KEY)=(.+)$/ + +module.exports = function optionMatcher (args) { + const options = args.reduce(function (acc, cur) { + const matches = cur.match(re) + if (matches) { + acc[matches[1]] = matches[2] + } + return acc + }, {}) + + if (!('quiet' in options)) { + options.quiet = 'true' + } + + return options +} diff --git a/backend/node_modules/dotenv/lib/env-options.js b/backend/node_modules/dotenv/lib/env-options.js new file mode 100644 index 0000000000000000000000000000000000000000..5dcee8a376febaada2962b4c5ed727e087cf512a --- /dev/null +++ b/backend/node_modules/dotenv/lib/env-options.js @@ -0,0 +1,28 @@ +// ../config.js accepts options via environment variables +const options = {} + +if (process.env.DOTENV_CONFIG_ENCODING != null) { + options.encoding = process.env.DOTENV_CONFIG_ENCODING +} + +if (process.env.DOTENV_CONFIG_PATH != null) { + options.path = process.env.DOTENV_CONFIG_PATH +} + +if (process.env.DOTENV_CONFIG_QUIET != null) { + options.quiet = process.env.DOTENV_CONFIG_QUIET +} + +if (process.env.DOTENV_CONFIG_DEBUG != null) { + options.debug = process.env.DOTENV_CONFIG_DEBUG +} + +if (process.env.DOTENV_CONFIG_OVERRIDE != null) { + options.override = process.env.DOTENV_CONFIG_OVERRIDE +} + +if (process.env.DOTENV_CONFIG_DOTENV_KEY != null) { + options.DOTENV_KEY = process.env.DOTENV_CONFIG_DOTENV_KEY +} + +module.exports = options diff --git a/backend/node_modules/dotenv/lib/main.d.ts b/backend/node_modules/dotenv/lib/main.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..82604e855eba9c1c2918e8371d1d778e4365141f --- /dev/null +++ b/backend/node_modules/dotenv/lib/main.d.ts @@ -0,0 +1,162 @@ +// TypeScript Version: 3.0 +/// +import type { URL } from 'url'; + +export interface DotenvParseOutput { + [name: string]: string; +} + +/** + * Parses a string or buffer in the .env file format into an object. + * + * See https://dotenvx.com/docs + * + * @param src - contents to be parsed. example: `'DB_HOST=localhost'` + * @returns an object with keys and values based on `src`. example: `{ DB_HOST : 'localhost' }` + */ +export function parse( + src: string | Buffer +): T; + +export interface DotenvConfigOptions { + /** + * Default: `path.resolve(process.cwd(), '.env')` + * + * Specify a custom path if your file containing environment variables is located elsewhere. + * Can also be an array of strings, specifying multiple paths. + * + * example: `require('dotenv').config({ path: '/custom/path/to/.env' })` + * example: `require('dotenv').config({ path: ['/path/to/first.env', '/path/to/second.env'] })` + */ + path?: string | string[] | URL; + + /** + * Default: `utf8` + * + * Specify the encoding of your file containing environment variables. + * + * example: `require('dotenv').config({ encoding: 'latin1' })` + */ + encoding?: string; + + /** + * Default: `false` + * + * Suppress all output (except errors). + * + * example: `require('dotenv').config({ quiet: true })` + */ + quiet?: boolean; + + /** + * Default: `false` + * + * Turn on logging to help debug why certain keys or values are not being set as you expect. + * + * example: `require('dotenv').config({ debug: process.env.DEBUG })` + */ + debug?: boolean; + + /** + * Default: `false` + * + * Override any environment variables that have already been set on your machine with values from your .env file. + * + * example: `require('dotenv').config({ override: true })` + */ + override?: boolean; + + /** + * Default: `process.env` + * + * Specify an object to write your secrets to. Defaults to process.env environment variables. + * + * example: `const processEnv = {}; require('dotenv').config({ processEnv: processEnv })` + */ + processEnv?: DotenvPopulateInput; + + /** + * Default: `undefined` + * + * Pass the DOTENV_KEY directly to config options. Defaults to looking for process.env.DOTENV_KEY environment variable. Note this only applies to decrypting .env.vault files. If passed as null or undefined, or not passed at all, dotenv falls back to its traditional job of parsing a .env file. + * + * example: `require('dotenv').config({ DOTENV_KEY: 'dotenv://:key_1234…@dotenvx.com/vault/.env.vault?environment=production' })` + */ + DOTENV_KEY?: string; +} + +export interface DotenvConfigOutput { + error?: Error; + parsed?: DotenvParseOutput; +} + +export interface DotenvPopulateOptions { + /** + * Default: `false` + * + * Turn on logging to help debug why certain keys or values are not being set as you expect. + * + * example: `require('dotenv').config({ debug: process.env.DEBUG })` + */ + debug?: boolean; + + /** + * Default: `false` + * + * Override any environment variables that have already been set on your machine with values from your .env file. + * + * example: `require('dotenv').config({ override: true })` + */ + override?: boolean; +} + +export interface DotenvPopulateInput { + [name: string]: string; +} + +/** + * Loads `.env` file contents into process.env by default. If `DOTENV_KEY` is present, it smartly attempts to load encrypted `.env.vault` file contents into process.env. + * + * See https://dotenvx.com/docs + * + * @param options - additional options. example: `{ path: './custom/path', encoding: 'latin1', quiet: false, debug: true, override: false }` + * @returns an object with a `parsed` key if successful or `error` key if an error occurred. example: { parsed: { KEY: 'value' } } + * + */ +export function config(options?: DotenvConfigOptions): DotenvConfigOutput; + +/** + * Loads `.env` file contents into process.env. + * + * See https://dotenvx.com/docs + * + * @param options - additional options. example: `{ path: './custom/path', encoding: 'latin1', quiet: false, debug: true, override: false }` + * @returns an object with a `parsed` key if successful or `error` key if an error occurred. example: { parsed: { KEY: 'value' } } + * + */ +export function configDotenv(options?: DotenvConfigOptions): DotenvConfigOutput; + +/** + * Loads `source` json contents into `target` like process.env. + * + * See https://dotenvx.com/docs + * + * @param processEnv - the target JSON object. in most cases use process.env but you can also pass your own JSON object + * @param parsed - the source JSON object + * @param options - additional options. example: `{ quiet: false, debug: true, override: false }` + * @returns {void} + * + */ +export function populate(processEnv: DotenvPopulateInput, parsed: DotenvPopulateInput, options?: DotenvConfigOptions): void; + +/** + * Decrypt ciphertext + * + * See https://dotenvx.com/docs + * + * @param encrypted - the encrypted ciphertext string + * @param keyStr - the decryption key string + * @returns {string} + * + */ +export function decrypt(encrypted: string, keyStr: string): string; diff --git a/backend/node_modules/dotenv/lib/main.js b/backend/node_modules/dotenv/lib/main.js new file mode 100644 index 0000000000000000000000000000000000000000..91cabe470f15384651232b86ff82509f71cd64d5 --- /dev/null +++ b/backend/node_modules/dotenv/lib/main.js @@ -0,0 +1,386 @@ +const fs = require('fs') +const path = require('path') +const os = require('os') +const crypto = require('crypto') +const packageJson = require('../package.json') + +const version = packageJson.version + +const LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/mg + +// Parse src into an Object +function parse (src) { + const obj = {} + + // Convert buffer to string + let lines = src.toString() + + // Convert line breaks to same format + lines = lines.replace(/\r\n?/mg, '\n') + + let match + while ((match = LINE.exec(lines)) != null) { + const key = match[1] + + // Default undefined or null to empty string + let value = (match[2] || '') + + // Remove whitespace + value = value.trim() + + // Check if double quoted + const maybeQuote = value[0] + + // Remove surrounding quotes + value = value.replace(/^(['"`])([\s\S]*)\1$/mg, '$2') + + // Expand newlines if double quoted + if (maybeQuote === '"') { + value = value.replace(/\\n/g, '\n') + value = value.replace(/\\r/g, '\r') + } + + // Add to object + obj[key] = value + } + + return obj +} + +function _parseVault (options) { + options = options || {} + + const vaultPath = _vaultPath(options) + options.path = vaultPath // parse .env.vault + const result = DotenvModule.configDotenv(options) + if (!result.parsed) { + const err = new Error(`MISSING_DATA: Cannot parse ${vaultPath} for an unknown reason`) + err.code = 'MISSING_DATA' + throw err + } + + // handle scenario for comma separated keys - for use with key rotation + // example: DOTENV_KEY="dotenv://:key_1234@dotenvx.com/vault/.env.vault?environment=prod,dotenv://:key_7890@dotenvx.com/vault/.env.vault?environment=prod" + const keys = _dotenvKey(options).split(',') + const length = keys.length + + let decrypted + for (let i = 0; i < length; i++) { + try { + // Get full key + const key = keys[i].trim() + + // Get instructions for decrypt + const attrs = _instructions(result, key) + + // Decrypt + decrypted = DotenvModule.decrypt(attrs.ciphertext, attrs.key) + + break + } catch (error) { + // last key + if (i + 1 >= length) { + throw error + } + // try next key + } + } + + // Parse decrypted .env string + return DotenvModule.parse(decrypted) +} + +function _warn (message) { + console.log(`[dotenv@${version}][WARN] ${message}`) +} + +function _debug (message) { + console.log(`[dotenv@${version}][DEBUG] ${message}`) +} + +function _log (message) { + console.log(`[dotenv@${version}] ${message}`) +} + +function _dotenvKey (options) { + // prioritize developer directly setting options.DOTENV_KEY + if (options && options.DOTENV_KEY && options.DOTENV_KEY.length > 0) { + return options.DOTENV_KEY + } + + // secondary infra already contains a DOTENV_KEY environment variable + if (process.env.DOTENV_KEY && process.env.DOTENV_KEY.length > 0) { + return process.env.DOTENV_KEY + } + + // fallback to empty string + return '' +} + +function _instructions (result, dotenvKey) { + // Parse DOTENV_KEY. Format is a URI + let uri + try { + uri = new URL(dotenvKey) + } catch (error) { + if (error.code === 'ERR_INVALID_URL') { + const err = new Error('INVALID_DOTENV_KEY: Wrong format. Must be in valid uri format like dotenv://:key_1234@dotenvx.com/vault/.env.vault?environment=development') + err.code = 'INVALID_DOTENV_KEY' + throw err + } + + throw error + } + + // Get decrypt key + const key = uri.password + if (!key) { + const err = new Error('INVALID_DOTENV_KEY: Missing key part') + err.code = 'INVALID_DOTENV_KEY' + throw err + } + + // Get environment + const environment = uri.searchParams.get('environment') + if (!environment) { + const err = new Error('INVALID_DOTENV_KEY: Missing environment part') + err.code = 'INVALID_DOTENV_KEY' + throw err + } + + // Get ciphertext payload + const environmentKey = `DOTENV_VAULT_${environment.toUpperCase()}` + const ciphertext = result.parsed[environmentKey] // DOTENV_VAULT_PRODUCTION + if (!ciphertext) { + const err = new Error(`NOT_FOUND_DOTENV_ENVIRONMENT: Cannot locate environment ${environmentKey} in your .env.vault file.`) + err.code = 'NOT_FOUND_DOTENV_ENVIRONMENT' + throw err + } + + return { ciphertext, key } +} + +function _vaultPath (options) { + let possibleVaultPath = null + + if (options && options.path && options.path.length > 0) { + if (Array.isArray(options.path)) { + for (const filepath of options.path) { + if (fs.existsSync(filepath)) { + possibleVaultPath = filepath.endsWith('.vault') ? filepath : `${filepath}.vault` + } + } + } else { + possibleVaultPath = options.path.endsWith('.vault') ? options.path : `${options.path}.vault` + } + } else { + possibleVaultPath = path.resolve(process.cwd(), '.env.vault') + } + + if (fs.existsSync(possibleVaultPath)) { + return possibleVaultPath + } + + return null +} + +function _resolveHome (envPath) { + return envPath[0] === '~' ? path.join(os.homedir(), envPath.slice(1)) : envPath +} + +function _configVault (options) { + const debug = Boolean(options && options.debug) + const quiet = options && 'quiet' in options ? options.quiet : true + + if (debug || !quiet) { + _log('Loading env from encrypted .env.vault') + } + + const parsed = DotenvModule._parseVault(options) + + let processEnv = process.env + if (options && options.processEnv != null) { + processEnv = options.processEnv + } + + DotenvModule.populate(processEnv, parsed, options) + + return { parsed } +} + +function configDotenv (options) { + const dotenvPath = path.resolve(process.cwd(), '.env') + let encoding = 'utf8' + const debug = Boolean(options && options.debug) + const quiet = options && 'quiet' in options ? options.quiet : true + + if (options && options.encoding) { + encoding = options.encoding + } else { + if (debug) { + _debug('No encoding is specified. UTF-8 is used by default') + } + } + + let optionPaths = [dotenvPath] // default, look for .env + if (options && options.path) { + if (!Array.isArray(options.path)) { + optionPaths = [_resolveHome(options.path)] + } else { + optionPaths = [] // reset default + for (const filepath of options.path) { + optionPaths.push(_resolveHome(filepath)) + } + } + } + + // Build the parsed data in a temporary object (because we need to return it). Once we have the final + // parsed data, we will combine it with process.env (or options.processEnv if provided). + let lastError + const parsedAll = {} + for (const path of optionPaths) { + try { + // Specifying an encoding returns a string instead of a buffer + const parsed = DotenvModule.parse(fs.readFileSync(path, { encoding })) + + DotenvModule.populate(parsedAll, parsed, options) + } catch (e) { + if (debug) { + _debug(`Failed to load ${path} ${e.message}`) + } + lastError = e + } + } + + let processEnv = process.env + if (options && options.processEnv != null) { + processEnv = options.processEnv + } + + DotenvModule.populate(processEnv, parsedAll, options) + + if (debug || !quiet) { + const keysCount = Object.keys(parsedAll).length + const shortPaths = [] + for (const filePath of optionPaths) { + try { + const relative = path.relative(process.cwd(), filePath) + shortPaths.push(relative) + } catch (e) { + if (debug) { + _debug(`Failed to load ${filePath} ${e.message}`) + } + lastError = e + } + } + + _log(`injecting env (${keysCount}) from ${shortPaths.join(',')}`) + } + + if (lastError) { + return { parsed: parsedAll, error: lastError } + } else { + return { parsed: parsedAll } + } +} + +// Populates process.env from .env file +function config (options) { + // fallback to original dotenv if DOTENV_KEY is not set + if (_dotenvKey(options).length === 0) { + return DotenvModule.configDotenv(options) + } + + const vaultPath = _vaultPath(options) + + // dotenvKey exists but .env.vault file does not exist + if (!vaultPath) { + _warn(`You set DOTENV_KEY but you are missing a .env.vault file at ${vaultPath}. Did you forget to build it?`) + + return DotenvModule.configDotenv(options) + } + + return DotenvModule._configVault(options) +} + +function decrypt (encrypted, keyStr) { + const key = Buffer.from(keyStr.slice(-64), 'hex') + let ciphertext = Buffer.from(encrypted, 'base64') + + const nonce = ciphertext.subarray(0, 12) + const authTag = ciphertext.subarray(-16) + ciphertext = ciphertext.subarray(12, -16) + + try { + const aesgcm = crypto.createDecipheriv('aes-256-gcm', key, nonce) + aesgcm.setAuthTag(authTag) + return `${aesgcm.update(ciphertext)}${aesgcm.final()}` + } catch (error) { + const isRange = error instanceof RangeError + const invalidKeyLength = error.message === 'Invalid key length' + const decryptionFailed = error.message === 'Unsupported state or unable to authenticate data' + + if (isRange || invalidKeyLength) { + const err = new Error('INVALID_DOTENV_KEY: It must be 64 characters long (or more)') + err.code = 'INVALID_DOTENV_KEY' + throw err + } else if (decryptionFailed) { + const err = new Error('DECRYPTION_FAILED: Please check your DOTENV_KEY') + err.code = 'DECRYPTION_FAILED' + throw err + } else { + throw error + } + } +} + +// Populate process.env with parsed values +function populate (processEnv, parsed, options = {}) { + const debug = Boolean(options && options.debug) + const override = Boolean(options && options.override) + + if (typeof parsed !== 'object') { + const err = new Error('OBJECT_REQUIRED: Please check the processEnv argument being passed to populate') + err.code = 'OBJECT_REQUIRED' + throw err + } + + // Set process.env + for (const key of Object.keys(parsed)) { + if (Object.prototype.hasOwnProperty.call(processEnv, key)) { + if (override === true) { + processEnv[key] = parsed[key] + } + + if (debug) { + if (override === true) { + _debug(`"${key}" is already defined and WAS overwritten`) + } else { + _debug(`"${key}" is already defined and was NOT overwritten`) + } + } + } else { + processEnv[key] = parsed[key] + } + } +} + +const DotenvModule = { + configDotenv, + _configVault, + _parseVault, + config, + decrypt, + parse, + populate +} + +module.exports.configDotenv = DotenvModule.configDotenv +module.exports._configVault = DotenvModule._configVault +module.exports._parseVault = DotenvModule._parseVault +module.exports.config = DotenvModule.config +module.exports.decrypt = DotenvModule.decrypt +module.exports.parse = DotenvModule.parse +module.exports.populate = DotenvModule.populate + +module.exports = DotenvModule diff --git a/backend/node_modules/effect/src/internal/layer/circular.ts b/backend/node_modules/effect/src/internal/layer/circular.ts new file mode 100644 index 0000000000000000000000000000000000000000..70852008d377aa8aa6d8d1e8c3212ca8af5dc90f --- /dev/null +++ b/backend/node_modules/effect/src/internal/layer/circular.ts @@ -0,0 +1,214 @@ +import type * as ConfigProvider from "../../ConfigProvider.js" +import * as Context from "../../Context.js" +import type * as Effect from "../../Effect.js" +import type * as Exit from "../../Exit.js" +import { dual } from "../../Function.js" +import * as HashSet from "../../HashSet.js" +import type * as Layer from "../../Layer.js" +import type * as Logger from "../../Logger.js" +import type * as LogLevel from "../../LogLevel.js" +import type { Scope } from "../../Scope.js" +import type * as Supervisor from "../../Supervisor.js" +import type * as Tracer from "../../Tracer.js" +import * as core from "../core.js" +import * as fiberRuntime from "../fiberRuntime.js" +import * as layer from "../layer.js" +import * as runtimeFlags from "../runtimeFlags.js" +import * as runtimeFlagsPatch from "../runtimeFlagsPatch.js" +import * as supervisor_ from "../supervisor.js" +import * as tracer from "../tracer.js" + +// circular with Logger + +/** @internal */ +export const minimumLogLevel = (level: LogLevel.LogLevel): Layer.Layer => + layer.scopedDiscard( + fiberRuntime.fiberRefLocallyScoped( + fiberRuntime.currentMinimumLogLevel, + level + ) + ) + +/** @internal */ +export const withMinimumLogLevel = dual< + (level: LogLevel.LogLevel) => (self: Effect.Effect) => Effect.Effect, + (self: Effect.Effect, level: LogLevel.LogLevel) => Effect.Effect +>(2, (self, level) => + core.fiberRefLocally( + fiberRuntime.currentMinimumLogLevel, + level + )(self)) + +/** @internal */ +export const addLogger = (logger: Logger.Logger): Layer.Layer => + layer.scopedDiscard( + fiberRuntime.fiberRefLocallyScopedWith( + fiberRuntime.currentLoggers, + HashSet.add(logger) + ) + ) + +/** @internal */ +export const addLoggerEffect = ( + effect: Effect.Effect, E, R> +): Layer.Layer => + layer.unwrapEffect( + core.map(effect, addLogger) + ) + +/** @internal */ +export const addLoggerScoped = ( + effect: Effect.Effect, E, R> +): Layer.Layer> => + layer.unwrapScoped( + core.map(effect, addLogger) + ) + +/** @internal */ +export const removeLogger = (logger: Logger.Logger): Layer.Layer => + layer.scopedDiscard( + fiberRuntime.fiberRefLocallyScopedWith( + fiberRuntime.currentLoggers, + HashSet.remove(logger) + ) + ) + +/** @internal */ +export const replaceLogger = dual< + (that: Logger.Logger) => (self: Logger.Logger) => Layer.Layer, + (self: Logger.Logger, that: Logger.Logger) => Layer.Layer +>(2, (self, that) => layer.flatMap(removeLogger(self), () => addLogger(that))) + +/** @internal */ +export const replaceLoggerEffect = dual< + ( + that: Effect.Effect, E, R> + ) => (self: Logger.Logger) => Layer.Layer, + ( + self: Logger.Logger, + that: Effect.Effect, E, R> + ) => Layer.Layer +>(2, (self, that) => layer.flatMap(removeLogger(self), () => addLoggerEffect(that))) + +/** @internal */ +export const replaceLoggerScoped = dual< + ( + that: Effect.Effect, E, R> + ) => (self: Logger.Logger) => Layer.Layer>, + ( + self: Logger.Logger, + that: Effect.Effect, E, R> + ) => Layer.Layer> +>(2, (self, that) => layer.flatMap(removeLogger(self), () => addLoggerScoped(that))) + +/** @internal */ +export const addSupervisor = (supervisor: Supervisor.Supervisor): Layer.Layer => + layer.scopedDiscard( + fiberRuntime.fiberRefLocallyScopedWith( + fiberRuntime.currentSupervisor, + (current) => new supervisor_.Zip(current, supervisor) + ) + ) + +/** @internal */ +export const enableCooperativeYielding: Layer.Layer = layer.scopedDiscard( + fiberRuntime.withRuntimeFlagsScoped( + runtimeFlagsPatch.enable(runtimeFlags.CooperativeYielding) + ) +) + +/** @internal */ +export const enableInterruption: Layer.Layer = layer.scopedDiscard( + fiberRuntime.withRuntimeFlagsScoped( + runtimeFlagsPatch.enable(runtimeFlags.Interruption) + ) +) + +/** @internal */ +export const enableOpSupervision: Layer.Layer = layer.scopedDiscard( + fiberRuntime.withRuntimeFlagsScoped( + runtimeFlagsPatch.enable(runtimeFlags.OpSupervision) + ) +) + +/** @internal */ +export const enableRuntimeMetrics: Layer.Layer = layer.scopedDiscard( + fiberRuntime.withRuntimeFlagsScoped( + runtimeFlagsPatch.enable(runtimeFlags.RuntimeMetrics) + ) +) + +/** @internal */ +export const enableWindDown: Layer.Layer = layer.scopedDiscard( + fiberRuntime.withRuntimeFlagsScoped( + runtimeFlagsPatch.enable(runtimeFlags.WindDown) + ) +) + +/** @internal */ +export const disableCooperativeYielding: Layer.Layer = layer.scopedDiscard( + fiberRuntime.withRuntimeFlagsScoped( + runtimeFlagsPatch.disable(runtimeFlags.CooperativeYielding) + ) +) + +/** @internal */ +export const disableInterruption: Layer.Layer = layer.scopedDiscard( + fiberRuntime.withRuntimeFlagsScoped( + runtimeFlagsPatch.disable(runtimeFlags.Interruption) + ) +) + +/** @internal */ +export const disableOpSupervision: Layer.Layer = layer.scopedDiscard( + fiberRuntime.withRuntimeFlagsScoped( + runtimeFlagsPatch.disable(runtimeFlags.OpSupervision) + ) +) + +/** @internal */ +export const disableRuntimeMetrics: Layer.Layer = layer.scopedDiscard( + fiberRuntime.withRuntimeFlagsScoped( + runtimeFlagsPatch.disable(runtimeFlags.RuntimeMetrics) + ) +) + +/** @internal */ +export const disableWindDown: Layer.Layer = layer.scopedDiscard( + fiberRuntime.withRuntimeFlagsScoped( + runtimeFlagsPatch.disable(runtimeFlags.WindDown) + ) +) + +/** @internal */ +export const setConfigProvider = (configProvider: ConfigProvider.ConfigProvider): Layer.Layer => + layer.scopedDiscard(fiberRuntime.withConfigProviderScoped(configProvider)) + +/** @internal */ +export const parentSpan = (span: Tracer.AnySpan): Layer.Layer => + layer.succeedContext(Context.make(tracer.spanTag, span)) + +/** @internal */ +export const span = ( + name: string, + options?: Tracer.SpanOptions & { + readonly onEnd?: + | ((span: Tracer.Span, exit: Exit.Exit) => Effect.Effect) + | undefined + } +): Layer.Layer => { + options = tracer.addSpanStackTrace(options) as any + return layer.scoped( + tracer.spanTag, + options?.onEnd + ? core.tap( + fiberRuntime.makeSpanScoped(name, options), + (span) => fiberRuntime.addFinalizer((exit) => options.onEnd!(span, exit)) + ) + : fiberRuntime.makeSpanScoped(name, options) + ) +} + +/** @internal */ +export const setTracer = (tracer: Tracer.Tracer): Layer.Layer => + layer.scopedDiscard(fiberRuntime.withTracerScoped(tracer)) diff --git a/backend/node_modules/effect/src/internal/metric/label.ts b/backend/node_modules/effect/src/internal/metric/label.ts new file mode 100644 index 0000000000000000000000000000000000000000..35a63f2e930428fd495bd1238345ca41253e6619 --- /dev/null +++ b/backend/node_modules/effect/src/internal/metric/label.ts @@ -0,0 +1,41 @@ +import * as Equal from "../../Equal.js" +import * as Hash from "../../Hash.js" +import type * as MetricLabel from "../../MetricLabel.js" +import { pipeArguments } from "../../Pipeable.js" +import { hasProperty } from "../../Predicate.js" + +/** @internal */ +const MetricLabelSymbolKey = "effect/MetricLabel" + +/** @internal */ +export const MetricLabelTypeId: MetricLabel.MetricLabelTypeId = Symbol.for( + MetricLabelSymbolKey +) as MetricLabel.MetricLabelTypeId + +/** @internal */ +class MetricLabelImpl implements MetricLabel.MetricLabel { + readonly [MetricLabelTypeId]: MetricLabel.MetricLabelTypeId = MetricLabelTypeId + readonly _hash: number + constructor(readonly key: string, readonly value: string) { + this._hash = Hash.string(MetricLabelSymbolKey + this.key + this.value) + } + [Hash.symbol](): number { + return this._hash + } + [Equal.symbol](that: unknown): boolean { + return isMetricLabel(that) && + this.key === that.key && + this.value === that.value + } + pipe() { + return pipeArguments(this, arguments) + } +} + +/** @internal */ +export const make = (key: string, value: string): MetricLabel.MetricLabel => { + return new MetricLabelImpl(key, value) +} + +/** @internal */ +export const isMetricLabel = (u: unknown): u is MetricLabel.MetricLabel => hasProperty(u, MetricLabelTypeId) diff --git a/backend/node_modules/effect/src/internal/metric/pair.ts b/backend/node_modules/effect/src/internal/metric/pair.ts new file mode 100644 index 0000000000000000000000000000000000000000..7df92e87028e0f259d4dda55f56757fb06dcd58f --- /dev/null +++ b/backend/node_modules/effect/src/internal/metric/pair.ts @@ -0,0 +1,48 @@ +import type * as MetricKey from "../../MetricKey.js" +import type * as MetricKeyType from "../../MetricKeyType.js" +import type * as MetricPair from "../../MetricPair.js" +import type * as MetricState from "../../MetricState.js" +import { pipeArguments } from "../../Pipeable.js" + +/** @internal */ +const MetricPairSymbolKey = "effect/MetricPair" + +/** @internal */ +export const MetricPairTypeId: MetricPair.MetricPairTypeId = Symbol.for( + MetricPairSymbolKey +) as MetricPair.MetricPairTypeId + +const metricPairVariance = { + /* c8 ignore next */ + _Type: (_: never) => _ +} + +/** @internal */ +export const make = >( + metricKey: MetricKey.MetricKey, + metricState: MetricState.MetricState> +): MetricPair.MetricPair.Untyped => { + return { + [MetricPairTypeId]: metricPairVariance, + metricKey, + metricState, + pipe() { + return pipeArguments(this, arguments) + } + } +} + +/** @internal */ +export const unsafeMake = >( + metricKey: MetricKey.MetricKey, + metricState: MetricState.MetricState.Untyped +): MetricPair.MetricPair.Untyped => { + return { + [MetricPairTypeId]: metricPairVariance, + metricKey, + metricState, + pipe() { + return pipeArguments(this, arguments) + } + } +} diff --git a/backend/node_modules/effect/src/internal/metric/polling.ts b/backend/node_modules/effect/src/internal/metric/polling.ts new file mode 100644 index 0000000000000000000000000000000000000000..14d489093efe81a23e65a42f1e56d14042915732 --- /dev/null +++ b/backend/node_modules/effect/src/internal/metric/polling.ts @@ -0,0 +1,149 @@ +import type * as Effect from "../../Effect.js" +import type * as Fiber from "../../Fiber.js" +import { dual, pipe } from "../../Function.js" +import type * as Metric from "../../Metric.js" +import type * as MetricPolling from "../../MetricPolling.js" +import { pipeArguments } from "../../Pipeable.js" +import type * as Schedule from "../../Schedule.js" +import type * as Scope from "../../Scope.js" +import * as core from "../core.js" +import * as metric from "../metric.js" +import * as schedule_ from "../schedule.js" + +/** @internal */ +const MetricPollingSymbolKey = "effect/MetricPolling" + +/** @internal */ +export const MetricPollingTypeId: MetricPolling.MetricPollingTypeId = Symbol.for( + MetricPollingSymbolKey +) as MetricPolling.MetricPollingTypeId + +/** @internal */ +export const make = ( + metric: Metric.Metric, + poll: Effect.Effect +): MetricPolling.MetricPolling => { + return { + [MetricPollingTypeId]: MetricPollingTypeId, + pipe() { + return pipeArguments(this, arguments) + }, + metric, + poll + } +} + +/** @internal */ +export const collectAll = ( + iterable: Iterable> +): MetricPolling.MetricPolling, Array, R, E, Array> => { + const metrics = Array.from(iterable) + return { + [MetricPollingTypeId]: MetricPollingTypeId, + pipe() { + return pipeArguments(this, arguments) + }, + metric: metric.make( + Array.of(void 0) as Array, + (inputs: Array, extraTags) => { + for (let i = 0; i < inputs.length; i++) { + const pollingMetric = metrics[i]! + const input = pipe(inputs, (x) => x[i]) + pollingMetric.metric.unsafeUpdate(input, extraTags) + } + }, + (extraTags) => + Array.from( + metrics.map((pollingMetric) => pollingMetric.metric.unsafeValue(extraTags)) + ), + (inputs: Array, extraTags) => { + for (let i = 0; i < inputs.length; i++) { + const pollingMetric = metrics[i]! + const input = pipe(inputs, (x) => x[i]) + pollingMetric.metric.unsafeModify(input, extraTags) + } + } + ), + poll: core.forEachSequential(metrics, (metric) => metric.poll) + } +} + +/** @internal */ +export const launch = dual< + ( + schedule: Schedule.Schedule + ) => ( + self: MetricPolling.MetricPolling + ) => Effect.Effect, never, R | R2 | Scope.Scope>, + ( + self: MetricPolling.MetricPolling, + schedule: Schedule.Schedule + ) => Effect.Effect, never, R | R2 | Scope.Scope> +>(2, (self, schedule) => + pipe( + pollAndUpdate(self), + core.zipRight(metric.value(self.metric)), + schedule_.scheduleForked(schedule) + )) + +/** @internal */ +export const poll = ( + self: MetricPolling.MetricPolling +): Effect.Effect => self.poll + +/** @internal */ +export const pollAndUpdate = ( + self: MetricPolling.MetricPolling +): Effect.Effect => core.flatMap(self.poll, (value) => metric.update(self.metric, value)) + +/** @internal */ +export const retry = dual< + ( + policy: Schedule.Schedule + ) => ( + self: MetricPolling.MetricPolling + ) => MetricPolling.MetricPolling, + ( + self: MetricPolling.MetricPolling, + policy: Schedule.Schedule + ) => MetricPolling.MetricPolling +>(2, (self, policy) => ({ + [MetricPollingTypeId]: MetricPollingTypeId, + pipe() { + return pipeArguments(this, arguments) + }, + metric: self.metric, + poll: schedule_.retry_Effect(self.poll, policy) +})) + +/** @internal */ +export const zip = dual< + ( + that: MetricPolling.MetricPolling + ) => ( + self: MetricPolling.MetricPolling + ) => MetricPolling.MetricPolling< + readonly [Type, Type2], + readonly [In, In2], + R | R2, + E | E2, + [Out, Out2] + >, + ( + self: MetricPolling.MetricPolling, + that: MetricPolling.MetricPolling + ) => MetricPolling.MetricPolling< + readonly [Type, Type2], + readonly [In, In2], + R | R2, + E | E2, + [Out, Out2] + > +>(2, (self, that) => ({ + [MetricPollingTypeId]: MetricPollingTypeId, + pipe() { + return pipeArguments(this, arguments) + }, + metric: pipe(self.metric, metric.zip(that.metric)), + poll: core.zip(self.poll, that.poll) +})) diff --git a/backend/node_modules/effect/src/internal/metric/state.ts b/backend/node_modules/effect/src/internal/metric/state.ts new file mode 100644 index 0000000000000000000000000000000000000000..aff36216c50d4e4d2ad4d831025cc776c4abb181 --- /dev/null +++ b/backend/node_modules/effect/src/internal/metric/state.ts @@ -0,0 +1,290 @@ +import * as Arr from "../../Array.js" +import * as Equal from "../../Equal.js" +import { pipe } from "../../Function.js" +import * as Hash from "../../Hash.js" +import type * as MetricState from "../../MetricState.js" +import type * as Option from "../../Option.js" +import { pipeArguments } from "../../Pipeable.js" +import { hasProperty } from "../../Predicate.js" + +/** @internal */ +const MetricStateSymbolKey = "effect/MetricState" + +/** @internal */ +export const MetricStateTypeId: MetricState.MetricStateTypeId = Symbol.for( + MetricStateSymbolKey +) as MetricState.MetricStateTypeId + +/** @internal */ +const CounterStateSymbolKey = "effect/MetricState/Counter" + +/** @internal */ +export const CounterStateTypeId: MetricState.CounterStateTypeId = Symbol.for( + CounterStateSymbolKey +) as MetricState.CounterStateTypeId + +/** @internal */ +const FrequencyStateSymbolKey = "effect/MetricState/Frequency" + +/** @internal */ +export const FrequencyStateTypeId: MetricState.FrequencyStateTypeId = Symbol.for( + FrequencyStateSymbolKey +) as MetricState.FrequencyStateTypeId + +/** @internal */ +const GaugeStateSymbolKey = "effect/MetricState/Gauge" + +/** @internal */ +export const GaugeStateTypeId: MetricState.GaugeStateTypeId = Symbol.for( + GaugeStateSymbolKey +) as MetricState.GaugeStateTypeId + +/** @internal */ +const HistogramStateSymbolKey = "effect/MetricState/Histogram" + +/** @internal */ +export const HistogramStateTypeId: MetricState.HistogramStateTypeId = Symbol.for( + HistogramStateSymbolKey +) as MetricState.HistogramStateTypeId + +/** @internal */ +const SummaryStateSymbolKey = "effect/MetricState/Summary" + +/** @internal */ +export const SummaryStateTypeId: MetricState.SummaryStateTypeId = Symbol.for( + SummaryStateSymbolKey +) as MetricState.SummaryStateTypeId + +const metricStateVariance = { + /* c8 ignore next */ + _A: (_: unknown) => _ +} + +/** @internal */ +class CounterState implements MetricState.MetricState.Counter { + readonly [MetricStateTypeId] = metricStateVariance + readonly [CounterStateTypeId]: MetricState.CounterStateTypeId = CounterStateTypeId + constructor(readonly count: A) {} + [Hash.symbol](): number { + return pipe( + Hash.hash(CounterStateSymbolKey), + Hash.combine(Hash.hash(this.count)), + Hash.cached(this) + ) + } + [Equal.symbol](that: unknown): boolean { + return isCounterState(that) && this.count === that.count + } + pipe() { + return pipeArguments(this, arguments) + } +} + +const arrayEquals = Arr.getEquivalence(Equal.equals) + +/** @internal */ +class FrequencyState implements MetricState.MetricState.Frequency { + readonly [MetricStateTypeId] = metricStateVariance + readonly [FrequencyStateTypeId]: MetricState.FrequencyStateTypeId = FrequencyStateTypeId + constructor(readonly occurrences: ReadonlyMap) {} + _hash: number | undefined; + [Hash.symbol](): number { + return pipe( + Hash.string(FrequencyStateSymbolKey), + Hash.combine(Hash.array(Arr.fromIterable(this.occurrences.entries()))), + Hash.cached(this) + ) + } + [Equal.symbol](that: unknown): boolean { + return isFrequencyState(that) && arrayEquals( + Arr.fromIterable(this.occurrences.entries()), + Arr.fromIterable(that.occurrences.entries()) + ) + } + pipe() { + return pipeArguments(this, arguments) + } +} + +/** @internal */ +class GaugeState implements MetricState.MetricState.Gauge { + readonly [MetricStateTypeId] = metricStateVariance + readonly [GaugeStateTypeId]: MetricState.GaugeStateTypeId = GaugeStateTypeId + constructor(readonly value: A) {} + [Hash.symbol](): number { + return pipe( + Hash.hash(GaugeStateSymbolKey), + Hash.combine(Hash.hash(this.value)), + Hash.cached(this) + ) + } + [Equal.symbol](u: unknown): boolean { + return isGaugeState(u) && this.value === u.value + } + pipe() { + return pipeArguments(this, arguments) + } +} + +/** @internal */ +export class HistogramState implements MetricState.MetricState.Histogram { + readonly [MetricStateTypeId] = metricStateVariance + readonly [HistogramStateTypeId]: MetricState.HistogramStateTypeId = HistogramStateTypeId + constructor( + readonly buckets: ReadonlyArray, + readonly count: number, + readonly min: number, + readonly max: number, + readonly sum: number + ) {} + [Hash.symbol](): number { + return pipe( + Hash.hash(HistogramStateSymbolKey), + Hash.combine(Hash.hash(this.buckets)), + Hash.combine(Hash.hash(this.count)), + Hash.combine(Hash.hash(this.min)), + Hash.combine(Hash.hash(this.max)), + Hash.combine(Hash.hash(this.sum)), + Hash.cached(this) + ) + } + [Equal.symbol](that: unknown): boolean { + return isHistogramState(that) && + Equal.equals(this.buckets, that.buckets) && + this.count === that.count && + this.min === that.min && + this.max === that.max && + this.sum === that.sum + } + pipe() { + return pipeArguments(this, arguments) + } +} + +/** @internal */ +export class SummaryState implements MetricState.MetricState.Summary { + readonly [MetricStateTypeId] = metricStateVariance + readonly [SummaryStateTypeId]: MetricState.SummaryStateTypeId = SummaryStateTypeId + constructor( + readonly error: number, + readonly quantiles: ReadonlyArray]>, + readonly count: number, + readonly min: number, + readonly max: number, + readonly sum: number + ) {} + [Hash.symbol](): number { + return pipe( + Hash.hash(SummaryStateSymbolKey), + Hash.combine(Hash.hash(this.error)), + Hash.combine(Hash.hash(this.quantiles)), + Hash.combine(Hash.hash(this.count)), + Hash.combine(Hash.hash(this.min)), + Hash.combine(Hash.hash(this.max)), + Hash.combine(Hash.hash(this.sum)), + Hash.cached(this) + ) + } + [Equal.symbol](that: unknown): boolean { + return isSummaryState(that) && + this.error === that.error && + Equal.equals(this.quantiles, that.quantiles) && + this.count === that.count && + this.min === that.min && + this.max === that.max && + this.sum === that.sum + } + pipe() { + return pipeArguments(this, arguments) + } +} + +/** @internal */ +export const counter: { + (count: number): MetricState.MetricState.Counter + (count: bigint): MetricState.MetricState.Counter +} = (count) => new CounterState(count) as any + +/** @internal */ +export const frequency = (occurrences: ReadonlyMap): MetricState.MetricState.Frequency => { + return new FrequencyState(occurrences) +} + +/** @internal */ +export const gauge: { + (count: number): MetricState.MetricState.Gauge + (count: bigint): MetricState.MetricState.Gauge +} = (count) => new GaugeState(count) as any + +/** @internal */ +export const histogram = ( + options: { + readonly buckets: ReadonlyArray + readonly count: number + readonly min: number + readonly max: number + readonly sum: number + } +): MetricState.MetricState.Histogram => + new HistogramState( + options.buckets, + options.count, + options.min, + options.max, + options.sum + ) + +/** @internal */ +export const summary = ( + options: { + readonly error: number + readonly quantiles: ReadonlyArray]> + readonly count: number + readonly min: number + readonly max: number + readonly sum: number + } +): MetricState.MetricState.Summary => + new SummaryState( + options.error, + options.quantiles, + options.count, + options.min, + options.max, + options.sum + ) + +/** @internal */ +export const isMetricState = (u: unknown): u is MetricState.MetricState.Counter => + hasProperty(u, MetricStateTypeId) + +/** @internal */ +export const isCounterState = (u: unknown): u is MetricState.MetricState.Counter => + hasProperty(u, CounterStateTypeId) + +/** + * @since 2.0.0 + * @category refinements + */ +export const isFrequencyState = (u: unknown): u is MetricState.MetricState.Frequency => + hasProperty(u, FrequencyStateTypeId) + +/** + * @since 2.0.0 + * @category refinements + */ +export const isGaugeState = (u: unknown): u is MetricState.MetricState.Gauge => + hasProperty(u, GaugeStateTypeId) + +/** + * @since 2.0.0 + * @category refinements + */ +export const isHistogramState = (u: unknown): u is MetricState.MetricState.Histogram => + hasProperty(u, HistogramStateTypeId) + +/** + * @since 2.0.0 + * @category refinements + */ +export const isSummaryState = (u: unknown): u is MetricState.MetricState.Summary => hasProperty(u, SummaryStateTypeId) diff --git a/backend/node_modules/effect/src/internal/opCodes/channelUpstreamPullStrategy.ts b/backend/node_modules/effect/src/internal/opCodes/channelUpstreamPullStrategy.ts new file mode 100644 index 0000000000000000000000000000000000000000..621c98effc9cc20574c4299a6356c6fcc1ce3ce8 --- /dev/null +++ b/backend/node_modules/effect/src/internal/opCodes/channelUpstreamPullStrategy.ts @@ -0,0 +1,11 @@ +/** @internal */ +export const OP_PULL_AFTER_NEXT = "PullAfterNext" as const + +/** @internal */ +export type OP_PULL_AFTER_NEXT = typeof OP_PULL_AFTER_NEXT + +/** @internal */ +export const OP_PULL_AFTER_ALL_ENQUEUED = "PullAfterAllEnqueued" as const + +/** @internal */ +export type OP_PULL_AFTER_ALL_ENQUEUED = typeof OP_PULL_AFTER_ALL_ENQUEUED diff --git a/backend/node_modules/effect/src/internal/schema/util.ts b/backend/node_modules/effect/src/internal/schema/util.ts new file mode 100644 index 0000000000000000000000000000000000000000..d17bdbda31148f05829d75203162d2b2e543dd26 --- /dev/null +++ b/backend/node_modules/effect/src/internal/schema/util.ts @@ -0,0 +1,50 @@ +import type { NonEmptyReadonlyArray } from "../../Array.js" +import * as Inspectable from "../../Inspectable.js" +import type * as ParseResult from "../../ParseResult.js" +import type * as AST from "../../SchemaAST.js" + +/** @internal */ +export const getKeysForIndexSignature = ( + input: { readonly [x: PropertyKey]: unknown }, + parameter: AST.Parameter +): ReadonlyArray | ReadonlyArray => { + switch (parameter._tag) { + case "StringKeyword": + case "TemplateLiteral": + return Object.keys(input) + case "SymbolKeyword": + return Object.getOwnPropertySymbols(input) + case "Refinement": + return getKeysForIndexSignature(input, parameter.from) + } +} + +/** @internal */ +export const memoizeThunk = (f: () => A): () => A => { + let done = false + let a: A + return () => { + if (done) { + return a + } + a = f() + done = true + return a + } +} + +/** @internal */ +export type SingleOrArray = A | ReadonlyArray + +/** @internal */ +export const isNonEmpty = (x: ParseResult.SingleOrNonEmpty): x is NonEmptyReadonlyArray => Array.isArray(x) + +/** @internal */ +export const isSingle = (x: A | ReadonlyArray): x is A => !Array.isArray(x) + +/** @internal */ +export const formatPathKey = (key: PropertyKey): string => `[${Inspectable.formatPropertyKey(key)}]` + +/** @internal */ +export const formatPath = (path: ParseResult.Path): string => + isNonEmpty(path) ? path.map(formatPathKey).join("") : formatPathKey(path) diff --git a/backend/node_modules/effect/src/internal/supervisor/patch.ts b/backend/node_modules/effect/src/internal/supervisor/patch.ts new file mode 100644 index 0000000000000000000000000000000000000000..1f1a4bd1cf0398c380d4e81608deff8e90175d2b --- /dev/null +++ b/backend/node_modules/effect/src/internal/supervisor/patch.ts @@ -0,0 +1,190 @@ +import * as Chunk from "../../Chunk.js" +import * as Differ from "../../Differ.js" +import * as Equal from "../../Equal.js" +import { pipe } from "../../Function.js" +import * as HashSet from "../../HashSet.js" +import type * as Supervisor from "../../Supervisor.js" +import * as supervisor from "../supervisor.js" + +/** @internal */ +export type SupervisorPatch = Empty | AddSupervisor | RemoveSupervisor | AndThen + +/** @internal */ +export const OP_EMPTY = "Empty" as const + +/** @internal */ +export type OP_EMPTY = typeof OP_EMPTY + +/** @internal */ +export const OP_ADD_SUPERVISOR = "AddSupervisor" as const + +/** @internal */ +export type OP_ADD_SUPERVISOR = typeof OP_ADD_SUPERVISOR + +/** @internal */ +export const OP_REMOVE_SUPERVISOR = "RemoveSupervisor" as const + +/** @internal */ +export type OP_REMOVE_SUPERVISOR = typeof OP_REMOVE_SUPERVISOR + +/** @internal */ +export const OP_AND_THEN = "AndThen" as const + +/** @internal */ +export type OP_AND_THEN = typeof OP_AND_THEN + +/** @internal */ +export interface Empty { + readonly _tag: OP_EMPTY +} + +/** @internal */ +export interface AddSupervisor { + readonly _tag: OP_ADD_SUPERVISOR + readonly supervisor: Supervisor.Supervisor +} + +/** @internal */ +export interface RemoveSupervisor { + readonly _tag: OP_REMOVE_SUPERVISOR + readonly supervisor: Supervisor.Supervisor +} + +/** @internal */ +export interface AndThen { + readonly _tag: OP_AND_THEN + readonly first: SupervisorPatch + readonly second: SupervisorPatch +} + +/** + * The empty `SupervisorPatch`. + * + * @internal + */ +export const empty: SupervisorPatch = { _tag: OP_EMPTY } + +/** + * Combines two patches to produce a new patch that describes applying the + * updates from this patch and then the updates from the specified patch. + * + * @internal + */ +export const combine = (self: SupervisorPatch, that: SupervisorPatch): SupervisorPatch => { + return { + _tag: OP_AND_THEN, + first: self, + second: that + } +} + +/** + * Applies a `SupervisorPatch` to a `Supervisor` to produce a new `Supervisor`. + * + * @internal + */ +export const patch = ( + self: SupervisorPatch, + supervisor: Supervisor.Supervisor +): Supervisor.Supervisor => { + return patchLoop(supervisor, Chunk.of(self)) +} + +/** @internal */ +const patchLoop = ( + _supervisor: Supervisor.Supervisor, + _patches: Chunk.Chunk +): Supervisor.Supervisor => { + let supervisor = _supervisor + let patches = _patches + while (Chunk.isNonEmpty(patches)) { + const head = Chunk.headNonEmpty(patches) + switch (head._tag) { + case OP_EMPTY: { + patches = Chunk.tailNonEmpty(patches) + break + } + case OP_ADD_SUPERVISOR: { + supervisor = supervisor.zip(head.supervisor) + patches = Chunk.tailNonEmpty(patches) + break + } + case OP_REMOVE_SUPERVISOR: { + supervisor = removeSupervisor(supervisor, head.supervisor) + patches = Chunk.tailNonEmpty(patches) + break + } + case OP_AND_THEN: { + patches = Chunk.prepend(head.first)(Chunk.prepend(head.second)(Chunk.tailNonEmpty(patches))) + break + } + } + } + return supervisor +} + +/** @internal */ +const removeSupervisor = ( + self: Supervisor.Supervisor, + that: Supervisor.Supervisor +): Supervisor.Supervisor => { + if (Equal.equals(self, that)) { + return supervisor.none + } else { + if (supervisor.isZip(self)) { + return removeSupervisor(self.left, that).zip(removeSupervisor(self.right, that)) + } else { + return self + } + } +} + +/** @internal */ +const toSet = (self: Supervisor.Supervisor): HashSet.HashSet> => { + if (Equal.equals(self, supervisor.none)) { + return HashSet.empty() + } else { + if (supervisor.isZip(self)) { + return pipe(toSet(self.left), HashSet.union(toSet(self.right))) + } else { + return HashSet.make(self) + } + } +} + +/** @internal */ +export const diff = ( + oldValue: Supervisor.Supervisor, + newValue: Supervisor.Supervisor +): SupervisorPatch => { + if (Equal.equals(oldValue, newValue)) { + return empty + } + const oldSupervisors = toSet(oldValue) + const newSupervisors = toSet(newValue) + const added = pipe( + newSupervisors, + HashSet.difference(oldSupervisors), + HashSet.reduce( + empty as SupervisorPatch, + (patch, supervisor) => combine(patch, { _tag: OP_ADD_SUPERVISOR, supervisor }) + ) + ) + const removed = pipe( + oldSupervisors, + HashSet.difference(newSupervisors), + HashSet.reduce( + empty as SupervisorPatch, + (patch, supervisor) => combine(patch, { _tag: OP_REMOVE_SUPERVISOR, supervisor }) + ) + ) + return combine(added, removed) +} + +/** @internal */ +export const differ = Differ.make, SupervisorPatch>({ + empty, + patch, + combine, + diff +}) diff --git a/backend/node_modules/perfect-debounce/dist/index.cjs b/backend/node_modules/perfect-debounce/dist/index.cjs new file mode 100644 index 0000000000000000000000000000000000000000..1ccc156af3affec30678d4c7d55194e4827409bb --- /dev/null +++ b/backend/node_modules/perfect-debounce/dist/index.cjs @@ -0,0 +1,59 @@ +'use strict'; + +const DEBOUNCE_DEFAULTS = { + trailing: true +}; +function debounce(fn, wait = 25, options = {}) { + options = { ...DEBOUNCE_DEFAULTS, ...options }; + if (!Number.isFinite(wait)) { + throw new TypeError("Expected `wait` to be a finite number"); + } + let leadingValue; + let timeout; + let resolveList = []; + let currentPromise; + let trailingArgs; + const applyFn = (_this, args) => { + currentPromise = _applyPromised(fn, _this, args); + currentPromise.finally(() => { + currentPromise = null; + if (options.trailing && trailingArgs && !timeout) { + const promise = applyFn(_this, trailingArgs); + trailingArgs = null; + return promise; + } + }); + return currentPromise; + }; + return function(...args) { + if (currentPromise) { + if (options.trailing) { + trailingArgs = args; + } + return currentPromise; + } + return new Promise((resolve) => { + const shouldCallNow = !timeout && options.leading; + clearTimeout(timeout); + timeout = setTimeout(() => { + timeout = null; + const promise = options.leading ? leadingValue : applyFn(this, args); + for (const _resolve of resolveList) { + _resolve(promise); + } + resolveList = []; + }, wait); + if (shouldCallNow) { + leadingValue = applyFn(this, args); + resolve(leadingValue); + } else { + resolveList.push(resolve); + } + }); + }; +} +async function _applyPromised(fn, _this, args) { + return await fn.apply(_this, args); +} + +exports.debounce = debounce; diff --git a/backend/node_modules/perfect-debounce/dist/index.d.ts b/backend/node_modules/perfect-debounce/dist/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..68242f930dfd27a0d65e2be9e08695afaee5f6da --- /dev/null +++ b/backend/node_modules/perfect-debounce/dist/index.d.ts @@ -0,0 +1,34 @@ +interface DebounceOptions { + /** + Call the `fn` on the [leading edge of the timeout](https://css-tricks.com/debouncing-throttling-explained-examples/#article-header-id-1). + Meaning immediately, instead of waiting for `wait` milliseconds. + @default false + */ + readonly leading?: boolean; + /** + Call the `fn` on trailing edge with last used arguments. Result of call is from previous call. + @default false + */ + readonly trailing?: boolean; +} +/** +Debounce functions +@param fn - Promise-returning/async function to debounce. +@param wait - Milliseconds to wait before calling `fn`. Default value is 25ms +@returns A function that delays calling `fn` until after `wait` milliseconds have elapsed since the last time it was called. +@example +``` +import { debounce } from 'perfect-debounce'; +const expensiveCall = async input => input; +const debouncedFn = debounce(expensiveCall, 200); +for (const number of [1, 2, 3]) { + console.log(await debouncedFn(number)); +} +//=> 3 +//=> 3 +//=> 3 +``` +*/ +declare function debounce(fn: (...args: ArgumentsT) => PromiseLike | ReturnT, wait?: number, options?: DebounceOptions): (...args: ArgumentsT) => Promise; + +export { DebounceOptions, debounce }; diff --git a/backend/node_modules/perfect-debounce/dist/index.mjs b/backend/node_modules/perfect-debounce/dist/index.mjs new file mode 100644 index 0000000000000000000000000000000000000000..6496a9bdfeaceb149c4643060b18709564b75620 --- /dev/null +++ b/backend/node_modules/perfect-debounce/dist/index.mjs @@ -0,0 +1,57 @@ +const DEBOUNCE_DEFAULTS = { + trailing: true +}; +function debounce(fn, wait = 25, options = {}) { + options = { ...DEBOUNCE_DEFAULTS, ...options }; + if (!Number.isFinite(wait)) { + throw new TypeError("Expected `wait` to be a finite number"); + } + let leadingValue; + let timeout; + let resolveList = []; + let currentPromise; + let trailingArgs; + const applyFn = (_this, args) => { + currentPromise = _applyPromised(fn, _this, args); + currentPromise.finally(() => { + currentPromise = null; + if (options.trailing && trailingArgs && !timeout) { + const promise = applyFn(_this, trailingArgs); + trailingArgs = null; + return promise; + } + }); + return currentPromise; + }; + return function(...args) { + if (currentPromise) { + if (options.trailing) { + trailingArgs = args; + } + return currentPromise; + } + return new Promise((resolve) => { + const shouldCallNow = !timeout && options.leading; + clearTimeout(timeout); + timeout = setTimeout(() => { + timeout = null; + const promise = options.leading ? leadingValue : applyFn(this, args); + for (const _resolve of resolveList) { + _resolve(promise); + } + resolveList = []; + }, wait); + if (shouldCallNow) { + leadingValue = applyFn(this, args); + resolve(leadingValue); + } else { + resolveList.push(resolve); + } + }); + }; +} +async function _applyPromised(fn, _this, args) { + return await fn.apply(_this, args); +} + +export { debounce }; diff --git a/backend/node_modules/prisma/build/child.js b/backend/node_modules/prisma/build/child.js new file mode 100644 index 0000000000000000000000000000000000000000..3aab50fffddde658435fc00bf602169f56d86cfa --- /dev/null +++ b/backend/node_modules/prisma/build/child.js @@ -0,0 +1,82915 @@ +'use strict'; + +var require$$0 = require('fs'); +var path$2 = require('path'); +var require$$2 = require('util'); +var fs$1 = require('fs/promises'); +var require$$1$1 = require('os'); +var crypto = require('crypto'); +var Stream = require('stream'); +var http = require('http'); +var Url = require('url'); +var require$$0$1 = require('punycode'); +var https = require('https'); +var zlib = require('zlib'); + +function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; } + +var require$$0__default = /*#__PURE__*/_interopDefaultLegacy(require$$0); +var path__default = /*#__PURE__*/_interopDefaultLegacy(path$2); +var require$$2__default = /*#__PURE__*/_interopDefaultLegacy(require$$2); +var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs$1); +var require$$1__default = /*#__PURE__*/_interopDefaultLegacy(require$$1$1); +var crypto__default = /*#__PURE__*/_interopDefaultLegacy(crypto); +var Stream__default = /*#__PURE__*/_interopDefaultLegacy(Stream); +var http__default = /*#__PURE__*/_interopDefaultLegacy(http); +var Url__default = /*#__PURE__*/_interopDefaultLegacy(Url); +var require$$0__default$1 = /*#__PURE__*/_interopDefaultLegacy(require$$0$1); +var https__default = /*#__PURE__*/_interopDefaultLegacy(https); +var zlib__default = /*#__PURE__*/_interopDefaultLegacy(zlib); + +var makeDir$2 = {exports: {}}; + +const debug$1 = ( + typeof process === 'object' && + process.env && + process.env.NODE_DEBUG && + /\bsemver\b/i.test(process.env.NODE_DEBUG) +) ? (...args) => console.error('SEMVER', ...args) + : () => {}; + +var debug_1 = debug$1; + +// Note: this is the semver.org version of the spec that it implements +// Not necessarily the package version of this code. +const SEMVER_SPEC_VERSION = '2.0.0'; + +const MAX_LENGTH$1 = 256; +const MAX_SAFE_INTEGER$1 = Number.MAX_SAFE_INTEGER || +/* istanbul ignore next */ 9007199254740991; + +// Max safe segment length for coercion. +const MAX_SAFE_COMPONENT_LENGTH = 16; + +// Max safe length for a build identifier. The max length minus 6 characters for +// the shortest version with a build 0.0.0+BUILD. +const MAX_SAFE_BUILD_LENGTH = MAX_LENGTH$1 - 6; + +const RELEASE_TYPES = [ + 'major', + 'premajor', + 'minor', + 'preminor', + 'patch', + 'prepatch', + 'prerelease', +]; + +var constants = { + MAX_LENGTH: MAX_LENGTH$1, + MAX_SAFE_COMPONENT_LENGTH, + MAX_SAFE_BUILD_LENGTH, + MAX_SAFE_INTEGER: MAX_SAFE_INTEGER$1, + RELEASE_TYPES, + SEMVER_SPEC_VERSION, + FLAG_INCLUDE_PRERELEASE: 0b001, + FLAG_LOOSE: 0b010, +}; + +var re$1 = {exports: {}}; + +(function (module, exports) { +const { MAX_SAFE_COMPONENT_LENGTH, MAX_SAFE_BUILD_LENGTH } = constants; +const debug = debug_1; +exports = module.exports = {}; + +// The actual regexps go on exports.re +const re = exports.re = []; +const safeRe = exports.safeRe = []; +const src = exports.src = []; +const t = exports.t = {}; +let R = 0; + +const LETTERDASHNUMBER = '[a-zA-Z0-9-]'; + +// Replace some greedy regex tokens to prevent regex dos issues. These regex are +// used internally via the safeRe object since all inputs in this library get +// normalized first to trim and collapse all extra whitespace. The original +// regexes are exported for userland consumption and lower level usage. A +// future breaking change could export the safer regex only with a note that +// all input should have extra whitespace removed. +const safeRegexReplacements = [ + ['\\s', 1], + ['\\d', MAX_SAFE_COMPONENT_LENGTH], + [LETTERDASHNUMBER, MAX_SAFE_BUILD_LENGTH], +]; + +const makeSafeRegex = (value) => { + for (const [token, max] of safeRegexReplacements) { + value = value + .split(`${token}*`).join(`${token}{0,${max}}`) + .split(`${token}+`).join(`${token}{1,${max}}`); + } + return value +}; + +const createToken = (name, value, isGlobal) => { + const safe = makeSafeRegex(value); + const index = R++; + debug(name, index, value); + t[name] = index; + src[index] = value; + re[index] = new RegExp(value, isGlobal ? 'g' : undefined); + safeRe[index] = new RegExp(safe, isGlobal ? 'g' : undefined); +}; + +// The following Regular Expressions can be used for tokenizing, +// validating, and parsing SemVer version strings. + +// ## Numeric Identifier +// A single `0`, or a non-zero digit followed by zero or more digits. + +createToken('NUMERICIDENTIFIER', '0|[1-9]\\d*'); +createToken('NUMERICIDENTIFIERLOOSE', '\\d+'); + +// ## Non-numeric Identifier +// Zero or more digits, followed by a letter or hyphen, and then zero or +// more letters, digits, or hyphens. + +createToken('NONNUMERICIDENTIFIER', `\\d*[a-zA-Z-]${LETTERDASHNUMBER}*`); + +// ## Main Version +// Three dot-separated numeric identifiers. + +createToken('MAINVERSION', `(${src[t.NUMERICIDENTIFIER]})\\.` + + `(${src[t.NUMERICIDENTIFIER]})\\.` + + `(${src[t.NUMERICIDENTIFIER]})`); + +createToken('MAINVERSIONLOOSE', `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.` + + `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.` + + `(${src[t.NUMERICIDENTIFIERLOOSE]})`); + +// ## Pre-release Version Identifier +// A numeric identifier, or a non-numeric identifier. + +createToken('PRERELEASEIDENTIFIER', `(?:${src[t.NUMERICIDENTIFIER] +}|${src[t.NONNUMERICIDENTIFIER]})`); + +createToken('PRERELEASEIDENTIFIERLOOSE', `(?:${src[t.NUMERICIDENTIFIERLOOSE] +}|${src[t.NONNUMERICIDENTIFIER]})`); + +// ## Pre-release Version +// Hyphen, followed by one or more dot-separated pre-release version +// identifiers. + +createToken('PRERELEASE', `(?:-(${src[t.PRERELEASEIDENTIFIER] +}(?:\\.${src[t.PRERELEASEIDENTIFIER]})*))`); + +createToken('PRERELEASELOOSE', `(?:-?(${src[t.PRERELEASEIDENTIFIERLOOSE] +}(?:\\.${src[t.PRERELEASEIDENTIFIERLOOSE]})*))`); + +// ## Build Metadata Identifier +// Any combination of digits, letters, or hyphens. + +createToken('BUILDIDENTIFIER', `${LETTERDASHNUMBER}+`); + +// ## Build Metadata +// Plus sign, followed by one or more period-separated build metadata +// identifiers. + +createToken('BUILD', `(?:\\+(${src[t.BUILDIDENTIFIER] +}(?:\\.${src[t.BUILDIDENTIFIER]})*))`); + +// ## Full Version String +// A main version, followed optionally by a pre-release version and +// build metadata. + +// Note that the only major, minor, patch, and pre-release sections of +// the version string are capturing groups. The build metadata is not a +// capturing group, because it should not ever be used in version +// comparison. + +createToken('FULLPLAIN', `v?${src[t.MAINVERSION] +}${src[t.PRERELEASE]}?${ + src[t.BUILD]}?`); + +createToken('FULL', `^${src[t.FULLPLAIN]}$`); + +// like full, but allows v1.2.3 and =1.2.3, which people do sometimes. +// also, 1.0.0alpha1 (prerelease without the hyphen) which is pretty +// common in the npm registry. +createToken('LOOSEPLAIN', `[v=\\s]*${src[t.MAINVERSIONLOOSE] +}${src[t.PRERELEASELOOSE]}?${ + src[t.BUILD]}?`); + +createToken('LOOSE', `^${src[t.LOOSEPLAIN]}$`); + +createToken('GTLT', '((?:<|>)?=?)'); + +// Something like "2.*" or "1.2.x". +// Note that "x.x" is a valid xRange identifer, meaning "any version" +// Only the first item is strictly required. +createToken('XRANGEIDENTIFIERLOOSE', `${src[t.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`); +createToken('XRANGEIDENTIFIER', `${src[t.NUMERICIDENTIFIER]}|x|X|\\*`); + +createToken('XRANGEPLAIN', `[v=\\s]*(${src[t.XRANGEIDENTIFIER]})` + + `(?:\\.(${src[t.XRANGEIDENTIFIER]})` + + `(?:\\.(${src[t.XRANGEIDENTIFIER]})` + + `(?:${src[t.PRERELEASE]})?${ + src[t.BUILD]}?` + + `)?)?`); + +createToken('XRANGEPLAINLOOSE', `[v=\\s]*(${src[t.XRANGEIDENTIFIERLOOSE]})` + + `(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})` + + `(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})` + + `(?:${src[t.PRERELEASELOOSE]})?${ + src[t.BUILD]}?` + + `)?)?`); + +createToken('XRANGE', `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAIN]}$`); +createToken('XRANGELOOSE', `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAINLOOSE]}$`); + +// Coercion. +// Extract anything that could conceivably be a part of a valid semver +createToken('COERCE', `${'(^|[^\\d])' + + '(\\d{1,'}${MAX_SAFE_COMPONENT_LENGTH}})` + + `(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?` + + `(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?` + + `(?:$|[^\\d])`); +createToken('COERCERTL', src[t.COERCE], true); + +// Tilde ranges. +// Meaning is "reasonably at or greater than" +createToken('LONETILDE', '(?:~>?)'); + +createToken('TILDETRIM', `(\\s*)${src[t.LONETILDE]}\\s+`, true); +exports.tildeTrimReplace = '$1~'; + +createToken('TILDE', `^${src[t.LONETILDE]}${src[t.XRANGEPLAIN]}$`); +createToken('TILDELOOSE', `^${src[t.LONETILDE]}${src[t.XRANGEPLAINLOOSE]}$`); + +// Caret ranges. +// Meaning is "at least and backwards compatible with" +createToken('LONECARET', '(?:\\^)'); + +createToken('CARETTRIM', `(\\s*)${src[t.LONECARET]}\\s+`, true); +exports.caretTrimReplace = '$1^'; + +createToken('CARET', `^${src[t.LONECARET]}${src[t.XRANGEPLAIN]}$`); +createToken('CARETLOOSE', `^${src[t.LONECARET]}${src[t.XRANGEPLAINLOOSE]}$`); + +// A simple gt/lt/eq thing, or just "" to indicate "any version" +createToken('COMPARATORLOOSE', `^${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]})$|^$`); +createToken('COMPARATOR', `^${src[t.GTLT]}\\s*(${src[t.FULLPLAIN]})$|^$`); + +// An expression to strip any whitespace between the gtlt and the thing +// it modifies, so that `> 1.2.3` ==> `>1.2.3` +createToken('COMPARATORTRIM', `(\\s*)${src[t.GTLT] +}\\s*(${src[t.LOOSEPLAIN]}|${src[t.XRANGEPLAIN]})`, true); +exports.comparatorTrimReplace = '$1$2$3'; + +// Something like `1.2.3 - 1.2.4` +// Note that these all use the loose form, because they'll be +// checked against either the strict or loose comparator form +// later. +createToken('HYPHENRANGE', `^\\s*(${src[t.XRANGEPLAIN]})` + + `\\s+-\\s+` + + `(${src[t.XRANGEPLAIN]})` + + `\\s*$`); + +createToken('HYPHENRANGELOOSE', `^\\s*(${src[t.XRANGEPLAINLOOSE]})` + + `\\s+-\\s+` + + `(${src[t.XRANGEPLAINLOOSE]})` + + `\\s*$`); + +// Star ranges basically just allow anything at all. +createToken('STAR', '(<|>)?=?\\s*\\*'); +// >=0.0.0 is like a star +createToken('GTE0', '^\\s*>=\\s*0\\.0\\.0\\s*$'); +createToken('GTE0PRE', '^\\s*>=\\s*0\\.0\\.0-0\\s*$'); +}(re$1, re$1.exports)); + +// parse out just the options we care about +const looseOption = Object.freeze({ loose: true }); +const emptyOpts = Object.freeze({ }); +const parseOptions$1 = options => { + if (!options) { + return emptyOpts + } + + if (typeof options !== 'object') { + return looseOption + } + + return options +}; +var parseOptions_1 = parseOptions$1; + +const numeric = /^[0-9]+$/; +const compareIdentifiers$1 = (a, b) => { + const anum = numeric.test(a); + const 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 +}; + +const rcompareIdentifiers = (a, b) => compareIdentifiers$1(b, a); + +var identifiers = { + compareIdentifiers: compareIdentifiers$1, + rcompareIdentifiers, +}; + +const debug = debug_1; +const { MAX_LENGTH, MAX_SAFE_INTEGER } = constants; +const { safeRe: re, t } = re$1.exports; + +const parseOptions = parseOptions_1; +const { compareIdentifiers } = identifiers; +class SemVer$1 { + constructor (version, options) { + options = parseOptions(options); + + if (version instanceof SemVer$1) { + if (version.loose === !!options.loose && + version.includePrerelease === !!options.includePrerelease) { + return version + } else { + version = version.version; + } + } else if (typeof version !== 'string') { + throw new TypeError(`Invalid version. Must be a string. Got type "${typeof version}".`) + } + + if (version.length > MAX_LENGTH) { + throw new TypeError( + `version is longer than ${MAX_LENGTH} characters` + ) + } + + debug('SemVer', version, options); + this.options = options; + this.loose = !!options.loose; + // this isn't actually relevant for versions, but keep it so that we + // don't run into trouble passing this.options around. + this.includePrerelease = !!options.includePrerelease; + + const m = version.trim().match(options.loose ? re[t.LOOSE] : re[t.FULL]); + + if (!m) { + throw new TypeError(`Invalid Version: ${version}`) + } + + this.raw = version; + + // these are actually numbers + 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') + } + + // numberify any prerelease numeric ids + if (!m[4]) { + this.prerelease = []; + } else { + this.prerelease = m[4].split('.').map((id) => { + if (/^[0-9]+$/.test(id)) { + const num = +id; + if (num >= 0 && num < MAX_SAFE_INTEGER) { + return num + } + } + return id + }); + } + + this.build = m[5] ? m[5].split('.') : []; + this.format(); + } + + format () { + this.version = `${this.major}.${this.minor}.${this.patch}`; + if (this.prerelease.length) { + this.version += `-${this.prerelease.join('.')}`; + } + return this.version + } + + toString () { + return this.version + } + + compare (other) { + debug('SemVer.compare', this.version, this.options, other); + if (!(other instanceof SemVer$1)) { + if (typeof other === 'string' && other === this.version) { + return 0 + } + other = new SemVer$1(other, this.options); + } + + if (other.version === this.version) { + return 0 + } + + return this.compareMain(other) || this.comparePre(other) + } + + compareMain (other) { + if (!(other instanceof SemVer$1)) { + other = new SemVer$1(other, this.options); + } + + return ( + compareIdentifiers(this.major, other.major) || + compareIdentifiers(this.minor, other.minor) || + compareIdentifiers(this.patch, other.patch) + ) + } + + comparePre (other) { + if (!(other instanceof SemVer$1)) { + other = new SemVer$1(other, this.options); + } + + // NOT having a prerelease is > having one + 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 + } + + let i = 0; + do { + const a = this.prerelease[i]; + const b = other.prerelease[i]; + debug('prerelease compare', i, a, b); + if (a === undefined && b === undefined) { + return 0 + } else if (b === undefined) { + return 1 + } else if (a === undefined) { + return -1 + } else if (a === b) { + continue + } else { + return compareIdentifiers(a, b) + } + } while (++i) + } + + compareBuild (other) { + if (!(other instanceof SemVer$1)) { + other = new SemVer$1(other, this.options); + } + + let i = 0; + do { + const a = this.build[i]; + const b = other.build[i]; + debug('prerelease compare', i, a, b); + if (a === undefined && b === undefined) { + return 0 + } else if (b === undefined) { + return 1 + } else if (a === undefined) { + return -1 + } else if (a === b) { + continue + } else { + return compareIdentifiers(a, b) + } + } while (++i) + } + + // preminor will bump the version up to the next minor release, and immediately + // down to pre-release. premajor and prepatch work the same way. + inc (release, identifier, identifierBase) { + switch (release) { + case 'premajor': + this.prerelease.length = 0; + this.patch = 0; + this.minor = 0; + this.major++; + this.inc('pre', identifier, identifierBase); + break + case 'preminor': + this.prerelease.length = 0; + this.patch = 0; + this.minor++; + this.inc('pre', identifier, identifierBase); + break + case 'prepatch': + // If this is already a prerelease, it will bump to the next version + // drop any prereleases that might already exist, since they are not + // relevant at this point. + this.prerelease.length = 0; + this.inc('patch', identifier, identifierBase); + this.inc('pre', identifier, identifierBase); + break + // If the input is a non-prerelease version, this acts the same as + // prepatch. + case 'prerelease': + if (this.prerelease.length === 0) { + this.inc('patch', identifier, identifierBase); + } + this.inc('pre', identifier, identifierBase); + break + + case 'major': + // If this is a pre-major version, bump up to the same major version. + // Otherwise increment major. + // 1.0.0-5 bumps to 1.0.0 + // 1.1.0 bumps to 2.0.0 + 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 is a pre-minor version, bump up to the same minor version. + // Otherwise increment minor. + // 1.2.0-5 bumps to 1.2.0 + // 1.2.1 bumps to 1.3.0 + if (this.patch !== 0 || this.prerelease.length === 0) { + this.minor++; + } + this.patch = 0; + this.prerelease = []; + break + case 'patch': + // If this is not a pre-release version, it will increment the patch. + // If it is a pre-release it will bump up to the same patch version. + // 1.2.0-5 patches to 1.2.0 + // 1.2.0 patches to 1.2.1 + if (this.prerelease.length === 0) { + this.patch++; + } + this.prerelease = []; + break + // This probably shouldn't be used publicly. + // 1.0.0 'pre' would become 1.0.0-0 which is the wrong direction. + case 'pre': { + const base = Number(identifierBase) ? 1 : 0; + + if (!identifier && identifierBase === false) { + throw new Error('invalid increment argument: identifier is empty') + } + + if (this.prerelease.length === 0) { + this.prerelease = [base]; + } else { + let i = this.prerelease.length; + while (--i >= 0) { + if (typeof this.prerelease[i] === 'number') { + this.prerelease[i]++; + i = -2; + } + } + if (i === -1) { + // didn't increment anything + if (identifier === this.prerelease.join('.') && identifierBase === false) { + throw new Error('invalid increment argument: identifier already exists') + } + this.prerelease.push(base); + } + } + if (identifier) { + // 1.2.0-beta.1 bumps to 1.2.0-beta.2, + // 1.2.0-beta.fooblz or 1.2.0-beta bumps to 1.2.0-beta.0 + let prerelease = [identifier, base]; + if (identifierBase === false) { + prerelease = [identifier]; + } + if (compareIdentifiers(this.prerelease[0], identifier) === 0) { + if (isNaN(this.prerelease[1])) { + this.prerelease = prerelease; + } + } else { + this.prerelease = prerelease; + } + } + break + } + default: + throw new Error(`invalid increment argument: ${release}`) + } + this.raw = this.format(); + if (this.build.length) { + this.raw += `+${this.build.join('.')}`; + } + return this + } +} + +var semver = SemVer$1; + +const SemVer = semver; +const compare$1 = (a, b, loose) => + new SemVer(a, loose).compare(new SemVer(b, loose)); + +var compare_1 = compare$1; + +const compare = compare_1; +const gte = (a, b, loose) => compare(a, b, loose) >= 0; +var gte_1 = gte; + +const fs = require$$0__default["default"]; +const path$1 = path__default["default"]; +const {promisify} = require$$2__default["default"]; +const semverGte = gte_1; + +const useNativeRecursiveOption = semverGte(process.version, '10.12.0'); + +// https://github.com/nodejs/node/issues/8987 +// https://github.com/libuv/libuv/pull/1088 +const checkPath = pth => { + if (process.platform === 'win32') { + const pathHasInvalidWinCharacters = /[<>:"|?*]/.test(pth.replace(path$1.parse(pth).root, '')); + + if (pathHasInvalidWinCharacters) { + const error = new Error(`Path contains invalid characters: ${pth}`); + error.code = 'EINVAL'; + throw error; + } + } +}; + +const processOptions = options => { + const defaults = { + mode: 0o777, + fs + }; + + return { + ...defaults, + ...options + }; +}; + +const permissionError = pth => { + // This replicates the exception of `fs.mkdir` with native the + // `recusive` option when run on an invalid drive under Windows. + const error = new Error(`operation not permitted, mkdir '${pth}'`); + error.code = 'EPERM'; + error.errno = -4048; + error.path = pth; + error.syscall = 'mkdir'; + return error; +}; + +const makeDir = async (input, options) => { + checkPath(input); + options = processOptions(options); + + const mkdir = promisify(options.fs.mkdir); + const stat = promisify(options.fs.stat); + + if (useNativeRecursiveOption && options.fs.mkdir === fs.mkdir) { + const pth = path$1.resolve(input); + + await mkdir(pth, { + mode: options.mode, + recursive: true + }); + + return pth; + } + + const make = async pth => { + try { + await mkdir(pth, options.mode); + + return pth; + } catch (error) { + if (error.code === 'EPERM') { + throw error; + } + + if (error.code === 'ENOENT') { + if (path$1.dirname(pth) === pth) { + throw permissionError(pth); + } + + if (error.message.includes('null bytes')) { + throw error; + } + + await make(path$1.dirname(pth)); + + return make(pth); + } + + try { + const stats = await stat(pth); + if (!stats.isDirectory()) { + throw new Error('The path is not a directory'); + } + } catch { + throw error; + } + + return pth; + } + }; + + return make(path$1.resolve(input)); +}; + +makeDir$2.exports = makeDir; + +makeDir$2.exports.sync = (input, options) => { + checkPath(input); + options = processOptions(options); + + if (useNativeRecursiveOption && options.fs.mkdirSync === fs.mkdirSync) { + const pth = path$1.resolve(input); + + fs.mkdirSync(pth, { + mode: options.mode, + recursive: true + }); + + return pth; + } + + const make = pth => { + try { + options.fs.mkdirSync(pth, options.mode); + } catch (error) { + if (error.code === 'EPERM') { + throw error; + } + + if (error.code === 'ENOENT') { + if (path$1.dirname(pth) === pth) { + throw permissionError(pth); + } + + if (error.message.includes('null bytes')) { + throw error; + } + + make(path$1.dirname(pth)); + return make(pth); + } + + try { + if (!options.fs.statSync(pth).isDirectory()) { + throw new Error('The path is not a directory'); + } + } catch { + throw error; + } + } + + return pth; + }; + + return make(path$1.resolve(input)); +}; + +var makeDir$1 = makeDir$2.exports; + +// U is the subset of T, not sure why +// this works or why _T is necessary + + + + + + + + + + +// valid default schema +const defaultSchema = { + last_reminder: 0, + cached_at: 0, + version: '', + cli_path: '', + // User output + output: { + client_event_id: '', + previous_client_event_id: '', + product: '', + cli_path_hash: '', + local_timestamp: '', + previous_version: '', + current_version: '', + current_release_date: 0, + current_download_url: '', + current_changelog_url: '', + package: '', + release_tag: '', + install_command: '', + project_website: '', + outdated: false, + alerts: [], + }, +}; + +// initialize the configuration +class Config { + static async new(state, schema = defaultSchema) { + await makeDir$1(path__default["default"].dirname(state.cache_file)); + return new Config(state, schema) + } + + constructor( state, defaultSchema) {this.state = state;this.defaultSchema = defaultSchema;} + + // check and return the cache if (matches version or hasn't expired) + async checkCache(newState) { + const now = newState.now(); + // fetch the data from the cache + const cache = await this.all(); + + if (!cache) { + return { cache: undefined, stale: true } + } + // version has been upgraded or changed + // TODO: define this behaviour more clearly. + if (newState.version !== cache.version) { + return { cache, stale: true } + } + // cache expired + if (now - cache.cached_at > newState.cache_duration) { + return { cache, stale: true } + } + return { cache, stale: false } + } + + // set the configuration + async set(update) { + const existing = (await this.all()) || {}; + const schema = Object.assign(existing, update); + // TODO: figure out how to type this + for (let k in this.defaultSchema) { + // @ts-ignore + if (typeof schema[k] === 'undefined') { + // @ts-ignore + schema[k] = this.defaultSchema[k]; + } + } + await fs__default["default"].writeFile(this.state.cache_file, JSON.stringify(schema, null, ' ')); + } + + // get the entire schema + async all() { + try { + const data = await fs__default["default"].readFile(this.state.cache_file, 'utf8'); + return JSON.parse(data) + } catch (err) { + return + } + } + + // get a value from the schema + async get(key) { + const schema = await this.all(); + if (typeof schema === 'undefined') { + return + } + return schema[key] + } + + // reset the configuration + async reset() { + await fs__default["default"].writeFile(this.state.cache_file, JSON.stringify(this.defaultSchema, null, ' ')); + return + } + + // delete the configuration, ignoring any errors + async delete() { + try { + await fs__default["default"].unlink(this.state.cache_file); + return + } catch (err) { + return + } + } +} + +const rnds8Pool = new Uint8Array(256); // # of random values to pre-allocate + +let poolPtr = rnds8Pool.length; +function rng() { + if (poolPtr > rnds8Pool.length - 16) { + crypto__default["default"].randomFillSync(rnds8Pool); + poolPtr = 0; + } + + return rnds8Pool.slice(poolPtr, poolPtr += 16); +} + +/** + * Convert array of 16 byte values to UUID string format of the form: + * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX + */ + +const byteToHex = []; + +for (let i = 0; i < 256; ++i) { + byteToHex.push((i + 0x100).toString(16).slice(1)); +} + +function unsafeStringify(arr, offset = 0) { + // Note: Be careful editing this code! It's been tuned for performance + // and works in ways you may not expect. See https://github.com/uuidjs/uuid/pull/434 + return byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + '-' + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + '-' + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + '-' + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + '-' + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]; +} + +var native = { + randomUUID: crypto__default["default"].randomUUID +}; + +function v4(options, buf, offset) { + if (native.randomUUID && !buf && !options) { + return native.randomUUID(); + } + + options = options || {}; + const rnds = options.random || (options.rng || rng)(); // Per 4.4, set bits for version and `clock_seq_hi_and_reserved` + + rnds[6] = rnds[6] & 0x0f | 0x40; + rnds[8] = rnds[8] & 0x3f | 0x80; // Copy bytes to buffer, if provided + + if (buf) { + offset = offset || 0; + + for (let i = 0; i < 16; ++i) { + buf[offset + i] = rnds[i]; + } + + return buf; + } + + return unsafeStringify(rnds); +} + +var envPaths$1 = {exports: {}}; + +const path = path__default["default"]; +const os = require$$1__default["default"]; + +const homedir = os.homedir(); +const tmpdir = os.tmpdir(); +const {env} = process; + +const macos = name => { + const library = path.join(homedir, 'Library'); + + return { + data: path.join(library, 'Application Support', name), + config: path.join(library, 'Preferences', name), + cache: path.join(library, 'Caches', name), + log: path.join(library, 'Logs', name), + temp: path.join(tmpdir, name) + }; +}; + +const windows = name => { + const appData = env.APPDATA || path.join(homedir, 'AppData', 'Roaming'); + const localAppData = env.LOCALAPPDATA || path.join(homedir, 'AppData', 'Local'); + + return { + // Data/config/cache/log are invented by me as Windows isn't opinionated about this + data: path.join(localAppData, name, 'Data'), + config: path.join(appData, name, 'Config'), + cache: path.join(localAppData, name, 'Cache'), + log: path.join(localAppData, name, 'Log'), + temp: path.join(tmpdir, name) + }; +}; + +// https://specifications.freedesktop.org/basedir-spec/basedir-spec-latest.html +const linux = name => { + const username = path.basename(homedir); + + return { + data: path.join(env.XDG_DATA_HOME || path.join(homedir, '.local', 'share'), name), + config: path.join(env.XDG_CONFIG_HOME || path.join(homedir, '.config'), name), + cache: path.join(env.XDG_CACHE_HOME || path.join(homedir, '.cache'), name), + // https://wiki.debian.org/XDGBaseDirectorySpecification#state + log: path.join(env.XDG_STATE_HOME || path.join(homedir, '.local', 'state'), name), + temp: path.join(tmpdir, username, name) + }; +}; + +const envPaths = (name, options) => { + if (typeof name !== 'string') { + throw new TypeError(`Expected string, got ${typeof name}`); + } + + options = Object.assign({suffix: 'nodejs'}, options); + + if (options.suffix) { + // Add suffix to prevent possible conflict with native apps + name += `-${options.suffix}`; + } + + if (process.platform === 'darwin') { + return macos(name); + } + + if (process.platform === 'win32') { + return windows(name); + } + + return linux(name); +}; + +envPaths$1.exports = envPaths; +// TODO: Remove this for the next major release +envPaths$1.exports.default = envPaths; + +var paths = envPaths$1.exports; + +// Signature is a random signature that is stored and used + + + + + +// File identifier for global signature file +const PRISMA_SIGNATURE = 'signature'; + +// IMPORTANT: this is part of the public API +async function getSignature(signatureFile) { + const dirs = paths('checkpoint'); + signatureFile = signatureFile || path__default["default"].join(dirs.cache, PRISMA_SIGNATURE); // new file for signature + + // The signatureFile replaces cacheFile as the source of turth and therefore takes precedence + const signature = await readSignature(signatureFile); + if (signature) { + return signature + } + + return await createSignatureFile(signatureFile) +} + +function isSignatureValid(signature) { + return typeof signature === 'string' && signature.length === 36 +} + +/** + * Parse a file containing json and return the `signature` key from it + * @returns string empty if invalid or not found + */ +async function readSignature(file) { + try { + const data = await fs__default["default"].readFile(file, 'utf8'); + const { signature } = JSON.parse(data); + if (isSignatureValid(signature)) { + return signature + } + return '' + } catch (err) { + return '' + } +} + +async function createSignatureFile(signatureFile, signature) { + // Use passed signature or generate new + const signatureState = { + signature: signature || v4(), + }; + await makeDir$1(path__default["default"].dirname(signatureFile)); + await fs__default["default"].writeFile(signatureFile, JSON.stringify(signatureState, null, ' ')); + return signatureState.signature +} + +var publicApi = {}; + +var URL$2 = {exports: {}}; + +var conversions = {}; +var lib = conversions; + +function sign(x) { + return x < 0 ? -1 : 1; +} + +function evenRound(x) { + // Round x to the nearest integer, choosing the even integer if it lies halfway between two. + if ((x % 1) === 0.5 && (x & 1) === 0) { // [even number].5; round down (i.e. floor) + return Math.floor(x); + } else { + return Math.round(x); + } +} + +function createNumberConversion(bitLength, typeOpts) { + if (!typeOpts.unsigned) { + --bitLength; + } + const lowerBound = typeOpts.unsigned ? 0 : -Math.pow(2, bitLength); + const upperBound = Math.pow(2, bitLength) - 1; + + const moduloVal = typeOpts.moduloBitLength ? Math.pow(2, typeOpts.moduloBitLength) : Math.pow(2, bitLength); + const moduloBound = typeOpts.moduloBitLength ? Math.pow(2, typeOpts.moduloBitLength - 1) : Math.pow(2, bitLength - 1); + + return function(V, opts) { + if (!opts) opts = {}; + + let x = +V; + + if (opts.enforceRange) { + if (!Number.isFinite(x)) { + throw new TypeError("Argument is not a finite number"); + } + + x = sign(x) * Math.floor(Math.abs(x)); + if (x < lowerBound || x > upperBound) { + throw new TypeError("Argument is not in byte range"); + } + + return x; + } + + if (!isNaN(x) && opts.clamp) { + x = evenRound(x); + + if (x < lowerBound) x = lowerBound; + if (x > upperBound) x = upperBound; + return x; + } + + if (!Number.isFinite(x) || x === 0) { + return 0; + } + + x = sign(x) * Math.floor(Math.abs(x)); + x = x % moduloVal; + + if (!typeOpts.unsigned && x >= moduloBound) { + return x - moduloVal; + } else if (typeOpts.unsigned) { + if (x < 0) { + x += moduloVal; + } else if (x === -0) { // don't return negative zero + return 0; + } + } + + return x; + } +} + +conversions["void"] = function () { + return undefined; +}; + +conversions["boolean"] = function (val) { + return !!val; +}; + +conversions["byte"] = createNumberConversion(8, { unsigned: false }); +conversions["octet"] = createNumberConversion(8, { unsigned: true }); + +conversions["short"] = createNumberConversion(16, { unsigned: false }); +conversions["unsigned short"] = createNumberConversion(16, { unsigned: true }); + +conversions["long"] = createNumberConversion(32, { unsigned: false }); +conversions["unsigned long"] = createNumberConversion(32, { unsigned: true }); + +conversions["long long"] = createNumberConversion(32, { unsigned: false, moduloBitLength: 64 }); +conversions["unsigned long long"] = createNumberConversion(32, { unsigned: true, moduloBitLength: 64 }); + +conversions["double"] = function (V) { + const x = +V; + + if (!Number.isFinite(x)) { + throw new TypeError("Argument is not a finite floating-point value"); + } + + return x; +}; + +conversions["unrestricted double"] = function (V) { + const x = +V; + + if (isNaN(x)) { + throw new TypeError("Argument is NaN"); + } + + return x; +}; + +// not quite valid, but good enough for JS +conversions["float"] = conversions["double"]; +conversions["unrestricted float"] = conversions["unrestricted double"]; + +conversions["DOMString"] = function (V, opts) { + if (!opts) opts = {}; + + if (opts.treatNullAsEmptyString && V === null) { + return ""; + } + + return String(V); +}; + +conversions["ByteString"] = function (V, opts) { + const x = String(V); + let c = undefined; + for (let i = 0; (c = x.codePointAt(i)) !== undefined; ++i) { + if (c > 255) { + throw new TypeError("Argument is not a valid bytestring"); + } + } + + return x; +}; + +conversions["USVString"] = function (V) { + const S = String(V); + const n = S.length; + const U = []; + for (let i = 0; i < n; ++i) { + const c = S.charCodeAt(i); + if (c < 0xD800 || c > 0xDFFF) { + U.push(String.fromCodePoint(c)); + } else if (0xDC00 <= c && c <= 0xDFFF) { + U.push(String.fromCodePoint(0xFFFD)); + } else { + if (i === n - 1) { + U.push(String.fromCodePoint(0xFFFD)); + } else { + const d = S.charCodeAt(i + 1); + if (0xDC00 <= d && d <= 0xDFFF) { + const a = c & 0x3FF; + const b = d & 0x3FF; + U.push(String.fromCodePoint((2 << 15) + (2 << 9) * a + b)); + ++i; + } else { + U.push(String.fromCodePoint(0xFFFD)); + } + } + } + } + + return U.join(''); +}; + +conversions["Date"] = function (V, opts) { + if (!(V instanceof Date)) { + throw new TypeError("Argument is not a Date object"); + } + if (isNaN(V)) { + return undefined; + } + + return V; +}; + +conversions["RegExp"] = function (V, opts) { + if (!(V instanceof RegExp)) { + V = new RegExp(V); + } + + return V; +}; + +var utils = {exports: {}}; + +(function (module) { + +module.exports.mixin = function mixin(target, source) { + const keys = Object.getOwnPropertyNames(source); + for (let i = 0; i < keys.length; ++i) { + Object.defineProperty(target, keys[i], Object.getOwnPropertyDescriptor(source, keys[i])); + } +}; + +module.exports.wrapperSymbol = Symbol("wrapper"); +module.exports.implSymbol = Symbol("impl"); + +module.exports.wrapperForImpl = function (impl) { + return impl[module.exports.wrapperSymbol]; +}; + +module.exports.implForWrapper = function (wrapper) { + return wrapper[module.exports.implSymbol]; +}; +}(utils)); + +var URLImpl = {}; + +var urlStateMachine = {exports: {}}; + +var tr46 = {}; + +var require$$1 = [ + [ + [ + 0, + 44 + ], + "disallowed_STD3_valid" + ], + [ + [ + 45, + 46 + ], + "valid" + ], + [ + [ + 47, + 47 + ], + "disallowed_STD3_valid" + ], + [ + [ + 48, + 57 + ], + "valid" + ], + [ + [ + 58, + 64 + ], + "disallowed_STD3_valid" + ], + [ + [ + 65, + 65 + ], + "mapped", + [ + 97 + ] + ], + [ + [ + 66, + 66 + ], + "mapped", + [ + 98 + ] + ], + [ + [ + 67, + 67 + ], + "mapped", + [ + 99 + ] + ], + [ + [ + 68, + 68 + ], + "mapped", + [ + 100 + ] + ], + [ + [ + 69, + 69 + ], + "mapped", + [ + 101 + ] + ], + [ + [ + 70, + 70 + ], + "mapped", + [ + 102 + ] + ], + [ + [ + 71, + 71 + ], + "mapped", + [ + 103 + ] + ], + [ + [ + 72, + 72 + ], + "mapped", + [ + 104 + ] + ], + [ + [ + 73, + 73 + ], + "mapped", + [ + 105 + ] + ], + [ + [ + 74, + 74 + ], + "mapped", + [ + 106 + ] + ], + [ + [ + 75, + 75 + ], + "mapped", + [ + 107 + ] + ], + [ + [ + 76, + 76 + ], + "mapped", + [ + 108 + ] + ], + [ + [ + 77, + 77 + ], + "mapped", + [ + 109 + ] + ], + [ + [ + 78, + 78 + ], + "mapped", + [ + 110 + ] + ], + [ + [ + 79, + 79 + ], + "mapped", + [ + 111 + ] + ], + [ + [ + 80, + 80 + ], + "mapped", + [ + 112 + ] + ], + [ + [ + 81, + 81 + ], + "mapped", + [ + 113 + ] + ], + [ + [ + 82, + 82 + ], + "mapped", + [ + 114 + ] + ], + [ + [ + 83, + 83 + ], + "mapped", + [ + 115 + ] + ], + [ + [ + 84, + 84 + ], + "mapped", + [ + 116 + ] + ], + [ + [ + 85, + 85 + ], + "mapped", + [ + 117 + ] + ], + [ + [ + 86, + 86 + ], + "mapped", + [ + 118 + ] + ], + [ + [ + 87, + 87 + ], + "mapped", + [ + 119 + ] + ], + [ + [ + 88, + 88 + ], + "mapped", + [ + 120 + ] + ], + [ + [ + 89, + 89 + ], + "mapped", + [ + 121 + ] + ], + [ + [ + 90, + 90 + ], + "mapped", + [ + 122 + ] + ], + [ + [ + 91, + 96 + ], + "disallowed_STD3_valid" + ], + [ + [ + 97, + 122 + ], + "valid" + ], + [ + [ + 123, + 127 + ], + "disallowed_STD3_valid" + ], + [ + [ + 128, + 159 + ], + "disallowed" + ], + [ + [ + 160, + 160 + ], + "disallowed_STD3_mapped", + [ + 32 + ] + ], + [ + [ + 161, + 167 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 168, + 168 + ], + "disallowed_STD3_mapped", + [ + 32, + 776 + ] + ], + [ + [ + 169, + 169 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 170, + 170 + ], + "mapped", + [ + 97 + ] + ], + [ + [ + 171, + 172 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 173, + 173 + ], + "ignored" + ], + [ + [ + 174, + 174 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 175, + 175 + ], + "disallowed_STD3_mapped", + [ + 32, + 772 + ] + ], + [ + [ + 176, + 177 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 178, + 178 + ], + "mapped", + [ + 50 + ] + ], + [ + [ + 179, + 179 + ], + "mapped", + [ + 51 + ] + ], + [ + [ + 180, + 180 + ], + "disallowed_STD3_mapped", + [ + 32, + 769 + ] + ], + [ + [ + 181, + 181 + ], + "mapped", + [ + 956 + ] + ], + [ + [ + 182, + 182 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 183, + 183 + ], + "valid" + ], + [ + [ + 184, + 184 + ], + "disallowed_STD3_mapped", + [ + 32, + 807 + ] + ], + [ + [ + 185, + 185 + ], + "mapped", + [ + 49 + ] + ], + [ + [ + 186, + 186 + ], + "mapped", + [ + 111 + ] + ], + [ + [ + 187, + 187 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 188, + 188 + ], + "mapped", + [ + 49, + 8260, + 52 + ] + ], + [ + [ + 189, + 189 + ], + "mapped", + [ + 49, + 8260, + 50 + ] + ], + [ + [ + 190, + 190 + ], + "mapped", + [ + 51, + 8260, + 52 + ] + ], + [ + [ + 191, + 191 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 192, + 192 + ], + "mapped", + [ + 224 + ] + ], + [ + [ + 193, + 193 + ], + "mapped", + [ + 225 + ] + ], + [ + [ + 194, + 194 + ], + "mapped", + [ + 226 + ] + ], + [ + [ + 195, + 195 + ], + "mapped", + [ + 227 + ] + ], + [ + [ + 196, + 196 + ], + "mapped", + [ + 228 + ] + ], + [ + [ + 197, + 197 + ], + "mapped", + [ + 229 + ] + ], + [ + [ + 198, + 198 + ], + "mapped", + [ + 230 + ] + ], + [ + [ + 199, + 199 + ], + "mapped", + [ + 231 + ] + ], + [ + [ + 200, + 200 + ], + "mapped", + [ + 232 + ] + ], + [ + [ + 201, + 201 + ], + "mapped", + [ + 233 + ] + ], + [ + [ + 202, + 202 + ], + "mapped", + [ + 234 + ] + ], + [ + [ + 203, + 203 + ], + "mapped", + [ + 235 + ] + ], + [ + [ + 204, + 204 + ], + "mapped", + [ + 236 + ] + ], + [ + [ + 205, + 205 + ], + "mapped", + [ + 237 + ] + ], + [ + [ + 206, + 206 + ], + "mapped", + [ + 238 + ] + ], + [ + [ + 207, + 207 + ], + "mapped", + [ + 239 + ] + ], + [ + [ + 208, + 208 + ], + "mapped", + [ + 240 + ] + ], + [ + [ + 209, + 209 + ], + "mapped", + [ + 241 + ] + ], + [ + [ + 210, + 210 + ], + "mapped", + [ + 242 + ] + ], + [ + [ + 211, + 211 + ], + "mapped", + [ + 243 + ] + ], + [ + [ + 212, + 212 + ], + "mapped", + [ + 244 + ] + ], + [ + [ + 213, + 213 + ], + "mapped", + [ + 245 + ] + ], + [ + [ + 214, + 214 + ], + "mapped", + [ + 246 + ] + ], + [ + [ + 215, + 215 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 216, + 216 + ], + "mapped", + [ + 248 + ] + ], + [ + [ + 217, + 217 + ], + "mapped", + [ + 249 + ] + ], + [ + [ + 218, + 218 + ], + "mapped", + [ + 250 + ] + ], + [ + [ + 219, + 219 + ], + "mapped", + [ + 251 + ] + ], + [ + [ + 220, + 220 + ], + "mapped", + [ + 252 + ] + ], + [ + [ + 221, + 221 + ], + "mapped", + [ + 253 + ] + ], + [ + [ + 222, + 222 + ], + "mapped", + [ + 254 + ] + ], + [ + [ + 223, + 223 + ], + "deviation", + [ + 115, + 115 + ] + ], + [ + [ + 224, + 246 + ], + "valid" + ], + [ + [ + 247, + 247 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 248, + 255 + ], + "valid" + ], + [ + [ + 256, + 256 + ], + "mapped", + [ + 257 + ] + ], + [ + [ + 257, + 257 + ], + "valid" + ], + [ + [ + 258, + 258 + ], + "mapped", + [ + 259 + ] + ], + [ + [ + 259, + 259 + ], + "valid" + ], + [ + [ + 260, + 260 + ], + "mapped", + [ + 261 + ] + ], + [ + [ + 261, + 261 + ], + "valid" + ], + [ + [ + 262, + 262 + ], + "mapped", + [ + 263 + ] + ], + [ + [ + 263, + 263 + ], + "valid" + ], + [ + [ + 264, + 264 + ], + "mapped", + [ + 265 + ] + ], + [ + [ + 265, + 265 + ], + "valid" + ], + [ + [ + 266, + 266 + ], + "mapped", + [ + 267 + ] + ], + [ + [ + 267, + 267 + ], + "valid" + ], + [ + [ + 268, + 268 + ], + "mapped", + [ + 269 + ] + ], + [ + [ + 269, + 269 + ], + "valid" + ], + [ + [ + 270, + 270 + ], + "mapped", + [ + 271 + ] + ], + [ + [ + 271, + 271 + ], + "valid" + ], + [ + [ + 272, + 272 + ], + "mapped", + [ + 273 + ] + ], + [ + [ + 273, + 273 + ], + "valid" + ], + [ + [ + 274, + 274 + ], + "mapped", + [ + 275 + ] + ], + [ + [ + 275, + 275 + ], + "valid" + ], + [ + [ + 276, + 276 + ], + "mapped", + [ + 277 + ] + ], + [ + [ + 277, + 277 + ], + "valid" + ], + [ + [ + 278, + 278 + ], + "mapped", + [ + 279 + ] + ], + [ + [ + 279, + 279 + ], + "valid" + ], + [ + [ + 280, + 280 + ], + "mapped", + [ + 281 + ] + ], + [ + [ + 281, + 281 + ], + "valid" + ], + [ + [ + 282, + 282 + ], + "mapped", + [ + 283 + ] + ], + [ + [ + 283, + 283 + ], + "valid" + ], + [ + [ + 284, + 284 + ], + "mapped", + [ + 285 + ] + ], + [ + [ + 285, + 285 + ], + "valid" + ], + [ + [ + 286, + 286 + ], + "mapped", + [ + 287 + ] + ], + [ + [ + 287, + 287 + ], + "valid" + ], + [ + [ + 288, + 288 + ], + "mapped", + [ + 289 + ] + ], + [ + [ + 289, + 289 + ], + "valid" + ], + [ + [ + 290, + 290 + ], + "mapped", + [ + 291 + ] + ], + [ + [ + 291, + 291 + ], + "valid" + ], + [ + [ + 292, + 292 + ], + "mapped", + [ + 293 + ] + ], + [ + [ + 293, + 293 + ], + "valid" + ], + [ + [ + 294, + 294 + ], + "mapped", + [ + 295 + ] + ], + [ + [ + 295, + 295 + ], + "valid" + ], + [ + [ + 296, + 296 + ], + "mapped", + [ + 297 + ] + ], + [ + [ + 297, + 297 + ], + "valid" + ], + [ + [ + 298, + 298 + ], + "mapped", + [ + 299 + ] + ], + [ + [ + 299, + 299 + ], + "valid" + ], + [ + [ + 300, + 300 + ], + "mapped", + [ + 301 + ] + ], + [ + [ + 301, + 301 + ], + "valid" + ], + [ + [ + 302, + 302 + ], + "mapped", + [ + 303 + ] + ], + [ + [ + 303, + 303 + ], + "valid" + ], + [ + [ + 304, + 304 + ], + "mapped", + [ + 105, + 775 + ] + ], + [ + [ + 305, + 305 + ], + "valid" + ], + [ + [ + 306, + 307 + ], + "mapped", + [ + 105, + 106 + ] + ], + [ + [ + 308, + 308 + ], + "mapped", + [ + 309 + ] + ], + [ + [ + 309, + 309 + ], + "valid" + ], + [ + [ + 310, + 310 + ], + "mapped", + [ + 311 + ] + ], + [ + [ + 311, + 312 + ], + "valid" + ], + [ + [ + 313, + 313 + ], + "mapped", + [ + 314 + ] + ], + [ + [ + 314, + 314 + ], + "valid" + ], + [ + [ + 315, + 315 + ], + "mapped", + [ + 316 + ] + ], + [ + [ + 316, + 316 + ], + "valid" + ], + [ + [ + 317, + 317 + ], + "mapped", + [ + 318 + ] + ], + [ + [ + 318, + 318 + ], + "valid" + ], + [ + [ + 319, + 320 + ], + "mapped", + [ + 108, + 183 + ] + ], + [ + [ + 321, + 321 + ], + "mapped", + [ + 322 + ] + ], + [ + [ + 322, + 322 + ], + "valid" + ], + [ + [ + 323, + 323 + ], + "mapped", + [ + 324 + ] + ], + [ + [ + 324, + 324 + ], + "valid" + ], + [ + [ + 325, + 325 + ], + "mapped", + [ + 326 + ] + ], + [ + [ + 326, + 326 + ], + "valid" + ], + [ + [ + 327, + 327 + ], + "mapped", + [ + 328 + ] + ], + [ + [ + 328, + 328 + ], + "valid" + ], + [ + [ + 329, + 329 + ], + "mapped", + [ + 700, + 110 + ] + ], + [ + [ + 330, + 330 + ], + "mapped", + [ + 331 + ] + ], + [ + [ + 331, + 331 + ], + "valid" + ], + [ + [ + 332, + 332 + ], + "mapped", + [ + 333 + ] + ], + [ + [ + 333, + 333 + ], + "valid" + ], + [ + [ + 334, + 334 + ], + "mapped", + [ + 335 + ] + ], + [ + [ + 335, + 335 + ], + "valid" + ], + [ + [ + 336, + 336 + ], + "mapped", + [ + 337 + ] + ], + [ + [ + 337, + 337 + ], + "valid" + ], + [ + [ + 338, + 338 + ], + "mapped", + [ + 339 + ] + ], + [ + [ + 339, + 339 + ], + "valid" + ], + [ + [ + 340, + 340 + ], + "mapped", + [ + 341 + ] + ], + [ + [ + 341, + 341 + ], + "valid" + ], + [ + [ + 342, + 342 + ], + "mapped", + [ + 343 + ] + ], + [ + [ + 343, + 343 + ], + "valid" + ], + [ + [ + 344, + 344 + ], + "mapped", + [ + 345 + ] + ], + [ + [ + 345, + 345 + ], + "valid" + ], + [ + [ + 346, + 346 + ], + "mapped", + [ + 347 + ] + ], + [ + [ + 347, + 347 + ], + "valid" + ], + [ + [ + 348, + 348 + ], + "mapped", + [ + 349 + ] + ], + [ + [ + 349, + 349 + ], + "valid" + ], + [ + [ + 350, + 350 + ], + "mapped", + [ + 351 + ] + ], + [ + [ + 351, + 351 + ], + "valid" + ], + [ + [ + 352, + 352 + ], + "mapped", + [ + 353 + ] + ], + [ + [ + 353, + 353 + ], + "valid" + ], + [ + [ + 354, + 354 + ], + "mapped", + [ + 355 + ] + ], + [ + [ + 355, + 355 + ], + "valid" + ], + [ + [ + 356, + 356 + ], + "mapped", + [ + 357 + ] + ], + [ + [ + 357, + 357 + ], + "valid" + ], + [ + [ + 358, + 358 + ], + "mapped", + [ + 359 + ] + ], + [ + [ + 359, + 359 + ], + "valid" + ], + [ + [ + 360, + 360 + ], + "mapped", + [ + 361 + ] + ], + [ + [ + 361, + 361 + ], + "valid" + ], + [ + [ + 362, + 362 + ], + "mapped", + [ + 363 + ] + ], + [ + [ + 363, + 363 + ], + "valid" + ], + [ + [ + 364, + 364 + ], + "mapped", + [ + 365 + ] + ], + [ + [ + 365, + 365 + ], + "valid" + ], + [ + [ + 366, + 366 + ], + "mapped", + [ + 367 + ] + ], + [ + [ + 367, + 367 + ], + "valid" + ], + [ + [ + 368, + 368 + ], + "mapped", + [ + 369 + ] + ], + [ + [ + 369, + 369 + ], + "valid" + ], + [ + [ + 370, + 370 + ], + "mapped", + [ + 371 + ] + ], + [ + [ + 371, + 371 + ], + "valid" + ], + [ + [ + 372, + 372 + ], + "mapped", + [ + 373 + ] + ], + [ + [ + 373, + 373 + ], + "valid" + ], + [ + [ + 374, + 374 + ], + "mapped", + [ + 375 + ] + ], + [ + [ + 375, + 375 + ], + "valid" + ], + [ + [ + 376, + 376 + ], + "mapped", + [ + 255 + ] + ], + [ + [ + 377, + 377 + ], + "mapped", + [ + 378 + ] + ], + [ + [ + 378, + 378 + ], + "valid" + ], + [ + [ + 379, + 379 + ], + "mapped", + [ + 380 + ] + ], + [ + [ + 380, + 380 + ], + "valid" + ], + [ + [ + 381, + 381 + ], + "mapped", + [ + 382 + ] + ], + [ + [ + 382, + 382 + ], + "valid" + ], + [ + [ + 383, + 383 + ], + "mapped", + [ + 115 + ] + ], + [ + [ + 384, + 384 + ], + "valid" + ], + [ + [ + 385, + 385 + ], + "mapped", + [ + 595 + ] + ], + [ + [ + 386, + 386 + ], + "mapped", + [ + 387 + ] + ], + [ + [ + 387, + 387 + ], + "valid" + ], + [ + [ + 388, + 388 + ], + "mapped", + [ + 389 + ] + ], + [ + [ + 389, + 389 + ], + "valid" + ], + [ + [ + 390, + 390 + ], + "mapped", + [ + 596 + ] + ], + [ + [ + 391, + 391 + ], + "mapped", + [ + 392 + ] + ], + [ + [ + 392, + 392 + ], + "valid" + ], + [ + [ + 393, + 393 + ], + "mapped", + [ + 598 + ] + ], + [ + [ + 394, + 394 + ], + "mapped", + [ + 599 + ] + ], + [ + [ + 395, + 395 + ], + "mapped", + [ + 396 + ] + ], + [ + [ + 396, + 397 + ], + "valid" + ], + [ + [ + 398, + 398 + ], + "mapped", + [ + 477 + ] + ], + [ + [ + 399, + 399 + ], + "mapped", + [ + 601 + ] + ], + [ + [ + 400, + 400 + ], + "mapped", + [ + 603 + ] + ], + [ + [ + 401, + 401 + ], + "mapped", + [ + 402 + ] + ], + [ + [ + 402, + 402 + ], + "valid" + ], + [ + [ + 403, + 403 + ], + "mapped", + [ + 608 + ] + ], + [ + [ + 404, + 404 + ], + "mapped", + [ + 611 + ] + ], + [ + [ + 405, + 405 + ], + "valid" + ], + [ + [ + 406, + 406 + ], + "mapped", + [ + 617 + ] + ], + [ + [ + 407, + 407 + ], + "mapped", + [ + 616 + ] + ], + [ + [ + 408, + 408 + ], + "mapped", + [ + 409 + ] + ], + [ + [ + 409, + 411 + ], + "valid" + ], + [ + [ + 412, + 412 + ], + "mapped", + [ + 623 + ] + ], + [ + [ + 413, + 413 + ], + "mapped", + [ + 626 + ] + ], + [ + [ + 414, + 414 + ], + "valid" + ], + [ + [ + 415, + 415 + ], + "mapped", + [ + 629 + ] + ], + [ + [ + 416, + 416 + ], + "mapped", + [ + 417 + ] + ], + [ + [ + 417, + 417 + ], + "valid" + ], + [ + [ + 418, + 418 + ], + "mapped", + [ + 419 + ] + ], + [ + [ + 419, + 419 + ], + "valid" + ], + [ + [ + 420, + 420 + ], + "mapped", + [ + 421 + ] + ], + [ + [ + 421, + 421 + ], + "valid" + ], + [ + [ + 422, + 422 + ], + "mapped", + [ + 640 + ] + ], + [ + [ + 423, + 423 + ], + "mapped", + [ + 424 + ] + ], + [ + [ + 424, + 424 + ], + "valid" + ], + [ + [ + 425, + 425 + ], + "mapped", + [ + 643 + ] + ], + [ + [ + 426, + 427 + ], + "valid" + ], + [ + [ + 428, + 428 + ], + "mapped", + [ + 429 + ] + ], + [ + [ + 429, + 429 + ], + "valid" + ], + [ + [ + 430, + 430 + ], + "mapped", + [ + 648 + ] + ], + [ + [ + 431, + 431 + ], + "mapped", + [ + 432 + ] + ], + [ + [ + 432, + 432 + ], + "valid" + ], + [ + [ + 433, + 433 + ], + "mapped", + [ + 650 + ] + ], + [ + [ + 434, + 434 + ], + "mapped", + [ + 651 + ] + ], + [ + [ + 435, + 435 + ], + "mapped", + [ + 436 + ] + ], + [ + [ + 436, + 436 + ], + "valid" + ], + [ + [ + 437, + 437 + ], + "mapped", + [ + 438 + ] + ], + [ + [ + 438, + 438 + ], + "valid" + ], + [ + [ + 439, + 439 + ], + "mapped", + [ + 658 + ] + ], + [ + [ + 440, + 440 + ], + "mapped", + [ + 441 + ] + ], + [ + [ + 441, + 443 + ], + "valid" + ], + [ + [ + 444, + 444 + ], + "mapped", + [ + 445 + ] + ], + [ + [ + 445, + 451 + ], + "valid" + ], + [ + [ + 452, + 454 + ], + "mapped", + [ + 100, + 382 + ] + ], + [ + [ + 455, + 457 + ], + "mapped", + [ + 108, + 106 + ] + ], + [ + [ + 458, + 460 + ], + "mapped", + [ + 110, + 106 + ] + ], + [ + [ + 461, + 461 + ], + "mapped", + [ + 462 + ] + ], + [ + [ + 462, + 462 + ], + "valid" + ], + [ + [ + 463, + 463 + ], + "mapped", + [ + 464 + ] + ], + [ + [ + 464, + 464 + ], + "valid" + ], + [ + [ + 465, + 465 + ], + "mapped", + [ + 466 + ] + ], + [ + [ + 466, + 466 + ], + "valid" + ], + [ + [ + 467, + 467 + ], + "mapped", + [ + 468 + ] + ], + [ + [ + 468, + 468 + ], + "valid" + ], + [ + [ + 469, + 469 + ], + "mapped", + [ + 470 + ] + ], + [ + [ + 470, + 470 + ], + "valid" + ], + [ + [ + 471, + 471 + ], + "mapped", + [ + 472 + ] + ], + [ + [ + 472, + 472 + ], + "valid" + ], + [ + [ + 473, + 473 + ], + "mapped", + [ + 474 + ] + ], + [ + [ + 474, + 474 + ], + "valid" + ], + [ + [ + 475, + 475 + ], + "mapped", + [ + 476 + ] + ], + [ + [ + 476, + 477 + ], + "valid" + ], + [ + [ + 478, + 478 + ], + "mapped", + [ + 479 + ] + ], + [ + [ + 479, + 479 + ], + "valid" + ], + [ + [ + 480, + 480 + ], + "mapped", + [ + 481 + ] + ], + [ + [ + 481, + 481 + ], + "valid" + ], + [ + [ + 482, + 482 + ], + "mapped", + [ + 483 + ] + ], + [ + [ + 483, + 483 + ], + "valid" + ], + [ + [ + 484, + 484 + ], + "mapped", + [ + 485 + ] + ], + [ + [ + 485, + 485 + ], + "valid" + ], + [ + [ + 486, + 486 + ], + "mapped", + [ + 487 + ] + ], + [ + [ + 487, + 487 + ], + "valid" + ], + [ + [ + 488, + 488 + ], + "mapped", + [ + 489 + ] + ], + [ + [ + 489, + 489 + ], + "valid" + ], + [ + [ + 490, + 490 + ], + "mapped", + [ + 491 + ] + ], + [ + [ + 491, + 491 + ], + "valid" + ], + [ + [ + 492, + 492 + ], + "mapped", + [ + 493 + ] + ], + [ + [ + 493, + 493 + ], + "valid" + ], + [ + [ + 494, + 494 + ], + "mapped", + [ + 495 + ] + ], + [ + [ + 495, + 496 + ], + "valid" + ], + [ + [ + 497, + 499 + ], + "mapped", + [ + 100, + 122 + ] + ], + [ + [ + 500, + 500 + ], + "mapped", + [ + 501 + ] + ], + [ + [ + 501, + 501 + ], + "valid" + ], + [ + [ + 502, + 502 + ], + "mapped", + [ + 405 + ] + ], + [ + [ + 503, + 503 + ], + "mapped", + [ + 447 + ] + ], + [ + [ + 504, + 504 + ], + "mapped", + [ + 505 + ] + ], + [ + [ + 505, + 505 + ], + "valid" + ], + [ + [ + 506, + 506 + ], + "mapped", + [ + 507 + ] + ], + [ + [ + 507, + 507 + ], + "valid" + ], + [ + [ + 508, + 508 + ], + "mapped", + [ + 509 + ] + ], + [ + [ + 509, + 509 + ], + "valid" + ], + [ + [ + 510, + 510 + ], + "mapped", + [ + 511 + ] + ], + [ + [ + 511, + 511 + ], + "valid" + ], + [ + [ + 512, + 512 + ], + "mapped", + [ + 513 + ] + ], + [ + [ + 513, + 513 + ], + "valid" + ], + [ + [ + 514, + 514 + ], + "mapped", + [ + 515 + ] + ], + [ + [ + 515, + 515 + ], + "valid" + ], + [ + [ + 516, + 516 + ], + "mapped", + [ + 517 + ] + ], + [ + [ + 517, + 517 + ], + "valid" + ], + [ + [ + 518, + 518 + ], + "mapped", + [ + 519 + ] + ], + [ + [ + 519, + 519 + ], + "valid" + ], + [ + [ + 520, + 520 + ], + "mapped", + [ + 521 + ] + ], + [ + [ + 521, + 521 + ], + "valid" + ], + [ + [ + 522, + 522 + ], + "mapped", + [ + 523 + ] + ], + [ + [ + 523, + 523 + ], + "valid" + ], + [ + [ + 524, + 524 + ], + "mapped", + [ + 525 + ] + ], + [ + [ + 525, + 525 + ], + "valid" + ], + [ + [ + 526, + 526 + ], + "mapped", + [ + 527 + ] + ], + [ + [ + 527, + 527 + ], + "valid" + ], + [ + [ + 528, + 528 + ], + "mapped", + [ + 529 + ] + ], + [ + [ + 529, + 529 + ], + "valid" + ], + [ + [ + 530, + 530 + ], + "mapped", + [ + 531 + ] + ], + [ + [ + 531, + 531 + ], + "valid" + ], + [ + [ + 532, + 532 + ], + "mapped", + [ + 533 + ] + ], + [ + [ + 533, + 533 + ], + "valid" + ], + [ + [ + 534, + 534 + ], + "mapped", + [ + 535 + ] + ], + [ + [ + 535, + 535 + ], + "valid" + ], + [ + [ + 536, + 536 + ], + "mapped", + [ + 537 + ] + ], + [ + [ + 537, + 537 + ], + "valid" + ], + [ + [ + 538, + 538 + ], + "mapped", + [ + 539 + ] + ], + [ + [ + 539, + 539 + ], + "valid" + ], + [ + [ + 540, + 540 + ], + "mapped", + [ + 541 + ] + ], + [ + [ + 541, + 541 + ], + "valid" + ], + [ + [ + 542, + 542 + ], + "mapped", + [ + 543 + ] + ], + [ + [ + 543, + 543 + ], + "valid" + ], + [ + [ + 544, + 544 + ], + "mapped", + [ + 414 + ] + ], + [ + [ + 545, + 545 + ], + "valid" + ], + [ + [ + 546, + 546 + ], + "mapped", + [ + 547 + ] + ], + [ + [ + 547, + 547 + ], + "valid" + ], + [ + [ + 548, + 548 + ], + "mapped", + [ + 549 + ] + ], + [ + [ + 549, + 549 + ], + "valid" + ], + [ + [ + 550, + 550 + ], + "mapped", + [ + 551 + ] + ], + [ + [ + 551, + 551 + ], + "valid" + ], + [ + [ + 552, + 552 + ], + "mapped", + [ + 553 + ] + ], + [ + [ + 553, + 553 + ], + "valid" + ], + [ + [ + 554, + 554 + ], + "mapped", + [ + 555 + ] + ], + [ + [ + 555, + 555 + ], + "valid" + ], + [ + [ + 556, + 556 + ], + "mapped", + [ + 557 + ] + ], + [ + [ + 557, + 557 + ], + "valid" + ], + [ + [ + 558, + 558 + ], + "mapped", + [ + 559 + ] + ], + [ + [ + 559, + 559 + ], + "valid" + ], + [ + [ + 560, + 560 + ], + "mapped", + [ + 561 + ] + ], + [ + [ + 561, + 561 + ], + "valid" + ], + [ + [ + 562, + 562 + ], + "mapped", + [ + 563 + ] + ], + [ + [ + 563, + 563 + ], + "valid" + ], + [ + [ + 564, + 566 + ], + "valid" + ], + [ + [ + 567, + 569 + ], + "valid" + ], + [ + [ + 570, + 570 + ], + "mapped", + [ + 11365 + ] + ], + [ + [ + 571, + 571 + ], + "mapped", + [ + 572 + ] + ], + [ + [ + 572, + 572 + ], + "valid" + ], + [ + [ + 573, + 573 + ], + "mapped", + [ + 410 + ] + ], + [ + [ + 574, + 574 + ], + "mapped", + [ + 11366 + ] + ], + [ + [ + 575, + 576 + ], + "valid" + ], + [ + [ + 577, + 577 + ], + "mapped", + [ + 578 + ] + ], + [ + [ + 578, + 578 + ], + "valid" + ], + [ + [ + 579, + 579 + ], + "mapped", + [ + 384 + ] + ], + [ + [ + 580, + 580 + ], + "mapped", + [ + 649 + ] + ], + [ + [ + 581, + 581 + ], + "mapped", + [ + 652 + ] + ], + [ + [ + 582, + 582 + ], + "mapped", + [ + 583 + ] + ], + [ + [ + 583, + 583 + ], + "valid" + ], + [ + [ + 584, + 584 + ], + "mapped", + [ + 585 + ] + ], + [ + [ + 585, + 585 + ], + "valid" + ], + [ + [ + 586, + 586 + ], + "mapped", + [ + 587 + ] + ], + [ + [ + 587, + 587 + ], + "valid" + ], + [ + [ + 588, + 588 + ], + "mapped", + [ + 589 + ] + ], + [ + [ + 589, + 589 + ], + "valid" + ], + [ + [ + 590, + 590 + ], + "mapped", + [ + 591 + ] + ], + [ + [ + 591, + 591 + ], + "valid" + ], + [ + [ + 592, + 680 + ], + "valid" + ], + [ + [ + 681, + 685 + ], + "valid" + ], + [ + [ + 686, + 687 + ], + "valid" + ], + [ + [ + 688, + 688 + ], + "mapped", + [ + 104 + ] + ], + [ + [ + 689, + 689 + ], + "mapped", + [ + 614 + ] + ], + [ + [ + 690, + 690 + ], + "mapped", + [ + 106 + ] + ], + [ + [ + 691, + 691 + ], + "mapped", + [ + 114 + ] + ], + [ + [ + 692, + 692 + ], + "mapped", + [ + 633 + ] + ], + [ + [ + 693, + 693 + ], + "mapped", + [ + 635 + ] + ], + [ + [ + 694, + 694 + ], + "mapped", + [ + 641 + ] + ], + [ + [ + 695, + 695 + ], + "mapped", + [ + 119 + ] + ], + [ + [ + 696, + 696 + ], + "mapped", + [ + 121 + ] + ], + [ + [ + 697, + 705 + ], + "valid" + ], + [ + [ + 706, + 709 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 710, + 721 + ], + "valid" + ], + [ + [ + 722, + 727 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 728, + 728 + ], + "disallowed_STD3_mapped", + [ + 32, + 774 + ] + ], + [ + [ + 729, + 729 + ], + "disallowed_STD3_mapped", + [ + 32, + 775 + ] + ], + [ + [ + 730, + 730 + ], + "disallowed_STD3_mapped", + [ + 32, + 778 + ] + ], + [ + [ + 731, + 731 + ], + "disallowed_STD3_mapped", + [ + 32, + 808 + ] + ], + [ + [ + 732, + 732 + ], + "disallowed_STD3_mapped", + [ + 32, + 771 + ] + ], + [ + [ + 733, + 733 + ], + "disallowed_STD3_mapped", + [ + 32, + 779 + ] + ], + [ + [ + 734, + 734 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 735, + 735 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 736, + 736 + ], + "mapped", + [ + 611 + ] + ], + [ + [ + 737, + 737 + ], + "mapped", + [ + 108 + ] + ], + [ + [ + 738, + 738 + ], + "mapped", + [ + 115 + ] + ], + [ + [ + 739, + 739 + ], + "mapped", + [ + 120 + ] + ], + [ + [ + 740, + 740 + ], + "mapped", + [ + 661 + ] + ], + [ + [ + 741, + 745 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 746, + 747 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 748, + 748 + ], + "valid" + ], + [ + [ + 749, + 749 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 750, + 750 + ], + "valid" + ], + [ + [ + 751, + 767 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 768, + 831 + ], + "valid" + ], + [ + [ + 832, + 832 + ], + "mapped", + [ + 768 + ] + ], + [ + [ + 833, + 833 + ], + "mapped", + [ + 769 + ] + ], + [ + [ + 834, + 834 + ], + "valid" + ], + [ + [ + 835, + 835 + ], + "mapped", + [ + 787 + ] + ], + [ + [ + 836, + 836 + ], + "mapped", + [ + 776, + 769 + ] + ], + [ + [ + 837, + 837 + ], + "mapped", + [ + 953 + ] + ], + [ + [ + 838, + 846 + ], + "valid" + ], + [ + [ + 847, + 847 + ], + "ignored" + ], + [ + [ + 848, + 855 + ], + "valid" + ], + [ + [ + 856, + 860 + ], + "valid" + ], + [ + [ + 861, + 863 + ], + "valid" + ], + [ + [ + 864, + 865 + ], + "valid" + ], + [ + [ + 866, + 866 + ], + "valid" + ], + [ + [ + 867, + 879 + ], + "valid" + ], + [ + [ + 880, + 880 + ], + "mapped", + [ + 881 + ] + ], + [ + [ + 881, + 881 + ], + "valid" + ], + [ + [ + 882, + 882 + ], + "mapped", + [ + 883 + ] + ], + [ + [ + 883, + 883 + ], + "valid" + ], + [ + [ + 884, + 884 + ], + "mapped", + [ + 697 + ] + ], + [ + [ + 885, + 885 + ], + "valid" + ], + [ + [ + 886, + 886 + ], + "mapped", + [ + 887 + ] + ], + [ + [ + 887, + 887 + ], + "valid" + ], + [ + [ + 888, + 889 + ], + "disallowed" + ], + [ + [ + 890, + 890 + ], + "disallowed_STD3_mapped", + [ + 32, + 953 + ] + ], + [ + [ + 891, + 893 + ], + "valid" + ], + [ + [ + 894, + 894 + ], + "disallowed_STD3_mapped", + [ + 59 + ] + ], + [ + [ + 895, + 895 + ], + "mapped", + [ + 1011 + ] + ], + [ + [ + 896, + 899 + ], + "disallowed" + ], + [ + [ + 900, + 900 + ], + "disallowed_STD3_mapped", + [ + 32, + 769 + ] + ], + [ + [ + 901, + 901 + ], + "disallowed_STD3_mapped", + [ + 32, + 776, + 769 + ] + ], + [ + [ + 902, + 902 + ], + "mapped", + [ + 940 + ] + ], + [ + [ + 903, + 903 + ], + "mapped", + [ + 183 + ] + ], + [ + [ + 904, + 904 + ], + "mapped", + [ + 941 + ] + ], + [ + [ + 905, + 905 + ], + "mapped", + [ + 942 + ] + ], + [ + [ + 906, + 906 + ], + "mapped", + [ + 943 + ] + ], + [ + [ + 907, + 907 + ], + "disallowed" + ], + [ + [ + 908, + 908 + ], + "mapped", + [ + 972 + ] + ], + [ + [ + 909, + 909 + ], + "disallowed" + ], + [ + [ + 910, + 910 + ], + "mapped", + [ + 973 + ] + ], + [ + [ + 911, + 911 + ], + "mapped", + [ + 974 + ] + ], + [ + [ + 912, + 912 + ], + "valid" + ], + [ + [ + 913, + 913 + ], + "mapped", + [ + 945 + ] + ], + [ + [ + 914, + 914 + ], + "mapped", + [ + 946 + ] + ], + [ + [ + 915, + 915 + ], + "mapped", + [ + 947 + ] + ], + [ + [ + 916, + 916 + ], + "mapped", + [ + 948 + ] + ], + [ + [ + 917, + 917 + ], + "mapped", + [ + 949 + ] + ], + [ + [ + 918, + 918 + ], + "mapped", + [ + 950 + ] + ], + [ + [ + 919, + 919 + ], + "mapped", + [ + 951 + ] + ], + [ + [ + 920, + 920 + ], + "mapped", + [ + 952 + ] + ], + [ + [ + 921, + 921 + ], + "mapped", + [ + 953 + ] + ], + [ + [ + 922, + 922 + ], + "mapped", + [ + 954 + ] + ], + [ + [ + 923, + 923 + ], + "mapped", + [ + 955 + ] + ], + [ + [ + 924, + 924 + ], + "mapped", + [ + 956 + ] + ], + [ + [ + 925, + 925 + ], + "mapped", + [ + 957 + ] + ], + [ + [ + 926, + 926 + ], + "mapped", + [ + 958 + ] + ], + [ + [ + 927, + 927 + ], + "mapped", + [ + 959 + ] + ], + [ + [ + 928, + 928 + ], + "mapped", + [ + 960 + ] + ], + [ + [ + 929, + 929 + ], + "mapped", + [ + 961 + ] + ], + [ + [ + 930, + 930 + ], + "disallowed" + ], + [ + [ + 931, + 931 + ], + "mapped", + [ + 963 + ] + ], + [ + [ + 932, + 932 + ], + "mapped", + [ + 964 + ] + ], + [ + [ + 933, + 933 + ], + "mapped", + [ + 965 + ] + ], + [ + [ + 934, + 934 + ], + "mapped", + [ + 966 + ] + ], + [ + [ + 935, + 935 + ], + "mapped", + [ + 967 + ] + ], + [ + [ + 936, + 936 + ], + "mapped", + [ + 968 + ] + ], + [ + [ + 937, + 937 + ], + "mapped", + [ + 969 + ] + ], + [ + [ + 938, + 938 + ], + "mapped", + [ + 970 + ] + ], + [ + [ + 939, + 939 + ], + "mapped", + [ + 971 + ] + ], + [ + [ + 940, + 961 + ], + "valid" + ], + [ + [ + 962, + 962 + ], + "deviation", + [ + 963 + ] + ], + [ + [ + 963, + 974 + ], + "valid" + ], + [ + [ + 975, + 975 + ], + "mapped", + [ + 983 + ] + ], + [ + [ + 976, + 976 + ], + "mapped", + [ + 946 + ] + ], + [ + [ + 977, + 977 + ], + "mapped", + [ + 952 + ] + ], + [ + [ + 978, + 978 + ], + "mapped", + [ + 965 + ] + ], + [ + [ + 979, + 979 + ], + "mapped", + [ + 973 + ] + ], + [ + [ + 980, + 980 + ], + "mapped", + [ + 971 + ] + ], + [ + [ + 981, + 981 + ], + "mapped", + [ + 966 + ] + ], + [ + [ + 982, + 982 + ], + "mapped", + [ + 960 + ] + ], + [ + [ + 983, + 983 + ], + "valid" + ], + [ + [ + 984, + 984 + ], + "mapped", + [ + 985 + ] + ], + [ + [ + 985, + 985 + ], + "valid" + ], + [ + [ + 986, + 986 + ], + "mapped", + [ + 987 + ] + ], + [ + [ + 987, + 987 + ], + "valid" + ], + [ + [ + 988, + 988 + ], + "mapped", + [ + 989 + ] + ], + [ + [ + 989, + 989 + ], + "valid" + ], + [ + [ + 990, + 990 + ], + "mapped", + [ + 991 + ] + ], + [ + [ + 991, + 991 + ], + "valid" + ], + [ + [ + 992, + 992 + ], + "mapped", + [ + 993 + ] + ], + [ + [ + 993, + 993 + ], + "valid" + ], + [ + [ + 994, + 994 + ], + "mapped", + [ + 995 + ] + ], + [ + [ + 995, + 995 + ], + "valid" + ], + [ + [ + 996, + 996 + ], + "mapped", + [ + 997 + ] + ], + [ + [ + 997, + 997 + ], + "valid" + ], + [ + [ + 998, + 998 + ], + "mapped", + [ + 999 + ] + ], + [ + [ + 999, + 999 + ], + "valid" + ], + [ + [ + 1000, + 1000 + ], + "mapped", + [ + 1001 + ] + ], + [ + [ + 1001, + 1001 + ], + "valid" + ], + [ + [ + 1002, + 1002 + ], + "mapped", + [ + 1003 + ] + ], + [ + [ + 1003, + 1003 + ], + "valid" + ], + [ + [ + 1004, + 1004 + ], + "mapped", + [ + 1005 + ] + ], + [ + [ + 1005, + 1005 + ], + "valid" + ], + [ + [ + 1006, + 1006 + ], + "mapped", + [ + 1007 + ] + ], + [ + [ + 1007, + 1007 + ], + "valid" + ], + [ + [ + 1008, + 1008 + ], + "mapped", + [ + 954 + ] + ], + [ + [ + 1009, + 1009 + ], + "mapped", + [ + 961 + ] + ], + [ + [ + 1010, + 1010 + ], + "mapped", + [ + 963 + ] + ], + [ + [ + 1011, + 1011 + ], + "valid" + ], + [ + [ + 1012, + 1012 + ], + "mapped", + [ + 952 + ] + ], + [ + [ + 1013, + 1013 + ], + "mapped", + [ + 949 + ] + ], + [ + [ + 1014, + 1014 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 1015, + 1015 + ], + "mapped", + [ + 1016 + ] + ], + [ + [ + 1016, + 1016 + ], + "valid" + ], + [ + [ + 1017, + 1017 + ], + "mapped", + [ + 963 + ] + ], + [ + [ + 1018, + 1018 + ], + "mapped", + [ + 1019 + ] + ], + [ + [ + 1019, + 1019 + ], + "valid" + ], + [ + [ + 1020, + 1020 + ], + "valid" + ], + [ + [ + 1021, + 1021 + ], + "mapped", + [ + 891 + ] + ], + [ + [ + 1022, + 1022 + ], + "mapped", + [ + 892 + ] + ], + [ + [ + 1023, + 1023 + ], + "mapped", + [ + 893 + ] + ], + [ + [ + 1024, + 1024 + ], + "mapped", + [ + 1104 + ] + ], + [ + [ + 1025, + 1025 + ], + "mapped", + [ + 1105 + ] + ], + [ + [ + 1026, + 1026 + ], + "mapped", + [ + 1106 + ] + ], + [ + [ + 1027, + 1027 + ], + "mapped", + [ + 1107 + ] + ], + [ + [ + 1028, + 1028 + ], + "mapped", + [ + 1108 + ] + ], + [ + [ + 1029, + 1029 + ], + "mapped", + [ + 1109 + ] + ], + [ + [ + 1030, + 1030 + ], + "mapped", + [ + 1110 + ] + ], + [ + [ + 1031, + 1031 + ], + "mapped", + [ + 1111 + ] + ], + [ + [ + 1032, + 1032 + ], + "mapped", + [ + 1112 + ] + ], + [ + [ + 1033, + 1033 + ], + "mapped", + [ + 1113 + ] + ], + [ + [ + 1034, + 1034 + ], + "mapped", + [ + 1114 + ] + ], + [ + [ + 1035, + 1035 + ], + "mapped", + [ + 1115 + ] + ], + [ + [ + 1036, + 1036 + ], + "mapped", + [ + 1116 + ] + ], + [ + [ + 1037, + 1037 + ], + "mapped", + [ + 1117 + ] + ], + [ + [ + 1038, + 1038 + ], + "mapped", + [ + 1118 + ] + ], + [ + [ + 1039, + 1039 + ], + "mapped", + [ + 1119 + ] + ], + [ + [ + 1040, + 1040 + ], + "mapped", + [ + 1072 + ] + ], + [ + [ + 1041, + 1041 + ], + "mapped", + [ + 1073 + ] + ], + [ + [ + 1042, + 1042 + ], + "mapped", + [ + 1074 + ] + ], + [ + [ + 1043, + 1043 + ], + "mapped", + [ + 1075 + ] + ], + [ + [ + 1044, + 1044 + ], + "mapped", + [ + 1076 + ] + ], + [ + [ + 1045, + 1045 + ], + "mapped", + [ + 1077 + ] + ], + [ + [ + 1046, + 1046 + ], + "mapped", + [ + 1078 + ] + ], + [ + [ + 1047, + 1047 + ], + "mapped", + [ + 1079 + ] + ], + [ + [ + 1048, + 1048 + ], + "mapped", + [ + 1080 + ] + ], + [ + [ + 1049, + 1049 + ], + "mapped", + [ + 1081 + ] + ], + [ + [ + 1050, + 1050 + ], + "mapped", + [ + 1082 + ] + ], + [ + [ + 1051, + 1051 + ], + "mapped", + [ + 1083 + ] + ], + [ + [ + 1052, + 1052 + ], + "mapped", + [ + 1084 + ] + ], + [ + [ + 1053, + 1053 + ], + "mapped", + [ + 1085 + ] + ], + [ + [ + 1054, + 1054 + ], + "mapped", + [ + 1086 + ] + ], + [ + [ + 1055, + 1055 + ], + "mapped", + [ + 1087 + ] + ], + [ + [ + 1056, + 1056 + ], + "mapped", + [ + 1088 + ] + ], + [ + [ + 1057, + 1057 + ], + "mapped", + [ + 1089 + ] + ], + [ + [ + 1058, + 1058 + ], + "mapped", + [ + 1090 + ] + ], + [ + [ + 1059, + 1059 + ], + "mapped", + [ + 1091 + ] + ], + [ + [ + 1060, + 1060 + ], + "mapped", + [ + 1092 + ] + ], + [ + [ + 1061, + 1061 + ], + "mapped", + [ + 1093 + ] + ], + [ + [ + 1062, + 1062 + ], + "mapped", + [ + 1094 + ] + ], + [ + [ + 1063, + 1063 + ], + "mapped", + [ + 1095 + ] + ], + [ + [ + 1064, + 1064 + ], + "mapped", + [ + 1096 + ] + ], + [ + [ + 1065, + 1065 + ], + "mapped", + [ + 1097 + ] + ], + [ + [ + 1066, + 1066 + ], + "mapped", + [ + 1098 + ] + ], + [ + [ + 1067, + 1067 + ], + "mapped", + [ + 1099 + ] + ], + [ + [ + 1068, + 1068 + ], + "mapped", + [ + 1100 + ] + ], + [ + [ + 1069, + 1069 + ], + "mapped", + [ + 1101 + ] + ], + [ + [ + 1070, + 1070 + ], + "mapped", + [ + 1102 + ] + ], + [ + [ + 1071, + 1071 + ], + "mapped", + [ + 1103 + ] + ], + [ + [ + 1072, + 1103 + ], + "valid" + ], + [ + [ + 1104, + 1104 + ], + "valid" + ], + [ + [ + 1105, + 1116 + ], + "valid" + ], + [ + [ + 1117, + 1117 + ], + "valid" + ], + [ + [ + 1118, + 1119 + ], + "valid" + ], + [ + [ + 1120, + 1120 + ], + "mapped", + [ + 1121 + ] + ], + [ + [ + 1121, + 1121 + ], + "valid" + ], + [ + [ + 1122, + 1122 + ], + "mapped", + [ + 1123 + ] + ], + [ + [ + 1123, + 1123 + ], + "valid" + ], + [ + [ + 1124, + 1124 + ], + "mapped", + [ + 1125 + ] + ], + [ + [ + 1125, + 1125 + ], + "valid" + ], + [ + [ + 1126, + 1126 + ], + "mapped", + [ + 1127 + ] + ], + [ + [ + 1127, + 1127 + ], + "valid" + ], + [ + [ + 1128, + 1128 + ], + "mapped", + [ + 1129 + ] + ], + [ + [ + 1129, + 1129 + ], + "valid" + ], + [ + [ + 1130, + 1130 + ], + "mapped", + [ + 1131 + ] + ], + [ + [ + 1131, + 1131 + ], + "valid" + ], + [ + [ + 1132, + 1132 + ], + "mapped", + [ + 1133 + ] + ], + [ + [ + 1133, + 1133 + ], + "valid" + ], + [ + [ + 1134, + 1134 + ], + "mapped", + [ + 1135 + ] + ], + [ + [ + 1135, + 1135 + ], + "valid" + ], + [ + [ + 1136, + 1136 + ], + "mapped", + [ + 1137 + ] + ], + [ + [ + 1137, + 1137 + ], + "valid" + ], + [ + [ + 1138, + 1138 + ], + "mapped", + [ + 1139 + ] + ], + [ + [ + 1139, + 1139 + ], + "valid" + ], + [ + [ + 1140, + 1140 + ], + "mapped", + [ + 1141 + ] + ], + [ + [ + 1141, + 1141 + ], + "valid" + ], + [ + [ + 1142, + 1142 + ], + "mapped", + [ + 1143 + ] + ], + [ + [ + 1143, + 1143 + ], + "valid" + ], + [ + [ + 1144, + 1144 + ], + "mapped", + [ + 1145 + ] + ], + [ + [ + 1145, + 1145 + ], + "valid" + ], + [ + [ + 1146, + 1146 + ], + "mapped", + [ + 1147 + ] + ], + [ + [ + 1147, + 1147 + ], + "valid" + ], + [ + [ + 1148, + 1148 + ], + "mapped", + [ + 1149 + ] + ], + [ + [ + 1149, + 1149 + ], + "valid" + ], + [ + [ + 1150, + 1150 + ], + "mapped", + [ + 1151 + ] + ], + [ + [ + 1151, + 1151 + ], + "valid" + ], + [ + [ + 1152, + 1152 + ], + "mapped", + [ + 1153 + ] + ], + [ + [ + 1153, + 1153 + ], + "valid" + ], + [ + [ + 1154, + 1154 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 1155, + 1158 + ], + "valid" + ], + [ + [ + 1159, + 1159 + ], + "valid" + ], + [ + [ + 1160, + 1161 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 1162, + 1162 + ], + "mapped", + [ + 1163 + ] + ], + [ + [ + 1163, + 1163 + ], + "valid" + ], + [ + [ + 1164, + 1164 + ], + "mapped", + [ + 1165 + ] + ], + [ + [ + 1165, + 1165 + ], + "valid" + ], + [ + [ + 1166, + 1166 + ], + "mapped", + [ + 1167 + ] + ], + [ + [ + 1167, + 1167 + ], + "valid" + ], + [ + [ + 1168, + 1168 + ], + "mapped", + [ + 1169 + ] + ], + [ + [ + 1169, + 1169 + ], + "valid" + ], + [ + [ + 1170, + 1170 + ], + "mapped", + [ + 1171 + ] + ], + [ + [ + 1171, + 1171 + ], + "valid" + ], + [ + [ + 1172, + 1172 + ], + "mapped", + [ + 1173 + ] + ], + [ + [ + 1173, + 1173 + ], + "valid" + ], + [ + [ + 1174, + 1174 + ], + "mapped", + [ + 1175 + ] + ], + [ + [ + 1175, + 1175 + ], + "valid" + ], + [ + [ + 1176, + 1176 + ], + "mapped", + [ + 1177 + ] + ], + [ + [ + 1177, + 1177 + ], + "valid" + ], + [ + [ + 1178, + 1178 + ], + "mapped", + [ + 1179 + ] + ], + [ + [ + 1179, + 1179 + ], + "valid" + ], + [ + [ + 1180, + 1180 + ], + "mapped", + [ + 1181 + ] + ], + [ + [ + 1181, + 1181 + ], + "valid" + ], + [ + [ + 1182, + 1182 + ], + "mapped", + [ + 1183 + ] + ], + [ + [ + 1183, + 1183 + ], + "valid" + ], + [ + [ + 1184, + 1184 + ], + "mapped", + [ + 1185 + ] + ], + [ + [ + 1185, + 1185 + ], + "valid" + ], + [ + [ + 1186, + 1186 + ], + "mapped", + [ + 1187 + ] + ], + [ + [ + 1187, + 1187 + ], + "valid" + ], + [ + [ + 1188, + 1188 + ], + "mapped", + [ + 1189 + ] + ], + [ + [ + 1189, + 1189 + ], + "valid" + ], + [ + [ + 1190, + 1190 + ], + "mapped", + [ + 1191 + ] + ], + [ + [ + 1191, + 1191 + ], + "valid" + ], + [ + [ + 1192, + 1192 + ], + "mapped", + [ + 1193 + ] + ], + [ + [ + 1193, + 1193 + ], + "valid" + ], + [ + [ + 1194, + 1194 + ], + "mapped", + [ + 1195 + ] + ], + [ + [ + 1195, + 1195 + ], + "valid" + ], + [ + [ + 1196, + 1196 + ], + "mapped", + [ + 1197 + ] + ], + [ + [ + 1197, + 1197 + ], + "valid" + ], + [ + [ + 1198, + 1198 + ], + "mapped", + [ + 1199 + ] + ], + [ + [ + 1199, + 1199 + ], + "valid" + ], + [ + [ + 1200, + 1200 + ], + "mapped", + [ + 1201 + ] + ], + [ + [ + 1201, + 1201 + ], + "valid" + ], + [ + [ + 1202, + 1202 + ], + "mapped", + [ + 1203 + ] + ], + [ + [ + 1203, + 1203 + ], + "valid" + ], + [ + [ + 1204, + 1204 + ], + "mapped", + [ + 1205 + ] + ], + [ + [ + 1205, + 1205 + ], + "valid" + ], + [ + [ + 1206, + 1206 + ], + "mapped", + [ + 1207 + ] + ], + [ + [ + 1207, + 1207 + ], + "valid" + ], + [ + [ + 1208, + 1208 + ], + "mapped", + [ + 1209 + ] + ], + [ + [ + 1209, + 1209 + ], + "valid" + ], + [ + [ + 1210, + 1210 + ], + "mapped", + [ + 1211 + ] + ], + [ + [ + 1211, + 1211 + ], + "valid" + ], + [ + [ + 1212, + 1212 + ], + "mapped", + [ + 1213 + ] + ], + [ + [ + 1213, + 1213 + ], + "valid" + ], + [ + [ + 1214, + 1214 + ], + "mapped", + [ + 1215 + ] + ], + [ + [ + 1215, + 1215 + ], + "valid" + ], + [ + [ + 1216, + 1216 + ], + "disallowed" + ], + [ + [ + 1217, + 1217 + ], + "mapped", + [ + 1218 + ] + ], + [ + [ + 1218, + 1218 + ], + "valid" + ], + [ + [ + 1219, + 1219 + ], + "mapped", + [ + 1220 + ] + ], + [ + [ + 1220, + 1220 + ], + "valid" + ], + [ + [ + 1221, + 1221 + ], + "mapped", + [ + 1222 + ] + ], + [ + [ + 1222, + 1222 + ], + "valid" + ], + [ + [ + 1223, + 1223 + ], + "mapped", + [ + 1224 + ] + ], + [ + [ + 1224, + 1224 + ], + "valid" + ], + [ + [ + 1225, + 1225 + ], + "mapped", + [ + 1226 + ] + ], + [ + [ + 1226, + 1226 + ], + "valid" + ], + [ + [ + 1227, + 1227 + ], + "mapped", + [ + 1228 + ] + ], + [ + [ + 1228, + 1228 + ], + "valid" + ], + [ + [ + 1229, + 1229 + ], + "mapped", + [ + 1230 + ] + ], + [ + [ + 1230, + 1230 + ], + "valid" + ], + [ + [ + 1231, + 1231 + ], + "valid" + ], + [ + [ + 1232, + 1232 + ], + "mapped", + [ + 1233 + ] + ], + [ + [ + 1233, + 1233 + ], + "valid" + ], + [ + [ + 1234, + 1234 + ], + "mapped", + [ + 1235 + ] + ], + [ + [ + 1235, + 1235 + ], + "valid" + ], + [ + [ + 1236, + 1236 + ], + "mapped", + [ + 1237 + ] + ], + [ + [ + 1237, + 1237 + ], + "valid" + ], + [ + [ + 1238, + 1238 + ], + "mapped", + [ + 1239 + ] + ], + [ + [ + 1239, + 1239 + ], + "valid" + ], + [ + [ + 1240, + 1240 + ], + "mapped", + [ + 1241 + ] + ], + [ + [ + 1241, + 1241 + ], + "valid" + ], + [ + [ + 1242, + 1242 + ], + "mapped", + [ + 1243 + ] + ], + [ + [ + 1243, + 1243 + ], + "valid" + ], + [ + [ + 1244, + 1244 + ], + "mapped", + [ + 1245 + ] + ], + [ + [ + 1245, + 1245 + ], + "valid" + ], + [ + [ + 1246, + 1246 + ], + "mapped", + [ + 1247 + ] + ], + [ + [ + 1247, + 1247 + ], + "valid" + ], + [ + [ + 1248, + 1248 + ], + "mapped", + [ + 1249 + ] + ], + [ + [ + 1249, + 1249 + ], + "valid" + ], + [ + [ + 1250, + 1250 + ], + "mapped", + [ + 1251 + ] + ], + [ + [ + 1251, + 1251 + ], + "valid" + ], + [ + [ + 1252, + 1252 + ], + "mapped", + [ + 1253 + ] + ], + [ + [ + 1253, + 1253 + ], + "valid" + ], + [ + [ + 1254, + 1254 + ], + "mapped", + [ + 1255 + ] + ], + [ + [ + 1255, + 1255 + ], + "valid" + ], + [ + [ + 1256, + 1256 + ], + "mapped", + [ + 1257 + ] + ], + [ + [ + 1257, + 1257 + ], + "valid" + ], + [ + [ + 1258, + 1258 + ], + "mapped", + [ + 1259 + ] + ], + [ + [ + 1259, + 1259 + ], + "valid" + ], + [ + [ + 1260, + 1260 + ], + "mapped", + [ + 1261 + ] + ], + [ + [ + 1261, + 1261 + ], + "valid" + ], + [ + [ + 1262, + 1262 + ], + "mapped", + [ + 1263 + ] + ], + [ + [ + 1263, + 1263 + ], + "valid" + ], + [ + [ + 1264, + 1264 + ], + "mapped", + [ + 1265 + ] + ], + [ + [ + 1265, + 1265 + ], + "valid" + ], + [ + [ + 1266, + 1266 + ], + "mapped", + [ + 1267 + ] + ], + [ + [ + 1267, + 1267 + ], + "valid" + ], + [ + [ + 1268, + 1268 + ], + "mapped", + [ + 1269 + ] + ], + [ + [ + 1269, + 1269 + ], + "valid" + ], + [ + [ + 1270, + 1270 + ], + "mapped", + [ + 1271 + ] + ], + [ + [ + 1271, + 1271 + ], + "valid" + ], + [ + [ + 1272, + 1272 + ], + "mapped", + [ + 1273 + ] + ], + [ + [ + 1273, + 1273 + ], + "valid" + ], + [ + [ + 1274, + 1274 + ], + "mapped", + [ + 1275 + ] + ], + [ + [ + 1275, + 1275 + ], + "valid" + ], + [ + [ + 1276, + 1276 + ], + "mapped", + [ + 1277 + ] + ], + [ + [ + 1277, + 1277 + ], + "valid" + ], + [ + [ + 1278, + 1278 + ], + "mapped", + [ + 1279 + ] + ], + [ + [ + 1279, + 1279 + ], + "valid" + ], + [ + [ + 1280, + 1280 + ], + "mapped", + [ + 1281 + ] + ], + [ + [ + 1281, + 1281 + ], + "valid" + ], + [ + [ + 1282, + 1282 + ], + "mapped", + [ + 1283 + ] + ], + [ + [ + 1283, + 1283 + ], + "valid" + ], + [ + [ + 1284, + 1284 + ], + "mapped", + [ + 1285 + ] + ], + [ + [ + 1285, + 1285 + ], + "valid" + ], + [ + [ + 1286, + 1286 + ], + "mapped", + [ + 1287 + ] + ], + [ + [ + 1287, + 1287 + ], + "valid" + ], + [ + [ + 1288, + 1288 + ], + "mapped", + [ + 1289 + ] + ], + [ + [ + 1289, + 1289 + ], + "valid" + ], + [ + [ + 1290, + 1290 + ], + "mapped", + [ + 1291 + ] + ], + [ + [ + 1291, + 1291 + ], + "valid" + ], + [ + [ + 1292, + 1292 + ], + "mapped", + [ + 1293 + ] + ], + [ + [ + 1293, + 1293 + ], + "valid" + ], + [ + [ + 1294, + 1294 + ], + "mapped", + [ + 1295 + ] + ], + [ + [ + 1295, + 1295 + ], + "valid" + ], + [ + [ + 1296, + 1296 + ], + "mapped", + [ + 1297 + ] + ], + [ + [ + 1297, + 1297 + ], + "valid" + ], + [ + [ + 1298, + 1298 + ], + "mapped", + [ + 1299 + ] + ], + [ + [ + 1299, + 1299 + ], + "valid" + ], + [ + [ + 1300, + 1300 + ], + "mapped", + [ + 1301 + ] + ], + [ + [ + 1301, + 1301 + ], + "valid" + ], + [ + [ + 1302, + 1302 + ], + "mapped", + [ + 1303 + ] + ], + [ + [ + 1303, + 1303 + ], + "valid" + ], + [ + [ + 1304, + 1304 + ], + "mapped", + [ + 1305 + ] + ], + [ + [ + 1305, + 1305 + ], + "valid" + ], + [ + [ + 1306, + 1306 + ], + "mapped", + [ + 1307 + ] + ], + [ + [ + 1307, + 1307 + ], + "valid" + ], + [ + [ + 1308, + 1308 + ], + "mapped", + [ + 1309 + ] + ], + [ + [ + 1309, + 1309 + ], + "valid" + ], + [ + [ + 1310, + 1310 + ], + "mapped", + [ + 1311 + ] + ], + [ + [ + 1311, + 1311 + ], + "valid" + ], + [ + [ + 1312, + 1312 + ], + "mapped", + [ + 1313 + ] + ], + [ + [ + 1313, + 1313 + ], + "valid" + ], + [ + [ + 1314, + 1314 + ], + "mapped", + [ + 1315 + ] + ], + [ + [ + 1315, + 1315 + ], + "valid" + ], + [ + [ + 1316, + 1316 + ], + "mapped", + [ + 1317 + ] + ], + [ + [ + 1317, + 1317 + ], + "valid" + ], + [ + [ + 1318, + 1318 + ], + "mapped", + [ + 1319 + ] + ], + [ + [ + 1319, + 1319 + ], + "valid" + ], + [ + [ + 1320, + 1320 + ], + "mapped", + [ + 1321 + ] + ], + [ + [ + 1321, + 1321 + ], + "valid" + ], + [ + [ + 1322, + 1322 + ], + "mapped", + [ + 1323 + ] + ], + [ + [ + 1323, + 1323 + ], + "valid" + ], + [ + [ + 1324, + 1324 + ], + "mapped", + [ + 1325 + ] + ], + [ + [ + 1325, + 1325 + ], + "valid" + ], + [ + [ + 1326, + 1326 + ], + "mapped", + [ + 1327 + ] + ], + [ + [ + 1327, + 1327 + ], + "valid" + ], + [ + [ + 1328, + 1328 + ], + "disallowed" + ], + [ + [ + 1329, + 1329 + ], + "mapped", + [ + 1377 + ] + ], + [ + [ + 1330, + 1330 + ], + "mapped", + [ + 1378 + ] + ], + [ + [ + 1331, + 1331 + ], + "mapped", + [ + 1379 + ] + ], + [ + [ + 1332, + 1332 + ], + "mapped", + [ + 1380 + ] + ], + [ + [ + 1333, + 1333 + ], + "mapped", + [ + 1381 + ] + ], + [ + [ + 1334, + 1334 + ], + "mapped", + [ + 1382 + ] + ], + [ + [ + 1335, + 1335 + ], + "mapped", + [ + 1383 + ] + ], + [ + [ + 1336, + 1336 + ], + "mapped", + [ + 1384 + ] + ], + [ + [ + 1337, + 1337 + ], + "mapped", + [ + 1385 + ] + ], + [ + [ + 1338, + 1338 + ], + "mapped", + [ + 1386 + ] + ], + [ + [ + 1339, + 1339 + ], + "mapped", + [ + 1387 + ] + ], + [ + [ + 1340, + 1340 + ], + "mapped", + [ + 1388 + ] + ], + [ + [ + 1341, + 1341 + ], + "mapped", + [ + 1389 + ] + ], + [ + [ + 1342, + 1342 + ], + "mapped", + [ + 1390 + ] + ], + [ + [ + 1343, + 1343 + ], + "mapped", + [ + 1391 + ] + ], + [ + [ + 1344, + 1344 + ], + "mapped", + [ + 1392 + ] + ], + [ + [ + 1345, + 1345 + ], + "mapped", + [ + 1393 + ] + ], + [ + [ + 1346, + 1346 + ], + "mapped", + [ + 1394 + ] + ], + [ + [ + 1347, + 1347 + ], + "mapped", + [ + 1395 + ] + ], + [ + [ + 1348, + 1348 + ], + "mapped", + [ + 1396 + ] + ], + [ + [ + 1349, + 1349 + ], + "mapped", + [ + 1397 + ] + ], + [ + [ + 1350, + 1350 + ], + "mapped", + [ + 1398 + ] + ], + [ + [ + 1351, + 1351 + ], + "mapped", + [ + 1399 + ] + ], + [ + [ + 1352, + 1352 + ], + "mapped", + [ + 1400 + ] + ], + [ + [ + 1353, + 1353 + ], + "mapped", + [ + 1401 + ] + ], + [ + [ + 1354, + 1354 + ], + "mapped", + [ + 1402 + ] + ], + [ + [ + 1355, + 1355 + ], + "mapped", + [ + 1403 + ] + ], + [ + [ + 1356, + 1356 + ], + "mapped", + [ + 1404 + ] + ], + [ + [ + 1357, + 1357 + ], + "mapped", + [ + 1405 + ] + ], + [ + [ + 1358, + 1358 + ], + "mapped", + [ + 1406 + ] + ], + [ + [ + 1359, + 1359 + ], + "mapped", + [ + 1407 + ] + ], + [ + [ + 1360, + 1360 + ], + "mapped", + [ + 1408 + ] + ], + [ + [ + 1361, + 1361 + ], + "mapped", + [ + 1409 + ] + ], + [ + [ + 1362, + 1362 + ], + "mapped", + [ + 1410 + ] + ], + [ + [ + 1363, + 1363 + ], + "mapped", + [ + 1411 + ] + ], + [ + [ + 1364, + 1364 + ], + "mapped", + [ + 1412 + ] + ], + [ + [ + 1365, + 1365 + ], + "mapped", + [ + 1413 + ] + ], + [ + [ + 1366, + 1366 + ], + "mapped", + [ + 1414 + ] + ], + [ + [ + 1367, + 1368 + ], + "disallowed" + ], + [ + [ + 1369, + 1369 + ], + "valid" + ], + [ + [ + 1370, + 1375 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 1376, + 1376 + ], + "disallowed" + ], + [ + [ + 1377, + 1414 + ], + "valid" + ], + [ + [ + 1415, + 1415 + ], + "mapped", + [ + 1381, + 1410 + ] + ], + [ + [ + 1416, + 1416 + ], + "disallowed" + ], + [ + [ + 1417, + 1417 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 1418, + 1418 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 1419, + 1420 + ], + "disallowed" + ], + [ + [ + 1421, + 1422 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 1423, + 1423 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 1424, + 1424 + ], + "disallowed" + ], + [ + [ + 1425, + 1441 + ], + "valid" + ], + [ + [ + 1442, + 1442 + ], + "valid" + ], + [ + [ + 1443, + 1455 + ], + "valid" + ], + [ + [ + 1456, + 1465 + ], + "valid" + ], + [ + [ + 1466, + 1466 + ], + "valid" + ], + [ + [ + 1467, + 1469 + ], + "valid" + ], + [ + [ + 1470, + 1470 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 1471, + 1471 + ], + "valid" + ], + [ + [ + 1472, + 1472 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 1473, + 1474 + ], + "valid" + ], + [ + [ + 1475, + 1475 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 1476, + 1476 + ], + "valid" + ], + [ + [ + 1477, + 1477 + ], + "valid" + ], + [ + [ + 1478, + 1478 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 1479, + 1479 + ], + "valid" + ], + [ + [ + 1480, + 1487 + ], + "disallowed" + ], + [ + [ + 1488, + 1514 + ], + "valid" + ], + [ + [ + 1515, + 1519 + ], + "disallowed" + ], + [ + [ + 1520, + 1524 + ], + "valid" + ], + [ + [ + 1525, + 1535 + ], + "disallowed" + ], + [ + [ + 1536, + 1539 + ], + "disallowed" + ], + [ + [ + 1540, + 1540 + ], + "disallowed" + ], + [ + [ + 1541, + 1541 + ], + "disallowed" + ], + [ + [ + 1542, + 1546 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 1547, + 1547 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 1548, + 1548 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 1549, + 1551 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 1552, + 1557 + ], + "valid" + ], + [ + [ + 1558, + 1562 + ], + "valid" + ], + [ + [ + 1563, + 1563 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 1564, + 1564 + ], + "disallowed" + ], + [ + [ + 1565, + 1565 + ], + "disallowed" + ], + [ + [ + 1566, + 1566 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 1567, + 1567 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 1568, + 1568 + ], + "valid" + ], + [ + [ + 1569, + 1594 + ], + "valid" + ], + [ + [ + 1595, + 1599 + ], + "valid" + ], + [ + [ + 1600, + 1600 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 1601, + 1618 + ], + "valid" + ], + [ + [ + 1619, + 1621 + ], + "valid" + ], + [ + [ + 1622, + 1624 + ], + "valid" + ], + [ + [ + 1625, + 1630 + ], + "valid" + ], + [ + [ + 1631, + 1631 + ], + "valid" + ], + [ + [ + 1632, + 1641 + ], + "valid" + ], + [ + [ + 1642, + 1645 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 1646, + 1647 + ], + "valid" + ], + [ + [ + 1648, + 1652 + ], + "valid" + ], + [ + [ + 1653, + 1653 + ], + "mapped", + [ + 1575, + 1652 + ] + ], + [ + [ + 1654, + 1654 + ], + "mapped", + [ + 1608, + 1652 + ] + ], + [ + [ + 1655, + 1655 + ], + "mapped", + [ + 1735, + 1652 + ] + ], + [ + [ + 1656, + 1656 + ], + "mapped", + [ + 1610, + 1652 + ] + ], + [ + [ + 1657, + 1719 + ], + "valid" + ], + [ + [ + 1720, + 1721 + ], + "valid" + ], + [ + [ + 1722, + 1726 + ], + "valid" + ], + [ + [ + 1727, + 1727 + ], + "valid" + ], + [ + [ + 1728, + 1742 + ], + "valid" + ], + [ + [ + 1743, + 1743 + ], + "valid" + ], + [ + [ + 1744, + 1747 + ], + "valid" + ], + [ + [ + 1748, + 1748 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 1749, + 1756 + ], + "valid" + ], + [ + [ + 1757, + 1757 + ], + "disallowed" + ], + [ + [ + 1758, + 1758 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 1759, + 1768 + ], + "valid" + ], + [ + [ + 1769, + 1769 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 1770, + 1773 + ], + "valid" + ], + [ + [ + 1774, + 1775 + ], + "valid" + ], + [ + [ + 1776, + 1785 + ], + "valid" + ], + [ + [ + 1786, + 1790 + ], + "valid" + ], + [ + [ + 1791, + 1791 + ], + "valid" + ], + [ + [ + 1792, + 1805 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 1806, + 1806 + ], + "disallowed" + ], + [ + [ + 1807, + 1807 + ], + "disallowed" + ], + [ + [ + 1808, + 1836 + ], + "valid" + ], + [ + [ + 1837, + 1839 + ], + "valid" + ], + [ + [ + 1840, + 1866 + ], + "valid" + ], + [ + [ + 1867, + 1868 + ], + "disallowed" + ], + [ + [ + 1869, + 1871 + ], + "valid" + ], + [ + [ + 1872, + 1901 + ], + "valid" + ], + [ + [ + 1902, + 1919 + ], + "valid" + ], + [ + [ + 1920, + 1968 + ], + "valid" + ], + [ + [ + 1969, + 1969 + ], + "valid" + ], + [ + [ + 1970, + 1983 + ], + "disallowed" + ], + [ + [ + 1984, + 2037 + ], + "valid" + ], + [ + [ + 2038, + 2042 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 2043, + 2047 + ], + "disallowed" + ], + [ + [ + 2048, + 2093 + ], + "valid" + ], + [ + [ + 2094, + 2095 + ], + "disallowed" + ], + [ + [ + 2096, + 2110 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 2111, + 2111 + ], + "disallowed" + ], + [ + [ + 2112, + 2139 + ], + "valid" + ], + [ + [ + 2140, + 2141 + ], + "disallowed" + ], + [ + [ + 2142, + 2142 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 2143, + 2207 + ], + "disallowed" + ], + [ + [ + 2208, + 2208 + ], + "valid" + ], + [ + [ + 2209, + 2209 + ], + "valid" + ], + [ + [ + 2210, + 2220 + ], + "valid" + ], + [ + [ + 2221, + 2226 + ], + "valid" + ], + [ + [ + 2227, + 2228 + ], + "valid" + ], + [ + [ + 2229, + 2274 + ], + "disallowed" + ], + [ + [ + 2275, + 2275 + ], + "valid" + ], + [ + [ + 2276, + 2302 + ], + "valid" + ], + [ + [ + 2303, + 2303 + ], + "valid" + ], + [ + [ + 2304, + 2304 + ], + "valid" + ], + [ + [ + 2305, + 2307 + ], + "valid" + ], + [ + [ + 2308, + 2308 + ], + "valid" + ], + [ + [ + 2309, + 2361 + ], + "valid" + ], + [ + [ + 2362, + 2363 + ], + "valid" + ], + [ + [ + 2364, + 2381 + ], + "valid" + ], + [ + [ + 2382, + 2382 + ], + "valid" + ], + [ + [ + 2383, + 2383 + ], + "valid" + ], + [ + [ + 2384, + 2388 + ], + "valid" + ], + [ + [ + 2389, + 2389 + ], + "valid" + ], + [ + [ + 2390, + 2391 + ], + "valid" + ], + [ + [ + 2392, + 2392 + ], + "mapped", + [ + 2325, + 2364 + ] + ], + [ + [ + 2393, + 2393 + ], + "mapped", + [ + 2326, + 2364 + ] + ], + [ + [ + 2394, + 2394 + ], + "mapped", + [ + 2327, + 2364 + ] + ], + [ + [ + 2395, + 2395 + ], + "mapped", + [ + 2332, + 2364 + ] + ], + [ + [ + 2396, + 2396 + ], + "mapped", + [ + 2337, + 2364 + ] + ], + [ + [ + 2397, + 2397 + ], + "mapped", + [ + 2338, + 2364 + ] + ], + [ + [ + 2398, + 2398 + ], + "mapped", + [ + 2347, + 2364 + ] + ], + [ + [ + 2399, + 2399 + ], + "mapped", + [ + 2351, + 2364 + ] + ], + [ + [ + 2400, + 2403 + ], + "valid" + ], + [ + [ + 2404, + 2405 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 2406, + 2415 + ], + "valid" + ], + [ + [ + 2416, + 2416 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 2417, + 2418 + ], + "valid" + ], + [ + [ + 2419, + 2423 + ], + "valid" + ], + [ + [ + 2424, + 2424 + ], + "valid" + ], + [ + [ + 2425, + 2426 + ], + "valid" + ], + [ + [ + 2427, + 2428 + ], + "valid" + ], + [ + [ + 2429, + 2429 + ], + "valid" + ], + [ + [ + 2430, + 2431 + ], + "valid" + ], + [ + [ + 2432, + 2432 + ], + "valid" + ], + [ + [ + 2433, + 2435 + ], + "valid" + ], + [ + [ + 2436, + 2436 + ], + "disallowed" + ], + [ + [ + 2437, + 2444 + ], + "valid" + ], + [ + [ + 2445, + 2446 + ], + "disallowed" + ], + [ + [ + 2447, + 2448 + ], + "valid" + ], + [ + [ + 2449, + 2450 + ], + "disallowed" + ], + [ + [ + 2451, + 2472 + ], + "valid" + ], + [ + [ + 2473, + 2473 + ], + "disallowed" + ], + [ + [ + 2474, + 2480 + ], + "valid" + ], + [ + [ + 2481, + 2481 + ], + "disallowed" + ], + [ + [ + 2482, + 2482 + ], + "valid" + ], + [ + [ + 2483, + 2485 + ], + "disallowed" + ], + [ + [ + 2486, + 2489 + ], + "valid" + ], + [ + [ + 2490, + 2491 + ], + "disallowed" + ], + [ + [ + 2492, + 2492 + ], + "valid" + ], + [ + [ + 2493, + 2493 + ], + "valid" + ], + [ + [ + 2494, + 2500 + ], + "valid" + ], + [ + [ + 2501, + 2502 + ], + "disallowed" + ], + [ + [ + 2503, + 2504 + ], + "valid" + ], + [ + [ + 2505, + 2506 + ], + "disallowed" + ], + [ + [ + 2507, + 2509 + ], + "valid" + ], + [ + [ + 2510, + 2510 + ], + "valid" + ], + [ + [ + 2511, + 2518 + ], + "disallowed" + ], + [ + [ + 2519, + 2519 + ], + "valid" + ], + [ + [ + 2520, + 2523 + ], + "disallowed" + ], + [ + [ + 2524, + 2524 + ], + "mapped", + [ + 2465, + 2492 + ] + ], + [ + [ + 2525, + 2525 + ], + "mapped", + [ + 2466, + 2492 + ] + ], + [ + [ + 2526, + 2526 + ], + "disallowed" + ], + [ + [ + 2527, + 2527 + ], + "mapped", + [ + 2479, + 2492 + ] + ], + [ + [ + 2528, + 2531 + ], + "valid" + ], + [ + [ + 2532, + 2533 + ], + "disallowed" + ], + [ + [ + 2534, + 2545 + ], + "valid" + ], + [ + [ + 2546, + 2554 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 2555, + 2555 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 2556, + 2560 + ], + "disallowed" + ], + [ + [ + 2561, + 2561 + ], + "valid" + ], + [ + [ + 2562, + 2562 + ], + "valid" + ], + [ + [ + 2563, + 2563 + ], + "valid" + ], + [ + [ + 2564, + 2564 + ], + "disallowed" + ], + [ + [ + 2565, + 2570 + ], + "valid" + ], + [ + [ + 2571, + 2574 + ], + "disallowed" + ], + [ + [ + 2575, + 2576 + ], + "valid" + ], + [ + [ + 2577, + 2578 + ], + "disallowed" + ], + [ + [ + 2579, + 2600 + ], + "valid" + ], + [ + [ + 2601, + 2601 + ], + "disallowed" + ], + [ + [ + 2602, + 2608 + ], + "valid" + ], + [ + [ + 2609, + 2609 + ], + "disallowed" + ], + [ + [ + 2610, + 2610 + ], + "valid" + ], + [ + [ + 2611, + 2611 + ], + "mapped", + [ + 2610, + 2620 + ] + ], + [ + [ + 2612, + 2612 + ], + "disallowed" + ], + [ + [ + 2613, + 2613 + ], + "valid" + ], + [ + [ + 2614, + 2614 + ], + "mapped", + [ + 2616, + 2620 + ] + ], + [ + [ + 2615, + 2615 + ], + "disallowed" + ], + [ + [ + 2616, + 2617 + ], + "valid" + ], + [ + [ + 2618, + 2619 + ], + "disallowed" + ], + [ + [ + 2620, + 2620 + ], + "valid" + ], + [ + [ + 2621, + 2621 + ], + "disallowed" + ], + [ + [ + 2622, + 2626 + ], + "valid" + ], + [ + [ + 2627, + 2630 + ], + "disallowed" + ], + [ + [ + 2631, + 2632 + ], + "valid" + ], + [ + [ + 2633, + 2634 + ], + "disallowed" + ], + [ + [ + 2635, + 2637 + ], + "valid" + ], + [ + [ + 2638, + 2640 + ], + "disallowed" + ], + [ + [ + 2641, + 2641 + ], + "valid" + ], + [ + [ + 2642, + 2648 + ], + "disallowed" + ], + [ + [ + 2649, + 2649 + ], + "mapped", + [ + 2582, + 2620 + ] + ], + [ + [ + 2650, + 2650 + ], + "mapped", + [ + 2583, + 2620 + ] + ], + [ + [ + 2651, + 2651 + ], + "mapped", + [ + 2588, + 2620 + ] + ], + [ + [ + 2652, + 2652 + ], + "valid" + ], + [ + [ + 2653, + 2653 + ], + "disallowed" + ], + [ + [ + 2654, + 2654 + ], + "mapped", + [ + 2603, + 2620 + ] + ], + [ + [ + 2655, + 2661 + ], + "disallowed" + ], + [ + [ + 2662, + 2676 + ], + "valid" + ], + [ + [ + 2677, + 2677 + ], + "valid" + ], + [ + [ + 2678, + 2688 + ], + "disallowed" + ], + [ + [ + 2689, + 2691 + ], + "valid" + ], + [ + [ + 2692, + 2692 + ], + "disallowed" + ], + [ + [ + 2693, + 2699 + ], + "valid" + ], + [ + [ + 2700, + 2700 + ], + "valid" + ], + [ + [ + 2701, + 2701 + ], + "valid" + ], + [ + [ + 2702, + 2702 + ], + "disallowed" + ], + [ + [ + 2703, + 2705 + ], + "valid" + ], + [ + [ + 2706, + 2706 + ], + "disallowed" + ], + [ + [ + 2707, + 2728 + ], + "valid" + ], + [ + [ + 2729, + 2729 + ], + "disallowed" + ], + [ + [ + 2730, + 2736 + ], + "valid" + ], + [ + [ + 2737, + 2737 + ], + "disallowed" + ], + [ + [ + 2738, + 2739 + ], + "valid" + ], + [ + [ + 2740, + 2740 + ], + "disallowed" + ], + [ + [ + 2741, + 2745 + ], + "valid" + ], + [ + [ + 2746, + 2747 + ], + "disallowed" + ], + [ + [ + 2748, + 2757 + ], + "valid" + ], + [ + [ + 2758, + 2758 + ], + "disallowed" + ], + [ + [ + 2759, + 2761 + ], + "valid" + ], + [ + [ + 2762, + 2762 + ], + "disallowed" + ], + [ + [ + 2763, + 2765 + ], + "valid" + ], + [ + [ + 2766, + 2767 + ], + "disallowed" + ], + [ + [ + 2768, + 2768 + ], + "valid" + ], + [ + [ + 2769, + 2783 + ], + "disallowed" + ], + [ + [ + 2784, + 2784 + ], + "valid" + ], + [ + [ + 2785, + 2787 + ], + "valid" + ], + [ + [ + 2788, + 2789 + ], + "disallowed" + ], + [ + [ + 2790, + 2799 + ], + "valid" + ], + [ + [ + 2800, + 2800 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 2801, + 2801 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 2802, + 2808 + ], + "disallowed" + ], + [ + [ + 2809, + 2809 + ], + "valid" + ], + [ + [ + 2810, + 2816 + ], + "disallowed" + ], + [ + [ + 2817, + 2819 + ], + "valid" + ], + [ + [ + 2820, + 2820 + ], + "disallowed" + ], + [ + [ + 2821, + 2828 + ], + "valid" + ], + [ + [ + 2829, + 2830 + ], + "disallowed" + ], + [ + [ + 2831, + 2832 + ], + "valid" + ], + [ + [ + 2833, + 2834 + ], + "disallowed" + ], + [ + [ + 2835, + 2856 + ], + "valid" + ], + [ + [ + 2857, + 2857 + ], + "disallowed" + ], + [ + [ + 2858, + 2864 + ], + "valid" + ], + [ + [ + 2865, + 2865 + ], + "disallowed" + ], + [ + [ + 2866, + 2867 + ], + "valid" + ], + [ + [ + 2868, + 2868 + ], + "disallowed" + ], + [ + [ + 2869, + 2869 + ], + "valid" + ], + [ + [ + 2870, + 2873 + ], + "valid" + ], + [ + [ + 2874, + 2875 + ], + "disallowed" + ], + [ + [ + 2876, + 2883 + ], + "valid" + ], + [ + [ + 2884, + 2884 + ], + "valid" + ], + [ + [ + 2885, + 2886 + ], + "disallowed" + ], + [ + [ + 2887, + 2888 + ], + "valid" + ], + [ + [ + 2889, + 2890 + ], + "disallowed" + ], + [ + [ + 2891, + 2893 + ], + "valid" + ], + [ + [ + 2894, + 2901 + ], + "disallowed" + ], + [ + [ + 2902, + 2903 + ], + "valid" + ], + [ + [ + 2904, + 2907 + ], + "disallowed" + ], + [ + [ + 2908, + 2908 + ], + "mapped", + [ + 2849, + 2876 + ] + ], + [ + [ + 2909, + 2909 + ], + "mapped", + [ + 2850, + 2876 + ] + ], + [ + [ + 2910, + 2910 + ], + "disallowed" + ], + [ + [ + 2911, + 2913 + ], + "valid" + ], + [ + [ + 2914, + 2915 + ], + "valid" + ], + [ + [ + 2916, + 2917 + ], + "disallowed" + ], + [ + [ + 2918, + 2927 + ], + "valid" + ], + [ + [ + 2928, + 2928 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 2929, + 2929 + ], + "valid" + ], + [ + [ + 2930, + 2935 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 2936, + 2945 + ], + "disallowed" + ], + [ + [ + 2946, + 2947 + ], + "valid" + ], + [ + [ + 2948, + 2948 + ], + "disallowed" + ], + [ + [ + 2949, + 2954 + ], + "valid" + ], + [ + [ + 2955, + 2957 + ], + "disallowed" + ], + [ + [ + 2958, + 2960 + ], + "valid" + ], + [ + [ + 2961, + 2961 + ], + "disallowed" + ], + [ + [ + 2962, + 2965 + ], + "valid" + ], + [ + [ + 2966, + 2968 + ], + "disallowed" + ], + [ + [ + 2969, + 2970 + ], + "valid" + ], + [ + [ + 2971, + 2971 + ], + "disallowed" + ], + [ + [ + 2972, + 2972 + ], + "valid" + ], + [ + [ + 2973, + 2973 + ], + "disallowed" + ], + [ + [ + 2974, + 2975 + ], + "valid" + ], + [ + [ + 2976, + 2978 + ], + "disallowed" + ], + [ + [ + 2979, + 2980 + ], + "valid" + ], + [ + [ + 2981, + 2983 + ], + "disallowed" + ], + [ + [ + 2984, + 2986 + ], + "valid" + ], + [ + [ + 2987, + 2989 + ], + "disallowed" + ], + [ + [ + 2990, + 2997 + ], + "valid" + ], + [ + [ + 2998, + 2998 + ], + "valid" + ], + [ + [ + 2999, + 3001 + ], + "valid" + ], + [ + [ + 3002, + 3005 + ], + "disallowed" + ], + [ + [ + 3006, + 3010 + ], + "valid" + ], + [ + [ + 3011, + 3013 + ], + "disallowed" + ], + [ + [ + 3014, + 3016 + ], + "valid" + ], + [ + [ + 3017, + 3017 + ], + "disallowed" + ], + [ + [ + 3018, + 3021 + ], + "valid" + ], + [ + [ + 3022, + 3023 + ], + "disallowed" + ], + [ + [ + 3024, + 3024 + ], + "valid" + ], + [ + [ + 3025, + 3030 + ], + "disallowed" + ], + [ + [ + 3031, + 3031 + ], + "valid" + ], + [ + [ + 3032, + 3045 + ], + "disallowed" + ], + [ + [ + 3046, + 3046 + ], + "valid" + ], + [ + [ + 3047, + 3055 + ], + "valid" + ], + [ + [ + 3056, + 3058 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 3059, + 3066 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 3067, + 3071 + ], + "disallowed" + ], + [ + [ + 3072, + 3072 + ], + "valid" + ], + [ + [ + 3073, + 3075 + ], + "valid" + ], + [ + [ + 3076, + 3076 + ], + "disallowed" + ], + [ + [ + 3077, + 3084 + ], + "valid" + ], + [ + [ + 3085, + 3085 + ], + "disallowed" + ], + [ + [ + 3086, + 3088 + ], + "valid" + ], + [ + [ + 3089, + 3089 + ], + "disallowed" + ], + [ + [ + 3090, + 3112 + ], + "valid" + ], + [ + [ + 3113, + 3113 + ], + "disallowed" + ], + [ + [ + 3114, + 3123 + ], + "valid" + ], + [ + [ + 3124, + 3124 + ], + "valid" + ], + [ + [ + 3125, + 3129 + ], + "valid" + ], + [ + [ + 3130, + 3132 + ], + "disallowed" + ], + [ + [ + 3133, + 3133 + ], + "valid" + ], + [ + [ + 3134, + 3140 + ], + "valid" + ], + [ + [ + 3141, + 3141 + ], + "disallowed" + ], + [ + [ + 3142, + 3144 + ], + "valid" + ], + [ + [ + 3145, + 3145 + ], + "disallowed" + ], + [ + [ + 3146, + 3149 + ], + "valid" + ], + [ + [ + 3150, + 3156 + ], + "disallowed" + ], + [ + [ + 3157, + 3158 + ], + "valid" + ], + [ + [ + 3159, + 3159 + ], + "disallowed" + ], + [ + [ + 3160, + 3161 + ], + "valid" + ], + [ + [ + 3162, + 3162 + ], + "valid" + ], + [ + [ + 3163, + 3167 + ], + "disallowed" + ], + [ + [ + 3168, + 3169 + ], + "valid" + ], + [ + [ + 3170, + 3171 + ], + "valid" + ], + [ + [ + 3172, + 3173 + ], + "disallowed" + ], + [ + [ + 3174, + 3183 + ], + "valid" + ], + [ + [ + 3184, + 3191 + ], + "disallowed" + ], + [ + [ + 3192, + 3199 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 3200, + 3200 + ], + "disallowed" + ], + [ + [ + 3201, + 3201 + ], + "valid" + ], + [ + [ + 3202, + 3203 + ], + "valid" + ], + [ + [ + 3204, + 3204 + ], + "disallowed" + ], + [ + [ + 3205, + 3212 + ], + "valid" + ], + [ + [ + 3213, + 3213 + ], + "disallowed" + ], + [ + [ + 3214, + 3216 + ], + "valid" + ], + [ + [ + 3217, + 3217 + ], + "disallowed" + ], + [ + [ + 3218, + 3240 + ], + "valid" + ], + [ + [ + 3241, + 3241 + ], + "disallowed" + ], + [ + [ + 3242, + 3251 + ], + "valid" + ], + [ + [ + 3252, + 3252 + ], + "disallowed" + ], + [ + [ + 3253, + 3257 + ], + "valid" + ], + [ + [ + 3258, + 3259 + ], + "disallowed" + ], + [ + [ + 3260, + 3261 + ], + "valid" + ], + [ + [ + 3262, + 3268 + ], + "valid" + ], + [ + [ + 3269, + 3269 + ], + "disallowed" + ], + [ + [ + 3270, + 3272 + ], + "valid" + ], + [ + [ + 3273, + 3273 + ], + "disallowed" + ], + [ + [ + 3274, + 3277 + ], + "valid" + ], + [ + [ + 3278, + 3284 + ], + "disallowed" + ], + [ + [ + 3285, + 3286 + ], + "valid" + ], + [ + [ + 3287, + 3293 + ], + "disallowed" + ], + [ + [ + 3294, + 3294 + ], + "valid" + ], + [ + [ + 3295, + 3295 + ], + "disallowed" + ], + [ + [ + 3296, + 3297 + ], + "valid" + ], + [ + [ + 3298, + 3299 + ], + "valid" + ], + [ + [ + 3300, + 3301 + ], + "disallowed" + ], + [ + [ + 3302, + 3311 + ], + "valid" + ], + [ + [ + 3312, + 3312 + ], + "disallowed" + ], + [ + [ + 3313, + 3314 + ], + "valid" + ], + [ + [ + 3315, + 3328 + ], + "disallowed" + ], + [ + [ + 3329, + 3329 + ], + "valid" + ], + [ + [ + 3330, + 3331 + ], + "valid" + ], + [ + [ + 3332, + 3332 + ], + "disallowed" + ], + [ + [ + 3333, + 3340 + ], + "valid" + ], + [ + [ + 3341, + 3341 + ], + "disallowed" + ], + [ + [ + 3342, + 3344 + ], + "valid" + ], + [ + [ + 3345, + 3345 + ], + "disallowed" + ], + [ + [ + 3346, + 3368 + ], + "valid" + ], + [ + [ + 3369, + 3369 + ], + "valid" + ], + [ + [ + 3370, + 3385 + ], + "valid" + ], + [ + [ + 3386, + 3386 + ], + "valid" + ], + [ + [ + 3387, + 3388 + ], + "disallowed" + ], + [ + [ + 3389, + 3389 + ], + "valid" + ], + [ + [ + 3390, + 3395 + ], + "valid" + ], + [ + [ + 3396, + 3396 + ], + "valid" + ], + [ + [ + 3397, + 3397 + ], + "disallowed" + ], + [ + [ + 3398, + 3400 + ], + "valid" + ], + [ + [ + 3401, + 3401 + ], + "disallowed" + ], + [ + [ + 3402, + 3405 + ], + "valid" + ], + [ + [ + 3406, + 3406 + ], + "valid" + ], + [ + [ + 3407, + 3414 + ], + "disallowed" + ], + [ + [ + 3415, + 3415 + ], + "valid" + ], + [ + [ + 3416, + 3422 + ], + "disallowed" + ], + [ + [ + 3423, + 3423 + ], + "valid" + ], + [ + [ + 3424, + 3425 + ], + "valid" + ], + [ + [ + 3426, + 3427 + ], + "valid" + ], + [ + [ + 3428, + 3429 + ], + "disallowed" + ], + [ + [ + 3430, + 3439 + ], + "valid" + ], + [ + [ + 3440, + 3445 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 3446, + 3448 + ], + "disallowed" + ], + [ + [ + 3449, + 3449 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 3450, + 3455 + ], + "valid" + ], + [ + [ + 3456, + 3457 + ], + "disallowed" + ], + [ + [ + 3458, + 3459 + ], + "valid" + ], + [ + [ + 3460, + 3460 + ], + "disallowed" + ], + [ + [ + 3461, + 3478 + ], + "valid" + ], + [ + [ + 3479, + 3481 + ], + "disallowed" + ], + [ + [ + 3482, + 3505 + ], + "valid" + ], + [ + [ + 3506, + 3506 + ], + "disallowed" + ], + [ + [ + 3507, + 3515 + ], + "valid" + ], + [ + [ + 3516, + 3516 + ], + "disallowed" + ], + [ + [ + 3517, + 3517 + ], + "valid" + ], + [ + [ + 3518, + 3519 + ], + "disallowed" + ], + [ + [ + 3520, + 3526 + ], + "valid" + ], + [ + [ + 3527, + 3529 + ], + "disallowed" + ], + [ + [ + 3530, + 3530 + ], + "valid" + ], + [ + [ + 3531, + 3534 + ], + "disallowed" + ], + [ + [ + 3535, + 3540 + ], + "valid" + ], + [ + [ + 3541, + 3541 + ], + "disallowed" + ], + [ + [ + 3542, + 3542 + ], + "valid" + ], + [ + [ + 3543, + 3543 + ], + "disallowed" + ], + [ + [ + 3544, + 3551 + ], + "valid" + ], + [ + [ + 3552, + 3557 + ], + "disallowed" + ], + [ + [ + 3558, + 3567 + ], + "valid" + ], + [ + [ + 3568, + 3569 + ], + "disallowed" + ], + [ + [ + 3570, + 3571 + ], + "valid" + ], + [ + [ + 3572, + 3572 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 3573, + 3584 + ], + "disallowed" + ], + [ + [ + 3585, + 3634 + ], + "valid" + ], + [ + [ + 3635, + 3635 + ], + "mapped", + [ + 3661, + 3634 + ] + ], + [ + [ + 3636, + 3642 + ], + "valid" + ], + [ + [ + 3643, + 3646 + ], + "disallowed" + ], + [ + [ + 3647, + 3647 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 3648, + 3662 + ], + "valid" + ], + [ + [ + 3663, + 3663 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 3664, + 3673 + ], + "valid" + ], + [ + [ + 3674, + 3675 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 3676, + 3712 + ], + "disallowed" + ], + [ + [ + 3713, + 3714 + ], + "valid" + ], + [ + [ + 3715, + 3715 + ], + "disallowed" + ], + [ + [ + 3716, + 3716 + ], + "valid" + ], + [ + [ + 3717, + 3718 + ], + "disallowed" + ], + [ + [ + 3719, + 3720 + ], + "valid" + ], + [ + [ + 3721, + 3721 + ], + "disallowed" + ], + [ + [ + 3722, + 3722 + ], + "valid" + ], + [ + [ + 3723, + 3724 + ], + "disallowed" + ], + [ + [ + 3725, + 3725 + ], + "valid" + ], + [ + [ + 3726, + 3731 + ], + "disallowed" + ], + [ + [ + 3732, + 3735 + ], + "valid" + ], + [ + [ + 3736, + 3736 + ], + "disallowed" + ], + [ + [ + 3737, + 3743 + ], + "valid" + ], + [ + [ + 3744, + 3744 + ], + "disallowed" + ], + [ + [ + 3745, + 3747 + ], + "valid" + ], + [ + [ + 3748, + 3748 + ], + "disallowed" + ], + [ + [ + 3749, + 3749 + ], + "valid" + ], + [ + [ + 3750, + 3750 + ], + "disallowed" + ], + [ + [ + 3751, + 3751 + ], + "valid" + ], + [ + [ + 3752, + 3753 + ], + "disallowed" + ], + [ + [ + 3754, + 3755 + ], + "valid" + ], + [ + [ + 3756, + 3756 + ], + "disallowed" + ], + [ + [ + 3757, + 3762 + ], + "valid" + ], + [ + [ + 3763, + 3763 + ], + "mapped", + [ + 3789, + 3762 + ] + ], + [ + [ + 3764, + 3769 + ], + "valid" + ], + [ + [ + 3770, + 3770 + ], + "disallowed" + ], + [ + [ + 3771, + 3773 + ], + "valid" + ], + [ + [ + 3774, + 3775 + ], + "disallowed" + ], + [ + [ + 3776, + 3780 + ], + "valid" + ], + [ + [ + 3781, + 3781 + ], + "disallowed" + ], + [ + [ + 3782, + 3782 + ], + "valid" + ], + [ + [ + 3783, + 3783 + ], + "disallowed" + ], + [ + [ + 3784, + 3789 + ], + "valid" + ], + [ + [ + 3790, + 3791 + ], + "disallowed" + ], + [ + [ + 3792, + 3801 + ], + "valid" + ], + [ + [ + 3802, + 3803 + ], + "disallowed" + ], + [ + [ + 3804, + 3804 + ], + "mapped", + [ + 3755, + 3737 + ] + ], + [ + [ + 3805, + 3805 + ], + "mapped", + [ + 3755, + 3745 + ] + ], + [ + [ + 3806, + 3807 + ], + "valid" + ], + [ + [ + 3808, + 3839 + ], + "disallowed" + ], + [ + [ + 3840, + 3840 + ], + "valid" + ], + [ + [ + 3841, + 3850 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 3851, + 3851 + ], + "valid" + ], + [ + [ + 3852, + 3852 + ], + "mapped", + [ + 3851 + ] + ], + [ + [ + 3853, + 3863 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 3864, + 3865 + ], + "valid" + ], + [ + [ + 3866, + 3871 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 3872, + 3881 + ], + "valid" + ], + [ + [ + 3882, + 3892 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 3893, + 3893 + ], + "valid" + ], + [ + [ + 3894, + 3894 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 3895, + 3895 + ], + "valid" + ], + [ + [ + 3896, + 3896 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 3897, + 3897 + ], + "valid" + ], + [ + [ + 3898, + 3901 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 3902, + 3906 + ], + "valid" + ], + [ + [ + 3907, + 3907 + ], + "mapped", + [ + 3906, + 4023 + ] + ], + [ + [ + 3908, + 3911 + ], + "valid" + ], + [ + [ + 3912, + 3912 + ], + "disallowed" + ], + [ + [ + 3913, + 3916 + ], + "valid" + ], + [ + [ + 3917, + 3917 + ], + "mapped", + [ + 3916, + 4023 + ] + ], + [ + [ + 3918, + 3921 + ], + "valid" + ], + [ + [ + 3922, + 3922 + ], + "mapped", + [ + 3921, + 4023 + ] + ], + [ + [ + 3923, + 3926 + ], + "valid" + ], + [ + [ + 3927, + 3927 + ], + "mapped", + [ + 3926, + 4023 + ] + ], + [ + [ + 3928, + 3931 + ], + "valid" + ], + [ + [ + 3932, + 3932 + ], + "mapped", + [ + 3931, + 4023 + ] + ], + [ + [ + 3933, + 3944 + ], + "valid" + ], + [ + [ + 3945, + 3945 + ], + "mapped", + [ + 3904, + 4021 + ] + ], + [ + [ + 3946, + 3946 + ], + "valid" + ], + [ + [ + 3947, + 3948 + ], + "valid" + ], + [ + [ + 3949, + 3952 + ], + "disallowed" + ], + [ + [ + 3953, + 3954 + ], + "valid" + ], + [ + [ + 3955, + 3955 + ], + "mapped", + [ + 3953, + 3954 + ] + ], + [ + [ + 3956, + 3956 + ], + "valid" + ], + [ + [ + 3957, + 3957 + ], + "mapped", + [ + 3953, + 3956 + ] + ], + [ + [ + 3958, + 3958 + ], + "mapped", + [ + 4018, + 3968 + ] + ], + [ + [ + 3959, + 3959 + ], + "mapped", + [ + 4018, + 3953, + 3968 + ] + ], + [ + [ + 3960, + 3960 + ], + "mapped", + [ + 4019, + 3968 + ] + ], + [ + [ + 3961, + 3961 + ], + "mapped", + [ + 4019, + 3953, + 3968 + ] + ], + [ + [ + 3962, + 3968 + ], + "valid" + ], + [ + [ + 3969, + 3969 + ], + "mapped", + [ + 3953, + 3968 + ] + ], + [ + [ + 3970, + 3972 + ], + "valid" + ], + [ + [ + 3973, + 3973 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 3974, + 3979 + ], + "valid" + ], + [ + [ + 3980, + 3983 + ], + "valid" + ], + [ + [ + 3984, + 3986 + ], + "valid" + ], + [ + [ + 3987, + 3987 + ], + "mapped", + [ + 3986, + 4023 + ] + ], + [ + [ + 3988, + 3989 + ], + "valid" + ], + [ + [ + 3990, + 3990 + ], + "valid" + ], + [ + [ + 3991, + 3991 + ], + "valid" + ], + [ + [ + 3992, + 3992 + ], + "disallowed" + ], + [ + [ + 3993, + 3996 + ], + "valid" + ], + [ + [ + 3997, + 3997 + ], + "mapped", + [ + 3996, + 4023 + ] + ], + [ + [ + 3998, + 4001 + ], + "valid" + ], + [ + [ + 4002, + 4002 + ], + "mapped", + [ + 4001, + 4023 + ] + ], + [ + [ + 4003, + 4006 + ], + "valid" + ], + [ + [ + 4007, + 4007 + ], + "mapped", + [ + 4006, + 4023 + ] + ], + [ + [ + 4008, + 4011 + ], + "valid" + ], + [ + [ + 4012, + 4012 + ], + "mapped", + [ + 4011, + 4023 + ] + ], + [ + [ + 4013, + 4013 + ], + "valid" + ], + [ + [ + 4014, + 4016 + ], + "valid" + ], + [ + [ + 4017, + 4023 + ], + "valid" + ], + [ + [ + 4024, + 4024 + ], + "valid" + ], + [ + [ + 4025, + 4025 + ], + "mapped", + [ + 3984, + 4021 + ] + ], + [ + [ + 4026, + 4028 + ], + "valid" + ], + [ + [ + 4029, + 4029 + ], + "disallowed" + ], + [ + [ + 4030, + 4037 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 4038, + 4038 + ], + "valid" + ], + [ + [ + 4039, + 4044 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 4045, + 4045 + ], + "disallowed" + ], + [ + [ + 4046, + 4046 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 4047, + 4047 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 4048, + 4049 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 4050, + 4052 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 4053, + 4056 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 4057, + 4058 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 4059, + 4095 + ], + "disallowed" + ], + [ + [ + 4096, + 4129 + ], + "valid" + ], + [ + [ + 4130, + 4130 + ], + "valid" + ], + [ + [ + 4131, + 4135 + ], + "valid" + ], + [ + [ + 4136, + 4136 + ], + "valid" + ], + [ + [ + 4137, + 4138 + ], + "valid" + ], + [ + [ + 4139, + 4139 + ], + "valid" + ], + [ + [ + 4140, + 4146 + ], + "valid" + ], + [ + [ + 4147, + 4149 + ], + "valid" + ], + [ + [ + 4150, + 4153 + ], + "valid" + ], + [ + [ + 4154, + 4159 + ], + "valid" + ], + [ + [ + 4160, + 4169 + ], + "valid" + ], + [ + [ + 4170, + 4175 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 4176, + 4185 + ], + "valid" + ], + [ + [ + 4186, + 4249 + ], + "valid" + ], + [ + [ + 4250, + 4253 + ], + "valid" + ], + [ + [ + 4254, + 4255 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 4256, + 4293 + ], + "disallowed" + ], + [ + [ + 4294, + 4294 + ], + "disallowed" + ], + [ + [ + 4295, + 4295 + ], + "mapped", + [ + 11559 + ] + ], + [ + [ + 4296, + 4300 + ], + "disallowed" + ], + [ + [ + 4301, + 4301 + ], + "mapped", + [ + 11565 + ] + ], + [ + [ + 4302, + 4303 + ], + "disallowed" + ], + [ + [ + 4304, + 4342 + ], + "valid" + ], + [ + [ + 4343, + 4344 + ], + "valid" + ], + [ + [ + 4345, + 4346 + ], + "valid" + ], + [ + [ + 4347, + 4347 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 4348, + 4348 + ], + "mapped", + [ + 4316 + ] + ], + [ + [ + 4349, + 4351 + ], + "valid" + ], + [ + [ + 4352, + 4441 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 4442, + 4446 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 4447, + 4448 + ], + "disallowed" + ], + [ + [ + 4449, + 4514 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 4515, + 4519 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 4520, + 4601 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 4602, + 4607 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 4608, + 4614 + ], + "valid" + ], + [ + [ + 4615, + 4615 + ], + "valid" + ], + [ + [ + 4616, + 4678 + ], + "valid" + ], + [ + [ + 4679, + 4679 + ], + "valid" + ], + [ + [ + 4680, + 4680 + ], + "valid" + ], + [ + [ + 4681, + 4681 + ], + "disallowed" + ], + [ + [ + 4682, + 4685 + ], + "valid" + ], + [ + [ + 4686, + 4687 + ], + "disallowed" + ], + [ + [ + 4688, + 4694 + ], + "valid" + ], + [ + [ + 4695, + 4695 + ], + "disallowed" + ], + [ + [ + 4696, + 4696 + ], + "valid" + ], + [ + [ + 4697, + 4697 + ], + "disallowed" + ], + [ + [ + 4698, + 4701 + ], + "valid" + ], + [ + [ + 4702, + 4703 + ], + "disallowed" + ], + [ + [ + 4704, + 4742 + ], + "valid" + ], + [ + [ + 4743, + 4743 + ], + "valid" + ], + [ + [ + 4744, + 4744 + ], + "valid" + ], + [ + [ + 4745, + 4745 + ], + "disallowed" + ], + [ + [ + 4746, + 4749 + ], + "valid" + ], + [ + [ + 4750, + 4751 + ], + "disallowed" + ], + [ + [ + 4752, + 4782 + ], + "valid" + ], + [ + [ + 4783, + 4783 + ], + "valid" + ], + [ + [ + 4784, + 4784 + ], + "valid" + ], + [ + [ + 4785, + 4785 + ], + "disallowed" + ], + [ + [ + 4786, + 4789 + ], + "valid" + ], + [ + [ + 4790, + 4791 + ], + "disallowed" + ], + [ + [ + 4792, + 4798 + ], + "valid" + ], + [ + [ + 4799, + 4799 + ], + "disallowed" + ], + [ + [ + 4800, + 4800 + ], + "valid" + ], + [ + [ + 4801, + 4801 + ], + "disallowed" + ], + [ + [ + 4802, + 4805 + ], + "valid" + ], + [ + [ + 4806, + 4807 + ], + "disallowed" + ], + [ + [ + 4808, + 4814 + ], + "valid" + ], + [ + [ + 4815, + 4815 + ], + "valid" + ], + [ + [ + 4816, + 4822 + ], + "valid" + ], + [ + [ + 4823, + 4823 + ], + "disallowed" + ], + [ + [ + 4824, + 4846 + ], + "valid" + ], + [ + [ + 4847, + 4847 + ], + "valid" + ], + [ + [ + 4848, + 4878 + ], + "valid" + ], + [ + [ + 4879, + 4879 + ], + "valid" + ], + [ + [ + 4880, + 4880 + ], + "valid" + ], + [ + [ + 4881, + 4881 + ], + "disallowed" + ], + [ + [ + 4882, + 4885 + ], + "valid" + ], + [ + [ + 4886, + 4887 + ], + "disallowed" + ], + [ + [ + 4888, + 4894 + ], + "valid" + ], + [ + [ + 4895, + 4895 + ], + "valid" + ], + [ + [ + 4896, + 4934 + ], + "valid" + ], + [ + [ + 4935, + 4935 + ], + "valid" + ], + [ + [ + 4936, + 4954 + ], + "valid" + ], + [ + [ + 4955, + 4956 + ], + "disallowed" + ], + [ + [ + 4957, + 4958 + ], + "valid" + ], + [ + [ + 4959, + 4959 + ], + "valid" + ], + [ + [ + 4960, + 4960 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 4961, + 4988 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 4989, + 4991 + ], + "disallowed" + ], + [ + [ + 4992, + 5007 + ], + "valid" + ], + [ + [ + 5008, + 5017 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 5018, + 5023 + ], + "disallowed" + ], + [ + [ + 5024, + 5108 + ], + "valid" + ], + [ + [ + 5109, + 5109 + ], + "valid" + ], + [ + [ + 5110, + 5111 + ], + "disallowed" + ], + [ + [ + 5112, + 5112 + ], + "mapped", + [ + 5104 + ] + ], + [ + [ + 5113, + 5113 + ], + "mapped", + [ + 5105 + ] + ], + [ + [ + 5114, + 5114 + ], + "mapped", + [ + 5106 + ] + ], + [ + [ + 5115, + 5115 + ], + "mapped", + [ + 5107 + ] + ], + [ + [ + 5116, + 5116 + ], + "mapped", + [ + 5108 + ] + ], + [ + [ + 5117, + 5117 + ], + "mapped", + [ + 5109 + ] + ], + [ + [ + 5118, + 5119 + ], + "disallowed" + ], + [ + [ + 5120, + 5120 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 5121, + 5740 + ], + "valid" + ], + [ + [ + 5741, + 5742 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 5743, + 5750 + ], + "valid" + ], + [ + [ + 5751, + 5759 + ], + "valid" + ], + [ + [ + 5760, + 5760 + ], + "disallowed" + ], + [ + [ + 5761, + 5786 + ], + "valid" + ], + [ + [ + 5787, + 5788 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 5789, + 5791 + ], + "disallowed" + ], + [ + [ + 5792, + 5866 + ], + "valid" + ], + [ + [ + 5867, + 5872 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 5873, + 5880 + ], + "valid" + ], + [ + [ + 5881, + 5887 + ], + "disallowed" + ], + [ + [ + 5888, + 5900 + ], + "valid" + ], + [ + [ + 5901, + 5901 + ], + "disallowed" + ], + [ + [ + 5902, + 5908 + ], + "valid" + ], + [ + [ + 5909, + 5919 + ], + "disallowed" + ], + [ + [ + 5920, + 5940 + ], + "valid" + ], + [ + [ + 5941, + 5942 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 5943, + 5951 + ], + "disallowed" + ], + [ + [ + 5952, + 5971 + ], + "valid" + ], + [ + [ + 5972, + 5983 + ], + "disallowed" + ], + [ + [ + 5984, + 5996 + ], + "valid" + ], + [ + [ + 5997, + 5997 + ], + "disallowed" + ], + [ + [ + 5998, + 6000 + ], + "valid" + ], + [ + [ + 6001, + 6001 + ], + "disallowed" + ], + [ + [ + 6002, + 6003 + ], + "valid" + ], + [ + [ + 6004, + 6015 + ], + "disallowed" + ], + [ + [ + 6016, + 6067 + ], + "valid" + ], + [ + [ + 6068, + 6069 + ], + "disallowed" + ], + [ + [ + 6070, + 6099 + ], + "valid" + ], + [ + [ + 6100, + 6102 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 6103, + 6103 + ], + "valid" + ], + [ + [ + 6104, + 6107 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 6108, + 6108 + ], + "valid" + ], + [ + [ + 6109, + 6109 + ], + "valid" + ], + [ + [ + 6110, + 6111 + ], + "disallowed" + ], + [ + [ + 6112, + 6121 + ], + "valid" + ], + [ + [ + 6122, + 6127 + ], + "disallowed" + ], + [ + [ + 6128, + 6137 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 6138, + 6143 + ], + "disallowed" + ], + [ + [ + 6144, + 6149 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 6150, + 6150 + ], + "disallowed" + ], + [ + [ + 6151, + 6154 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 6155, + 6157 + ], + "ignored" + ], + [ + [ + 6158, + 6158 + ], + "disallowed" + ], + [ + [ + 6159, + 6159 + ], + "disallowed" + ], + [ + [ + 6160, + 6169 + ], + "valid" + ], + [ + [ + 6170, + 6175 + ], + "disallowed" + ], + [ + [ + 6176, + 6263 + ], + "valid" + ], + [ + [ + 6264, + 6271 + ], + "disallowed" + ], + [ + [ + 6272, + 6313 + ], + "valid" + ], + [ + [ + 6314, + 6314 + ], + "valid" + ], + [ + [ + 6315, + 6319 + ], + "disallowed" + ], + [ + [ + 6320, + 6389 + ], + "valid" + ], + [ + [ + 6390, + 6399 + ], + "disallowed" + ], + [ + [ + 6400, + 6428 + ], + "valid" + ], + [ + [ + 6429, + 6430 + ], + "valid" + ], + [ + [ + 6431, + 6431 + ], + "disallowed" + ], + [ + [ + 6432, + 6443 + ], + "valid" + ], + [ + [ + 6444, + 6447 + ], + "disallowed" + ], + [ + [ + 6448, + 6459 + ], + "valid" + ], + [ + [ + 6460, + 6463 + ], + "disallowed" + ], + [ + [ + 6464, + 6464 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 6465, + 6467 + ], + "disallowed" + ], + [ + [ + 6468, + 6469 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 6470, + 6509 + ], + "valid" + ], + [ + [ + 6510, + 6511 + ], + "disallowed" + ], + [ + [ + 6512, + 6516 + ], + "valid" + ], + [ + [ + 6517, + 6527 + ], + "disallowed" + ], + [ + [ + 6528, + 6569 + ], + "valid" + ], + [ + [ + 6570, + 6571 + ], + "valid" + ], + [ + [ + 6572, + 6575 + ], + "disallowed" + ], + [ + [ + 6576, + 6601 + ], + "valid" + ], + [ + [ + 6602, + 6607 + ], + "disallowed" + ], + [ + [ + 6608, + 6617 + ], + "valid" + ], + [ + [ + 6618, + 6618 + ], + "valid", + [ + ], + "XV8" + ], + [ + [ + 6619, + 6621 + ], + "disallowed" + ], + [ + [ + 6622, + 6623 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 6624, + 6655 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 6656, + 6683 + ], + "valid" + ], + [ + [ + 6684, + 6685 + ], + "disallowed" + ], + [ + [ + 6686, + 6687 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 6688, + 6750 + ], + "valid" + ], + [ + [ + 6751, + 6751 + ], + "disallowed" + ], + [ + [ + 6752, + 6780 + ], + "valid" + ], + [ + [ + 6781, + 6782 + ], + "disallowed" + ], + [ + [ + 6783, + 6793 + ], + "valid" + ], + [ + [ + 6794, + 6799 + ], + "disallowed" + ], + [ + [ + 6800, + 6809 + ], + "valid" + ], + [ + [ + 6810, + 6815 + ], + "disallowed" + ], + [ + [ + 6816, + 6822 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 6823, + 6823 + ], + "valid" + ], + [ + [ + 6824, + 6829 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 6830, + 6831 + ], + "disallowed" + ], + [ + [ + 6832, + 6845 + ], + "valid" + ], + [ + [ + 6846, + 6846 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 6847, + 6911 + ], + "disallowed" + ], + [ + [ + 6912, + 6987 + ], + "valid" + ], + [ + [ + 6988, + 6991 + ], + "disallowed" + ], + [ + [ + 6992, + 7001 + ], + "valid" + ], + [ + [ + 7002, + 7018 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 7019, + 7027 + ], + "valid" + ], + [ + [ + 7028, + 7036 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 7037, + 7039 + ], + "disallowed" + ], + [ + [ + 7040, + 7082 + ], + "valid" + ], + [ + [ + 7083, + 7085 + ], + "valid" + ], + [ + [ + 7086, + 7097 + ], + "valid" + ], + [ + [ + 7098, + 7103 + ], + "valid" + ], + [ + [ + 7104, + 7155 + ], + "valid" + ], + [ + [ + 7156, + 7163 + ], + "disallowed" + ], + [ + [ + 7164, + 7167 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 7168, + 7223 + ], + "valid" + ], + [ + [ + 7224, + 7226 + ], + "disallowed" + ], + [ + [ + 7227, + 7231 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 7232, + 7241 + ], + "valid" + ], + [ + [ + 7242, + 7244 + ], + "disallowed" + ], + [ + [ + 7245, + 7293 + ], + "valid" + ], + [ + [ + 7294, + 7295 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 7296, + 7359 + ], + "disallowed" + ], + [ + [ + 7360, + 7367 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 7368, + 7375 + ], + "disallowed" + ], + [ + [ + 7376, + 7378 + ], + "valid" + ], + [ + [ + 7379, + 7379 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 7380, + 7410 + ], + "valid" + ], + [ + [ + 7411, + 7414 + ], + "valid" + ], + [ + [ + 7415, + 7415 + ], + "disallowed" + ], + [ + [ + 7416, + 7417 + ], + "valid" + ], + [ + [ + 7418, + 7423 + ], + "disallowed" + ], + [ + [ + 7424, + 7467 + ], + "valid" + ], + [ + [ + 7468, + 7468 + ], + "mapped", + [ + 97 + ] + ], + [ + [ + 7469, + 7469 + ], + "mapped", + [ + 230 + ] + ], + [ + [ + 7470, + 7470 + ], + "mapped", + [ + 98 + ] + ], + [ + [ + 7471, + 7471 + ], + "valid" + ], + [ + [ + 7472, + 7472 + ], + "mapped", + [ + 100 + ] + ], + [ + [ + 7473, + 7473 + ], + "mapped", + [ + 101 + ] + ], + [ + [ + 7474, + 7474 + ], + "mapped", + [ + 477 + ] + ], + [ + [ + 7475, + 7475 + ], + "mapped", + [ + 103 + ] + ], + [ + [ + 7476, + 7476 + ], + "mapped", + [ + 104 + ] + ], + [ + [ + 7477, + 7477 + ], + "mapped", + [ + 105 + ] + ], + [ + [ + 7478, + 7478 + ], + "mapped", + [ + 106 + ] + ], + [ + [ + 7479, + 7479 + ], + "mapped", + [ + 107 + ] + ], + [ + [ + 7480, + 7480 + ], + "mapped", + [ + 108 + ] + ], + [ + [ + 7481, + 7481 + ], + "mapped", + [ + 109 + ] + ], + [ + [ + 7482, + 7482 + ], + "mapped", + [ + 110 + ] + ], + [ + [ + 7483, + 7483 + ], + "valid" + ], + [ + [ + 7484, + 7484 + ], + "mapped", + [ + 111 + ] + ], + [ + [ + 7485, + 7485 + ], + "mapped", + [ + 547 + ] + ], + [ + [ + 7486, + 7486 + ], + "mapped", + [ + 112 + ] + ], + [ + [ + 7487, + 7487 + ], + "mapped", + [ + 114 + ] + ], + [ + [ + 7488, + 7488 + ], + "mapped", + [ + 116 + ] + ], + [ + [ + 7489, + 7489 + ], + "mapped", + [ + 117 + ] + ], + [ + [ + 7490, + 7490 + ], + "mapped", + [ + 119 + ] + ], + [ + [ + 7491, + 7491 + ], + "mapped", + [ + 97 + ] + ], + [ + [ + 7492, + 7492 + ], + "mapped", + [ + 592 + ] + ], + [ + [ + 7493, + 7493 + ], + "mapped", + [ + 593 + ] + ], + [ + [ + 7494, + 7494 + ], + "mapped", + [ + 7426 + ] + ], + [ + [ + 7495, + 7495 + ], + "mapped", + [ + 98 + ] + ], + [ + [ + 7496, + 7496 + ], + "mapped", + [ + 100 + ] + ], + [ + [ + 7497, + 7497 + ], + "mapped", + [ + 101 + ] + ], + [ + [ + 7498, + 7498 + ], + "mapped", + [ + 601 + ] + ], + [ + [ + 7499, + 7499 + ], + "mapped", + [ + 603 + ] + ], + [ + [ + 7500, + 7500 + ], + "mapped", + [ + 604 + ] + ], + [ + [ + 7501, + 7501 + ], + "mapped", + [ + 103 + ] + ], + [ + [ + 7502, + 7502 + ], + "valid" + ], + [ + [ + 7503, + 7503 + ], + "mapped", + [ + 107 + ] + ], + [ + [ + 7504, + 7504 + ], + "mapped", + [ + 109 + ] + ], + [ + [ + 7505, + 7505 + ], + "mapped", + [ + 331 + ] + ], + [ + [ + 7506, + 7506 + ], + "mapped", + [ + 111 + ] + ], + [ + [ + 7507, + 7507 + ], + "mapped", + [ + 596 + ] + ], + [ + [ + 7508, + 7508 + ], + "mapped", + [ + 7446 + ] + ], + [ + [ + 7509, + 7509 + ], + "mapped", + [ + 7447 + ] + ], + [ + [ + 7510, + 7510 + ], + "mapped", + [ + 112 + ] + ], + [ + [ + 7511, + 7511 + ], + "mapped", + [ + 116 + ] + ], + [ + [ + 7512, + 7512 + ], + "mapped", + [ + 117 + ] + ], + [ + [ + 7513, + 7513 + ], + "mapped", + [ + 7453 + ] + ], + [ + [ + 7514, + 7514 + ], + "mapped", + [ + 623 + ] + ], + [ + [ + 7515, + 7515 + ], + "mapped", + [ + 118 + ] + ], + [ + [ + 7516, + 7516 + ], + "mapped", + [ + 7461 + ] + ], + [ + [ + 7517, + 7517 + ], + "mapped", + [ + 946 + ] + ], + [ + [ + 7518, + 7518 + ], + "mapped", + [ + 947 + ] + ], + [ + [ + 7519, + 7519 + ], + "mapped", + [ + 948 + ] + ], + [ + [ + 7520, + 7520 + ], + "mapped", + [ + 966 + ] + ], + [ + [ + 7521, + 7521 + ], + "mapped", + [ + 967 + ] + ], + [ + [ + 7522, + 7522 + ], + "mapped", + [ + 105 + ] + ], + [ + [ + 7523, + 7523 + ], + "mapped", + [ + 114 + ] + ], + [ + [ + 7524, + 7524 + ], + "mapped", + [ + 117 + ] + ], + [ + [ + 7525, + 7525 + ], + "mapped", + [ + 118 + ] + ], + [ + [ + 7526, + 7526 + ], + "mapped", + [ + 946 + ] + ], + [ + [ + 7527, + 7527 + ], + "mapped", + [ + 947 + ] + ], + [ + [ + 7528, + 7528 + ], + "mapped", + [ + 961 + ] + ], + [ + [ + 7529, + 7529 + ], + "mapped", + [ + 966 + ] + ], + [ + [ + 7530, + 7530 + ], + "mapped", + [ + 967 + ] + ], + [ + [ + 7531, + 7531 + ], + "valid" + ], + [ + [ + 7532, + 7543 + ], + "valid" + ], + [ + [ + 7544, + 7544 + ], + "mapped", + [ + 1085 + ] + ], + [ + [ + 7545, + 7578 + ], + "valid" + ], + [ + [ + 7579, + 7579 + ], + "mapped", + [ + 594 + ] + ], + [ + [ + 7580, + 7580 + ], + "mapped", + [ + 99 + ] + ], + [ + [ + 7581, + 7581 + ], + "mapped", + [ + 597 + ] + ], + [ + [ + 7582, + 7582 + ], + "mapped", + [ + 240 + ] + ], + [ + [ + 7583, + 7583 + ], + "mapped", + [ + 604 + ] + ], + [ + [ + 7584, + 7584 + ], + "mapped", + [ + 102 + ] + ], + [ + [ + 7585, + 7585 + ], + "mapped", + [ + 607 + ] + ], + [ + [ + 7586, + 7586 + ], + "mapped", + [ + 609 + ] + ], + [ + [ + 7587, + 7587 + ], + "mapped", + [ + 613 + ] + ], + [ + [ + 7588, + 7588 + ], + "mapped", + [ + 616 + ] + ], + [ + [ + 7589, + 7589 + ], + "mapped", + [ + 617 + ] + ], + [ + [ + 7590, + 7590 + ], + "mapped", + [ + 618 + ] + ], + [ + [ + 7591, + 7591 + ], + "mapped", + [ + 7547 + ] + ], + [ + [ + 7592, + 7592 + ], + "mapped", + [ + 669 + ] + ], + [ + [ + 7593, + 7593 + ], + "mapped", + [ + 621 + ] + ], + [ + [ + 7594, + 7594 + ], + "mapped", + [ + 7557 + ] + ], + [ + [ + 7595, + 7595 + ], + "mapped", + [ + 671 + ] + ], + [ + [ + 7596, + 7596 + ], + "mapped", + [ + 625 + ] + ], + [ + [ + 7597, + 7597 + ], + "mapped", + [ + 624 + ] + ], + [ + [ + 7598, + 7598 + ], + "mapped", + [ + 626 + ] + ], + [ + [ + 7599, + 7599 + ], + "mapped", + [ + 627 + ] + ], + [ + [ + 7600, + 7600 + ], + "mapped", + [ + 628 + ] + ], + [ + [ + 7601, + 7601 + ], + "mapped", + [ + 629 + ] + ], + [ + [ + 7602, + 7602 + ], + "mapped", + [ + 632 + ] + ], + [ + [ + 7603, + 7603 + ], + "mapped", + [ + 642 + ] + ], + [ + [ + 7604, + 7604 + ], + "mapped", + [ + 643 + ] + ], + [ + [ + 7605, + 7605 + ], + "mapped", + [ + 427 + ] + ], + [ + [ + 7606, + 7606 + ], + "mapped", + [ + 649 + ] + ], + [ + [ + 7607, + 7607 + ], + "mapped", + [ + 650 + ] + ], + [ + [ + 7608, + 7608 + ], + "mapped", + [ + 7452 + ] + ], + [ + [ + 7609, + 7609 + ], + "mapped", + [ + 651 + ] + ], + [ + [ + 7610, + 7610 + ], + "mapped", + [ + 652 + ] + ], + [ + [ + 7611, + 7611 + ], + "mapped", + [ + 122 + ] + ], + [ + [ + 7612, + 7612 + ], + "mapped", + [ + 656 + ] + ], + [ + [ + 7613, + 7613 + ], + "mapped", + [ + 657 + ] + ], + [ + [ + 7614, + 7614 + ], + "mapped", + [ + 658 + ] + ], + [ + [ + 7615, + 7615 + ], + "mapped", + [ + 952 + ] + ], + [ + [ + 7616, + 7619 + ], + "valid" + ], + [ + [ + 7620, + 7626 + ], + "valid" + ], + [ + [ + 7627, + 7654 + ], + "valid" + ], + [ + [ + 7655, + 7669 + ], + "valid" + ], + [ + [ + 7670, + 7675 + ], + "disallowed" + ], + [ + [ + 7676, + 7676 + ], + "valid" + ], + [ + [ + 7677, + 7677 + ], + "valid" + ], + [ + [ + 7678, + 7679 + ], + "valid" + ], + [ + [ + 7680, + 7680 + ], + "mapped", + [ + 7681 + ] + ], + [ + [ + 7681, + 7681 + ], + "valid" + ], + [ + [ + 7682, + 7682 + ], + "mapped", + [ + 7683 + ] + ], + [ + [ + 7683, + 7683 + ], + "valid" + ], + [ + [ + 7684, + 7684 + ], + "mapped", + [ + 7685 + ] + ], + [ + [ + 7685, + 7685 + ], + "valid" + ], + [ + [ + 7686, + 7686 + ], + "mapped", + [ + 7687 + ] + ], + [ + [ + 7687, + 7687 + ], + "valid" + ], + [ + [ + 7688, + 7688 + ], + "mapped", + [ + 7689 + ] + ], + [ + [ + 7689, + 7689 + ], + "valid" + ], + [ + [ + 7690, + 7690 + ], + "mapped", + [ + 7691 + ] + ], + [ + [ + 7691, + 7691 + ], + "valid" + ], + [ + [ + 7692, + 7692 + ], + "mapped", + [ + 7693 + ] + ], + [ + [ + 7693, + 7693 + ], + "valid" + ], + [ + [ + 7694, + 7694 + ], + "mapped", + [ + 7695 + ] + ], + [ + [ + 7695, + 7695 + ], + "valid" + ], + [ + [ + 7696, + 7696 + ], + "mapped", + [ + 7697 + ] + ], + [ + [ + 7697, + 7697 + ], + "valid" + ], + [ + [ + 7698, + 7698 + ], + "mapped", + [ + 7699 + ] + ], + [ + [ + 7699, + 7699 + ], + "valid" + ], + [ + [ + 7700, + 7700 + ], + "mapped", + [ + 7701 + ] + ], + [ + [ + 7701, + 7701 + ], + "valid" + ], + [ + [ + 7702, + 7702 + ], + "mapped", + [ + 7703 + ] + ], + [ + [ + 7703, + 7703 + ], + "valid" + ], + [ + [ + 7704, + 7704 + ], + "mapped", + [ + 7705 + ] + ], + [ + [ + 7705, + 7705 + ], + "valid" + ], + [ + [ + 7706, + 7706 + ], + "mapped", + [ + 7707 + ] + ], + [ + [ + 7707, + 7707 + ], + "valid" + ], + [ + [ + 7708, + 7708 + ], + "mapped", + [ + 7709 + ] + ], + [ + [ + 7709, + 7709 + ], + "valid" + ], + [ + [ + 7710, + 7710 + ], + "mapped", + [ + 7711 + ] + ], + [ + [ + 7711, + 7711 + ], + "valid" + ], + [ + [ + 7712, + 7712 + ], + "mapped", + [ + 7713 + ] + ], + [ + [ + 7713, + 7713 + ], + "valid" + ], + [ + [ + 7714, + 7714 + ], + "mapped", + [ + 7715 + ] + ], + [ + [ + 7715, + 7715 + ], + "valid" + ], + [ + [ + 7716, + 7716 + ], + "mapped", + [ + 7717 + ] + ], + [ + [ + 7717, + 7717 + ], + "valid" + ], + [ + [ + 7718, + 7718 + ], + "mapped", + [ + 7719 + ] + ], + [ + [ + 7719, + 7719 + ], + "valid" + ], + [ + [ + 7720, + 7720 + ], + "mapped", + [ + 7721 + ] + ], + [ + [ + 7721, + 7721 + ], + "valid" + ], + [ + [ + 7722, + 7722 + ], + "mapped", + [ + 7723 + ] + ], + [ + [ + 7723, + 7723 + ], + "valid" + ], + [ + [ + 7724, + 7724 + ], + "mapped", + [ + 7725 + ] + ], + [ + [ + 7725, + 7725 + ], + "valid" + ], + [ + [ + 7726, + 7726 + ], + "mapped", + [ + 7727 + ] + ], + [ + [ + 7727, + 7727 + ], + "valid" + ], + [ + [ + 7728, + 7728 + ], + "mapped", + [ + 7729 + ] + ], + [ + [ + 7729, + 7729 + ], + "valid" + ], + [ + [ + 7730, + 7730 + ], + "mapped", + [ + 7731 + ] + ], + [ + [ + 7731, + 7731 + ], + "valid" + ], + [ + [ + 7732, + 7732 + ], + "mapped", + [ + 7733 + ] + ], + [ + [ + 7733, + 7733 + ], + "valid" + ], + [ + [ + 7734, + 7734 + ], + "mapped", + [ + 7735 + ] + ], + [ + [ + 7735, + 7735 + ], + "valid" + ], + [ + [ + 7736, + 7736 + ], + "mapped", + [ + 7737 + ] + ], + [ + [ + 7737, + 7737 + ], + "valid" + ], + [ + [ + 7738, + 7738 + ], + "mapped", + [ + 7739 + ] + ], + [ + [ + 7739, + 7739 + ], + "valid" + ], + [ + [ + 7740, + 7740 + ], + "mapped", + [ + 7741 + ] + ], + [ + [ + 7741, + 7741 + ], + "valid" + ], + [ + [ + 7742, + 7742 + ], + "mapped", + [ + 7743 + ] + ], + [ + [ + 7743, + 7743 + ], + "valid" + ], + [ + [ + 7744, + 7744 + ], + "mapped", + [ + 7745 + ] + ], + [ + [ + 7745, + 7745 + ], + "valid" + ], + [ + [ + 7746, + 7746 + ], + "mapped", + [ + 7747 + ] + ], + [ + [ + 7747, + 7747 + ], + "valid" + ], + [ + [ + 7748, + 7748 + ], + "mapped", + [ + 7749 + ] + ], + [ + [ + 7749, + 7749 + ], + "valid" + ], + [ + [ + 7750, + 7750 + ], + "mapped", + [ + 7751 + ] + ], + [ + [ + 7751, + 7751 + ], + "valid" + ], + [ + [ + 7752, + 7752 + ], + "mapped", + [ + 7753 + ] + ], + [ + [ + 7753, + 7753 + ], + "valid" + ], + [ + [ + 7754, + 7754 + ], + "mapped", + [ + 7755 + ] + ], + [ + [ + 7755, + 7755 + ], + "valid" + ], + [ + [ + 7756, + 7756 + ], + "mapped", + [ + 7757 + ] + ], + [ + [ + 7757, + 7757 + ], + "valid" + ], + [ + [ + 7758, + 7758 + ], + "mapped", + [ + 7759 + ] + ], + [ + [ + 7759, + 7759 + ], + "valid" + ], + [ + [ + 7760, + 7760 + ], + "mapped", + [ + 7761 + ] + ], + [ + [ + 7761, + 7761 + ], + "valid" + ], + [ + [ + 7762, + 7762 + ], + "mapped", + [ + 7763 + ] + ], + [ + [ + 7763, + 7763 + ], + "valid" + ], + [ + [ + 7764, + 7764 + ], + "mapped", + [ + 7765 + ] + ], + [ + [ + 7765, + 7765 + ], + "valid" + ], + [ + [ + 7766, + 7766 + ], + "mapped", + [ + 7767 + ] + ], + [ + [ + 7767, + 7767 + ], + "valid" + ], + [ + [ + 7768, + 7768 + ], + "mapped", + [ + 7769 + ] + ], + [ + [ + 7769, + 7769 + ], + "valid" + ], + [ + [ + 7770, + 7770 + ], + "mapped", + [ + 7771 + ] + ], + [ + [ + 7771, + 7771 + ], + "valid" + ], + [ + [ + 7772, + 7772 + ], + "mapped", + [ + 7773 + ] + ], + [ + [ + 7773, + 7773 + ], + "valid" + ], + [ + [ + 7774, + 7774 + ], + "mapped", + [ + 7775 + ] + ], + [ + [ + 7775, + 7775 + ], + "valid" + ], + [ + [ + 7776, + 7776 + ], + "mapped", + [ + 7777 + ] + ], + [ + [ + 7777, + 7777 + ], + "valid" + ], + [ + [ + 7778, + 7778 + ], + "mapped", + [ + 7779 + ] + ], + [ + [ + 7779, + 7779 + ], + "valid" + ], + [ + [ + 7780, + 7780 + ], + "mapped", + [ + 7781 + ] + ], + [ + [ + 7781, + 7781 + ], + "valid" + ], + [ + [ + 7782, + 7782 + ], + "mapped", + [ + 7783 + ] + ], + [ + [ + 7783, + 7783 + ], + "valid" + ], + [ + [ + 7784, + 7784 + ], + "mapped", + [ + 7785 + ] + ], + [ + [ + 7785, + 7785 + ], + "valid" + ], + [ + [ + 7786, + 7786 + ], + "mapped", + [ + 7787 + ] + ], + [ + [ + 7787, + 7787 + ], + "valid" + ], + [ + [ + 7788, + 7788 + ], + "mapped", + [ + 7789 + ] + ], + [ + [ + 7789, + 7789 + ], + "valid" + ], + [ + [ + 7790, + 7790 + ], + "mapped", + [ + 7791 + ] + ], + [ + [ + 7791, + 7791 + ], + "valid" + ], + [ + [ + 7792, + 7792 + ], + "mapped", + [ + 7793 + ] + ], + [ + [ + 7793, + 7793 + ], + "valid" + ], + [ + [ + 7794, + 7794 + ], + "mapped", + [ + 7795 + ] + ], + [ + [ + 7795, + 7795 + ], + "valid" + ], + [ + [ + 7796, + 7796 + ], + "mapped", + [ + 7797 + ] + ], + [ + [ + 7797, + 7797 + ], + "valid" + ], + [ + [ + 7798, + 7798 + ], + "mapped", + [ + 7799 + ] + ], + [ + [ + 7799, + 7799 + ], + "valid" + ], + [ + [ + 7800, + 7800 + ], + "mapped", + [ + 7801 + ] + ], + [ + [ + 7801, + 7801 + ], + "valid" + ], + [ + [ + 7802, + 7802 + ], + "mapped", + [ + 7803 + ] + ], + [ + [ + 7803, + 7803 + ], + "valid" + ], + [ + [ + 7804, + 7804 + ], + "mapped", + [ + 7805 + ] + ], + [ + [ + 7805, + 7805 + ], + "valid" + ], + [ + [ + 7806, + 7806 + ], + "mapped", + [ + 7807 + ] + ], + [ + [ + 7807, + 7807 + ], + "valid" + ], + [ + [ + 7808, + 7808 + ], + "mapped", + [ + 7809 + ] + ], + [ + [ + 7809, + 7809 + ], + "valid" + ], + [ + [ + 7810, + 7810 + ], + "mapped", + [ + 7811 + ] + ], + [ + [ + 7811, + 7811 + ], + "valid" + ], + [ + [ + 7812, + 7812 + ], + "mapped", + [ + 7813 + ] + ], + [ + [ + 7813, + 7813 + ], + "valid" + ], + [ + [ + 7814, + 7814 + ], + "mapped", + [ + 7815 + ] + ], + [ + [ + 7815, + 7815 + ], + "valid" + ], + [ + [ + 7816, + 7816 + ], + "mapped", + [ + 7817 + ] + ], + [ + [ + 7817, + 7817 + ], + "valid" + ], + [ + [ + 7818, + 7818 + ], + "mapped", + [ + 7819 + ] + ], + [ + [ + 7819, + 7819 + ], + "valid" + ], + [ + [ + 7820, + 7820 + ], + "mapped", + [ + 7821 + ] + ], + [ + [ + 7821, + 7821 + ], + "valid" + ], + [ + [ + 7822, + 7822 + ], + "mapped", + [ + 7823 + ] + ], + [ + [ + 7823, + 7823 + ], + "valid" + ], + [ + [ + 7824, + 7824 + ], + "mapped", + [ + 7825 + ] + ], + [ + [ + 7825, + 7825 + ], + "valid" + ], + [ + [ + 7826, + 7826 + ], + "mapped", + [ + 7827 + ] + ], + [ + [ + 7827, + 7827 + ], + "valid" + ], + [ + [ + 7828, + 7828 + ], + "mapped", + [ + 7829 + ] + ], + [ + [ + 7829, + 7833 + ], + "valid" + ], + [ + [ + 7834, + 7834 + ], + "mapped", + [ + 97, + 702 + ] + ], + [ + [ + 7835, + 7835 + ], + "mapped", + [ + 7777 + ] + ], + [ + [ + 7836, + 7837 + ], + "valid" + ], + [ + [ + 7838, + 7838 + ], + "mapped", + [ + 115, + 115 + ] + ], + [ + [ + 7839, + 7839 + ], + "valid" + ], + [ + [ + 7840, + 7840 + ], + "mapped", + [ + 7841 + ] + ], + [ + [ + 7841, + 7841 + ], + "valid" + ], + [ + [ + 7842, + 7842 + ], + "mapped", + [ + 7843 + ] + ], + [ + [ + 7843, + 7843 + ], + "valid" + ], + [ + [ + 7844, + 7844 + ], + "mapped", + [ + 7845 + ] + ], + [ + [ + 7845, + 7845 + ], + "valid" + ], + [ + [ + 7846, + 7846 + ], + "mapped", + [ + 7847 + ] + ], + [ + [ + 7847, + 7847 + ], + "valid" + ], + [ + [ + 7848, + 7848 + ], + "mapped", + [ + 7849 + ] + ], + [ + [ + 7849, + 7849 + ], + "valid" + ], + [ + [ + 7850, + 7850 + ], + "mapped", + [ + 7851 + ] + ], + [ + [ + 7851, + 7851 + ], + "valid" + ], + [ + [ + 7852, + 7852 + ], + "mapped", + [ + 7853 + ] + ], + [ + [ + 7853, + 7853 + ], + "valid" + ], + [ + [ + 7854, + 7854 + ], + "mapped", + [ + 7855 + ] + ], + [ + [ + 7855, + 7855 + ], + "valid" + ], + [ + [ + 7856, + 7856 + ], + "mapped", + [ + 7857 + ] + ], + [ + [ + 7857, + 7857 + ], + "valid" + ], + [ + [ + 7858, + 7858 + ], + "mapped", + [ + 7859 + ] + ], + [ + [ + 7859, + 7859 + ], + "valid" + ], + [ + [ + 7860, + 7860 + ], + "mapped", + [ + 7861 + ] + ], + [ + [ + 7861, + 7861 + ], + "valid" + ], + [ + [ + 7862, + 7862 + ], + "mapped", + [ + 7863 + ] + ], + [ + [ + 7863, + 7863 + ], + "valid" + ], + [ + [ + 7864, + 7864 + ], + "mapped", + [ + 7865 + ] + ], + [ + [ + 7865, + 7865 + ], + "valid" + ], + [ + [ + 7866, + 7866 + ], + "mapped", + [ + 7867 + ] + ], + [ + [ + 7867, + 7867 + ], + "valid" + ], + [ + [ + 7868, + 7868 + ], + "mapped", + [ + 7869 + ] + ], + [ + [ + 7869, + 7869 + ], + "valid" + ], + [ + [ + 7870, + 7870 + ], + "mapped", + [ + 7871 + ] + ], + [ + [ + 7871, + 7871 + ], + "valid" + ], + [ + [ + 7872, + 7872 + ], + "mapped", + [ + 7873 + ] + ], + [ + [ + 7873, + 7873 + ], + "valid" + ], + [ + [ + 7874, + 7874 + ], + "mapped", + [ + 7875 + ] + ], + [ + [ + 7875, + 7875 + ], + "valid" + ], + [ + [ + 7876, + 7876 + ], + "mapped", + [ + 7877 + ] + ], + [ + [ + 7877, + 7877 + ], + "valid" + ], + [ + [ + 7878, + 7878 + ], + "mapped", + [ + 7879 + ] + ], + [ + [ + 7879, + 7879 + ], + "valid" + ], + [ + [ + 7880, + 7880 + ], + "mapped", + [ + 7881 + ] + ], + [ + [ + 7881, + 7881 + ], + "valid" + ], + [ + [ + 7882, + 7882 + ], + "mapped", + [ + 7883 + ] + ], + [ + [ + 7883, + 7883 + ], + "valid" + ], + [ + [ + 7884, + 7884 + ], + "mapped", + [ + 7885 + ] + ], + [ + [ + 7885, + 7885 + ], + "valid" + ], + [ + [ + 7886, + 7886 + ], + "mapped", + [ + 7887 + ] + ], + [ + [ + 7887, + 7887 + ], + "valid" + ], + [ + [ + 7888, + 7888 + ], + "mapped", + [ + 7889 + ] + ], + [ + [ + 7889, + 7889 + ], + "valid" + ], + [ + [ + 7890, + 7890 + ], + "mapped", + [ + 7891 + ] + ], + [ + [ + 7891, + 7891 + ], + "valid" + ], + [ + [ + 7892, + 7892 + ], + "mapped", + [ + 7893 + ] + ], + [ + [ + 7893, + 7893 + ], + "valid" + ], + [ + [ + 7894, + 7894 + ], + "mapped", + [ + 7895 + ] + ], + [ + [ + 7895, + 7895 + ], + "valid" + ], + [ + [ + 7896, + 7896 + ], + "mapped", + [ + 7897 + ] + ], + [ + [ + 7897, + 7897 + ], + "valid" + ], + [ + [ + 7898, + 7898 + ], + "mapped", + [ + 7899 + ] + ], + [ + [ + 7899, + 7899 + ], + "valid" + ], + [ + [ + 7900, + 7900 + ], + "mapped", + [ + 7901 + ] + ], + [ + [ + 7901, + 7901 + ], + "valid" + ], + [ + [ + 7902, + 7902 + ], + "mapped", + [ + 7903 + ] + ], + [ + [ + 7903, + 7903 + ], + "valid" + ], + [ + [ + 7904, + 7904 + ], + "mapped", + [ + 7905 + ] + ], + [ + [ + 7905, + 7905 + ], + "valid" + ], + [ + [ + 7906, + 7906 + ], + "mapped", + [ + 7907 + ] + ], + [ + [ + 7907, + 7907 + ], + "valid" + ], + [ + [ + 7908, + 7908 + ], + "mapped", + [ + 7909 + ] + ], + [ + [ + 7909, + 7909 + ], + "valid" + ], + [ + [ + 7910, + 7910 + ], + "mapped", + [ + 7911 + ] + ], + [ + [ + 7911, + 7911 + ], + "valid" + ], + [ + [ + 7912, + 7912 + ], + "mapped", + [ + 7913 + ] + ], + [ + [ + 7913, + 7913 + ], + "valid" + ], + [ + [ + 7914, + 7914 + ], + "mapped", + [ + 7915 + ] + ], + [ + [ + 7915, + 7915 + ], + "valid" + ], + [ + [ + 7916, + 7916 + ], + "mapped", + [ + 7917 + ] + ], + [ + [ + 7917, + 7917 + ], + "valid" + ], + [ + [ + 7918, + 7918 + ], + "mapped", + [ + 7919 + ] + ], + [ + [ + 7919, + 7919 + ], + "valid" + ], + [ + [ + 7920, + 7920 + ], + "mapped", + [ + 7921 + ] + ], + [ + [ + 7921, + 7921 + ], + "valid" + ], + [ + [ + 7922, + 7922 + ], + "mapped", + [ + 7923 + ] + ], + [ + [ + 7923, + 7923 + ], + "valid" + ], + [ + [ + 7924, + 7924 + ], + "mapped", + [ + 7925 + ] + ], + [ + [ + 7925, + 7925 + ], + "valid" + ], + [ + [ + 7926, + 7926 + ], + "mapped", + [ + 7927 + ] + ], + [ + [ + 7927, + 7927 + ], + "valid" + ], + [ + [ + 7928, + 7928 + ], + "mapped", + [ + 7929 + ] + ], + [ + [ + 7929, + 7929 + ], + "valid" + ], + [ + [ + 7930, + 7930 + ], + "mapped", + [ + 7931 + ] + ], + [ + [ + 7931, + 7931 + ], + "valid" + ], + [ + [ + 7932, + 7932 + ], + "mapped", + [ + 7933 + ] + ], + [ + [ + 7933, + 7933 + ], + "valid" + ], + [ + [ + 7934, + 7934 + ], + "mapped", + [ + 7935 + ] + ], + [ + [ + 7935, + 7935 + ], + "valid" + ], + [ + [ + 7936, + 7943 + ], + "valid" + ], + [ + [ + 7944, + 7944 + ], + "mapped", + [ + 7936 + ] + ], + [ + [ + 7945, + 7945 + ], + "mapped", + [ + 7937 + ] + ], + [ + [ + 7946, + 7946 + ], + "mapped", + [ + 7938 + ] + ], + [ + [ + 7947, + 7947 + ], + "mapped", + [ + 7939 + ] + ], + [ + [ + 7948, + 7948 + ], + "mapped", + [ + 7940 + ] + ], + [ + [ + 7949, + 7949 + ], + "mapped", + [ + 7941 + ] + ], + [ + [ + 7950, + 7950 + ], + "mapped", + [ + 7942 + ] + ], + [ + [ + 7951, + 7951 + ], + "mapped", + [ + 7943 + ] + ], + [ + [ + 7952, + 7957 + ], + "valid" + ], + [ + [ + 7958, + 7959 + ], + "disallowed" + ], + [ + [ + 7960, + 7960 + ], + "mapped", + [ + 7952 + ] + ], + [ + [ + 7961, + 7961 + ], + "mapped", + [ + 7953 + ] + ], + [ + [ + 7962, + 7962 + ], + "mapped", + [ + 7954 + ] + ], + [ + [ + 7963, + 7963 + ], + "mapped", + [ + 7955 + ] + ], + [ + [ + 7964, + 7964 + ], + "mapped", + [ + 7956 + ] + ], + [ + [ + 7965, + 7965 + ], + "mapped", + [ + 7957 + ] + ], + [ + [ + 7966, + 7967 + ], + "disallowed" + ], + [ + [ + 7968, + 7975 + ], + "valid" + ], + [ + [ + 7976, + 7976 + ], + "mapped", + [ + 7968 + ] + ], + [ + [ + 7977, + 7977 + ], + "mapped", + [ + 7969 + ] + ], + [ + [ + 7978, + 7978 + ], + "mapped", + [ + 7970 + ] + ], + [ + [ + 7979, + 7979 + ], + "mapped", + [ + 7971 + ] + ], + [ + [ + 7980, + 7980 + ], + "mapped", + [ + 7972 + ] + ], + [ + [ + 7981, + 7981 + ], + "mapped", + [ + 7973 + ] + ], + [ + [ + 7982, + 7982 + ], + "mapped", + [ + 7974 + ] + ], + [ + [ + 7983, + 7983 + ], + "mapped", + [ + 7975 + ] + ], + [ + [ + 7984, + 7991 + ], + "valid" + ], + [ + [ + 7992, + 7992 + ], + "mapped", + [ + 7984 + ] + ], + [ + [ + 7993, + 7993 + ], + "mapped", + [ + 7985 + ] + ], + [ + [ + 7994, + 7994 + ], + "mapped", + [ + 7986 + ] + ], + [ + [ + 7995, + 7995 + ], + "mapped", + [ + 7987 + ] + ], + [ + [ + 7996, + 7996 + ], + "mapped", + [ + 7988 + ] + ], + [ + [ + 7997, + 7997 + ], + "mapped", + [ + 7989 + ] + ], + [ + [ + 7998, + 7998 + ], + "mapped", + [ + 7990 + ] + ], + [ + [ + 7999, + 7999 + ], + "mapped", + [ + 7991 + ] + ], + [ + [ + 8000, + 8005 + ], + "valid" + ], + [ + [ + 8006, + 8007 + ], + "disallowed" + ], + [ + [ + 8008, + 8008 + ], + "mapped", + [ + 8000 + ] + ], + [ + [ + 8009, + 8009 + ], + "mapped", + [ + 8001 + ] + ], + [ + [ + 8010, + 8010 + ], + "mapped", + [ + 8002 + ] + ], + [ + [ + 8011, + 8011 + ], + "mapped", + [ + 8003 + ] + ], + [ + [ + 8012, + 8012 + ], + "mapped", + [ + 8004 + ] + ], + [ + [ + 8013, + 8013 + ], + "mapped", + [ + 8005 + ] + ], + [ + [ + 8014, + 8015 + ], + "disallowed" + ], + [ + [ + 8016, + 8023 + ], + "valid" + ], + [ + [ + 8024, + 8024 + ], + "disallowed" + ], + [ + [ + 8025, + 8025 + ], + "mapped", + [ + 8017 + ] + ], + [ + [ + 8026, + 8026 + ], + "disallowed" + ], + [ + [ + 8027, + 8027 + ], + "mapped", + [ + 8019 + ] + ], + [ + [ + 8028, + 8028 + ], + "disallowed" + ], + [ + [ + 8029, + 8029 + ], + "mapped", + [ + 8021 + ] + ], + [ + [ + 8030, + 8030 + ], + "disallowed" + ], + [ + [ + 8031, + 8031 + ], + "mapped", + [ + 8023 + ] + ], + [ + [ + 8032, + 8039 + ], + "valid" + ], + [ + [ + 8040, + 8040 + ], + "mapped", + [ + 8032 + ] + ], + [ + [ + 8041, + 8041 + ], + "mapped", + [ + 8033 + ] + ], + [ + [ + 8042, + 8042 + ], + "mapped", + [ + 8034 + ] + ], + [ + [ + 8043, + 8043 + ], + "mapped", + [ + 8035 + ] + ], + [ + [ + 8044, + 8044 + ], + "mapped", + [ + 8036 + ] + ], + [ + [ + 8045, + 8045 + ], + "mapped", + [ + 8037 + ] + ], + [ + [ + 8046, + 8046 + ], + "mapped", + [ + 8038 + ] + ], + [ + [ + 8047, + 8047 + ], + "mapped", + [ + 8039 + ] + ], + [ + [ + 8048, + 8048 + ], + "valid" + ], + [ + [ + 8049, + 8049 + ], + "mapped", + [ + 940 + ] + ], + [ + [ + 8050, + 8050 + ], + "valid" + ], + [ + [ + 8051, + 8051 + ], + "mapped", + [ + 941 + ] + ], + [ + [ + 8052, + 8052 + ], + "valid" + ], + [ + [ + 8053, + 8053 + ], + "mapped", + [ + 942 + ] + ], + [ + [ + 8054, + 8054 + ], + "valid" + ], + [ + [ + 8055, + 8055 + ], + "mapped", + [ + 943 + ] + ], + [ + [ + 8056, + 8056 + ], + "valid" + ], + [ + [ + 8057, + 8057 + ], + "mapped", + [ + 972 + ] + ], + [ + [ + 8058, + 8058 + ], + "valid" + ], + [ + [ + 8059, + 8059 + ], + "mapped", + [ + 973 + ] + ], + [ + [ + 8060, + 8060 + ], + "valid" + ], + [ + [ + 8061, + 8061 + ], + "mapped", + [ + 974 + ] + ], + [ + [ + 8062, + 8063 + ], + "disallowed" + ], + [ + [ + 8064, + 8064 + ], + "mapped", + [ + 7936, + 953 + ] + ], + [ + [ + 8065, + 8065 + ], + "mapped", + [ + 7937, + 953 + ] + ], + [ + [ + 8066, + 8066 + ], + "mapped", + [ + 7938, + 953 + ] + ], + [ + [ + 8067, + 8067 + ], + "mapped", + [ + 7939, + 953 + ] + ], + [ + [ + 8068, + 8068 + ], + "mapped", + [ + 7940, + 953 + ] + ], + [ + [ + 8069, + 8069 + ], + "mapped", + [ + 7941, + 953 + ] + ], + [ + [ + 8070, + 8070 + ], + "mapped", + [ + 7942, + 953 + ] + ], + [ + [ + 8071, + 8071 + ], + "mapped", + [ + 7943, + 953 + ] + ], + [ + [ + 8072, + 8072 + ], + "mapped", + [ + 7936, + 953 + ] + ], + [ + [ + 8073, + 8073 + ], + "mapped", + [ + 7937, + 953 + ] + ], + [ + [ + 8074, + 8074 + ], + "mapped", + [ + 7938, + 953 + ] + ], + [ + [ + 8075, + 8075 + ], + "mapped", + [ + 7939, + 953 + ] + ], + [ + [ + 8076, + 8076 + ], + "mapped", + [ + 7940, + 953 + ] + ], + [ + [ + 8077, + 8077 + ], + "mapped", + [ + 7941, + 953 + ] + ], + [ + [ + 8078, + 8078 + ], + "mapped", + [ + 7942, + 953 + ] + ], + [ + [ + 8079, + 8079 + ], + "mapped", + [ + 7943, + 953 + ] + ], + [ + [ + 8080, + 8080 + ], + "mapped", + [ + 7968, + 953 + ] + ], + [ + [ + 8081, + 8081 + ], + "mapped", + [ + 7969, + 953 + ] + ], + [ + [ + 8082, + 8082 + ], + "mapped", + [ + 7970, + 953 + ] + ], + [ + [ + 8083, + 8083 + ], + "mapped", + [ + 7971, + 953 + ] + ], + [ + [ + 8084, + 8084 + ], + "mapped", + [ + 7972, + 953 + ] + ], + [ + [ + 8085, + 8085 + ], + "mapped", + [ + 7973, + 953 + ] + ], + [ + [ + 8086, + 8086 + ], + "mapped", + [ + 7974, + 953 + ] + ], + [ + [ + 8087, + 8087 + ], + "mapped", + [ + 7975, + 953 + ] + ], + [ + [ + 8088, + 8088 + ], + "mapped", + [ + 7968, + 953 + ] + ], + [ + [ + 8089, + 8089 + ], + "mapped", + [ + 7969, + 953 + ] + ], + [ + [ + 8090, + 8090 + ], + "mapped", + [ + 7970, + 953 + ] + ], + [ + [ + 8091, + 8091 + ], + "mapped", + [ + 7971, + 953 + ] + ], + [ + [ + 8092, + 8092 + ], + "mapped", + [ + 7972, + 953 + ] + ], + [ + [ + 8093, + 8093 + ], + "mapped", + [ + 7973, + 953 + ] + ], + [ + [ + 8094, + 8094 + ], + "mapped", + [ + 7974, + 953 + ] + ], + [ + [ + 8095, + 8095 + ], + "mapped", + [ + 7975, + 953 + ] + ], + [ + [ + 8096, + 8096 + ], + "mapped", + [ + 8032, + 953 + ] + ], + [ + [ + 8097, + 8097 + ], + "mapped", + [ + 8033, + 953 + ] + ], + [ + [ + 8098, + 8098 + ], + "mapped", + [ + 8034, + 953 + ] + ], + [ + [ + 8099, + 8099 + ], + "mapped", + [ + 8035, + 953 + ] + ], + [ + [ + 8100, + 8100 + ], + "mapped", + [ + 8036, + 953 + ] + ], + [ + [ + 8101, + 8101 + ], + "mapped", + [ + 8037, + 953 + ] + ], + [ + [ + 8102, + 8102 + ], + "mapped", + [ + 8038, + 953 + ] + ], + [ + [ + 8103, + 8103 + ], + "mapped", + [ + 8039, + 953 + ] + ], + [ + [ + 8104, + 8104 + ], + "mapped", + [ + 8032, + 953 + ] + ], + [ + [ + 8105, + 8105 + ], + "mapped", + [ + 8033, + 953 + ] + ], + [ + [ + 8106, + 8106 + ], + "mapped", + [ + 8034, + 953 + ] + ], + [ + [ + 8107, + 8107 + ], + "mapped", + [ + 8035, + 953 + ] + ], + [ + [ + 8108, + 8108 + ], + "mapped", + [ + 8036, + 953 + ] + ], + [ + [ + 8109, + 8109 + ], + "mapped", + [ + 8037, + 953 + ] + ], + [ + [ + 8110, + 8110 + ], + "mapped", + [ + 8038, + 953 + ] + ], + [ + [ + 8111, + 8111 + ], + "mapped", + [ + 8039, + 953 + ] + ], + [ + [ + 8112, + 8113 + ], + "valid" + ], + [ + [ + 8114, + 8114 + ], + "mapped", + [ + 8048, + 953 + ] + ], + [ + [ + 8115, + 8115 + ], + "mapped", + [ + 945, + 953 + ] + ], + [ + [ + 8116, + 8116 + ], + "mapped", + [ + 940, + 953 + ] + ], + [ + [ + 8117, + 8117 + ], + "disallowed" + ], + [ + [ + 8118, + 8118 + ], + "valid" + ], + [ + [ + 8119, + 8119 + ], + "mapped", + [ + 8118, + 953 + ] + ], + [ + [ + 8120, + 8120 + ], + "mapped", + [ + 8112 + ] + ], + [ + [ + 8121, + 8121 + ], + "mapped", + [ + 8113 + ] + ], + [ + [ + 8122, + 8122 + ], + "mapped", + [ + 8048 + ] + ], + [ + [ + 8123, + 8123 + ], + "mapped", + [ + 940 + ] + ], + [ + [ + 8124, + 8124 + ], + "mapped", + [ + 945, + 953 + ] + ], + [ + [ + 8125, + 8125 + ], + "disallowed_STD3_mapped", + [ + 32, + 787 + ] + ], + [ + [ + 8126, + 8126 + ], + "mapped", + [ + 953 + ] + ], + [ + [ + 8127, + 8127 + ], + "disallowed_STD3_mapped", + [ + 32, + 787 + ] + ], + [ + [ + 8128, + 8128 + ], + "disallowed_STD3_mapped", + [ + 32, + 834 + ] + ], + [ + [ + 8129, + 8129 + ], + "disallowed_STD3_mapped", + [ + 32, + 776, + 834 + ] + ], + [ + [ + 8130, + 8130 + ], + "mapped", + [ + 8052, + 953 + ] + ], + [ + [ + 8131, + 8131 + ], + "mapped", + [ + 951, + 953 + ] + ], + [ + [ + 8132, + 8132 + ], + "mapped", + [ + 942, + 953 + ] + ], + [ + [ + 8133, + 8133 + ], + "disallowed" + ], + [ + [ + 8134, + 8134 + ], + "valid" + ], + [ + [ + 8135, + 8135 + ], + "mapped", + [ + 8134, + 953 + ] + ], + [ + [ + 8136, + 8136 + ], + "mapped", + [ + 8050 + ] + ], + [ + [ + 8137, + 8137 + ], + "mapped", + [ + 941 + ] + ], + [ + [ + 8138, + 8138 + ], + "mapped", + [ + 8052 + ] + ], + [ + [ + 8139, + 8139 + ], + "mapped", + [ + 942 + ] + ], + [ + [ + 8140, + 8140 + ], + "mapped", + [ + 951, + 953 + ] + ], + [ + [ + 8141, + 8141 + ], + "disallowed_STD3_mapped", + [ + 32, + 787, + 768 + ] + ], + [ + [ + 8142, + 8142 + ], + "disallowed_STD3_mapped", + [ + 32, + 787, + 769 + ] + ], + [ + [ + 8143, + 8143 + ], + "disallowed_STD3_mapped", + [ + 32, + 787, + 834 + ] + ], + [ + [ + 8144, + 8146 + ], + "valid" + ], + [ + [ + 8147, + 8147 + ], + "mapped", + [ + 912 + ] + ], + [ + [ + 8148, + 8149 + ], + "disallowed" + ], + [ + [ + 8150, + 8151 + ], + "valid" + ], + [ + [ + 8152, + 8152 + ], + "mapped", + [ + 8144 + ] + ], + [ + [ + 8153, + 8153 + ], + "mapped", + [ + 8145 + ] + ], + [ + [ + 8154, + 8154 + ], + "mapped", + [ + 8054 + ] + ], + [ + [ + 8155, + 8155 + ], + "mapped", + [ + 943 + ] + ], + [ + [ + 8156, + 8156 + ], + "disallowed" + ], + [ + [ + 8157, + 8157 + ], + "disallowed_STD3_mapped", + [ + 32, + 788, + 768 + ] + ], + [ + [ + 8158, + 8158 + ], + "disallowed_STD3_mapped", + [ + 32, + 788, + 769 + ] + ], + [ + [ + 8159, + 8159 + ], + "disallowed_STD3_mapped", + [ + 32, + 788, + 834 + ] + ], + [ + [ + 8160, + 8162 + ], + "valid" + ], + [ + [ + 8163, + 8163 + ], + "mapped", + [ + 944 + ] + ], + [ + [ + 8164, + 8167 + ], + "valid" + ], + [ + [ + 8168, + 8168 + ], + "mapped", + [ + 8160 + ] + ], + [ + [ + 8169, + 8169 + ], + "mapped", + [ + 8161 + ] + ], + [ + [ + 8170, + 8170 + ], + "mapped", + [ + 8058 + ] + ], + [ + [ + 8171, + 8171 + ], + "mapped", + [ + 973 + ] + ], + [ + [ + 8172, + 8172 + ], + "mapped", + [ + 8165 + ] + ], + [ + [ + 8173, + 8173 + ], + "disallowed_STD3_mapped", + [ + 32, + 776, + 768 + ] + ], + [ + [ + 8174, + 8174 + ], + "disallowed_STD3_mapped", + [ + 32, + 776, + 769 + ] + ], + [ + [ + 8175, + 8175 + ], + "disallowed_STD3_mapped", + [ + 96 + ] + ], + [ + [ + 8176, + 8177 + ], + "disallowed" + ], + [ + [ + 8178, + 8178 + ], + "mapped", + [ + 8060, + 953 + ] + ], + [ + [ + 8179, + 8179 + ], + "mapped", + [ + 969, + 953 + ] + ], + [ + [ + 8180, + 8180 + ], + "mapped", + [ + 974, + 953 + ] + ], + [ + [ + 8181, + 8181 + ], + "disallowed" + ], + [ + [ + 8182, + 8182 + ], + "valid" + ], + [ + [ + 8183, + 8183 + ], + "mapped", + [ + 8182, + 953 + ] + ], + [ + [ + 8184, + 8184 + ], + "mapped", + [ + 8056 + ] + ], + [ + [ + 8185, + 8185 + ], + "mapped", + [ + 972 + ] + ], + [ + [ + 8186, + 8186 + ], + "mapped", + [ + 8060 + ] + ], + [ + [ + 8187, + 8187 + ], + "mapped", + [ + 974 + ] + ], + [ + [ + 8188, + 8188 + ], + "mapped", + [ + 969, + 953 + ] + ], + [ + [ + 8189, + 8189 + ], + "disallowed_STD3_mapped", + [ + 32, + 769 + ] + ], + [ + [ + 8190, + 8190 + ], + "disallowed_STD3_mapped", + [ + 32, + 788 + ] + ], + [ + [ + 8191, + 8191 + ], + "disallowed" + ], + [ + [ + 8192, + 8202 + ], + "disallowed_STD3_mapped", + [ + 32 + ] + ], + [ + [ + 8203, + 8203 + ], + "ignored" + ], + [ + [ + 8204, + 8205 + ], + "deviation", + [ + ] + ], + [ + [ + 8206, + 8207 + ], + "disallowed" + ], + [ + [ + 8208, + 8208 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 8209, + 8209 + ], + "mapped", + [ + 8208 + ] + ], + [ + [ + 8210, + 8214 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 8215, + 8215 + ], + "disallowed_STD3_mapped", + [ + 32, + 819 + ] + ], + [ + [ + 8216, + 8227 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 8228, + 8230 + ], + "disallowed" + ], + [ + [ + 8231, + 8231 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 8232, + 8238 + ], + "disallowed" + ], + [ + [ + 8239, + 8239 + ], + "disallowed_STD3_mapped", + [ + 32 + ] + ], + [ + [ + 8240, + 8242 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 8243, + 8243 + ], + "mapped", + [ + 8242, + 8242 + ] + ], + [ + [ + 8244, + 8244 + ], + "mapped", + [ + 8242, + 8242, + 8242 + ] + ], + [ + [ + 8245, + 8245 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 8246, + 8246 + ], + "mapped", + [ + 8245, + 8245 + ] + ], + [ + [ + 8247, + 8247 + ], + "mapped", + [ + 8245, + 8245, + 8245 + ] + ], + [ + [ + 8248, + 8251 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 8252, + 8252 + ], + "disallowed_STD3_mapped", + [ + 33, + 33 + ] + ], + [ + [ + 8253, + 8253 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 8254, + 8254 + ], + "disallowed_STD3_mapped", + [ + 32, + 773 + ] + ], + [ + [ + 8255, + 8262 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 8263, + 8263 + ], + "disallowed_STD3_mapped", + [ + 63, + 63 + ] + ], + [ + [ + 8264, + 8264 + ], + "disallowed_STD3_mapped", + [ + 63, + 33 + ] + ], + [ + [ + 8265, + 8265 + ], + "disallowed_STD3_mapped", + [ + 33, + 63 + ] + ], + [ + [ + 8266, + 8269 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 8270, + 8274 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 8275, + 8276 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 8277, + 8278 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 8279, + 8279 + ], + "mapped", + [ + 8242, + 8242, + 8242, + 8242 + ] + ], + [ + [ + 8280, + 8286 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 8287, + 8287 + ], + "disallowed_STD3_mapped", + [ + 32 + ] + ], + [ + [ + 8288, + 8288 + ], + "ignored" + ], + [ + [ + 8289, + 8291 + ], + "disallowed" + ], + [ + [ + 8292, + 8292 + ], + "ignored" + ], + [ + [ + 8293, + 8293 + ], + "disallowed" + ], + [ + [ + 8294, + 8297 + ], + "disallowed" + ], + [ + [ + 8298, + 8303 + ], + "disallowed" + ], + [ + [ + 8304, + 8304 + ], + "mapped", + [ + 48 + ] + ], + [ + [ + 8305, + 8305 + ], + "mapped", + [ + 105 + ] + ], + [ + [ + 8306, + 8307 + ], + "disallowed" + ], + [ + [ + 8308, + 8308 + ], + "mapped", + [ + 52 + ] + ], + [ + [ + 8309, + 8309 + ], + "mapped", + [ + 53 + ] + ], + [ + [ + 8310, + 8310 + ], + "mapped", + [ + 54 + ] + ], + [ + [ + 8311, + 8311 + ], + "mapped", + [ + 55 + ] + ], + [ + [ + 8312, + 8312 + ], + "mapped", + [ + 56 + ] + ], + [ + [ + 8313, + 8313 + ], + "mapped", + [ + 57 + ] + ], + [ + [ + 8314, + 8314 + ], + "disallowed_STD3_mapped", + [ + 43 + ] + ], + [ + [ + 8315, + 8315 + ], + "mapped", + [ + 8722 + ] + ], + [ + [ + 8316, + 8316 + ], + "disallowed_STD3_mapped", + [ + 61 + ] + ], + [ + [ + 8317, + 8317 + ], + "disallowed_STD3_mapped", + [ + 40 + ] + ], + [ + [ + 8318, + 8318 + ], + "disallowed_STD3_mapped", + [ + 41 + ] + ], + [ + [ + 8319, + 8319 + ], + "mapped", + [ + 110 + ] + ], + [ + [ + 8320, + 8320 + ], + "mapped", + [ + 48 + ] + ], + [ + [ + 8321, + 8321 + ], + "mapped", + [ + 49 + ] + ], + [ + [ + 8322, + 8322 + ], + "mapped", + [ + 50 + ] + ], + [ + [ + 8323, + 8323 + ], + "mapped", + [ + 51 + ] + ], + [ + [ + 8324, + 8324 + ], + "mapped", + [ + 52 + ] + ], + [ + [ + 8325, + 8325 + ], + "mapped", + [ + 53 + ] + ], + [ + [ + 8326, + 8326 + ], + "mapped", + [ + 54 + ] + ], + [ + [ + 8327, + 8327 + ], + "mapped", + [ + 55 + ] + ], + [ + [ + 8328, + 8328 + ], + "mapped", + [ + 56 + ] + ], + [ + [ + 8329, + 8329 + ], + "mapped", + [ + 57 + ] + ], + [ + [ + 8330, + 8330 + ], + "disallowed_STD3_mapped", + [ + 43 + ] + ], + [ + [ + 8331, + 8331 + ], + "mapped", + [ + 8722 + ] + ], + [ + [ + 8332, + 8332 + ], + "disallowed_STD3_mapped", + [ + 61 + ] + ], + [ + [ + 8333, + 8333 + ], + "disallowed_STD3_mapped", + [ + 40 + ] + ], + [ + [ + 8334, + 8334 + ], + "disallowed_STD3_mapped", + [ + 41 + ] + ], + [ + [ + 8335, + 8335 + ], + "disallowed" + ], + [ + [ + 8336, + 8336 + ], + "mapped", + [ + 97 + ] + ], + [ + [ + 8337, + 8337 + ], + "mapped", + [ + 101 + ] + ], + [ + [ + 8338, + 8338 + ], + "mapped", + [ + 111 + ] + ], + [ + [ + 8339, + 8339 + ], + "mapped", + [ + 120 + ] + ], + [ + [ + 8340, + 8340 + ], + "mapped", + [ + 601 + ] + ], + [ + [ + 8341, + 8341 + ], + "mapped", + [ + 104 + ] + ], + [ + [ + 8342, + 8342 + ], + "mapped", + [ + 107 + ] + ], + [ + [ + 8343, + 8343 + ], + "mapped", + [ + 108 + ] + ], + [ + [ + 8344, + 8344 + ], + "mapped", + [ + 109 + ] + ], + [ + [ + 8345, + 8345 + ], + "mapped", + [ + 110 + ] + ], + [ + [ + 8346, + 8346 + ], + "mapped", + [ + 112 + ] + ], + [ + [ + 8347, + 8347 + ], + "mapped", + [ + 115 + ] + ], + [ + [ + 8348, + 8348 + ], + "mapped", + [ + 116 + ] + ], + [ + [ + 8349, + 8351 + ], + "disallowed" + ], + [ + [ + 8352, + 8359 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 8360, + 8360 + ], + "mapped", + [ + 114, + 115 + ] + ], + [ + [ + 8361, + 8362 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 8363, + 8363 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 8364, + 8364 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 8365, + 8367 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 8368, + 8369 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 8370, + 8373 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 8374, + 8376 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 8377, + 8377 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 8378, + 8378 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 8379, + 8381 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 8382, + 8382 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 8383, + 8399 + ], + "disallowed" + ], + [ + [ + 8400, + 8417 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 8418, + 8419 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 8420, + 8426 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 8427, + 8427 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 8428, + 8431 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 8432, + 8432 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 8433, + 8447 + ], + "disallowed" + ], + [ + [ + 8448, + 8448 + ], + "disallowed_STD3_mapped", + [ + 97, + 47, + 99 + ] + ], + [ + [ + 8449, + 8449 + ], + "disallowed_STD3_mapped", + [ + 97, + 47, + 115 + ] + ], + [ + [ + 8450, + 8450 + ], + "mapped", + [ + 99 + ] + ], + [ + [ + 8451, + 8451 + ], + "mapped", + [ + 176, + 99 + ] + ], + [ + [ + 8452, + 8452 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 8453, + 8453 + ], + "disallowed_STD3_mapped", + [ + 99, + 47, + 111 + ] + ], + [ + [ + 8454, + 8454 + ], + "disallowed_STD3_mapped", + [ + 99, + 47, + 117 + ] + ], + [ + [ + 8455, + 8455 + ], + "mapped", + [ + 603 + ] + ], + [ + [ + 8456, + 8456 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 8457, + 8457 + ], + "mapped", + [ + 176, + 102 + ] + ], + [ + [ + 8458, + 8458 + ], + "mapped", + [ + 103 + ] + ], + [ + [ + 8459, + 8462 + ], + "mapped", + [ + 104 + ] + ], + [ + [ + 8463, + 8463 + ], + "mapped", + [ + 295 + ] + ], + [ + [ + 8464, + 8465 + ], + "mapped", + [ + 105 + ] + ], + [ + [ + 8466, + 8467 + ], + "mapped", + [ + 108 + ] + ], + [ + [ + 8468, + 8468 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 8469, + 8469 + ], + "mapped", + [ + 110 + ] + ], + [ + [ + 8470, + 8470 + ], + "mapped", + [ + 110, + 111 + ] + ], + [ + [ + 8471, + 8472 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 8473, + 8473 + ], + "mapped", + [ + 112 + ] + ], + [ + [ + 8474, + 8474 + ], + "mapped", + [ + 113 + ] + ], + [ + [ + 8475, + 8477 + ], + "mapped", + [ + 114 + ] + ], + [ + [ + 8478, + 8479 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 8480, + 8480 + ], + "mapped", + [ + 115, + 109 + ] + ], + [ + [ + 8481, + 8481 + ], + "mapped", + [ + 116, + 101, + 108 + ] + ], + [ + [ + 8482, + 8482 + ], + "mapped", + [ + 116, + 109 + ] + ], + [ + [ + 8483, + 8483 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 8484, + 8484 + ], + "mapped", + [ + 122 + ] + ], + [ + [ + 8485, + 8485 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 8486, + 8486 + ], + "mapped", + [ + 969 + ] + ], + [ + [ + 8487, + 8487 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 8488, + 8488 + ], + "mapped", + [ + 122 + ] + ], + [ + [ + 8489, + 8489 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 8490, + 8490 + ], + "mapped", + [ + 107 + ] + ], + [ + [ + 8491, + 8491 + ], + "mapped", + [ + 229 + ] + ], + [ + [ + 8492, + 8492 + ], + "mapped", + [ + 98 + ] + ], + [ + [ + 8493, + 8493 + ], + "mapped", + [ + 99 + ] + ], + [ + [ + 8494, + 8494 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 8495, + 8496 + ], + "mapped", + [ + 101 + ] + ], + [ + [ + 8497, + 8497 + ], + "mapped", + [ + 102 + ] + ], + [ + [ + 8498, + 8498 + ], + "disallowed" + ], + [ + [ + 8499, + 8499 + ], + "mapped", + [ + 109 + ] + ], + [ + [ + 8500, + 8500 + ], + "mapped", + [ + 111 + ] + ], + [ + [ + 8501, + 8501 + ], + "mapped", + [ + 1488 + ] + ], + [ + [ + 8502, + 8502 + ], + "mapped", + [ + 1489 + ] + ], + [ + [ + 8503, + 8503 + ], + "mapped", + [ + 1490 + ] + ], + [ + [ + 8504, + 8504 + ], + "mapped", + [ + 1491 + ] + ], + [ + [ + 8505, + 8505 + ], + "mapped", + [ + 105 + ] + ], + [ + [ + 8506, + 8506 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 8507, + 8507 + ], + "mapped", + [ + 102, + 97, + 120 + ] + ], + [ + [ + 8508, + 8508 + ], + "mapped", + [ + 960 + ] + ], + [ + [ + 8509, + 8510 + ], + "mapped", + [ + 947 + ] + ], + [ + [ + 8511, + 8511 + ], + "mapped", + [ + 960 + ] + ], + [ + [ + 8512, + 8512 + ], + "mapped", + [ + 8721 + ] + ], + [ + [ + 8513, + 8516 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 8517, + 8518 + ], + "mapped", + [ + 100 + ] + ], + [ + [ + 8519, + 8519 + ], + "mapped", + [ + 101 + ] + ], + [ + [ + 8520, + 8520 + ], + "mapped", + [ + 105 + ] + ], + [ + [ + 8521, + 8521 + ], + "mapped", + [ + 106 + ] + ], + [ + [ + 8522, + 8523 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 8524, + 8524 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 8525, + 8525 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 8526, + 8526 + ], + "valid" + ], + [ + [ + 8527, + 8527 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 8528, + 8528 + ], + "mapped", + [ + 49, + 8260, + 55 + ] + ], + [ + [ + 8529, + 8529 + ], + "mapped", + [ + 49, + 8260, + 57 + ] + ], + [ + [ + 8530, + 8530 + ], + "mapped", + [ + 49, + 8260, + 49, + 48 + ] + ], + [ + [ + 8531, + 8531 + ], + "mapped", + [ + 49, + 8260, + 51 + ] + ], + [ + [ + 8532, + 8532 + ], + "mapped", + [ + 50, + 8260, + 51 + ] + ], + [ + [ + 8533, + 8533 + ], + "mapped", + [ + 49, + 8260, + 53 + ] + ], + [ + [ + 8534, + 8534 + ], + "mapped", + [ + 50, + 8260, + 53 + ] + ], + [ + [ + 8535, + 8535 + ], + "mapped", + [ + 51, + 8260, + 53 + ] + ], + [ + [ + 8536, + 8536 + ], + "mapped", + [ + 52, + 8260, + 53 + ] + ], + [ + [ + 8537, + 8537 + ], + "mapped", + [ + 49, + 8260, + 54 + ] + ], + [ + [ + 8538, + 8538 + ], + "mapped", + [ + 53, + 8260, + 54 + ] + ], + [ + [ + 8539, + 8539 + ], + "mapped", + [ + 49, + 8260, + 56 + ] + ], + [ + [ + 8540, + 8540 + ], + "mapped", + [ + 51, + 8260, + 56 + ] + ], + [ + [ + 8541, + 8541 + ], + "mapped", + [ + 53, + 8260, + 56 + ] + ], + [ + [ + 8542, + 8542 + ], + "mapped", + [ + 55, + 8260, + 56 + ] + ], + [ + [ + 8543, + 8543 + ], + "mapped", + [ + 49, + 8260 + ] + ], + [ + [ + 8544, + 8544 + ], + "mapped", + [ + 105 + ] + ], + [ + [ + 8545, + 8545 + ], + "mapped", + [ + 105, + 105 + ] + ], + [ + [ + 8546, + 8546 + ], + "mapped", + [ + 105, + 105, + 105 + ] + ], + [ + [ + 8547, + 8547 + ], + "mapped", + [ + 105, + 118 + ] + ], + [ + [ + 8548, + 8548 + ], + "mapped", + [ + 118 + ] + ], + [ + [ + 8549, + 8549 + ], + "mapped", + [ + 118, + 105 + ] + ], + [ + [ + 8550, + 8550 + ], + "mapped", + [ + 118, + 105, + 105 + ] + ], + [ + [ + 8551, + 8551 + ], + "mapped", + [ + 118, + 105, + 105, + 105 + ] + ], + [ + [ + 8552, + 8552 + ], + "mapped", + [ + 105, + 120 + ] + ], + [ + [ + 8553, + 8553 + ], + "mapped", + [ + 120 + ] + ], + [ + [ + 8554, + 8554 + ], + "mapped", + [ + 120, + 105 + ] + ], + [ + [ + 8555, + 8555 + ], + "mapped", + [ + 120, + 105, + 105 + ] + ], + [ + [ + 8556, + 8556 + ], + "mapped", + [ + 108 + ] + ], + [ + [ + 8557, + 8557 + ], + "mapped", + [ + 99 + ] + ], + [ + [ + 8558, + 8558 + ], + "mapped", + [ + 100 + ] + ], + [ + [ + 8559, + 8559 + ], + "mapped", + [ + 109 + ] + ], + [ + [ + 8560, + 8560 + ], + "mapped", + [ + 105 + ] + ], + [ + [ + 8561, + 8561 + ], + "mapped", + [ + 105, + 105 + ] + ], + [ + [ + 8562, + 8562 + ], + "mapped", + [ + 105, + 105, + 105 + ] + ], + [ + [ + 8563, + 8563 + ], + "mapped", + [ + 105, + 118 + ] + ], + [ + [ + 8564, + 8564 + ], + "mapped", + [ + 118 + ] + ], + [ + [ + 8565, + 8565 + ], + "mapped", + [ + 118, + 105 + ] + ], + [ + [ + 8566, + 8566 + ], + "mapped", + [ + 118, + 105, + 105 + ] + ], + [ + [ + 8567, + 8567 + ], + "mapped", + [ + 118, + 105, + 105, + 105 + ] + ], + [ + [ + 8568, + 8568 + ], + "mapped", + [ + 105, + 120 + ] + ], + [ + [ + 8569, + 8569 + ], + "mapped", + [ + 120 + ] + ], + [ + [ + 8570, + 8570 + ], + "mapped", + [ + 120, + 105 + ] + ], + [ + [ + 8571, + 8571 + ], + "mapped", + [ + 120, + 105, + 105 + ] + ], + [ + [ + 8572, + 8572 + ], + "mapped", + [ + 108 + ] + ], + [ + [ + 8573, + 8573 + ], + "mapped", + [ + 99 + ] + ], + [ + [ + 8574, + 8574 + ], + "mapped", + [ + 100 + ] + ], + [ + [ + 8575, + 8575 + ], + "mapped", + [ + 109 + ] + ], + [ + [ + 8576, + 8578 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 8579, + 8579 + ], + "disallowed" + ], + [ + [ + 8580, + 8580 + ], + "valid" + ], + [ + [ + 8581, + 8584 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 8585, + 8585 + ], + "mapped", + [ + 48, + 8260, + 51 + ] + ], + [ + [ + 8586, + 8587 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 8588, + 8591 + ], + "disallowed" + ], + [ + [ + 8592, + 8682 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 8683, + 8691 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 8692, + 8703 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 8704, + 8747 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 8748, + 8748 + ], + "mapped", + [ + 8747, + 8747 + ] + ], + [ + [ + 8749, + 8749 + ], + "mapped", + [ + 8747, + 8747, + 8747 + ] + ], + [ + [ + 8750, + 8750 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 8751, + 8751 + ], + "mapped", + [ + 8750, + 8750 + ] + ], + [ + [ + 8752, + 8752 + ], + "mapped", + [ + 8750, + 8750, + 8750 + ] + ], + [ + [ + 8753, + 8799 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 8800, + 8800 + ], + "disallowed_STD3_valid" + ], + [ + [ + 8801, + 8813 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 8814, + 8815 + ], + "disallowed_STD3_valid" + ], + [ + [ + 8816, + 8945 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 8946, + 8959 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 8960, + 8960 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 8961, + 8961 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 8962, + 9000 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 9001, + 9001 + ], + "mapped", + [ + 12296 + ] + ], + [ + [ + 9002, + 9002 + ], + "mapped", + [ + 12297 + ] + ], + [ + [ + 9003, + 9082 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 9083, + 9083 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 9084, + 9084 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 9085, + 9114 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 9115, + 9166 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 9167, + 9168 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 9169, + 9179 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 9180, + 9191 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 9192, + 9192 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 9193, + 9203 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 9204, + 9210 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 9211, + 9215 + ], + "disallowed" + ], + [ + [ + 9216, + 9252 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 9253, + 9254 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 9255, + 9279 + ], + "disallowed" + ], + [ + [ + 9280, + 9290 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 9291, + 9311 + ], + "disallowed" + ], + [ + [ + 9312, + 9312 + ], + "mapped", + [ + 49 + ] + ], + [ + [ + 9313, + 9313 + ], + "mapped", + [ + 50 + ] + ], + [ + [ + 9314, + 9314 + ], + "mapped", + [ + 51 + ] + ], + [ + [ + 9315, + 9315 + ], + "mapped", + [ + 52 + ] + ], + [ + [ + 9316, + 9316 + ], + "mapped", + [ + 53 + ] + ], + [ + [ + 9317, + 9317 + ], + "mapped", + [ + 54 + ] + ], + [ + [ + 9318, + 9318 + ], + "mapped", + [ + 55 + ] + ], + [ + [ + 9319, + 9319 + ], + "mapped", + [ + 56 + ] + ], + [ + [ + 9320, + 9320 + ], + "mapped", + [ + 57 + ] + ], + [ + [ + 9321, + 9321 + ], + "mapped", + [ + 49, + 48 + ] + ], + [ + [ + 9322, + 9322 + ], + "mapped", + [ + 49, + 49 + ] + ], + [ + [ + 9323, + 9323 + ], + "mapped", + [ + 49, + 50 + ] + ], + [ + [ + 9324, + 9324 + ], + "mapped", + [ + 49, + 51 + ] + ], + [ + [ + 9325, + 9325 + ], + "mapped", + [ + 49, + 52 + ] + ], + [ + [ + 9326, + 9326 + ], + "mapped", + [ + 49, + 53 + ] + ], + [ + [ + 9327, + 9327 + ], + "mapped", + [ + 49, + 54 + ] + ], + [ + [ + 9328, + 9328 + ], + "mapped", + [ + 49, + 55 + ] + ], + [ + [ + 9329, + 9329 + ], + "mapped", + [ + 49, + 56 + ] + ], + [ + [ + 9330, + 9330 + ], + "mapped", + [ + 49, + 57 + ] + ], + [ + [ + 9331, + 9331 + ], + "mapped", + [ + 50, + 48 + ] + ], + [ + [ + 9332, + 9332 + ], + "disallowed_STD3_mapped", + [ + 40, + 49, + 41 + ] + ], + [ + [ + 9333, + 9333 + ], + "disallowed_STD3_mapped", + [ + 40, + 50, + 41 + ] + ], + [ + [ + 9334, + 9334 + ], + "disallowed_STD3_mapped", + [ + 40, + 51, + 41 + ] + ], + [ + [ + 9335, + 9335 + ], + "disallowed_STD3_mapped", + [ + 40, + 52, + 41 + ] + ], + [ + [ + 9336, + 9336 + ], + "disallowed_STD3_mapped", + [ + 40, + 53, + 41 + ] + ], + [ + [ + 9337, + 9337 + ], + "disallowed_STD3_mapped", + [ + 40, + 54, + 41 + ] + ], + [ + [ + 9338, + 9338 + ], + "disallowed_STD3_mapped", + [ + 40, + 55, + 41 + ] + ], + [ + [ + 9339, + 9339 + ], + "disallowed_STD3_mapped", + [ + 40, + 56, + 41 + ] + ], + [ + [ + 9340, + 9340 + ], + "disallowed_STD3_mapped", + [ + 40, + 57, + 41 + ] + ], + [ + [ + 9341, + 9341 + ], + "disallowed_STD3_mapped", + [ + 40, + 49, + 48, + 41 + ] + ], + [ + [ + 9342, + 9342 + ], + "disallowed_STD3_mapped", + [ + 40, + 49, + 49, + 41 + ] + ], + [ + [ + 9343, + 9343 + ], + "disallowed_STD3_mapped", + [ + 40, + 49, + 50, + 41 + ] + ], + [ + [ + 9344, + 9344 + ], + "disallowed_STD3_mapped", + [ + 40, + 49, + 51, + 41 + ] + ], + [ + [ + 9345, + 9345 + ], + "disallowed_STD3_mapped", + [ + 40, + 49, + 52, + 41 + ] + ], + [ + [ + 9346, + 9346 + ], + "disallowed_STD3_mapped", + [ + 40, + 49, + 53, + 41 + ] + ], + [ + [ + 9347, + 9347 + ], + "disallowed_STD3_mapped", + [ + 40, + 49, + 54, + 41 + ] + ], + [ + [ + 9348, + 9348 + ], + "disallowed_STD3_mapped", + [ + 40, + 49, + 55, + 41 + ] + ], + [ + [ + 9349, + 9349 + ], + "disallowed_STD3_mapped", + [ + 40, + 49, + 56, + 41 + ] + ], + [ + [ + 9350, + 9350 + ], + "disallowed_STD3_mapped", + [ + 40, + 49, + 57, + 41 + ] + ], + [ + [ + 9351, + 9351 + ], + "disallowed_STD3_mapped", + [ + 40, + 50, + 48, + 41 + ] + ], + [ + [ + 9352, + 9371 + ], + "disallowed" + ], + [ + [ + 9372, + 9372 + ], + "disallowed_STD3_mapped", + [ + 40, + 97, + 41 + ] + ], + [ + [ + 9373, + 9373 + ], + "disallowed_STD3_mapped", + [ + 40, + 98, + 41 + ] + ], + [ + [ + 9374, + 9374 + ], + "disallowed_STD3_mapped", + [ + 40, + 99, + 41 + ] + ], + [ + [ + 9375, + 9375 + ], + "disallowed_STD3_mapped", + [ + 40, + 100, + 41 + ] + ], + [ + [ + 9376, + 9376 + ], + "disallowed_STD3_mapped", + [ + 40, + 101, + 41 + ] + ], + [ + [ + 9377, + 9377 + ], + "disallowed_STD3_mapped", + [ + 40, + 102, + 41 + ] + ], + [ + [ + 9378, + 9378 + ], + "disallowed_STD3_mapped", + [ + 40, + 103, + 41 + ] + ], + [ + [ + 9379, + 9379 + ], + "disallowed_STD3_mapped", + [ + 40, + 104, + 41 + ] + ], + [ + [ + 9380, + 9380 + ], + "disallowed_STD3_mapped", + [ + 40, + 105, + 41 + ] + ], + [ + [ + 9381, + 9381 + ], + "disallowed_STD3_mapped", + [ + 40, + 106, + 41 + ] + ], + [ + [ + 9382, + 9382 + ], + "disallowed_STD3_mapped", + [ + 40, + 107, + 41 + ] + ], + [ + [ + 9383, + 9383 + ], + "disallowed_STD3_mapped", + [ + 40, + 108, + 41 + ] + ], + [ + [ + 9384, + 9384 + ], + "disallowed_STD3_mapped", + [ + 40, + 109, + 41 + ] + ], + [ + [ + 9385, + 9385 + ], + "disallowed_STD3_mapped", + [ + 40, + 110, + 41 + ] + ], + [ + [ + 9386, + 9386 + ], + "disallowed_STD3_mapped", + [ + 40, + 111, + 41 + ] + ], + [ + [ + 9387, + 9387 + ], + "disallowed_STD3_mapped", + [ + 40, + 112, + 41 + ] + ], + [ + [ + 9388, + 9388 + ], + "disallowed_STD3_mapped", + [ + 40, + 113, + 41 + ] + ], + [ + [ + 9389, + 9389 + ], + "disallowed_STD3_mapped", + [ + 40, + 114, + 41 + ] + ], + [ + [ + 9390, + 9390 + ], + "disallowed_STD3_mapped", + [ + 40, + 115, + 41 + ] + ], + [ + [ + 9391, + 9391 + ], + "disallowed_STD3_mapped", + [ + 40, + 116, + 41 + ] + ], + [ + [ + 9392, + 9392 + ], + "disallowed_STD3_mapped", + [ + 40, + 117, + 41 + ] + ], + [ + [ + 9393, + 9393 + ], + "disallowed_STD3_mapped", + [ + 40, + 118, + 41 + ] + ], + [ + [ + 9394, + 9394 + ], + "disallowed_STD3_mapped", + [ + 40, + 119, + 41 + ] + ], + [ + [ + 9395, + 9395 + ], + "disallowed_STD3_mapped", + [ + 40, + 120, + 41 + ] + ], + [ + [ + 9396, + 9396 + ], + "disallowed_STD3_mapped", + [ + 40, + 121, + 41 + ] + ], + [ + [ + 9397, + 9397 + ], + "disallowed_STD3_mapped", + [ + 40, + 122, + 41 + ] + ], + [ + [ + 9398, + 9398 + ], + "mapped", + [ + 97 + ] + ], + [ + [ + 9399, + 9399 + ], + "mapped", + [ + 98 + ] + ], + [ + [ + 9400, + 9400 + ], + "mapped", + [ + 99 + ] + ], + [ + [ + 9401, + 9401 + ], + "mapped", + [ + 100 + ] + ], + [ + [ + 9402, + 9402 + ], + "mapped", + [ + 101 + ] + ], + [ + [ + 9403, + 9403 + ], + "mapped", + [ + 102 + ] + ], + [ + [ + 9404, + 9404 + ], + "mapped", + [ + 103 + ] + ], + [ + [ + 9405, + 9405 + ], + "mapped", + [ + 104 + ] + ], + [ + [ + 9406, + 9406 + ], + "mapped", + [ + 105 + ] + ], + [ + [ + 9407, + 9407 + ], + "mapped", + [ + 106 + ] + ], + [ + [ + 9408, + 9408 + ], + "mapped", + [ + 107 + ] + ], + [ + [ + 9409, + 9409 + ], + "mapped", + [ + 108 + ] + ], + [ + [ + 9410, + 9410 + ], + "mapped", + [ + 109 + ] + ], + [ + [ + 9411, + 9411 + ], + "mapped", + [ + 110 + ] + ], + [ + [ + 9412, + 9412 + ], + "mapped", + [ + 111 + ] + ], + [ + [ + 9413, + 9413 + ], + "mapped", + [ + 112 + ] + ], + [ + [ + 9414, + 9414 + ], + "mapped", + [ + 113 + ] + ], + [ + [ + 9415, + 9415 + ], + "mapped", + [ + 114 + ] + ], + [ + [ + 9416, + 9416 + ], + "mapped", + [ + 115 + ] + ], + [ + [ + 9417, + 9417 + ], + "mapped", + [ + 116 + ] + ], + [ + [ + 9418, + 9418 + ], + "mapped", + [ + 117 + ] + ], + [ + [ + 9419, + 9419 + ], + "mapped", + [ + 118 + ] + ], + [ + [ + 9420, + 9420 + ], + "mapped", + [ + 119 + ] + ], + [ + [ + 9421, + 9421 + ], + "mapped", + [ + 120 + ] + ], + [ + [ + 9422, + 9422 + ], + "mapped", + [ + 121 + ] + ], + [ + [ + 9423, + 9423 + ], + "mapped", + [ + 122 + ] + ], + [ + [ + 9424, + 9424 + ], + "mapped", + [ + 97 + ] + ], + [ + [ + 9425, + 9425 + ], + "mapped", + [ + 98 + ] + ], + [ + [ + 9426, + 9426 + ], + "mapped", + [ + 99 + ] + ], + [ + [ + 9427, + 9427 + ], + "mapped", + [ + 100 + ] + ], + [ + [ + 9428, + 9428 + ], + "mapped", + [ + 101 + ] + ], + [ + [ + 9429, + 9429 + ], + "mapped", + [ + 102 + ] + ], + [ + [ + 9430, + 9430 + ], + "mapped", + [ + 103 + ] + ], + [ + [ + 9431, + 9431 + ], + "mapped", + [ + 104 + ] + ], + [ + [ + 9432, + 9432 + ], + "mapped", + [ + 105 + ] + ], + [ + [ + 9433, + 9433 + ], + "mapped", + [ + 106 + ] + ], + [ + [ + 9434, + 9434 + ], + "mapped", + [ + 107 + ] + ], + [ + [ + 9435, + 9435 + ], + "mapped", + [ + 108 + ] + ], + [ + [ + 9436, + 9436 + ], + "mapped", + [ + 109 + ] + ], + [ + [ + 9437, + 9437 + ], + "mapped", + [ + 110 + ] + ], + [ + [ + 9438, + 9438 + ], + "mapped", + [ + 111 + ] + ], + [ + [ + 9439, + 9439 + ], + "mapped", + [ + 112 + ] + ], + [ + [ + 9440, + 9440 + ], + "mapped", + [ + 113 + ] + ], + [ + [ + 9441, + 9441 + ], + "mapped", + [ + 114 + ] + ], + [ + [ + 9442, + 9442 + ], + "mapped", + [ + 115 + ] + ], + [ + [ + 9443, + 9443 + ], + "mapped", + [ + 116 + ] + ], + [ + [ + 9444, + 9444 + ], + "mapped", + [ + 117 + ] + ], + [ + [ + 9445, + 9445 + ], + "mapped", + [ + 118 + ] + ], + [ + [ + 9446, + 9446 + ], + "mapped", + [ + 119 + ] + ], + [ + [ + 9447, + 9447 + ], + "mapped", + [ + 120 + ] + ], + [ + [ + 9448, + 9448 + ], + "mapped", + [ + 121 + ] + ], + [ + [ + 9449, + 9449 + ], + "mapped", + [ + 122 + ] + ], + [ + [ + 9450, + 9450 + ], + "mapped", + [ + 48 + ] + ], + [ + [ + 9451, + 9470 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 9471, + 9471 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 9472, + 9621 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 9622, + 9631 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 9632, + 9711 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 9712, + 9719 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 9720, + 9727 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 9728, + 9747 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 9748, + 9749 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 9750, + 9751 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 9752, + 9752 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 9753, + 9753 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 9754, + 9839 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 9840, + 9841 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 9842, + 9853 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 9854, + 9855 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 9856, + 9865 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 9866, + 9873 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 9874, + 9884 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 9885, + 9885 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 9886, + 9887 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 9888, + 9889 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 9890, + 9905 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 9906, + 9906 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 9907, + 9916 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 9917, + 9919 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 9920, + 9923 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 9924, + 9933 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 9934, + 9934 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 9935, + 9953 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 9954, + 9954 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 9955, + 9955 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 9956, + 9959 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 9960, + 9983 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 9984, + 9984 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 9985, + 9988 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 9989, + 9989 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 9990, + 9993 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 9994, + 9995 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 9996, + 10023 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 10024, + 10024 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 10025, + 10059 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 10060, + 10060 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 10061, + 10061 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 10062, + 10062 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 10063, + 10066 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 10067, + 10069 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 10070, + 10070 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 10071, + 10071 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 10072, + 10078 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 10079, + 10080 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 10081, + 10087 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 10088, + 10101 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 10102, + 10132 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 10133, + 10135 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 10136, + 10159 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 10160, + 10160 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 10161, + 10174 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 10175, + 10175 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 10176, + 10182 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 10183, + 10186 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 10187, + 10187 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 10188, + 10188 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 10189, + 10189 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 10190, + 10191 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 10192, + 10219 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 10220, + 10223 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 10224, + 10239 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 10240, + 10495 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 10496, + 10763 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 10764, + 10764 + ], + "mapped", + [ + 8747, + 8747, + 8747, + 8747 + ] + ], + [ + [ + 10765, + 10867 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 10868, + 10868 + ], + "disallowed_STD3_mapped", + [ + 58, + 58, + 61 + ] + ], + [ + [ + 10869, + 10869 + ], + "disallowed_STD3_mapped", + [ + 61, + 61 + ] + ], + [ + [ + 10870, + 10870 + ], + "disallowed_STD3_mapped", + [ + 61, + 61, + 61 + ] + ], + [ + [ + 10871, + 10971 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 10972, + 10972 + ], + "mapped", + [ + 10973, + 824 + ] + ], + [ + [ + 10973, + 11007 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 11008, + 11021 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 11022, + 11027 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 11028, + 11034 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 11035, + 11039 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 11040, + 11043 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 11044, + 11084 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 11085, + 11087 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 11088, + 11092 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 11093, + 11097 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 11098, + 11123 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 11124, + 11125 + ], + "disallowed" + ], + [ + [ + 11126, + 11157 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 11158, + 11159 + ], + "disallowed" + ], + [ + [ + 11160, + 11193 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 11194, + 11196 + ], + "disallowed" + ], + [ + [ + 11197, + 11208 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 11209, + 11209 + ], + "disallowed" + ], + [ + [ + 11210, + 11217 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 11218, + 11243 + ], + "disallowed" + ], + [ + [ + 11244, + 11247 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 11248, + 11263 + ], + "disallowed" + ], + [ + [ + 11264, + 11264 + ], + "mapped", + [ + 11312 + ] + ], + [ + [ + 11265, + 11265 + ], + "mapped", + [ + 11313 + ] + ], + [ + [ + 11266, + 11266 + ], + "mapped", + [ + 11314 + ] + ], + [ + [ + 11267, + 11267 + ], + "mapped", + [ + 11315 + ] + ], + [ + [ + 11268, + 11268 + ], + "mapped", + [ + 11316 + ] + ], + [ + [ + 11269, + 11269 + ], + "mapped", + [ + 11317 + ] + ], + [ + [ + 11270, + 11270 + ], + "mapped", + [ + 11318 + ] + ], + [ + [ + 11271, + 11271 + ], + "mapped", + [ + 11319 + ] + ], + [ + [ + 11272, + 11272 + ], + "mapped", + [ + 11320 + ] + ], + [ + [ + 11273, + 11273 + ], + "mapped", + [ + 11321 + ] + ], + [ + [ + 11274, + 11274 + ], + "mapped", + [ + 11322 + ] + ], + [ + [ + 11275, + 11275 + ], + "mapped", + [ + 11323 + ] + ], + [ + [ + 11276, + 11276 + ], + "mapped", + [ + 11324 + ] + ], + [ + [ + 11277, + 11277 + ], + "mapped", + [ + 11325 + ] + ], + [ + [ + 11278, + 11278 + ], + "mapped", + [ + 11326 + ] + ], + [ + [ + 11279, + 11279 + ], + "mapped", + [ + 11327 + ] + ], + [ + [ + 11280, + 11280 + ], + "mapped", + [ + 11328 + ] + ], + [ + [ + 11281, + 11281 + ], + "mapped", + [ + 11329 + ] + ], + [ + [ + 11282, + 11282 + ], + "mapped", + [ + 11330 + ] + ], + [ + [ + 11283, + 11283 + ], + "mapped", + [ + 11331 + ] + ], + [ + [ + 11284, + 11284 + ], + "mapped", + [ + 11332 + ] + ], + [ + [ + 11285, + 11285 + ], + "mapped", + [ + 11333 + ] + ], + [ + [ + 11286, + 11286 + ], + "mapped", + [ + 11334 + ] + ], + [ + [ + 11287, + 11287 + ], + "mapped", + [ + 11335 + ] + ], + [ + [ + 11288, + 11288 + ], + "mapped", + [ + 11336 + ] + ], + [ + [ + 11289, + 11289 + ], + "mapped", + [ + 11337 + ] + ], + [ + [ + 11290, + 11290 + ], + "mapped", + [ + 11338 + ] + ], + [ + [ + 11291, + 11291 + ], + "mapped", + [ + 11339 + ] + ], + [ + [ + 11292, + 11292 + ], + "mapped", + [ + 11340 + ] + ], + [ + [ + 11293, + 11293 + ], + "mapped", + [ + 11341 + ] + ], + [ + [ + 11294, + 11294 + ], + "mapped", + [ + 11342 + ] + ], + [ + [ + 11295, + 11295 + ], + "mapped", + [ + 11343 + ] + ], + [ + [ + 11296, + 11296 + ], + "mapped", + [ + 11344 + ] + ], + [ + [ + 11297, + 11297 + ], + "mapped", + [ + 11345 + ] + ], + [ + [ + 11298, + 11298 + ], + "mapped", + [ + 11346 + ] + ], + [ + [ + 11299, + 11299 + ], + "mapped", + [ + 11347 + ] + ], + [ + [ + 11300, + 11300 + ], + "mapped", + [ + 11348 + ] + ], + [ + [ + 11301, + 11301 + ], + "mapped", + [ + 11349 + ] + ], + [ + [ + 11302, + 11302 + ], + "mapped", + [ + 11350 + ] + ], + [ + [ + 11303, + 11303 + ], + "mapped", + [ + 11351 + ] + ], + [ + [ + 11304, + 11304 + ], + "mapped", + [ + 11352 + ] + ], + [ + [ + 11305, + 11305 + ], + "mapped", + [ + 11353 + ] + ], + [ + [ + 11306, + 11306 + ], + "mapped", + [ + 11354 + ] + ], + [ + [ + 11307, + 11307 + ], + "mapped", + [ + 11355 + ] + ], + [ + [ + 11308, + 11308 + ], + "mapped", + [ + 11356 + ] + ], + [ + [ + 11309, + 11309 + ], + "mapped", + [ + 11357 + ] + ], + [ + [ + 11310, + 11310 + ], + "mapped", + [ + 11358 + ] + ], + [ + [ + 11311, + 11311 + ], + "disallowed" + ], + [ + [ + 11312, + 11358 + ], + "valid" + ], + [ + [ + 11359, + 11359 + ], + "disallowed" + ], + [ + [ + 11360, + 11360 + ], + "mapped", + [ + 11361 + ] + ], + [ + [ + 11361, + 11361 + ], + "valid" + ], + [ + [ + 11362, + 11362 + ], + "mapped", + [ + 619 + ] + ], + [ + [ + 11363, + 11363 + ], + "mapped", + [ + 7549 + ] + ], + [ + [ + 11364, + 11364 + ], + "mapped", + [ + 637 + ] + ], + [ + [ + 11365, + 11366 + ], + "valid" + ], + [ + [ + 11367, + 11367 + ], + "mapped", + [ + 11368 + ] + ], + [ + [ + 11368, + 11368 + ], + "valid" + ], + [ + [ + 11369, + 11369 + ], + "mapped", + [ + 11370 + ] + ], + [ + [ + 11370, + 11370 + ], + "valid" + ], + [ + [ + 11371, + 11371 + ], + "mapped", + [ + 11372 + ] + ], + [ + [ + 11372, + 11372 + ], + "valid" + ], + [ + [ + 11373, + 11373 + ], + "mapped", + [ + 593 + ] + ], + [ + [ + 11374, + 11374 + ], + "mapped", + [ + 625 + ] + ], + [ + [ + 11375, + 11375 + ], + "mapped", + [ + 592 + ] + ], + [ + [ + 11376, + 11376 + ], + "mapped", + [ + 594 + ] + ], + [ + [ + 11377, + 11377 + ], + "valid" + ], + [ + [ + 11378, + 11378 + ], + "mapped", + [ + 11379 + ] + ], + [ + [ + 11379, + 11379 + ], + "valid" + ], + [ + [ + 11380, + 11380 + ], + "valid" + ], + [ + [ + 11381, + 11381 + ], + "mapped", + [ + 11382 + ] + ], + [ + [ + 11382, + 11383 + ], + "valid" + ], + [ + [ + 11384, + 11387 + ], + "valid" + ], + [ + [ + 11388, + 11388 + ], + "mapped", + [ + 106 + ] + ], + [ + [ + 11389, + 11389 + ], + "mapped", + [ + 118 + ] + ], + [ + [ + 11390, + 11390 + ], + "mapped", + [ + 575 + ] + ], + [ + [ + 11391, + 11391 + ], + "mapped", + [ + 576 + ] + ], + [ + [ + 11392, + 11392 + ], + "mapped", + [ + 11393 + ] + ], + [ + [ + 11393, + 11393 + ], + "valid" + ], + [ + [ + 11394, + 11394 + ], + "mapped", + [ + 11395 + ] + ], + [ + [ + 11395, + 11395 + ], + "valid" + ], + [ + [ + 11396, + 11396 + ], + "mapped", + [ + 11397 + ] + ], + [ + [ + 11397, + 11397 + ], + "valid" + ], + [ + [ + 11398, + 11398 + ], + "mapped", + [ + 11399 + ] + ], + [ + [ + 11399, + 11399 + ], + "valid" + ], + [ + [ + 11400, + 11400 + ], + "mapped", + [ + 11401 + ] + ], + [ + [ + 11401, + 11401 + ], + "valid" + ], + [ + [ + 11402, + 11402 + ], + "mapped", + [ + 11403 + ] + ], + [ + [ + 11403, + 11403 + ], + "valid" + ], + [ + [ + 11404, + 11404 + ], + "mapped", + [ + 11405 + ] + ], + [ + [ + 11405, + 11405 + ], + "valid" + ], + [ + [ + 11406, + 11406 + ], + "mapped", + [ + 11407 + ] + ], + [ + [ + 11407, + 11407 + ], + "valid" + ], + [ + [ + 11408, + 11408 + ], + "mapped", + [ + 11409 + ] + ], + [ + [ + 11409, + 11409 + ], + "valid" + ], + [ + [ + 11410, + 11410 + ], + "mapped", + [ + 11411 + ] + ], + [ + [ + 11411, + 11411 + ], + "valid" + ], + [ + [ + 11412, + 11412 + ], + "mapped", + [ + 11413 + ] + ], + [ + [ + 11413, + 11413 + ], + "valid" + ], + [ + [ + 11414, + 11414 + ], + "mapped", + [ + 11415 + ] + ], + [ + [ + 11415, + 11415 + ], + "valid" + ], + [ + [ + 11416, + 11416 + ], + "mapped", + [ + 11417 + ] + ], + [ + [ + 11417, + 11417 + ], + "valid" + ], + [ + [ + 11418, + 11418 + ], + "mapped", + [ + 11419 + ] + ], + [ + [ + 11419, + 11419 + ], + "valid" + ], + [ + [ + 11420, + 11420 + ], + "mapped", + [ + 11421 + ] + ], + [ + [ + 11421, + 11421 + ], + "valid" + ], + [ + [ + 11422, + 11422 + ], + "mapped", + [ + 11423 + ] + ], + [ + [ + 11423, + 11423 + ], + "valid" + ], + [ + [ + 11424, + 11424 + ], + "mapped", + [ + 11425 + ] + ], + [ + [ + 11425, + 11425 + ], + "valid" + ], + [ + [ + 11426, + 11426 + ], + "mapped", + [ + 11427 + ] + ], + [ + [ + 11427, + 11427 + ], + "valid" + ], + [ + [ + 11428, + 11428 + ], + "mapped", + [ + 11429 + ] + ], + [ + [ + 11429, + 11429 + ], + "valid" + ], + [ + [ + 11430, + 11430 + ], + "mapped", + [ + 11431 + ] + ], + [ + [ + 11431, + 11431 + ], + "valid" + ], + [ + [ + 11432, + 11432 + ], + "mapped", + [ + 11433 + ] + ], + [ + [ + 11433, + 11433 + ], + "valid" + ], + [ + [ + 11434, + 11434 + ], + "mapped", + [ + 11435 + ] + ], + [ + [ + 11435, + 11435 + ], + "valid" + ], + [ + [ + 11436, + 11436 + ], + "mapped", + [ + 11437 + ] + ], + [ + [ + 11437, + 11437 + ], + "valid" + ], + [ + [ + 11438, + 11438 + ], + "mapped", + [ + 11439 + ] + ], + [ + [ + 11439, + 11439 + ], + "valid" + ], + [ + [ + 11440, + 11440 + ], + "mapped", + [ + 11441 + ] + ], + [ + [ + 11441, + 11441 + ], + "valid" + ], + [ + [ + 11442, + 11442 + ], + "mapped", + [ + 11443 + ] + ], + [ + [ + 11443, + 11443 + ], + "valid" + ], + [ + [ + 11444, + 11444 + ], + "mapped", + [ + 11445 + ] + ], + [ + [ + 11445, + 11445 + ], + "valid" + ], + [ + [ + 11446, + 11446 + ], + "mapped", + [ + 11447 + ] + ], + [ + [ + 11447, + 11447 + ], + "valid" + ], + [ + [ + 11448, + 11448 + ], + "mapped", + [ + 11449 + ] + ], + [ + [ + 11449, + 11449 + ], + "valid" + ], + [ + [ + 11450, + 11450 + ], + "mapped", + [ + 11451 + ] + ], + [ + [ + 11451, + 11451 + ], + "valid" + ], + [ + [ + 11452, + 11452 + ], + "mapped", + [ + 11453 + ] + ], + [ + [ + 11453, + 11453 + ], + "valid" + ], + [ + [ + 11454, + 11454 + ], + "mapped", + [ + 11455 + ] + ], + [ + [ + 11455, + 11455 + ], + "valid" + ], + [ + [ + 11456, + 11456 + ], + "mapped", + [ + 11457 + ] + ], + [ + [ + 11457, + 11457 + ], + "valid" + ], + [ + [ + 11458, + 11458 + ], + "mapped", + [ + 11459 + ] + ], + [ + [ + 11459, + 11459 + ], + "valid" + ], + [ + [ + 11460, + 11460 + ], + "mapped", + [ + 11461 + ] + ], + [ + [ + 11461, + 11461 + ], + "valid" + ], + [ + [ + 11462, + 11462 + ], + "mapped", + [ + 11463 + ] + ], + [ + [ + 11463, + 11463 + ], + "valid" + ], + [ + [ + 11464, + 11464 + ], + "mapped", + [ + 11465 + ] + ], + [ + [ + 11465, + 11465 + ], + "valid" + ], + [ + [ + 11466, + 11466 + ], + "mapped", + [ + 11467 + ] + ], + [ + [ + 11467, + 11467 + ], + "valid" + ], + [ + [ + 11468, + 11468 + ], + "mapped", + [ + 11469 + ] + ], + [ + [ + 11469, + 11469 + ], + "valid" + ], + [ + [ + 11470, + 11470 + ], + "mapped", + [ + 11471 + ] + ], + [ + [ + 11471, + 11471 + ], + "valid" + ], + [ + [ + 11472, + 11472 + ], + "mapped", + [ + 11473 + ] + ], + [ + [ + 11473, + 11473 + ], + "valid" + ], + [ + [ + 11474, + 11474 + ], + "mapped", + [ + 11475 + ] + ], + [ + [ + 11475, + 11475 + ], + "valid" + ], + [ + [ + 11476, + 11476 + ], + "mapped", + [ + 11477 + ] + ], + [ + [ + 11477, + 11477 + ], + "valid" + ], + [ + [ + 11478, + 11478 + ], + "mapped", + [ + 11479 + ] + ], + [ + [ + 11479, + 11479 + ], + "valid" + ], + [ + [ + 11480, + 11480 + ], + "mapped", + [ + 11481 + ] + ], + [ + [ + 11481, + 11481 + ], + "valid" + ], + [ + [ + 11482, + 11482 + ], + "mapped", + [ + 11483 + ] + ], + [ + [ + 11483, + 11483 + ], + "valid" + ], + [ + [ + 11484, + 11484 + ], + "mapped", + [ + 11485 + ] + ], + [ + [ + 11485, + 11485 + ], + "valid" + ], + [ + [ + 11486, + 11486 + ], + "mapped", + [ + 11487 + ] + ], + [ + [ + 11487, + 11487 + ], + "valid" + ], + [ + [ + 11488, + 11488 + ], + "mapped", + [ + 11489 + ] + ], + [ + [ + 11489, + 11489 + ], + "valid" + ], + [ + [ + 11490, + 11490 + ], + "mapped", + [ + 11491 + ] + ], + [ + [ + 11491, + 11492 + ], + "valid" + ], + [ + [ + 11493, + 11498 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 11499, + 11499 + ], + "mapped", + [ + 11500 + ] + ], + [ + [ + 11500, + 11500 + ], + "valid" + ], + [ + [ + 11501, + 11501 + ], + "mapped", + [ + 11502 + ] + ], + [ + [ + 11502, + 11505 + ], + "valid" + ], + [ + [ + 11506, + 11506 + ], + "mapped", + [ + 11507 + ] + ], + [ + [ + 11507, + 11507 + ], + "valid" + ], + [ + [ + 11508, + 11512 + ], + "disallowed" + ], + [ + [ + 11513, + 11519 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 11520, + 11557 + ], + "valid" + ], + [ + [ + 11558, + 11558 + ], + "disallowed" + ], + [ + [ + 11559, + 11559 + ], + "valid" + ], + [ + [ + 11560, + 11564 + ], + "disallowed" + ], + [ + [ + 11565, + 11565 + ], + "valid" + ], + [ + [ + 11566, + 11567 + ], + "disallowed" + ], + [ + [ + 11568, + 11621 + ], + "valid" + ], + [ + [ + 11622, + 11623 + ], + "valid" + ], + [ + [ + 11624, + 11630 + ], + "disallowed" + ], + [ + [ + 11631, + 11631 + ], + "mapped", + [ + 11617 + ] + ], + [ + [ + 11632, + 11632 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 11633, + 11646 + ], + "disallowed" + ], + [ + [ + 11647, + 11647 + ], + "valid" + ], + [ + [ + 11648, + 11670 + ], + "valid" + ], + [ + [ + 11671, + 11679 + ], + "disallowed" + ], + [ + [ + 11680, + 11686 + ], + "valid" + ], + [ + [ + 11687, + 11687 + ], + "disallowed" + ], + [ + [ + 11688, + 11694 + ], + "valid" + ], + [ + [ + 11695, + 11695 + ], + "disallowed" + ], + [ + [ + 11696, + 11702 + ], + "valid" + ], + [ + [ + 11703, + 11703 + ], + "disallowed" + ], + [ + [ + 11704, + 11710 + ], + "valid" + ], + [ + [ + 11711, + 11711 + ], + "disallowed" + ], + [ + [ + 11712, + 11718 + ], + "valid" + ], + [ + [ + 11719, + 11719 + ], + "disallowed" + ], + [ + [ + 11720, + 11726 + ], + "valid" + ], + [ + [ + 11727, + 11727 + ], + "disallowed" + ], + [ + [ + 11728, + 11734 + ], + "valid" + ], + [ + [ + 11735, + 11735 + ], + "disallowed" + ], + [ + [ + 11736, + 11742 + ], + "valid" + ], + [ + [ + 11743, + 11743 + ], + "disallowed" + ], + [ + [ + 11744, + 11775 + ], + "valid" + ], + [ + [ + 11776, + 11799 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 11800, + 11803 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 11804, + 11805 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 11806, + 11822 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 11823, + 11823 + ], + "valid" + ], + [ + [ + 11824, + 11824 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 11825, + 11825 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 11826, + 11835 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 11836, + 11842 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 11843, + 11903 + ], + "disallowed" + ], + [ + [ + 11904, + 11929 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 11930, + 11930 + ], + "disallowed" + ], + [ + [ + 11931, + 11934 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 11935, + 11935 + ], + "mapped", + [ + 27597 + ] + ], + [ + [ + 11936, + 12018 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 12019, + 12019 + ], + "mapped", + [ + 40863 + ] + ], + [ + [ + 12020, + 12031 + ], + "disallowed" + ], + [ + [ + 12032, + 12032 + ], + "mapped", + [ + 19968 + ] + ], + [ + [ + 12033, + 12033 + ], + "mapped", + [ + 20008 + ] + ], + [ + [ + 12034, + 12034 + ], + "mapped", + [ + 20022 + ] + ], + [ + [ + 12035, + 12035 + ], + "mapped", + [ + 20031 + ] + ], + [ + [ + 12036, + 12036 + ], + "mapped", + [ + 20057 + ] + ], + [ + [ + 12037, + 12037 + ], + "mapped", + [ + 20101 + ] + ], + [ + [ + 12038, + 12038 + ], + "mapped", + [ + 20108 + ] + ], + [ + [ + 12039, + 12039 + ], + "mapped", + [ + 20128 + ] + ], + [ + [ + 12040, + 12040 + ], + "mapped", + [ + 20154 + ] + ], + [ + [ + 12041, + 12041 + ], + "mapped", + [ + 20799 + ] + ], + [ + [ + 12042, + 12042 + ], + "mapped", + [ + 20837 + ] + ], + [ + [ + 12043, + 12043 + ], + "mapped", + [ + 20843 + ] + ], + [ + [ + 12044, + 12044 + ], + "mapped", + [ + 20866 + ] + ], + [ + [ + 12045, + 12045 + ], + "mapped", + [ + 20886 + ] + ], + [ + [ + 12046, + 12046 + ], + "mapped", + [ + 20907 + ] + ], + [ + [ + 12047, + 12047 + ], + "mapped", + [ + 20960 + ] + ], + [ + [ + 12048, + 12048 + ], + "mapped", + [ + 20981 + ] + ], + [ + [ + 12049, + 12049 + ], + "mapped", + [ + 20992 + ] + ], + [ + [ + 12050, + 12050 + ], + "mapped", + [ + 21147 + ] + ], + [ + [ + 12051, + 12051 + ], + "mapped", + [ + 21241 + ] + ], + [ + [ + 12052, + 12052 + ], + "mapped", + [ + 21269 + ] + ], + [ + [ + 12053, + 12053 + ], + "mapped", + [ + 21274 + ] + ], + [ + [ + 12054, + 12054 + ], + "mapped", + [ + 21304 + ] + ], + [ + [ + 12055, + 12055 + ], + "mapped", + [ + 21313 + ] + ], + [ + [ + 12056, + 12056 + ], + "mapped", + [ + 21340 + ] + ], + [ + [ + 12057, + 12057 + ], + "mapped", + [ + 21353 + ] + ], + [ + [ + 12058, + 12058 + ], + "mapped", + [ + 21378 + ] + ], + [ + [ + 12059, + 12059 + ], + "mapped", + [ + 21430 + ] + ], + [ + [ + 12060, + 12060 + ], + "mapped", + [ + 21448 + ] + ], + [ + [ + 12061, + 12061 + ], + "mapped", + [ + 21475 + ] + ], + [ + [ + 12062, + 12062 + ], + "mapped", + [ + 22231 + ] + ], + [ + [ + 12063, + 12063 + ], + "mapped", + [ + 22303 + ] + ], + [ + [ + 12064, + 12064 + ], + "mapped", + [ + 22763 + ] + ], + [ + [ + 12065, + 12065 + ], + "mapped", + [ + 22786 + ] + ], + [ + [ + 12066, + 12066 + ], + "mapped", + [ + 22794 + ] + ], + [ + [ + 12067, + 12067 + ], + "mapped", + [ + 22805 + ] + ], + [ + [ + 12068, + 12068 + ], + "mapped", + [ + 22823 + ] + ], + [ + [ + 12069, + 12069 + ], + "mapped", + [ + 22899 + ] + ], + [ + [ + 12070, + 12070 + ], + "mapped", + [ + 23376 + ] + ], + [ + [ + 12071, + 12071 + ], + "mapped", + [ + 23424 + ] + ], + [ + [ + 12072, + 12072 + ], + "mapped", + [ + 23544 + ] + ], + [ + [ + 12073, + 12073 + ], + "mapped", + [ + 23567 + ] + ], + [ + [ + 12074, + 12074 + ], + "mapped", + [ + 23586 + ] + ], + [ + [ + 12075, + 12075 + ], + "mapped", + [ + 23608 + ] + ], + [ + [ + 12076, + 12076 + ], + "mapped", + [ + 23662 + ] + ], + [ + [ + 12077, + 12077 + ], + "mapped", + [ + 23665 + ] + ], + [ + [ + 12078, + 12078 + ], + "mapped", + [ + 24027 + ] + ], + [ + [ + 12079, + 12079 + ], + "mapped", + [ + 24037 + ] + ], + [ + [ + 12080, + 12080 + ], + "mapped", + [ + 24049 + ] + ], + [ + [ + 12081, + 12081 + ], + "mapped", + [ + 24062 + ] + ], + [ + [ + 12082, + 12082 + ], + "mapped", + [ + 24178 + ] + ], + [ + [ + 12083, + 12083 + ], + "mapped", + [ + 24186 + ] + ], + [ + [ + 12084, + 12084 + ], + "mapped", + [ + 24191 + ] + ], + [ + [ + 12085, + 12085 + ], + "mapped", + [ + 24308 + ] + ], + [ + [ + 12086, + 12086 + ], + "mapped", + [ + 24318 + ] + ], + [ + [ + 12087, + 12087 + ], + "mapped", + [ + 24331 + ] + ], + [ + [ + 12088, + 12088 + ], + "mapped", + [ + 24339 + ] + ], + [ + [ + 12089, + 12089 + ], + "mapped", + [ + 24400 + ] + ], + [ + [ + 12090, + 12090 + ], + "mapped", + [ + 24417 + ] + ], + [ + [ + 12091, + 12091 + ], + "mapped", + [ + 24435 + ] + ], + [ + [ + 12092, + 12092 + ], + "mapped", + [ + 24515 + ] + ], + [ + [ + 12093, + 12093 + ], + "mapped", + [ + 25096 + ] + ], + [ + [ + 12094, + 12094 + ], + "mapped", + [ + 25142 + ] + ], + [ + [ + 12095, + 12095 + ], + "mapped", + [ + 25163 + ] + ], + [ + [ + 12096, + 12096 + ], + "mapped", + [ + 25903 + ] + ], + [ + [ + 12097, + 12097 + ], + "mapped", + [ + 25908 + ] + ], + [ + [ + 12098, + 12098 + ], + "mapped", + [ + 25991 + ] + ], + [ + [ + 12099, + 12099 + ], + "mapped", + [ + 26007 + ] + ], + [ + [ + 12100, + 12100 + ], + "mapped", + [ + 26020 + ] + ], + [ + [ + 12101, + 12101 + ], + "mapped", + [ + 26041 + ] + ], + [ + [ + 12102, + 12102 + ], + "mapped", + [ + 26080 + ] + ], + [ + [ + 12103, + 12103 + ], + "mapped", + [ + 26085 + ] + ], + [ + [ + 12104, + 12104 + ], + "mapped", + [ + 26352 + ] + ], + [ + [ + 12105, + 12105 + ], + "mapped", + [ + 26376 + ] + ], + [ + [ + 12106, + 12106 + ], + "mapped", + [ + 26408 + ] + ], + [ + [ + 12107, + 12107 + ], + "mapped", + [ + 27424 + ] + ], + [ + [ + 12108, + 12108 + ], + "mapped", + [ + 27490 + ] + ], + [ + [ + 12109, + 12109 + ], + "mapped", + [ + 27513 + ] + ], + [ + [ + 12110, + 12110 + ], + "mapped", + [ + 27571 + ] + ], + [ + [ + 12111, + 12111 + ], + "mapped", + [ + 27595 + ] + ], + [ + [ + 12112, + 12112 + ], + "mapped", + [ + 27604 + ] + ], + [ + [ + 12113, + 12113 + ], + "mapped", + [ + 27611 + ] + ], + [ + [ + 12114, + 12114 + ], + "mapped", + [ + 27663 + ] + ], + [ + [ + 12115, + 12115 + ], + "mapped", + [ + 27668 + ] + ], + [ + [ + 12116, + 12116 + ], + "mapped", + [ + 27700 + ] + ], + [ + [ + 12117, + 12117 + ], + "mapped", + [ + 28779 + ] + ], + [ + [ + 12118, + 12118 + ], + "mapped", + [ + 29226 + ] + ], + [ + [ + 12119, + 12119 + ], + "mapped", + [ + 29238 + ] + ], + [ + [ + 12120, + 12120 + ], + "mapped", + [ + 29243 + ] + ], + [ + [ + 12121, + 12121 + ], + "mapped", + [ + 29247 + ] + ], + [ + [ + 12122, + 12122 + ], + "mapped", + [ + 29255 + ] + ], + [ + [ + 12123, + 12123 + ], + "mapped", + [ + 29273 + ] + ], + [ + [ + 12124, + 12124 + ], + "mapped", + [ + 29275 + ] + ], + [ + [ + 12125, + 12125 + ], + "mapped", + [ + 29356 + ] + ], + [ + [ + 12126, + 12126 + ], + "mapped", + [ + 29572 + ] + ], + [ + [ + 12127, + 12127 + ], + "mapped", + [ + 29577 + ] + ], + [ + [ + 12128, + 12128 + ], + "mapped", + [ + 29916 + ] + ], + [ + [ + 12129, + 12129 + ], + "mapped", + [ + 29926 + ] + ], + [ + [ + 12130, + 12130 + ], + "mapped", + [ + 29976 + ] + ], + [ + [ + 12131, + 12131 + ], + "mapped", + [ + 29983 + ] + ], + [ + [ + 12132, + 12132 + ], + "mapped", + [ + 29992 + ] + ], + [ + [ + 12133, + 12133 + ], + "mapped", + [ + 30000 + ] + ], + [ + [ + 12134, + 12134 + ], + "mapped", + [ + 30091 + ] + ], + [ + [ + 12135, + 12135 + ], + "mapped", + [ + 30098 + ] + ], + [ + [ + 12136, + 12136 + ], + "mapped", + [ + 30326 + ] + ], + [ + [ + 12137, + 12137 + ], + "mapped", + [ + 30333 + ] + ], + [ + [ + 12138, + 12138 + ], + "mapped", + [ + 30382 + ] + ], + [ + [ + 12139, + 12139 + ], + "mapped", + [ + 30399 + ] + ], + [ + [ + 12140, + 12140 + ], + "mapped", + [ + 30446 + ] + ], + [ + [ + 12141, + 12141 + ], + "mapped", + [ + 30683 + ] + ], + [ + [ + 12142, + 12142 + ], + "mapped", + [ + 30690 + ] + ], + [ + [ + 12143, + 12143 + ], + "mapped", + [ + 30707 + ] + ], + [ + [ + 12144, + 12144 + ], + "mapped", + [ + 31034 + ] + ], + [ + [ + 12145, + 12145 + ], + "mapped", + [ + 31160 + ] + ], + [ + [ + 12146, + 12146 + ], + "mapped", + [ + 31166 + ] + ], + [ + [ + 12147, + 12147 + ], + "mapped", + [ + 31348 + ] + ], + [ + [ + 12148, + 12148 + ], + "mapped", + [ + 31435 + ] + ], + [ + [ + 12149, + 12149 + ], + "mapped", + [ + 31481 + ] + ], + [ + [ + 12150, + 12150 + ], + "mapped", + [ + 31859 + ] + ], + [ + [ + 12151, + 12151 + ], + "mapped", + [ + 31992 + ] + ], + [ + [ + 12152, + 12152 + ], + "mapped", + [ + 32566 + ] + ], + [ + [ + 12153, + 12153 + ], + "mapped", + [ + 32593 + ] + ], + [ + [ + 12154, + 12154 + ], + "mapped", + [ + 32650 + ] + ], + [ + [ + 12155, + 12155 + ], + "mapped", + [ + 32701 + ] + ], + [ + [ + 12156, + 12156 + ], + "mapped", + [ + 32769 + ] + ], + [ + [ + 12157, + 12157 + ], + "mapped", + [ + 32780 + ] + ], + [ + [ + 12158, + 12158 + ], + "mapped", + [ + 32786 + ] + ], + [ + [ + 12159, + 12159 + ], + "mapped", + [ + 32819 + ] + ], + [ + [ + 12160, + 12160 + ], + "mapped", + [ + 32895 + ] + ], + [ + [ + 12161, + 12161 + ], + "mapped", + [ + 32905 + ] + ], + [ + [ + 12162, + 12162 + ], + "mapped", + [ + 33251 + ] + ], + [ + [ + 12163, + 12163 + ], + "mapped", + [ + 33258 + ] + ], + [ + [ + 12164, + 12164 + ], + "mapped", + [ + 33267 + ] + ], + [ + [ + 12165, + 12165 + ], + "mapped", + [ + 33276 + ] + ], + [ + [ + 12166, + 12166 + ], + "mapped", + [ + 33292 + ] + ], + [ + [ + 12167, + 12167 + ], + "mapped", + [ + 33307 + ] + ], + [ + [ + 12168, + 12168 + ], + "mapped", + [ + 33311 + ] + ], + [ + [ + 12169, + 12169 + ], + "mapped", + [ + 33390 + ] + ], + [ + [ + 12170, + 12170 + ], + "mapped", + [ + 33394 + ] + ], + [ + [ + 12171, + 12171 + ], + "mapped", + [ + 33400 + ] + ], + [ + [ + 12172, + 12172 + ], + "mapped", + [ + 34381 + ] + ], + [ + [ + 12173, + 12173 + ], + "mapped", + [ + 34411 + ] + ], + [ + [ + 12174, + 12174 + ], + "mapped", + [ + 34880 + ] + ], + [ + [ + 12175, + 12175 + ], + "mapped", + [ + 34892 + ] + ], + [ + [ + 12176, + 12176 + ], + "mapped", + [ + 34915 + ] + ], + [ + [ + 12177, + 12177 + ], + "mapped", + [ + 35198 + ] + ], + [ + [ + 12178, + 12178 + ], + "mapped", + [ + 35211 + ] + ], + [ + [ + 12179, + 12179 + ], + "mapped", + [ + 35282 + ] + ], + [ + [ + 12180, + 12180 + ], + "mapped", + [ + 35328 + ] + ], + [ + [ + 12181, + 12181 + ], + "mapped", + [ + 35895 + ] + ], + [ + [ + 12182, + 12182 + ], + "mapped", + [ + 35910 + ] + ], + [ + [ + 12183, + 12183 + ], + "mapped", + [ + 35925 + ] + ], + [ + [ + 12184, + 12184 + ], + "mapped", + [ + 35960 + ] + ], + [ + [ + 12185, + 12185 + ], + "mapped", + [ + 35997 + ] + ], + [ + [ + 12186, + 12186 + ], + "mapped", + [ + 36196 + ] + ], + [ + [ + 12187, + 12187 + ], + "mapped", + [ + 36208 + ] + ], + [ + [ + 12188, + 12188 + ], + "mapped", + [ + 36275 + ] + ], + [ + [ + 12189, + 12189 + ], + "mapped", + [ + 36523 + ] + ], + [ + [ + 12190, + 12190 + ], + "mapped", + [ + 36554 + ] + ], + [ + [ + 12191, + 12191 + ], + "mapped", + [ + 36763 + ] + ], + [ + [ + 12192, + 12192 + ], + "mapped", + [ + 36784 + ] + ], + [ + [ + 12193, + 12193 + ], + "mapped", + [ + 36789 + ] + ], + [ + [ + 12194, + 12194 + ], + "mapped", + [ + 37009 + ] + ], + [ + [ + 12195, + 12195 + ], + "mapped", + [ + 37193 + ] + ], + [ + [ + 12196, + 12196 + ], + "mapped", + [ + 37318 + ] + ], + [ + [ + 12197, + 12197 + ], + "mapped", + [ + 37324 + ] + ], + [ + [ + 12198, + 12198 + ], + "mapped", + [ + 37329 + ] + ], + [ + [ + 12199, + 12199 + ], + "mapped", + [ + 38263 + ] + ], + [ + [ + 12200, + 12200 + ], + "mapped", + [ + 38272 + ] + ], + [ + [ + 12201, + 12201 + ], + "mapped", + [ + 38428 + ] + ], + [ + [ + 12202, + 12202 + ], + "mapped", + [ + 38582 + ] + ], + [ + [ + 12203, + 12203 + ], + "mapped", + [ + 38585 + ] + ], + [ + [ + 12204, + 12204 + ], + "mapped", + [ + 38632 + ] + ], + [ + [ + 12205, + 12205 + ], + "mapped", + [ + 38737 + ] + ], + [ + [ + 12206, + 12206 + ], + "mapped", + [ + 38750 + ] + ], + [ + [ + 12207, + 12207 + ], + "mapped", + [ + 38754 + ] + ], + [ + [ + 12208, + 12208 + ], + "mapped", + [ + 38761 + ] + ], + [ + [ + 12209, + 12209 + ], + "mapped", + [ + 38859 + ] + ], + [ + [ + 12210, + 12210 + ], + "mapped", + [ + 38893 + ] + ], + [ + [ + 12211, + 12211 + ], + "mapped", + [ + 38899 + ] + ], + [ + [ + 12212, + 12212 + ], + "mapped", + [ + 38913 + ] + ], + [ + [ + 12213, + 12213 + ], + "mapped", + [ + 39080 + ] + ], + [ + [ + 12214, + 12214 + ], + "mapped", + [ + 39131 + ] + ], + [ + [ + 12215, + 12215 + ], + "mapped", + [ + 39135 + ] + ], + [ + [ + 12216, + 12216 + ], + "mapped", + [ + 39318 + ] + ], + [ + [ + 12217, + 12217 + ], + "mapped", + [ + 39321 + ] + ], + [ + [ + 12218, + 12218 + ], + "mapped", + [ + 39340 + ] + ], + [ + [ + 12219, + 12219 + ], + "mapped", + [ + 39592 + ] + ], + [ + [ + 12220, + 12220 + ], + "mapped", + [ + 39640 + ] + ], + [ + [ + 12221, + 12221 + ], + "mapped", + [ + 39647 + ] + ], + [ + [ + 12222, + 12222 + ], + "mapped", + [ + 39717 + ] + ], + [ + [ + 12223, + 12223 + ], + "mapped", + [ + 39727 + ] + ], + [ + [ + 12224, + 12224 + ], + "mapped", + [ + 39730 + ] + ], + [ + [ + 12225, + 12225 + ], + "mapped", + [ + 39740 + ] + ], + [ + [ + 12226, + 12226 + ], + "mapped", + [ + 39770 + ] + ], + [ + [ + 12227, + 12227 + ], + "mapped", + [ + 40165 + ] + ], + [ + [ + 12228, + 12228 + ], + "mapped", + [ + 40565 + ] + ], + [ + [ + 12229, + 12229 + ], + "mapped", + [ + 40575 + ] + ], + [ + [ + 12230, + 12230 + ], + "mapped", + [ + 40613 + ] + ], + [ + [ + 12231, + 12231 + ], + "mapped", + [ + 40635 + ] + ], + [ + [ + 12232, + 12232 + ], + "mapped", + [ + 40643 + ] + ], + [ + [ + 12233, + 12233 + ], + "mapped", + [ + 40653 + ] + ], + [ + [ + 12234, + 12234 + ], + "mapped", + [ + 40657 + ] + ], + [ + [ + 12235, + 12235 + ], + "mapped", + [ + 40697 + ] + ], + [ + [ + 12236, + 12236 + ], + "mapped", + [ + 40701 + ] + ], + [ + [ + 12237, + 12237 + ], + "mapped", + [ + 40718 + ] + ], + [ + [ + 12238, + 12238 + ], + "mapped", + [ + 40723 + ] + ], + [ + [ + 12239, + 12239 + ], + "mapped", + [ + 40736 + ] + ], + [ + [ + 12240, + 12240 + ], + "mapped", + [ + 40763 + ] + ], + [ + [ + 12241, + 12241 + ], + "mapped", + [ + 40778 + ] + ], + [ + [ + 12242, + 12242 + ], + "mapped", + [ + 40786 + ] + ], + [ + [ + 12243, + 12243 + ], + "mapped", + [ + 40845 + ] + ], + [ + [ + 12244, + 12244 + ], + "mapped", + [ + 40860 + ] + ], + [ + [ + 12245, + 12245 + ], + "mapped", + [ + 40864 + ] + ], + [ + [ + 12246, + 12271 + ], + "disallowed" + ], + [ + [ + 12272, + 12283 + ], + "disallowed" + ], + [ + [ + 12284, + 12287 + ], + "disallowed" + ], + [ + [ + 12288, + 12288 + ], + "disallowed_STD3_mapped", + [ + 32 + ] + ], + [ + [ + 12289, + 12289 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 12290, + 12290 + ], + "mapped", + [ + 46 + ] + ], + [ + [ + 12291, + 12292 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 12293, + 12295 + ], + "valid" + ], + [ + [ + 12296, + 12329 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 12330, + 12333 + ], + "valid" + ], + [ + [ + 12334, + 12341 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 12342, + 12342 + ], + "mapped", + [ + 12306 + ] + ], + [ + [ + 12343, + 12343 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 12344, + 12344 + ], + "mapped", + [ + 21313 + ] + ], + [ + [ + 12345, + 12345 + ], + "mapped", + [ + 21316 + ] + ], + [ + [ + 12346, + 12346 + ], + "mapped", + [ + 21317 + ] + ], + [ + [ + 12347, + 12347 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 12348, + 12348 + ], + "valid" + ], + [ + [ + 12349, + 12349 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 12350, + 12350 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 12351, + 12351 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 12352, + 12352 + ], + "disallowed" + ], + [ + [ + 12353, + 12436 + ], + "valid" + ], + [ + [ + 12437, + 12438 + ], + "valid" + ], + [ + [ + 12439, + 12440 + ], + "disallowed" + ], + [ + [ + 12441, + 12442 + ], + "valid" + ], + [ + [ + 12443, + 12443 + ], + "disallowed_STD3_mapped", + [ + 32, + 12441 + ] + ], + [ + [ + 12444, + 12444 + ], + "disallowed_STD3_mapped", + [ + 32, + 12442 + ] + ], + [ + [ + 12445, + 12446 + ], + "valid" + ], + [ + [ + 12447, + 12447 + ], + "mapped", + [ + 12424, + 12426 + ] + ], + [ + [ + 12448, + 12448 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 12449, + 12542 + ], + "valid" + ], + [ + [ + 12543, + 12543 + ], + "mapped", + [ + 12467, + 12488 + ] + ], + [ + [ + 12544, + 12548 + ], + "disallowed" + ], + [ + [ + 12549, + 12588 + ], + "valid" + ], + [ + [ + 12589, + 12589 + ], + "valid" + ], + [ + [ + 12590, + 12592 + ], + "disallowed" + ], + [ + [ + 12593, + 12593 + ], + "mapped", + [ + 4352 + ] + ], + [ + [ + 12594, + 12594 + ], + "mapped", + [ + 4353 + ] + ], + [ + [ + 12595, + 12595 + ], + "mapped", + [ + 4522 + ] + ], + [ + [ + 12596, + 12596 + ], + "mapped", + [ + 4354 + ] + ], + [ + [ + 12597, + 12597 + ], + "mapped", + [ + 4524 + ] + ], + [ + [ + 12598, + 12598 + ], + "mapped", + [ + 4525 + ] + ], + [ + [ + 12599, + 12599 + ], + "mapped", + [ + 4355 + ] + ], + [ + [ + 12600, + 12600 + ], + "mapped", + [ + 4356 + ] + ], + [ + [ + 12601, + 12601 + ], + "mapped", + [ + 4357 + ] + ], + [ + [ + 12602, + 12602 + ], + "mapped", + [ + 4528 + ] + ], + [ + [ + 12603, + 12603 + ], + "mapped", + [ + 4529 + ] + ], + [ + [ + 12604, + 12604 + ], + "mapped", + [ + 4530 + ] + ], + [ + [ + 12605, + 12605 + ], + "mapped", + [ + 4531 + ] + ], + [ + [ + 12606, + 12606 + ], + "mapped", + [ + 4532 + ] + ], + [ + [ + 12607, + 12607 + ], + "mapped", + [ + 4533 + ] + ], + [ + [ + 12608, + 12608 + ], + "mapped", + [ + 4378 + ] + ], + [ + [ + 12609, + 12609 + ], + "mapped", + [ + 4358 + ] + ], + [ + [ + 12610, + 12610 + ], + "mapped", + [ + 4359 + ] + ], + [ + [ + 12611, + 12611 + ], + "mapped", + [ + 4360 + ] + ], + [ + [ + 12612, + 12612 + ], + "mapped", + [ + 4385 + ] + ], + [ + [ + 12613, + 12613 + ], + "mapped", + [ + 4361 + ] + ], + [ + [ + 12614, + 12614 + ], + "mapped", + [ + 4362 + ] + ], + [ + [ + 12615, + 12615 + ], + "mapped", + [ + 4363 + ] + ], + [ + [ + 12616, + 12616 + ], + "mapped", + [ + 4364 + ] + ], + [ + [ + 12617, + 12617 + ], + "mapped", + [ + 4365 + ] + ], + [ + [ + 12618, + 12618 + ], + "mapped", + [ + 4366 + ] + ], + [ + [ + 12619, + 12619 + ], + "mapped", + [ + 4367 + ] + ], + [ + [ + 12620, + 12620 + ], + "mapped", + [ + 4368 + ] + ], + [ + [ + 12621, + 12621 + ], + "mapped", + [ + 4369 + ] + ], + [ + [ + 12622, + 12622 + ], + "mapped", + [ + 4370 + ] + ], + [ + [ + 12623, + 12623 + ], + "mapped", + [ + 4449 + ] + ], + [ + [ + 12624, + 12624 + ], + "mapped", + [ + 4450 + ] + ], + [ + [ + 12625, + 12625 + ], + "mapped", + [ + 4451 + ] + ], + [ + [ + 12626, + 12626 + ], + "mapped", + [ + 4452 + ] + ], + [ + [ + 12627, + 12627 + ], + "mapped", + [ + 4453 + ] + ], + [ + [ + 12628, + 12628 + ], + "mapped", + [ + 4454 + ] + ], + [ + [ + 12629, + 12629 + ], + "mapped", + [ + 4455 + ] + ], + [ + [ + 12630, + 12630 + ], + "mapped", + [ + 4456 + ] + ], + [ + [ + 12631, + 12631 + ], + "mapped", + [ + 4457 + ] + ], + [ + [ + 12632, + 12632 + ], + "mapped", + [ + 4458 + ] + ], + [ + [ + 12633, + 12633 + ], + "mapped", + [ + 4459 + ] + ], + [ + [ + 12634, + 12634 + ], + "mapped", + [ + 4460 + ] + ], + [ + [ + 12635, + 12635 + ], + "mapped", + [ + 4461 + ] + ], + [ + [ + 12636, + 12636 + ], + "mapped", + [ + 4462 + ] + ], + [ + [ + 12637, + 12637 + ], + "mapped", + [ + 4463 + ] + ], + [ + [ + 12638, + 12638 + ], + "mapped", + [ + 4464 + ] + ], + [ + [ + 12639, + 12639 + ], + "mapped", + [ + 4465 + ] + ], + [ + [ + 12640, + 12640 + ], + "mapped", + [ + 4466 + ] + ], + [ + [ + 12641, + 12641 + ], + "mapped", + [ + 4467 + ] + ], + [ + [ + 12642, + 12642 + ], + "mapped", + [ + 4468 + ] + ], + [ + [ + 12643, + 12643 + ], + "mapped", + [ + 4469 + ] + ], + [ + [ + 12644, + 12644 + ], + "disallowed" + ], + [ + [ + 12645, + 12645 + ], + "mapped", + [ + 4372 + ] + ], + [ + [ + 12646, + 12646 + ], + "mapped", + [ + 4373 + ] + ], + [ + [ + 12647, + 12647 + ], + "mapped", + [ + 4551 + ] + ], + [ + [ + 12648, + 12648 + ], + "mapped", + [ + 4552 + ] + ], + [ + [ + 12649, + 12649 + ], + "mapped", + [ + 4556 + ] + ], + [ + [ + 12650, + 12650 + ], + "mapped", + [ + 4558 + ] + ], + [ + [ + 12651, + 12651 + ], + "mapped", + [ + 4563 + ] + ], + [ + [ + 12652, + 12652 + ], + "mapped", + [ + 4567 + ] + ], + [ + [ + 12653, + 12653 + ], + "mapped", + [ + 4569 + ] + ], + [ + [ + 12654, + 12654 + ], + "mapped", + [ + 4380 + ] + ], + [ + [ + 12655, + 12655 + ], + "mapped", + [ + 4573 + ] + ], + [ + [ + 12656, + 12656 + ], + "mapped", + [ + 4575 + ] + ], + [ + [ + 12657, + 12657 + ], + "mapped", + [ + 4381 + ] + ], + [ + [ + 12658, + 12658 + ], + "mapped", + [ + 4382 + ] + ], + [ + [ + 12659, + 12659 + ], + "mapped", + [ + 4384 + ] + ], + [ + [ + 12660, + 12660 + ], + "mapped", + [ + 4386 + ] + ], + [ + [ + 12661, + 12661 + ], + "mapped", + [ + 4387 + ] + ], + [ + [ + 12662, + 12662 + ], + "mapped", + [ + 4391 + ] + ], + [ + [ + 12663, + 12663 + ], + "mapped", + [ + 4393 + ] + ], + [ + [ + 12664, + 12664 + ], + "mapped", + [ + 4395 + ] + ], + [ + [ + 12665, + 12665 + ], + "mapped", + [ + 4396 + ] + ], + [ + [ + 12666, + 12666 + ], + "mapped", + [ + 4397 + ] + ], + [ + [ + 12667, + 12667 + ], + "mapped", + [ + 4398 + ] + ], + [ + [ + 12668, + 12668 + ], + "mapped", + [ + 4399 + ] + ], + [ + [ + 12669, + 12669 + ], + "mapped", + [ + 4402 + ] + ], + [ + [ + 12670, + 12670 + ], + "mapped", + [ + 4406 + ] + ], + [ + [ + 12671, + 12671 + ], + "mapped", + [ + 4416 + ] + ], + [ + [ + 12672, + 12672 + ], + "mapped", + [ + 4423 + ] + ], + [ + [ + 12673, + 12673 + ], + "mapped", + [ + 4428 + ] + ], + [ + [ + 12674, + 12674 + ], + "mapped", + [ + 4593 + ] + ], + [ + [ + 12675, + 12675 + ], + "mapped", + [ + 4594 + ] + ], + [ + [ + 12676, + 12676 + ], + "mapped", + [ + 4439 + ] + ], + [ + [ + 12677, + 12677 + ], + "mapped", + [ + 4440 + ] + ], + [ + [ + 12678, + 12678 + ], + "mapped", + [ + 4441 + ] + ], + [ + [ + 12679, + 12679 + ], + "mapped", + [ + 4484 + ] + ], + [ + [ + 12680, + 12680 + ], + "mapped", + [ + 4485 + ] + ], + [ + [ + 12681, + 12681 + ], + "mapped", + [ + 4488 + ] + ], + [ + [ + 12682, + 12682 + ], + "mapped", + [ + 4497 + ] + ], + [ + [ + 12683, + 12683 + ], + "mapped", + [ + 4498 + ] + ], + [ + [ + 12684, + 12684 + ], + "mapped", + [ + 4500 + ] + ], + [ + [ + 12685, + 12685 + ], + "mapped", + [ + 4510 + ] + ], + [ + [ + 12686, + 12686 + ], + "mapped", + [ + 4513 + ] + ], + [ + [ + 12687, + 12687 + ], + "disallowed" + ], + [ + [ + 12688, + 12689 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 12690, + 12690 + ], + "mapped", + [ + 19968 + ] + ], + [ + [ + 12691, + 12691 + ], + "mapped", + [ + 20108 + ] + ], + [ + [ + 12692, + 12692 + ], + "mapped", + [ + 19977 + ] + ], + [ + [ + 12693, + 12693 + ], + "mapped", + [ + 22235 + ] + ], + [ + [ + 12694, + 12694 + ], + "mapped", + [ + 19978 + ] + ], + [ + [ + 12695, + 12695 + ], + "mapped", + [ + 20013 + ] + ], + [ + [ + 12696, + 12696 + ], + "mapped", + [ + 19979 + ] + ], + [ + [ + 12697, + 12697 + ], + "mapped", + [ + 30002 + ] + ], + [ + [ + 12698, + 12698 + ], + "mapped", + [ + 20057 + ] + ], + [ + [ + 12699, + 12699 + ], + "mapped", + [ + 19993 + ] + ], + [ + [ + 12700, + 12700 + ], + "mapped", + [ + 19969 + ] + ], + [ + [ + 12701, + 12701 + ], + "mapped", + [ + 22825 + ] + ], + [ + [ + 12702, + 12702 + ], + "mapped", + [ + 22320 + ] + ], + [ + [ + 12703, + 12703 + ], + "mapped", + [ + 20154 + ] + ], + [ + [ + 12704, + 12727 + ], + "valid" + ], + [ + [ + 12728, + 12730 + ], + "valid" + ], + [ + [ + 12731, + 12735 + ], + "disallowed" + ], + [ + [ + 12736, + 12751 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 12752, + 12771 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 12772, + 12783 + ], + "disallowed" + ], + [ + [ + 12784, + 12799 + ], + "valid" + ], + [ + [ + 12800, + 12800 + ], + "disallowed_STD3_mapped", + [ + 40, + 4352, + 41 + ] + ], + [ + [ + 12801, + 12801 + ], + "disallowed_STD3_mapped", + [ + 40, + 4354, + 41 + ] + ], + [ + [ + 12802, + 12802 + ], + "disallowed_STD3_mapped", + [ + 40, + 4355, + 41 + ] + ], + [ + [ + 12803, + 12803 + ], + "disallowed_STD3_mapped", + [ + 40, + 4357, + 41 + ] + ], + [ + [ + 12804, + 12804 + ], + "disallowed_STD3_mapped", + [ + 40, + 4358, + 41 + ] + ], + [ + [ + 12805, + 12805 + ], + "disallowed_STD3_mapped", + [ + 40, + 4359, + 41 + ] + ], + [ + [ + 12806, + 12806 + ], + "disallowed_STD3_mapped", + [ + 40, + 4361, + 41 + ] + ], + [ + [ + 12807, + 12807 + ], + "disallowed_STD3_mapped", + [ + 40, + 4363, + 41 + ] + ], + [ + [ + 12808, + 12808 + ], + "disallowed_STD3_mapped", + [ + 40, + 4364, + 41 + ] + ], + [ + [ + 12809, + 12809 + ], + "disallowed_STD3_mapped", + [ + 40, + 4366, + 41 + ] + ], + [ + [ + 12810, + 12810 + ], + "disallowed_STD3_mapped", + [ + 40, + 4367, + 41 + ] + ], + [ + [ + 12811, + 12811 + ], + "disallowed_STD3_mapped", + [ + 40, + 4368, + 41 + ] + ], + [ + [ + 12812, + 12812 + ], + "disallowed_STD3_mapped", + [ + 40, + 4369, + 41 + ] + ], + [ + [ + 12813, + 12813 + ], + "disallowed_STD3_mapped", + [ + 40, + 4370, + 41 + ] + ], + [ + [ + 12814, + 12814 + ], + "disallowed_STD3_mapped", + [ + 40, + 44032, + 41 + ] + ], + [ + [ + 12815, + 12815 + ], + "disallowed_STD3_mapped", + [ + 40, + 45208, + 41 + ] + ], + [ + [ + 12816, + 12816 + ], + "disallowed_STD3_mapped", + [ + 40, + 45796, + 41 + ] + ], + [ + [ + 12817, + 12817 + ], + "disallowed_STD3_mapped", + [ + 40, + 46972, + 41 + ] + ], + [ + [ + 12818, + 12818 + ], + "disallowed_STD3_mapped", + [ + 40, + 47560, + 41 + ] + ], + [ + [ + 12819, + 12819 + ], + "disallowed_STD3_mapped", + [ + 40, + 48148, + 41 + ] + ], + [ + [ + 12820, + 12820 + ], + "disallowed_STD3_mapped", + [ + 40, + 49324, + 41 + ] + ], + [ + [ + 12821, + 12821 + ], + "disallowed_STD3_mapped", + [ + 40, + 50500, + 41 + ] + ], + [ + [ + 12822, + 12822 + ], + "disallowed_STD3_mapped", + [ + 40, + 51088, + 41 + ] + ], + [ + [ + 12823, + 12823 + ], + "disallowed_STD3_mapped", + [ + 40, + 52264, + 41 + ] + ], + [ + [ + 12824, + 12824 + ], + "disallowed_STD3_mapped", + [ + 40, + 52852, + 41 + ] + ], + [ + [ + 12825, + 12825 + ], + "disallowed_STD3_mapped", + [ + 40, + 53440, + 41 + ] + ], + [ + [ + 12826, + 12826 + ], + "disallowed_STD3_mapped", + [ + 40, + 54028, + 41 + ] + ], + [ + [ + 12827, + 12827 + ], + "disallowed_STD3_mapped", + [ + 40, + 54616, + 41 + ] + ], + [ + [ + 12828, + 12828 + ], + "disallowed_STD3_mapped", + [ + 40, + 51452, + 41 + ] + ], + [ + [ + 12829, + 12829 + ], + "disallowed_STD3_mapped", + [ + 40, + 50724, + 51204, + 41 + ] + ], + [ + [ + 12830, + 12830 + ], + "disallowed_STD3_mapped", + [ + 40, + 50724, + 54980, + 41 + ] + ], + [ + [ + 12831, + 12831 + ], + "disallowed" + ], + [ + [ + 12832, + 12832 + ], + "disallowed_STD3_mapped", + [ + 40, + 19968, + 41 + ] + ], + [ + [ + 12833, + 12833 + ], + "disallowed_STD3_mapped", + [ + 40, + 20108, + 41 + ] + ], + [ + [ + 12834, + 12834 + ], + "disallowed_STD3_mapped", + [ + 40, + 19977, + 41 + ] + ], + [ + [ + 12835, + 12835 + ], + "disallowed_STD3_mapped", + [ + 40, + 22235, + 41 + ] + ], + [ + [ + 12836, + 12836 + ], + "disallowed_STD3_mapped", + [ + 40, + 20116, + 41 + ] + ], + [ + [ + 12837, + 12837 + ], + "disallowed_STD3_mapped", + [ + 40, + 20845, + 41 + ] + ], + [ + [ + 12838, + 12838 + ], + "disallowed_STD3_mapped", + [ + 40, + 19971, + 41 + ] + ], + [ + [ + 12839, + 12839 + ], + "disallowed_STD3_mapped", + [ + 40, + 20843, + 41 + ] + ], + [ + [ + 12840, + 12840 + ], + "disallowed_STD3_mapped", + [ + 40, + 20061, + 41 + ] + ], + [ + [ + 12841, + 12841 + ], + "disallowed_STD3_mapped", + [ + 40, + 21313, + 41 + ] + ], + [ + [ + 12842, + 12842 + ], + "disallowed_STD3_mapped", + [ + 40, + 26376, + 41 + ] + ], + [ + [ + 12843, + 12843 + ], + "disallowed_STD3_mapped", + [ + 40, + 28779, + 41 + ] + ], + [ + [ + 12844, + 12844 + ], + "disallowed_STD3_mapped", + [ + 40, + 27700, + 41 + ] + ], + [ + [ + 12845, + 12845 + ], + "disallowed_STD3_mapped", + [ + 40, + 26408, + 41 + ] + ], + [ + [ + 12846, + 12846 + ], + "disallowed_STD3_mapped", + [ + 40, + 37329, + 41 + ] + ], + [ + [ + 12847, + 12847 + ], + "disallowed_STD3_mapped", + [ + 40, + 22303, + 41 + ] + ], + [ + [ + 12848, + 12848 + ], + "disallowed_STD3_mapped", + [ + 40, + 26085, + 41 + ] + ], + [ + [ + 12849, + 12849 + ], + "disallowed_STD3_mapped", + [ + 40, + 26666, + 41 + ] + ], + [ + [ + 12850, + 12850 + ], + "disallowed_STD3_mapped", + [ + 40, + 26377, + 41 + ] + ], + [ + [ + 12851, + 12851 + ], + "disallowed_STD3_mapped", + [ + 40, + 31038, + 41 + ] + ], + [ + [ + 12852, + 12852 + ], + "disallowed_STD3_mapped", + [ + 40, + 21517, + 41 + ] + ], + [ + [ + 12853, + 12853 + ], + "disallowed_STD3_mapped", + [ + 40, + 29305, + 41 + ] + ], + [ + [ + 12854, + 12854 + ], + "disallowed_STD3_mapped", + [ + 40, + 36001, + 41 + ] + ], + [ + [ + 12855, + 12855 + ], + "disallowed_STD3_mapped", + [ + 40, + 31069, + 41 + ] + ], + [ + [ + 12856, + 12856 + ], + "disallowed_STD3_mapped", + [ + 40, + 21172, + 41 + ] + ], + [ + [ + 12857, + 12857 + ], + "disallowed_STD3_mapped", + [ + 40, + 20195, + 41 + ] + ], + [ + [ + 12858, + 12858 + ], + "disallowed_STD3_mapped", + [ + 40, + 21628, + 41 + ] + ], + [ + [ + 12859, + 12859 + ], + "disallowed_STD3_mapped", + [ + 40, + 23398, + 41 + ] + ], + [ + [ + 12860, + 12860 + ], + "disallowed_STD3_mapped", + [ + 40, + 30435, + 41 + ] + ], + [ + [ + 12861, + 12861 + ], + "disallowed_STD3_mapped", + [ + 40, + 20225, + 41 + ] + ], + [ + [ + 12862, + 12862 + ], + "disallowed_STD3_mapped", + [ + 40, + 36039, + 41 + ] + ], + [ + [ + 12863, + 12863 + ], + "disallowed_STD3_mapped", + [ + 40, + 21332, + 41 + ] + ], + [ + [ + 12864, + 12864 + ], + "disallowed_STD3_mapped", + [ + 40, + 31085, + 41 + ] + ], + [ + [ + 12865, + 12865 + ], + "disallowed_STD3_mapped", + [ + 40, + 20241, + 41 + ] + ], + [ + [ + 12866, + 12866 + ], + "disallowed_STD3_mapped", + [ + 40, + 33258, + 41 + ] + ], + [ + [ + 12867, + 12867 + ], + "disallowed_STD3_mapped", + [ + 40, + 33267, + 41 + ] + ], + [ + [ + 12868, + 12868 + ], + "mapped", + [ + 21839 + ] + ], + [ + [ + 12869, + 12869 + ], + "mapped", + [ + 24188 + ] + ], + [ + [ + 12870, + 12870 + ], + "mapped", + [ + 25991 + ] + ], + [ + [ + 12871, + 12871 + ], + "mapped", + [ + 31631 + ] + ], + [ + [ + 12872, + 12879 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 12880, + 12880 + ], + "mapped", + [ + 112, + 116, + 101 + ] + ], + [ + [ + 12881, + 12881 + ], + "mapped", + [ + 50, + 49 + ] + ], + [ + [ + 12882, + 12882 + ], + "mapped", + [ + 50, + 50 + ] + ], + [ + [ + 12883, + 12883 + ], + "mapped", + [ + 50, + 51 + ] + ], + [ + [ + 12884, + 12884 + ], + "mapped", + [ + 50, + 52 + ] + ], + [ + [ + 12885, + 12885 + ], + "mapped", + [ + 50, + 53 + ] + ], + [ + [ + 12886, + 12886 + ], + "mapped", + [ + 50, + 54 + ] + ], + [ + [ + 12887, + 12887 + ], + "mapped", + [ + 50, + 55 + ] + ], + [ + [ + 12888, + 12888 + ], + "mapped", + [ + 50, + 56 + ] + ], + [ + [ + 12889, + 12889 + ], + "mapped", + [ + 50, + 57 + ] + ], + [ + [ + 12890, + 12890 + ], + "mapped", + [ + 51, + 48 + ] + ], + [ + [ + 12891, + 12891 + ], + "mapped", + [ + 51, + 49 + ] + ], + [ + [ + 12892, + 12892 + ], + "mapped", + [ + 51, + 50 + ] + ], + [ + [ + 12893, + 12893 + ], + "mapped", + [ + 51, + 51 + ] + ], + [ + [ + 12894, + 12894 + ], + "mapped", + [ + 51, + 52 + ] + ], + [ + [ + 12895, + 12895 + ], + "mapped", + [ + 51, + 53 + ] + ], + [ + [ + 12896, + 12896 + ], + "mapped", + [ + 4352 + ] + ], + [ + [ + 12897, + 12897 + ], + "mapped", + [ + 4354 + ] + ], + [ + [ + 12898, + 12898 + ], + "mapped", + [ + 4355 + ] + ], + [ + [ + 12899, + 12899 + ], + "mapped", + [ + 4357 + ] + ], + [ + [ + 12900, + 12900 + ], + "mapped", + [ + 4358 + ] + ], + [ + [ + 12901, + 12901 + ], + "mapped", + [ + 4359 + ] + ], + [ + [ + 12902, + 12902 + ], + "mapped", + [ + 4361 + ] + ], + [ + [ + 12903, + 12903 + ], + "mapped", + [ + 4363 + ] + ], + [ + [ + 12904, + 12904 + ], + "mapped", + [ + 4364 + ] + ], + [ + [ + 12905, + 12905 + ], + "mapped", + [ + 4366 + ] + ], + [ + [ + 12906, + 12906 + ], + "mapped", + [ + 4367 + ] + ], + [ + [ + 12907, + 12907 + ], + "mapped", + [ + 4368 + ] + ], + [ + [ + 12908, + 12908 + ], + "mapped", + [ + 4369 + ] + ], + [ + [ + 12909, + 12909 + ], + "mapped", + [ + 4370 + ] + ], + [ + [ + 12910, + 12910 + ], + "mapped", + [ + 44032 + ] + ], + [ + [ + 12911, + 12911 + ], + "mapped", + [ + 45208 + ] + ], + [ + [ + 12912, + 12912 + ], + "mapped", + [ + 45796 + ] + ], + [ + [ + 12913, + 12913 + ], + "mapped", + [ + 46972 + ] + ], + [ + [ + 12914, + 12914 + ], + "mapped", + [ + 47560 + ] + ], + [ + [ + 12915, + 12915 + ], + "mapped", + [ + 48148 + ] + ], + [ + [ + 12916, + 12916 + ], + "mapped", + [ + 49324 + ] + ], + [ + [ + 12917, + 12917 + ], + "mapped", + [ + 50500 + ] + ], + [ + [ + 12918, + 12918 + ], + "mapped", + [ + 51088 + ] + ], + [ + [ + 12919, + 12919 + ], + "mapped", + [ + 52264 + ] + ], + [ + [ + 12920, + 12920 + ], + "mapped", + [ + 52852 + ] + ], + [ + [ + 12921, + 12921 + ], + "mapped", + [ + 53440 + ] + ], + [ + [ + 12922, + 12922 + ], + "mapped", + [ + 54028 + ] + ], + [ + [ + 12923, + 12923 + ], + "mapped", + [ + 54616 + ] + ], + [ + [ + 12924, + 12924 + ], + "mapped", + [ + 52280, + 44256 + ] + ], + [ + [ + 12925, + 12925 + ], + "mapped", + [ + 51452, + 51032 + ] + ], + [ + [ + 12926, + 12926 + ], + "mapped", + [ + 50864 + ] + ], + [ + [ + 12927, + 12927 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 12928, + 12928 + ], + "mapped", + [ + 19968 + ] + ], + [ + [ + 12929, + 12929 + ], + "mapped", + [ + 20108 + ] + ], + [ + [ + 12930, + 12930 + ], + "mapped", + [ + 19977 + ] + ], + [ + [ + 12931, + 12931 + ], + "mapped", + [ + 22235 + ] + ], + [ + [ + 12932, + 12932 + ], + "mapped", + [ + 20116 + ] + ], + [ + [ + 12933, + 12933 + ], + "mapped", + [ + 20845 + ] + ], + [ + [ + 12934, + 12934 + ], + "mapped", + [ + 19971 + ] + ], + [ + [ + 12935, + 12935 + ], + "mapped", + [ + 20843 + ] + ], + [ + [ + 12936, + 12936 + ], + "mapped", + [ + 20061 + ] + ], + [ + [ + 12937, + 12937 + ], + "mapped", + [ + 21313 + ] + ], + [ + [ + 12938, + 12938 + ], + "mapped", + [ + 26376 + ] + ], + [ + [ + 12939, + 12939 + ], + "mapped", + [ + 28779 + ] + ], + [ + [ + 12940, + 12940 + ], + "mapped", + [ + 27700 + ] + ], + [ + [ + 12941, + 12941 + ], + "mapped", + [ + 26408 + ] + ], + [ + [ + 12942, + 12942 + ], + "mapped", + [ + 37329 + ] + ], + [ + [ + 12943, + 12943 + ], + "mapped", + [ + 22303 + ] + ], + [ + [ + 12944, + 12944 + ], + "mapped", + [ + 26085 + ] + ], + [ + [ + 12945, + 12945 + ], + "mapped", + [ + 26666 + ] + ], + [ + [ + 12946, + 12946 + ], + "mapped", + [ + 26377 + ] + ], + [ + [ + 12947, + 12947 + ], + "mapped", + [ + 31038 + ] + ], + [ + [ + 12948, + 12948 + ], + "mapped", + [ + 21517 + ] + ], + [ + [ + 12949, + 12949 + ], + "mapped", + [ + 29305 + ] + ], + [ + [ + 12950, + 12950 + ], + "mapped", + [ + 36001 + ] + ], + [ + [ + 12951, + 12951 + ], + "mapped", + [ + 31069 + ] + ], + [ + [ + 12952, + 12952 + ], + "mapped", + [ + 21172 + ] + ], + [ + [ + 12953, + 12953 + ], + "mapped", + [ + 31192 + ] + ], + [ + [ + 12954, + 12954 + ], + "mapped", + [ + 30007 + ] + ], + [ + [ + 12955, + 12955 + ], + "mapped", + [ + 22899 + ] + ], + [ + [ + 12956, + 12956 + ], + "mapped", + [ + 36969 + ] + ], + [ + [ + 12957, + 12957 + ], + "mapped", + [ + 20778 + ] + ], + [ + [ + 12958, + 12958 + ], + "mapped", + [ + 21360 + ] + ], + [ + [ + 12959, + 12959 + ], + "mapped", + [ + 27880 + ] + ], + [ + [ + 12960, + 12960 + ], + "mapped", + [ + 38917 + ] + ], + [ + [ + 12961, + 12961 + ], + "mapped", + [ + 20241 + ] + ], + [ + [ + 12962, + 12962 + ], + "mapped", + [ + 20889 + ] + ], + [ + [ + 12963, + 12963 + ], + "mapped", + [ + 27491 + ] + ], + [ + [ + 12964, + 12964 + ], + "mapped", + [ + 19978 + ] + ], + [ + [ + 12965, + 12965 + ], + "mapped", + [ + 20013 + ] + ], + [ + [ + 12966, + 12966 + ], + "mapped", + [ + 19979 + ] + ], + [ + [ + 12967, + 12967 + ], + "mapped", + [ + 24038 + ] + ], + [ + [ + 12968, + 12968 + ], + "mapped", + [ + 21491 + ] + ], + [ + [ + 12969, + 12969 + ], + "mapped", + [ + 21307 + ] + ], + [ + [ + 12970, + 12970 + ], + "mapped", + [ + 23447 + ] + ], + [ + [ + 12971, + 12971 + ], + "mapped", + [ + 23398 + ] + ], + [ + [ + 12972, + 12972 + ], + "mapped", + [ + 30435 + ] + ], + [ + [ + 12973, + 12973 + ], + "mapped", + [ + 20225 + ] + ], + [ + [ + 12974, + 12974 + ], + "mapped", + [ + 36039 + ] + ], + [ + [ + 12975, + 12975 + ], + "mapped", + [ + 21332 + ] + ], + [ + [ + 12976, + 12976 + ], + "mapped", + [ + 22812 + ] + ], + [ + [ + 12977, + 12977 + ], + "mapped", + [ + 51, + 54 + ] + ], + [ + [ + 12978, + 12978 + ], + "mapped", + [ + 51, + 55 + ] + ], + [ + [ + 12979, + 12979 + ], + "mapped", + [ + 51, + 56 + ] + ], + [ + [ + 12980, + 12980 + ], + "mapped", + [ + 51, + 57 + ] + ], + [ + [ + 12981, + 12981 + ], + "mapped", + [ + 52, + 48 + ] + ], + [ + [ + 12982, + 12982 + ], + "mapped", + [ + 52, + 49 + ] + ], + [ + [ + 12983, + 12983 + ], + "mapped", + [ + 52, + 50 + ] + ], + [ + [ + 12984, + 12984 + ], + "mapped", + [ + 52, + 51 + ] + ], + [ + [ + 12985, + 12985 + ], + "mapped", + [ + 52, + 52 + ] + ], + [ + [ + 12986, + 12986 + ], + "mapped", + [ + 52, + 53 + ] + ], + [ + [ + 12987, + 12987 + ], + "mapped", + [ + 52, + 54 + ] + ], + [ + [ + 12988, + 12988 + ], + "mapped", + [ + 52, + 55 + ] + ], + [ + [ + 12989, + 12989 + ], + "mapped", + [ + 52, + 56 + ] + ], + [ + [ + 12990, + 12990 + ], + "mapped", + [ + 52, + 57 + ] + ], + [ + [ + 12991, + 12991 + ], + "mapped", + [ + 53, + 48 + ] + ], + [ + [ + 12992, + 12992 + ], + "mapped", + [ + 49, + 26376 + ] + ], + [ + [ + 12993, + 12993 + ], + "mapped", + [ + 50, + 26376 + ] + ], + [ + [ + 12994, + 12994 + ], + "mapped", + [ + 51, + 26376 + ] + ], + [ + [ + 12995, + 12995 + ], + "mapped", + [ + 52, + 26376 + ] + ], + [ + [ + 12996, + 12996 + ], + "mapped", + [ + 53, + 26376 + ] + ], + [ + [ + 12997, + 12997 + ], + "mapped", + [ + 54, + 26376 + ] + ], + [ + [ + 12998, + 12998 + ], + "mapped", + [ + 55, + 26376 + ] + ], + [ + [ + 12999, + 12999 + ], + "mapped", + [ + 56, + 26376 + ] + ], + [ + [ + 13000, + 13000 + ], + "mapped", + [ + 57, + 26376 + ] + ], + [ + [ + 13001, + 13001 + ], + "mapped", + [ + 49, + 48, + 26376 + ] + ], + [ + [ + 13002, + 13002 + ], + "mapped", + [ + 49, + 49, + 26376 + ] + ], + [ + [ + 13003, + 13003 + ], + "mapped", + [ + 49, + 50, + 26376 + ] + ], + [ + [ + 13004, + 13004 + ], + "mapped", + [ + 104, + 103 + ] + ], + [ + [ + 13005, + 13005 + ], + "mapped", + [ + 101, + 114, + 103 + ] + ], + [ + [ + 13006, + 13006 + ], + "mapped", + [ + 101, + 118 + ] + ], + [ + [ + 13007, + 13007 + ], + "mapped", + [ + 108, + 116, + 100 + ] + ], + [ + [ + 13008, + 13008 + ], + "mapped", + [ + 12450 + ] + ], + [ + [ + 13009, + 13009 + ], + "mapped", + [ + 12452 + ] + ], + [ + [ + 13010, + 13010 + ], + "mapped", + [ + 12454 + ] + ], + [ + [ + 13011, + 13011 + ], + "mapped", + [ + 12456 + ] + ], + [ + [ + 13012, + 13012 + ], + "mapped", + [ + 12458 + ] + ], + [ + [ + 13013, + 13013 + ], + "mapped", + [ + 12459 + ] + ], + [ + [ + 13014, + 13014 + ], + "mapped", + [ + 12461 + ] + ], + [ + [ + 13015, + 13015 + ], + "mapped", + [ + 12463 + ] + ], + [ + [ + 13016, + 13016 + ], + "mapped", + [ + 12465 + ] + ], + [ + [ + 13017, + 13017 + ], + "mapped", + [ + 12467 + ] + ], + [ + [ + 13018, + 13018 + ], + "mapped", + [ + 12469 + ] + ], + [ + [ + 13019, + 13019 + ], + "mapped", + [ + 12471 + ] + ], + [ + [ + 13020, + 13020 + ], + "mapped", + [ + 12473 + ] + ], + [ + [ + 13021, + 13021 + ], + "mapped", + [ + 12475 + ] + ], + [ + [ + 13022, + 13022 + ], + "mapped", + [ + 12477 + ] + ], + [ + [ + 13023, + 13023 + ], + "mapped", + [ + 12479 + ] + ], + [ + [ + 13024, + 13024 + ], + "mapped", + [ + 12481 + ] + ], + [ + [ + 13025, + 13025 + ], + "mapped", + [ + 12484 + ] + ], + [ + [ + 13026, + 13026 + ], + "mapped", + [ + 12486 + ] + ], + [ + [ + 13027, + 13027 + ], + "mapped", + [ + 12488 + ] + ], + [ + [ + 13028, + 13028 + ], + "mapped", + [ + 12490 + ] + ], + [ + [ + 13029, + 13029 + ], + "mapped", + [ + 12491 + ] + ], + [ + [ + 13030, + 13030 + ], + "mapped", + [ + 12492 + ] + ], + [ + [ + 13031, + 13031 + ], + "mapped", + [ + 12493 + ] + ], + [ + [ + 13032, + 13032 + ], + "mapped", + [ + 12494 + ] + ], + [ + [ + 13033, + 13033 + ], + "mapped", + [ + 12495 + ] + ], + [ + [ + 13034, + 13034 + ], + "mapped", + [ + 12498 + ] + ], + [ + [ + 13035, + 13035 + ], + "mapped", + [ + 12501 + ] + ], + [ + [ + 13036, + 13036 + ], + "mapped", + [ + 12504 + ] + ], + [ + [ + 13037, + 13037 + ], + "mapped", + [ + 12507 + ] + ], + [ + [ + 13038, + 13038 + ], + "mapped", + [ + 12510 + ] + ], + [ + [ + 13039, + 13039 + ], + "mapped", + [ + 12511 + ] + ], + [ + [ + 13040, + 13040 + ], + "mapped", + [ + 12512 + ] + ], + [ + [ + 13041, + 13041 + ], + "mapped", + [ + 12513 + ] + ], + [ + [ + 13042, + 13042 + ], + "mapped", + [ + 12514 + ] + ], + [ + [ + 13043, + 13043 + ], + "mapped", + [ + 12516 + ] + ], + [ + [ + 13044, + 13044 + ], + "mapped", + [ + 12518 + ] + ], + [ + [ + 13045, + 13045 + ], + "mapped", + [ + 12520 + ] + ], + [ + [ + 13046, + 13046 + ], + "mapped", + [ + 12521 + ] + ], + [ + [ + 13047, + 13047 + ], + "mapped", + [ + 12522 + ] + ], + [ + [ + 13048, + 13048 + ], + "mapped", + [ + 12523 + ] + ], + [ + [ + 13049, + 13049 + ], + "mapped", + [ + 12524 + ] + ], + [ + [ + 13050, + 13050 + ], + "mapped", + [ + 12525 + ] + ], + [ + [ + 13051, + 13051 + ], + "mapped", + [ + 12527 + ] + ], + [ + [ + 13052, + 13052 + ], + "mapped", + [ + 12528 + ] + ], + [ + [ + 13053, + 13053 + ], + "mapped", + [ + 12529 + ] + ], + [ + [ + 13054, + 13054 + ], + "mapped", + [ + 12530 + ] + ], + [ + [ + 13055, + 13055 + ], + "disallowed" + ], + [ + [ + 13056, + 13056 + ], + "mapped", + [ + 12450, + 12497, + 12540, + 12488 + ] + ], + [ + [ + 13057, + 13057 + ], + "mapped", + [ + 12450, + 12523, + 12501, + 12449 + ] + ], + [ + [ + 13058, + 13058 + ], + "mapped", + [ + 12450, + 12531, + 12506, + 12450 + ] + ], + [ + [ + 13059, + 13059 + ], + "mapped", + [ + 12450, + 12540, + 12523 + ] + ], + [ + [ + 13060, + 13060 + ], + "mapped", + [ + 12452, + 12491, + 12531, + 12464 + ] + ], + [ + [ + 13061, + 13061 + ], + "mapped", + [ + 12452, + 12531, + 12481 + ] + ], + [ + [ + 13062, + 13062 + ], + "mapped", + [ + 12454, + 12457, + 12531 + ] + ], + [ + [ + 13063, + 13063 + ], + "mapped", + [ + 12456, + 12473, + 12463, + 12540, + 12489 + ] + ], + [ + [ + 13064, + 13064 + ], + "mapped", + [ + 12456, + 12540, + 12459, + 12540 + ] + ], + [ + [ + 13065, + 13065 + ], + "mapped", + [ + 12458, + 12531, + 12473 + ] + ], + [ + [ + 13066, + 13066 + ], + "mapped", + [ + 12458, + 12540, + 12512 + ] + ], + [ + [ + 13067, + 13067 + ], + "mapped", + [ + 12459, + 12452, + 12522 + ] + ], + [ + [ + 13068, + 13068 + ], + "mapped", + [ + 12459, + 12521, + 12483, + 12488 + ] + ], + [ + [ + 13069, + 13069 + ], + "mapped", + [ + 12459, + 12525, + 12522, + 12540 + ] + ], + [ + [ + 13070, + 13070 + ], + "mapped", + [ + 12460, + 12525, + 12531 + ] + ], + [ + [ + 13071, + 13071 + ], + "mapped", + [ + 12460, + 12531, + 12510 + ] + ], + [ + [ + 13072, + 13072 + ], + "mapped", + [ + 12462, + 12460 + ] + ], + [ + [ + 13073, + 13073 + ], + "mapped", + [ + 12462, + 12491, + 12540 + ] + ], + [ + [ + 13074, + 13074 + ], + "mapped", + [ + 12461, + 12517, + 12522, + 12540 + ] + ], + [ + [ + 13075, + 13075 + ], + "mapped", + [ + 12462, + 12523, + 12480, + 12540 + ] + ], + [ + [ + 13076, + 13076 + ], + "mapped", + [ + 12461, + 12525 + ] + ], + [ + [ + 13077, + 13077 + ], + "mapped", + [ + 12461, + 12525, + 12464, + 12521, + 12512 + ] + ], + [ + [ + 13078, + 13078 + ], + "mapped", + [ + 12461, + 12525, + 12513, + 12540, + 12488, + 12523 + ] + ], + [ + [ + 13079, + 13079 + ], + "mapped", + [ + 12461, + 12525, + 12527, + 12483, + 12488 + ] + ], + [ + [ + 13080, + 13080 + ], + "mapped", + [ + 12464, + 12521, + 12512 + ] + ], + [ + [ + 13081, + 13081 + ], + "mapped", + [ + 12464, + 12521, + 12512, + 12488, + 12531 + ] + ], + [ + [ + 13082, + 13082 + ], + "mapped", + [ + 12463, + 12523, + 12476, + 12452, + 12525 + ] + ], + [ + [ + 13083, + 13083 + ], + "mapped", + [ + 12463, + 12525, + 12540, + 12493 + ] + ], + [ + [ + 13084, + 13084 + ], + "mapped", + [ + 12465, + 12540, + 12473 + ] + ], + [ + [ + 13085, + 13085 + ], + "mapped", + [ + 12467, + 12523, + 12490 + ] + ], + [ + [ + 13086, + 13086 + ], + "mapped", + [ + 12467, + 12540, + 12509 + ] + ], + [ + [ + 13087, + 13087 + ], + "mapped", + [ + 12469, + 12452, + 12463, + 12523 + ] + ], + [ + [ + 13088, + 13088 + ], + "mapped", + [ + 12469, + 12531, + 12481, + 12540, + 12512 + ] + ], + [ + [ + 13089, + 13089 + ], + "mapped", + [ + 12471, + 12522, + 12531, + 12464 + ] + ], + [ + [ + 13090, + 13090 + ], + "mapped", + [ + 12475, + 12531, + 12481 + ] + ], + [ + [ + 13091, + 13091 + ], + "mapped", + [ + 12475, + 12531, + 12488 + ] + ], + [ + [ + 13092, + 13092 + ], + "mapped", + [ + 12480, + 12540, + 12473 + ] + ], + [ + [ + 13093, + 13093 + ], + "mapped", + [ + 12487, + 12471 + ] + ], + [ + [ + 13094, + 13094 + ], + "mapped", + [ + 12489, + 12523 + ] + ], + [ + [ + 13095, + 13095 + ], + "mapped", + [ + 12488, + 12531 + ] + ], + [ + [ + 13096, + 13096 + ], + "mapped", + [ + 12490, + 12494 + ] + ], + [ + [ + 13097, + 13097 + ], + "mapped", + [ + 12494, + 12483, + 12488 + ] + ], + [ + [ + 13098, + 13098 + ], + "mapped", + [ + 12495, + 12452, + 12484 + ] + ], + [ + [ + 13099, + 13099 + ], + "mapped", + [ + 12497, + 12540, + 12475, + 12531, + 12488 + ] + ], + [ + [ + 13100, + 13100 + ], + "mapped", + [ + 12497, + 12540, + 12484 + ] + ], + [ + [ + 13101, + 13101 + ], + "mapped", + [ + 12496, + 12540, + 12524, + 12523 + ] + ], + [ + [ + 13102, + 13102 + ], + "mapped", + [ + 12500, + 12450, + 12473, + 12488, + 12523 + ] + ], + [ + [ + 13103, + 13103 + ], + "mapped", + [ + 12500, + 12463, + 12523 + ] + ], + [ + [ + 13104, + 13104 + ], + "mapped", + [ + 12500, + 12467 + ] + ], + [ + [ + 13105, + 13105 + ], + "mapped", + [ + 12499, + 12523 + ] + ], + [ + [ + 13106, + 13106 + ], + "mapped", + [ + 12501, + 12449, + 12521, + 12483, + 12489 + ] + ], + [ + [ + 13107, + 13107 + ], + "mapped", + [ + 12501, + 12451, + 12540, + 12488 + ] + ], + [ + [ + 13108, + 13108 + ], + "mapped", + [ + 12502, + 12483, + 12471, + 12455, + 12523 + ] + ], + [ + [ + 13109, + 13109 + ], + "mapped", + [ + 12501, + 12521, + 12531 + ] + ], + [ + [ + 13110, + 13110 + ], + "mapped", + [ + 12504, + 12463, + 12479, + 12540, + 12523 + ] + ], + [ + [ + 13111, + 13111 + ], + "mapped", + [ + 12506, + 12477 + ] + ], + [ + [ + 13112, + 13112 + ], + "mapped", + [ + 12506, + 12491, + 12498 + ] + ], + [ + [ + 13113, + 13113 + ], + "mapped", + [ + 12504, + 12523, + 12484 + ] + ], + [ + [ + 13114, + 13114 + ], + "mapped", + [ + 12506, + 12531, + 12473 + ] + ], + [ + [ + 13115, + 13115 + ], + "mapped", + [ + 12506, + 12540, + 12472 + ] + ], + [ + [ + 13116, + 13116 + ], + "mapped", + [ + 12505, + 12540, + 12479 + ] + ], + [ + [ + 13117, + 13117 + ], + "mapped", + [ + 12509, + 12452, + 12531, + 12488 + ] + ], + [ + [ + 13118, + 13118 + ], + "mapped", + [ + 12508, + 12523, + 12488 + ] + ], + [ + [ + 13119, + 13119 + ], + "mapped", + [ + 12507, + 12531 + ] + ], + [ + [ + 13120, + 13120 + ], + "mapped", + [ + 12509, + 12531, + 12489 + ] + ], + [ + [ + 13121, + 13121 + ], + "mapped", + [ + 12507, + 12540, + 12523 + ] + ], + [ + [ + 13122, + 13122 + ], + "mapped", + [ + 12507, + 12540, + 12531 + ] + ], + [ + [ + 13123, + 13123 + ], + "mapped", + [ + 12510, + 12452, + 12463, + 12525 + ] + ], + [ + [ + 13124, + 13124 + ], + "mapped", + [ + 12510, + 12452, + 12523 + ] + ], + [ + [ + 13125, + 13125 + ], + "mapped", + [ + 12510, + 12483, + 12495 + ] + ], + [ + [ + 13126, + 13126 + ], + "mapped", + [ + 12510, + 12523, + 12463 + ] + ], + [ + [ + 13127, + 13127 + ], + "mapped", + [ + 12510, + 12531, + 12471, + 12519, + 12531 + ] + ], + [ + [ + 13128, + 13128 + ], + "mapped", + [ + 12511, + 12463, + 12525, + 12531 + ] + ], + [ + [ + 13129, + 13129 + ], + "mapped", + [ + 12511, + 12522 + ] + ], + [ + [ + 13130, + 13130 + ], + "mapped", + [ + 12511, + 12522, + 12496, + 12540, + 12523 + ] + ], + [ + [ + 13131, + 13131 + ], + "mapped", + [ + 12513, + 12460 + ] + ], + [ + [ + 13132, + 13132 + ], + "mapped", + [ + 12513, + 12460, + 12488, + 12531 + ] + ], + [ + [ + 13133, + 13133 + ], + "mapped", + [ + 12513, + 12540, + 12488, + 12523 + ] + ], + [ + [ + 13134, + 13134 + ], + "mapped", + [ + 12516, + 12540, + 12489 + ] + ], + [ + [ + 13135, + 13135 + ], + "mapped", + [ + 12516, + 12540, + 12523 + ] + ], + [ + [ + 13136, + 13136 + ], + "mapped", + [ + 12518, + 12450, + 12531 + ] + ], + [ + [ + 13137, + 13137 + ], + "mapped", + [ + 12522, + 12483, + 12488, + 12523 + ] + ], + [ + [ + 13138, + 13138 + ], + "mapped", + [ + 12522, + 12521 + ] + ], + [ + [ + 13139, + 13139 + ], + "mapped", + [ + 12523, + 12500, + 12540 + ] + ], + [ + [ + 13140, + 13140 + ], + "mapped", + [ + 12523, + 12540, + 12502, + 12523 + ] + ], + [ + [ + 13141, + 13141 + ], + "mapped", + [ + 12524, + 12512 + ] + ], + [ + [ + 13142, + 13142 + ], + "mapped", + [ + 12524, + 12531, + 12488, + 12466, + 12531 + ] + ], + [ + [ + 13143, + 13143 + ], + "mapped", + [ + 12527, + 12483, + 12488 + ] + ], + [ + [ + 13144, + 13144 + ], + "mapped", + [ + 48, + 28857 + ] + ], + [ + [ + 13145, + 13145 + ], + "mapped", + [ + 49, + 28857 + ] + ], + [ + [ + 13146, + 13146 + ], + "mapped", + [ + 50, + 28857 + ] + ], + [ + [ + 13147, + 13147 + ], + "mapped", + [ + 51, + 28857 + ] + ], + [ + [ + 13148, + 13148 + ], + "mapped", + [ + 52, + 28857 + ] + ], + [ + [ + 13149, + 13149 + ], + "mapped", + [ + 53, + 28857 + ] + ], + [ + [ + 13150, + 13150 + ], + "mapped", + [ + 54, + 28857 + ] + ], + [ + [ + 13151, + 13151 + ], + "mapped", + [ + 55, + 28857 + ] + ], + [ + [ + 13152, + 13152 + ], + "mapped", + [ + 56, + 28857 + ] + ], + [ + [ + 13153, + 13153 + ], + "mapped", + [ + 57, + 28857 + ] + ], + [ + [ + 13154, + 13154 + ], + "mapped", + [ + 49, + 48, + 28857 + ] + ], + [ + [ + 13155, + 13155 + ], + "mapped", + [ + 49, + 49, + 28857 + ] + ], + [ + [ + 13156, + 13156 + ], + "mapped", + [ + 49, + 50, + 28857 + ] + ], + [ + [ + 13157, + 13157 + ], + "mapped", + [ + 49, + 51, + 28857 + ] + ], + [ + [ + 13158, + 13158 + ], + "mapped", + [ + 49, + 52, + 28857 + ] + ], + [ + [ + 13159, + 13159 + ], + "mapped", + [ + 49, + 53, + 28857 + ] + ], + [ + [ + 13160, + 13160 + ], + "mapped", + [ + 49, + 54, + 28857 + ] + ], + [ + [ + 13161, + 13161 + ], + "mapped", + [ + 49, + 55, + 28857 + ] + ], + [ + [ + 13162, + 13162 + ], + "mapped", + [ + 49, + 56, + 28857 + ] + ], + [ + [ + 13163, + 13163 + ], + "mapped", + [ + 49, + 57, + 28857 + ] + ], + [ + [ + 13164, + 13164 + ], + "mapped", + [ + 50, + 48, + 28857 + ] + ], + [ + [ + 13165, + 13165 + ], + "mapped", + [ + 50, + 49, + 28857 + ] + ], + [ + [ + 13166, + 13166 + ], + "mapped", + [ + 50, + 50, + 28857 + ] + ], + [ + [ + 13167, + 13167 + ], + "mapped", + [ + 50, + 51, + 28857 + ] + ], + [ + [ + 13168, + 13168 + ], + "mapped", + [ + 50, + 52, + 28857 + ] + ], + [ + [ + 13169, + 13169 + ], + "mapped", + [ + 104, + 112, + 97 + ] + ], + [ + [ + 13170, + 13170 + ], + "mapped", + [ + 100, + 97 + ] + ], + [ + [ + 13171, + 13171 + ], + "mapped", + [ + 97, + 117 + ] + ], + [ + [ + 13172, + 13172 + ], + "mapped", + [ + 98, + 97, + 114 + ] + ], + [ + [ + 13173, + 13173 + ], + "mapped", + [ + 111, + 118 + ] + ], + [ + [ + 13174, + 13174 + ], + "mapped", + [ + 112, + 99 + ] + ], + [ + [ + 13175, + 13175 + ], + "mapped", + [ + 100, + 109 + ] + ], + [ + [ + 13176, + 13176 + ], + "mapped", + [ + 100, + 109, + 50 + ] + ], + [ + [ + 13177, + 13177 + ], + "mapped", + [ + 100, + 109, + 51 + ] + ], + [ + [ + 13178, + 13178 + ], + "mapped", + [ + 105, + 117 + ] + ], + [ + [ + 13179, + 13179 + ], + "mapped", + [ + 24179, + 25104 + ] + ], + [ + [ + 13180, + 13180 + ], + "mapped", + [ + 26157, + 21644 + ] + ], + [ + [ + 13181, + 13181 + ], + "mapped", + [ + 22823, + 27491 + ] + ], + [ + [ + 13182, + 13182 + ], + "mapped", + [ + 26126, + 27835 + ] + ], + [ + [ + 13183, + 13183 + ], + "mapped", + [ + 26666, + 24335, + 20250, + 31038 + ] + ], + [ + [ + 13184, + 13184 + ], + "mapped", + [ + 112, + 97 + ] + ], + [ + [ + 13185, + 13185 + ], + "mapped", + [ + 110, + 97 + ] + ], + [ + [ + 13186, + 13186 + ], + "mapped", + [ + 956, + 97 + ] + ], + [ + [ + 13187, + 13187 + ], + "mapped", + [ + 109, + 97 + ] + ], + [ + [ + 13188, + 13188 + ], + "mapped", + [ + 107, + 97 + ] + ], + [ + [ + 13189, + 13189 + ], + "mapped", + [ + 107, + 98 + ] + ], + [ + [ + 13190, + 13190 + ], + "mapped", + [ + 109, + 98 + ] + ], + [ + [ + 13191, + 13191 + ], + "mapped", + [ + 103, + 98 + ] + ], + [ + [ + 13192, + 13192 + ], + "mapped", + [ + 99, + 97, + 108 + ] + ], + [ + [ + 13193, + 13193 + ], + "mapped", + [ + 107, + 99, + 97, + 108 + ] + ], + [ + [ + 13194, + 13194 + ], + "mapped", + [ + 112, + 102 + ] + ], + [ + [ + 13195, + 13195 + ], + "mapped", + [ + 110, + 102 + ] + ], + [ + [ + 13196, + 13196 + ], + "mapped", + [ + 956, + 102 + ] + ], + [ + [ + 13197, + 13197 + ], + "mapped", + [ + 956, + 103 + ] + ], + [ + [ + 13198, + 13198 + ], + "mapped", + [ + 109, + 103 + ] + ], + [ + [ + 13199, + 13199 + ], + "mapped", + [ + 107, + 103 + ] + ], + [ + [ + 13200, + 13200 + ], + "mapped", + [ + 104, + 122 + ] + ], + [ + [ + 13201, + 13201 + ], + "mapped", + [ + 107, + 104, + 122 + ] + ], + [ + [ + 13202, + 13202 + ], + "mapped", + [ + 109, + 104, + 122 + ] + ], + [ + [ + 13203, + 13203 + ], + "mapped", + [ + 103, + 104, + 122 + ] + ], + [ + [ + 13204, + 13204 + ], + "mapped", + [ + 116, + 104, + 122 + ] + ], + [ + [ + 13205, + 13205 + ], + "mapped", + [ + 956, + 108 + ] + ], + [ + [ + 13206, + 13206 + ], + "mapped", + [ + 109, + 108 + ] + ], + [ + [ + 13207, + 13207 + ], + "mapped", + [ + 100, + 108 + ] + ], + [ + [ + 13208, + 13208 + ], + "mapped", + [ + 107, + 108 + ] + ], + [ + [ + 13209, + 13209 + ], + "mapped", + [ + 102, + 109 + ] + ], + [ + [ + 13210, + 13210 + ], + "mapped", + [ + 110, + 109 + ] + ], + [ + [ + 13211, + 13211 + ], + "mapped", + [ + 956, + 109 + ] + ], + [ + [ + 13212, + 13212 + ], + "mapped", + [ + 109, + 109 + ] + ], + [ + [ + 13213, + 13213 + ], + "mapped", + [ + 99, + 109 + ] + ], + [ + [ + 13214, + 13214 + ], + "mapped", + [ + 107, + 109 + ] + ], + [ + [ + 13215, + 13215 + ], + "mapped", + [ + 109, + 109, + 50 + ] + ], + [ + [ + 13216, + 13216 + ], + "mapped", + [ + 99, + 109, + 50 + ] + ], + [ + [ + 13217, + 13217 + ], + "mapped", + [ + 109, + 50 + ] + ], + [ + [ + 13218, + 13218 + ], + "mapped", + [ + 107, + 109, + 50 + ] + ], + [ + [ + 13219, + 13219 + ], + "mapped", + [ + 109, + 109, + 51 + ] + ], + [ + [ + 13220, + 13220 + ], + "mapped", + [ + 99, + 109, + 51 + ] + ], + [ + [ + 13221, + 13221 + ], + "mapped", + [ + 109, + 51 + ] + ], + [ + [ + 13222, + 13222 + ], + "mapped", + [ + 107, + 109, + 51 + ] + ], + [ + [ + 13223, + 13223 + ], + "mapped", + [ + 109, + 8725, + 115 + ] + ], + [ + [ + 13224, + 13224 + ], + "mapped", + [ + 109, + 8725, + 115, + 50 + ] + ], + [ + [ + 13225, + 13225 + ], + "mapped", + [ + 112, + 97 + ] + ], + [ + [ + 13226, + 13226 + ], + "mapped", + [ + 107, + 112, + 97 + ] + ], + [ + [ + 13227, + 13227 + ], + "mapped", + [ + 109, + 112, + 97 + ] + ], + [ + [ + 13228, + 13228 + ], + "mapped", + [ + 103, + 112, + 97 + ] + ], + [ + [ + 13229, + 13229 + ], + "mapped", + [ + 114, + 97, + 100 + ] + ], + [ + [ + 13230, + 13230 + ], + "mapped", + [ + 114, + 97, + 100, + 8725, + 115 + ] + ], + [ + [ + 13231, + 13231 + ], + "mapped", + [ + 114, + 97, + 100, + 8725, + 115, + 50 + ] + ], + [ + [ + 13232, + 13232 + ], + "mapped", + [ + 112, + 115 + ] + ], + [ + [ + 13233, + 13233 + ], + "mapped", + [ + 110, + 115 + ] + ], + [ + [ + 13234, + 13234 + ], + "mapped", + [ + 956, + 115 + ] + ], + [ + [ + 13235, + 13235 + ], + "mapped", + [ + 109, + 115 + ] + ], + [ + [ + 13236, + 13236 + ], + "mapped", + [ + 112, + 118 + ] + ], + [ + [ + 13237, + 13237 + ], + "mapped", + [ + 110, + 118 + ] + ], + [ + [ + 13238, + 13238 + ], + "mapped", + [ + 956, + 118 + ] + ], + [ + [ + 13239, + 13239 + ], + "mapped", + [ + 109, + 118 + ] + ], + [ + [ + 13240, + 13240 + ], + "mapped", + [ + 107, + 118 + ] + ], + [ + [ + 13241, + 13241 + ], + "mapped", + [ + 109, + 118 + ] + ], + [ + [ + 13242, + 13242 + ], + "mapped", + [ + 112, + 119 + ] + ], + [ + [ + 13243, + 13243 + ], + "mapped", + [ + 110, + 119 + ] + ], + [ + [ + 13244, + 13244 + ], + "mapped", + [ + 956, + 119 + ] + ], + [ + [ + 13245, + 13245 + ], + "mapped", + [ + 109, + 119 + ] + ], + [ + [ + 13246, + 13246 + ], + "mapped", + [ + 107, + 119 + ] + ], + [ + [ + 13247, + 13247 + ], + "mapped", + [ + 109, + 119 + ] + ], + [ + [ + 13248, + 13248 + ], + "mapped", + [ + 107, + 969 + ] + ], + [ + [ + 13249, + 13249 + ], + "mapped", + [ + 109, + 969 + ] + ], + [ + [ + 13250, + 13250 + ], + "disallowed" + ], + [ + [ + 13251, + 13251 + ], + "mapped", + [ + 98, + 113 + ] + ], + [ + [ + 13252, + 13252 + ], + "mapped", + [ + 99, + 99 + ] + ], + [ + [ + 13253, + 13253 + ], + "mapped", + [ + 99, + 100 + ] + ], + [ + [ + 13254, + 13254 + ], + "mapped", + [ + 99, + 8725, + 107, + 103 + ] + ], + [ + [ + 13255, + 13255 + ], + "disallowed" + ], + [ + [ + 13256, + 13256 + ], + "mapped", + [ + 100, + 98 + ] + ], + [ + [ + 13257, + 13257 + ], + "mapped", + [ + 103, + 121 + ] + ], + [ + [ + 13258, + 13258 + ], + "mapped", + [ + 104, + 97 + ] + ], + [ + [ + 13259, + 13259 + ], + "mapped", + [ + 104, + 112 + ] + ], + [ + [ + 13260, + 13260 + ], + "mapped", + [ + 105, + 110 + ] + ], + [ + [ + 13261, + 13261 + ], + "mapped", + [ + 107, + 107 + ] + ], + [ + [ + 13262, + 13262 + ], + "mapped", + [ + 107, + 109 + ] + ], + [ + [ + 13263, + 13263 + ], + "mapped", + [ + 107, + 116 + ] + ], + [ + [ + 13264, + 13264 + ], + "mapped", + [ + 108, + 109 + ] + ], + [ + [ + 13265, + 13265 + ], + "mapped", + [ + 108, + 110 + ] + ], + [ + [ + 13266, + 13266 + ], + "mapped", + [ + 108, + 111, + 103 + ] + ], + [ + [ + 13267, + 13267 + ], + "mapped", + [ + 108, + 120 + ] + ], + [ + [ + 13268, + 13268 + ], + "mapped", + [ + 109, + 98 + ] + ], + [ + [ + 13269, + 13269 + ], + "mapped", + [ + 109, + 105, + 108 + ] + ], + [ + [ + 13270, + 13270 + ], + "mapped", + [ + 109, + 111, + 108 + ] + ], + [ + [ + 13271, + 13271 + ], + "mapped", + [ + 112, + 104 + ] + ], + [ + [ + 13272, + 13272 + ], + "disallowed" + ], + [ + [ + 13273, + 13273 + ], + "mapped", + [ + 112, + 112, + 109 + ] + ], + [ + [ + 13274, + 13274 + ], + "mapped", + [ + 112, + 114 + ] + ], + [ + [ + 13275, + 13275 + ], + "mapped", + [ + 115, + 114 + ] + ], + [ + [ + 13276, + 13276 + ], + "mapped", + [ + 115, + 118 + ] + ], + [ + [ + 13277, + 13277 + ], + "mapped", + [ + 119, + 98 + ] + ], + [ + [ + 13278, + 13278 + ], + "mapped", + [ + 118, + 8725, + 109 + ] + ], + [ + [ + 13279, + 13279 + ], + "mapped", + [ + 97, + 8725, + 109 + ] + ], + [ + [ + 13280, + 13280 + ], + "mapped", + [ + 49, + 26085 + ] + ], + [ + [ + 13281, + 13281 + ], + "mapped", + [ + 50, + 26085 + ] + ], + [ + [ + 13282, + 13282 + ], + "mapped", + [ + 51, + 26085 + ] + ], + [ + [ + 13283, + 13283 + ], + "mapped", + [ + 52, + 26085 + ] + ], + [ + [ + 13284, + 13284 + ], + "mapped", + [ + 53, + 26085 + ] + ], + [ + [ + 13285, + 13285 + ], + "mapped", + [ + 54, + 26085 + ] + ], + [ + [ + 13286, + 13286 + ], + "mapped", + [ + 55, + 26085 + ] + ], + [ + [ + 13287, + 13287 + ], + "mapped", + [ + 56, + 26085 + ] + ], + [ + [ + 13288, + 13288 + ], + "mapped", + [ + 57, + 26085 + ] + ], + [ + [ + 13289, + 13289 + ], + "mapped", + [ + 49, + 48, + 26085 + ] + ], + [ + [ + 13290, + 13290 + ], + "mapped", + [ + 49, + 49, + 26085 + ] + ], + [ + [ + 13291, + 13291 + ], + "mapped", + [ + 49, + 50, + 26085 + ] + ], + [ + [ + 13292, + 13292 + ], + "mapped", + [ + 49, + 51, + 26085 + ] + ], + [ + [ + 13293, + 13293 + ], + "mapped", + [ + 49, + 52, + 26085 + ] + ], + [ + [ + 13294, + 13294 + ], + "mapped", + [ + 49, + 53, + 26085 + ] + ], + [ + [ + 13295, + 13295 + ], + "mapped", + [ + 49, + 54, + 26085 + ] + ], + [ + [ + 13296, + 13296 + ], + "mapped", + [ + 49, + 55, + 26085 + ] + ], + [ + [ + 13297, + 13297 + ], + "mapped", + [ + 49, + 56, + 26085 + ] + ], + [ + [ + 13298, + 13298 + ], + "mapped", + [ + 49, + 57, + 26085 + ] + ], + [ + [ + 13299, + 13299 + ], + "mapped", + [ + 50, + 48, + 26085 + ] + ], + [ + [ + 13300, + 13300 + ], + "mapped", + [ + 50, + 49, + 26085 + ] + ], + [ + [ + 13301, + 13301 + ], + "mapped", + [ + 50, + 50, + 26085 + ] + ], + [ + [ + 13302, + 13302 + ], + "mapped", + [ + 50, + 51, + 26085 + ] + ], + [ + [ + 13303, + 13303 + ], + "mapped", + [ + 50, + 52, + 26085 + ] + ], + [ + [ + 13304, + 13304 + ], + "mapped", + [ + 50, + 53, + 26085 + ] + ], + [ + [ + 13305, + 13305 + ], + "mapped", + [ + 50, + 54, + 26085 + ] + ], + [ + [ + 13306, + 13306 + ], + "mapped", + [ + 50, + 55, + 26085 + ] + ], + [ + [ + 13307, + 13307 + ], + "mapped", + [ + 50, + 56, + 26085 + ] + ], + [ + [ + 13308, + 13308 + ], + "mapped", + [ + 50, + 57, + 26085 + ] + ], + [ + [ + 13309, + 13309 + ], + "mapped", + [ + 51, + 48, + 26085 + ] + ], + [ + [ + 13310, + 13310 + ], + "mapped", + [ + 51, + 49, + 26085 + ] + ], + [ + [ + 13311, + 13311 + ], + "mapped", + [ + 103, + 97, + 108 + ] + ], + [ + [ + 13312, + 19893 + ], + "valid" + ], + [ + [ + 19894, + 19903 + ], + "disallowed" + ], + [ + [ + 19904, + 19967 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 19968, + 40869 + ], + "valid" + ], + [ + [ + 40870, + 40891 + ], + "valid" + ], + [ + [ + 40892, + 40899 + ], + "valid" + ], + [ + [ + 40900, + 40907 + ], + "valid" + ], + [ + [ + 40908, + 40908 + ], + "valid" + ], + [ + [ + 40909, + 40917 + ], + "valid" + ], + [ + [ + 40918, + 40959 + ], + "disallowed" + ], + [ + [ + 40960, + 42124 + ], + "valid" + ], + [ + [ + 42125, + 42127 + ], + "disallowed" + ], + [ + [ + 42128, + 42145 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 42146, + 42147 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 42148, + 42163 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 42164, + 42164 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 42165, + 42176 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 42177, + 42177 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 42178, + 42180 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 42181, + 42181 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 42182, + 42182 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 42183, + 42191 + ], + "disallowed" + ], + [ + [ + 42192, + 42237 + ], + "valid" + ], + [ + [ + 42238, + 42239 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 42240, + 42508 + ], + "valid" + ], + [ + [ + 42509, + 42511 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 42512, + 42539 + ], + "valid" + ], + [ + [ + 42540, + 42559 + ], + "disallowed" + ], + [ + [ + 42560, + 42560 + ], + "mapped", + [ + 42561 + ] + ], + [ + [ + 42561, + 42561 + ], + "valid" + ], + [ + [ + 42562, + 42562 + ], + "mapped", + [ + 42563 + ] + ], + [ + [ + 42563, + 42563 + ], + "valid" + ], + [ + [ + 42564, + 42564 + ], + "mapped", + [ + 42565 + ] + ], + [ + [ + 42565, + 42565 + ], + "valid" + ], + [ + [ + 42566, + 42566 + ], + "mapped", + [ + 42567 + ] + ], + [ + [ + 42567, + 42567 + ], + "valid" + ], + [ + [ + 42568, + 42568 + ], + "mapped", + [ + 42569 + ] + ], + [ + [ + 42569, + 42569 + ], + "valid" + ], + [ + [ + 42570, + 42570 + ], + "mapped", + [ + 42571 + ] + ], + [ + [ + 42571, + 42571 + ], + "valid" + ], + [ + [ + 42572, + 42572 + ], + "mapped", + [ + 42573 + ] + ], + [ + [ + 42573, + 42573 + ], + "valid" + ], + [ + [ + 42574, + 42574 + ], + "mapped", + [ + 42575 + ] + ], + [ + [ + 42575, + 42575 + ], + "valid" + ], + [ + [ + 42576, + 42576 + ], + "mapped", + [ + 42577 + ] + ], + [ + [ + 42577, + 42577 + ], + "valid" + ], + [ + [ + 42578, + 42578 + ], + "mapped", + [ + 42579 + ] + ], + [ + [ + 42579, + 42579 + ], + "valid" + ], + [ + [ + 42580, + 42580 + ], + "mapped", + [ + 42581 + ] + ], + [ + [ + 42581, + 42581 + ], + "valid" + ], + [ + [ + 42582, + 42582 + ], + "mapped", + [ + 42583 + ] + ], + [ + [ + 42583, + 42583 + ], + "valid" + ], + [ + [ + 42584, + 42584 + ], + "mapped", + [ + 42585 + ] + ], + [ + [ + 42585, + 42585 + ], + "valid" + ], + [ + [ + 42586, + 42586 + ], + "mapped", + [ + 42587 + ] + ], + [ + [ + 42587, + 42587 + ], + "valid" + ], + [ + [ + 42588, + 42588 + ], + "mapped", + [ + 42589 + ] + ], + [ + [ + 42589, + 42589 + ], + "valid" + ], + [ + [ + 42590, + 42590 + ], + "mapped", + [ + 42591 + ] + ], + [ + [ + 42591, + 42591 + ], + "valid" + ], + [ + [ + 42592, + 42592 + ], + "mapped", + [ + 42593 + ] + ], + [ + [ + 42593, + 42593 + ], + "valid" + ], + [ + [ + 42594, + 42594 + ], + "mapped", + [ + 42595 + ] + ], + [ + [ + 42595, + 42595 + ], + "valid" + ], + [ + [ + 42596, + 42596 + ], + "mapped", + [ + 42597 + ] + ], + [ + [ + 42597, + 42597 + ], + "valid" + ], + [ + [ + 42598, + 42598 + ], + "mapped", + [ + 42599 + ] + ], + [ + [ + 42599, + 42599 + ], + "valid" + ], + [ + [ + 42600, + 42600 + ], + "mapped", + [ + 42601 + ] + ], + [ + [ + 42601, + 42601 + ], + "valid" + ], + [ + [ + 42602, + 42602 + ], + "mapped", + [ + 42603 + ] + ], + [ + [ + 42603, + 42603 + ], + "valid" + ], + [ + [ + 42604, + 42604 + ], + "mapped", + [ + 42605 + ] + ], + [ + [ + 42605, + 42607 + ], + "valid" + ], + [ + [ + 42608, + 42611 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 42612, + 42619 + ], + "valid" + ], + [ + [ + 42620, + 42621 + ], + "valid" + ], + [ + [ + 42622, + 42622 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 42623, + 42623 + ], + "valid" + ], + [ + [ + 42624, + 42624 + ], + "mapped", + [ + 42625 + ] + ], + [ + [ + 42625, + 42625 + ], + "valid" + ], + [ + [ + 42626, + 42626 + ], + "mapped", + [ + 42627 + ] + ], + [ + [ + 42627, + 42627 + ], + "valid" + ], + [ + [ + 42628, + 42628 + ], + "mapped", + [ + 42629 + ] + ], + [ + [ + 42629, + 42629 + ], + "valid" + ], + [ + [ + 42630, + 42630 + ], + "mapped", + [ + 42631 + ] + ], + [ + [ + 42631, + 42631 + ], + "valid" + ], + [ + [ + 42632, + 42632 + ], + "mapped", + [ + 42633 + ] + ], + [ + [ + 42633, + 42633 + ], + "valid" + ], + [ + [ + 42634, + 42634 + ], + "mapped", + [ + 42635 + ] + ], + [ + [ + 42635, + 42635 + ], + "valid" + ], + [ + [ + 42636, + 42636 + ], + "mapped", + [ + 42637 + ] + ], + [ + [ + 42637, + 42637 + ], + "valid" + ], + [ + [ + 42638, + 42638 + ], + "mapped", + [ + 42639 + ] + ], + [ + [ + 42639, + 42639 + ], + "valid" + ], + [ + [ + 42640, + 42640 + ], + "mapped", + [ + 42641 + ] + ], + [ + [ + 42641, + 42641 + ], + "valid" + ], + [ + [ + 42642, + 42642 + ], + "mapped", + [ + 42643 + ] + ], + [ + [ + 42643, + 42643 + ], + "valid" + ], + [ + [ + 42644, + 42644 + ], + "mapped", + [ + 42645 + ] + ], + [ + [ + 42645, + 42645 + ], + "valid" + ], + [ + [ + 42646, + 42646 + ], + "mapped", + [ + 42647 + ] + ], + [ + [ + 42647, + 42647 + ], + "valid" + ], + [ + [ + 42648, + 42648 + ], + "mapped", + [ + 42649 + ] + ], + [ + [ + 42649, + 42649 + ], + "valid" + ], + [ + [ + 42650, + 42650 + ], + "mapped", + [ + 42651 + ] + ], + [ + [ + 42651, + 42651 + ], + "valid" + ], + [ + [ + 42652, + 42652 + ], + "mapped", + [ + 1098 + ] + ], + [ + [ + 42653, + 42653 + ], + "mapped", + [ + 1100 + ] + ], + [ + [ + 42654, + 42654 + ], + "valid" + ], + [ + [ + 42655, + 42655 + ], + "valid" + ], + [ + [ + 42656, + 42725 + ], + "valid" + ], + [ + [ + 42726, + 42735 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 42736, + 42737 + ], + "valid" + ], + [ + [ + 42738, + 42743 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 42744, + 42751 + ], + "disallowed" + ], + [ + [ + 42752, + 42774 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 42775, + 42778 + ], + "valid" + ], + [ + [ + 42779, + 42783 + ], + "valid" + ], + [ + [ + 42784, + 42785 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 42786, + 42786 + ], + "mapped", + [ + 42787 + ] + ], + [ + [ + 42787, + 42787 + ], + "valid" + ], + [ + [ + 42788, + 42788 + ], + "mapped", + [ + 42789 + ] + ], + [ + [ + 42789, + 42789 + ], + "valid" + ], + [ + [ + 42790, + 42790 + ], + "mapped", + [ + 42791 + ] + ], + [ + [ + 42791, + 42791 + ], + "valid" + ], + [ + [ + 42792, + 42792 + ], + "mapped", + [ + 42793 + ] + ], + [ + [ + 42793, + 42793 + ], + "valid" + ], + [ + [ + 42794, + 42794 + ], + "mapped", + [ + 42795 + ] + ], + [ + [ + 42795, + 42795 + ], + "valid" + ], + [ + [ + 42796, + 42796 + ], + "mapped", + [ + 42797 + ] + ], + [ + [ + 42797, + 42797 + ], + "valid" + ], + [ + [ + 42798, + 42798 + ], + "mapped", + [ + 42799 + ] + ], + [ + [ + 42799, + 42801 + ], + "valid" + ], + [ + [ + 42802, + 42802 + ], + "mapped", + [ + 42803 + ] + ], + [ + [ + 42803, + 42803 + ], + "valid" + ], + [ + [ + 42804, + 42804 + ], + "mapped", + [ + 42805 + ] + ], + [ + [ + 42805, + 42805 + ], + "valid" + ], + [ + [ + 42806, + 42806 + ], + "mapped", + [ + 42807 + ] + ], + [ + [ + 42807, + 42807 + ], + "valid" + ], + [ + [ + 42808, + 42808 + ], + "mapped", + [ + 42809 + ] + ], + [ + [ + 42809, + 42809 + ], + "valid" + ], + [ + [ + 42810, + 42810 + ], + "mapped", + [ + 42811 + ] + ], + [ + [ + 42811, + 42811 + ], + "valid" + ], + [ + [ + 42812, + 42812 + ], + "mapped", + [ + 42813 + ] + ], + [ + [ + 42813, + 42813 + ], + "valid" + ], + [ + [ + 42814, + 42814 + ], + "mapped", + [ + 42815 + ] + ], + [ + [ + 42815, + 42815 + ], + "valid" + ], + [ + [ + 42816, + 42816 + ], + "mapped", + [ + 42817 + ] + ], + [ + [ + 42817, + 42817 + ], + "valid" + ], + [ + [ + 42818, + 42818 + ], + "mapped", + [ + 42819 + ] + ], + [ + [ + 42819, + 42819 + ], + "valid" + ], + [ + [ + 42820, + 42820 + ], + "mapped", + [ + 42821 + ] + ], + [ + [ + 42821, + 42821 + ], + "valid" + ], + [ + [ + 42822, + 42822 + ], + "mapped", + [ + 42823 + ] + ], + [ + [ + 42823, + 42823 + ], + "valid" + ], + [ + [ + 42824, + 42824 + ], + "mapped", + [ + 42825 + ] + ], + [ + [ + 42825, + 42825 + ], + "valid" + ], + [ + [ + 42826, + 42826 + ], + "mapped", + [ + 42827 + ] + ], + [ + [ + 42827, + 42827 + ], + "valid" + ], + [ + [ + 42828, + 42828 + ], + "mapped", + [ + 42829 + ] + ], + [ + [ + 42829, + 42829 + ], + "valid" + ], + [ + [ + 42830, + 42830 + ], + "mapped", + [ + 42831 + ] + ], + [ + [ + 42831, + 42831 + ], + "valid" + ], + [ + [ + 42832, + 42832 + ], + "mapped", + [ + 42833 + ] + ], + [ + [ + 42833, + 42833 + ], + "valid" + ], + [ + [ + 42834, + 42834 + ], + "mapped", + [ + 42835 + ] + ], + [ + [ + 42835, + 42835 + ], + "valid" + ], + [ + [ + 42836, + 42836 + ], + "mapped", + [ + 42837 + ] + ], + [ + [ + 42837, + 42837 + ], + "valid" + ], + [ + [ + 42838, + 42838 + ], + "mapped", + [ + 42839 + ] + ], + [ + [ + 42839, + 42839 + ], + "valid" + ], + [ + [ + 42840, + 42840 + ], + "mapped", + [ + 42841 + ] + ], + [ + [ + 42841, + 42841 + ], + "valid" + ], + [ + [ + 42842, + 42842 + ], + "mapped", + [ + 42843 + ] + ], + [ + [ + 42843, + 42843 + ], + "valid" + ], + [ + [ + 42844, + 42844 + ], + "mapped", + [ + 42845 + ] + ], + [ + [ + 42845, + 42845 + ], + "valid" + ], + [ + [ + 42846, + 42846 + ], + "mapped", + [ + 42847 + ] + ], + [ + [ + 42847, + 42847 + ], + "valid" + ], + [ + [ + 42848, + 42848 + ], + "mapped", + [ + 42849 + ] + ], + [ + [ + 42849, + 42849 + ], + "valid" + ], + [ + [ + 42850, + 42850 + ], + "mapped", + [ + 42851 + ] + ], + [ + [ + 42851, + 42851 + ], + "valid" + ], + [ + [ + 42852, + 42852 + ], + "mapped", + [ + 42853 + ] + ], + [ + [ + 42853, + 42853 + ], + "valid" + ], + [ + [ + 42854, + 42854 + ], + "mapped", + [ + 42855 + ] + ], + [ + [ + 42855, + 42855 + ], + "valid" + ], + [ + [ + 42856, + 42856 + ], + "mapped", + [ + 42857 + ] + ], + [ + [ + 42857, + 42857 + ], + "valid" + ], + [ + [ + 42858, + 42858 + ], + "mapped", + [ + 42859 + ] + ], + [ + [ + 42859, + 42859 + ], + "valid" + ], + [ + [ + 42860, + 42860 + ], + "mapped", + [ + 42861 + ] + ], + [ + [ + 42861, + 42861 + ], + "valid" + ], + [ + [ + 42862, + 42862 + ], + "mapped", + [ + 42863 + ] + ], + [ + [ + 42863, + 42863 + ], + "valid" + ], + [ + [ + 42864, + 42864 + ], + "mapped", + [ + 42863 + ] + ], + [ + [ + 42865, + 42872 + ], + "valid" + ], + [ + [ + 42873, + 42873 + ], + "mapped", + [ + 42874 + ] + ], + [ + [ + 42874, + 42874 + ], + "valid" + ], + [ + [ + 42875, + 42875 + ], + "mapped", + [ + 42876 + ] + ], + [ + [ + 42876, + 42876 + ], + "valid" + ], + [ + [ + 42877, + 42877 + ], + "mapped", + [ + 7545 + ] + ], + [ + [ + 42878, + 42878 + ], + "mapped", + [ + 42879 + ] + ], + [ + [ + 42879, + 42879 + ], + "valid" + ], + [ + [ + 42880, + 42880 + ], + "mapped", + [ + 42881 + ] + ], + [ + [ + 42881, + 42881 + ], + "valid" + ], + [ + [ + 42882, + 42882 + ], + "mapped", + [ + 42883 + ] + ], + [ + [ + 42883, + 42883 + ], + "valid" + ], + [ + [ + 42884, + 42884 + ], + "mapped", + [ + 42885 + ] + ], + [ + [ + 42885, + 42885 + ], + "valid" + ], + [ + [ + 42886, + 42886 + ], + "mapped", + [ + 42887 + ] + ], + [ + [ + 42887, + 42888 + ], + "valid" + ], + [ + [ + 42889, + 42890 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 42891, + 42891 + ], + "mapped", + [ + 42892 + ] + ], + [ + [ + 42892, + 42892 + ], + "valid" + ], + [ + [ + 42893, + 42893 + ], + "mapped", + [ + 613 + ] + ], + [ + [ + 42894, + 42894 + ], + "valid" + ], + [ + [ + 42895, + 42895 + ], + "valid" + ], + [ + [ + 42896, + 42896 + ], + "mapped", + [ + 42897 + ] + ], + [ + [ + 42897, + 42897 + ], + "valid" + ], + [ + [ + 42898, + 42898 + ], + "mapped", + [ + 42899 + ] + ], + [ + [ + 42899, + 42899 + ], + "valid" + ], + [ + [ + 42900, + 42901 + ], + "valid" + ], + [ + [ + 42902, + 42902 + ], + "mapped", + [ + 42903 + ] + ], + [ + [ + 42903, + 42903 + ], + "valid" + ], + [ + [ + 42904, + 42904 + ], + "mapped", + [ + 42905 + ] + ], + [ + [ + 42905, + 42905 + ], + "valid" + ], + [ + [ + 42906, + 42906 + ], + "mapped", + [ + 42907 + ] + ], + [ + [ + 42907, + 42907 + ], + "valid" + ], + [ + [ + 42908, + 42908 + ], + "mapped", + [ + 42909 + ] + ], + [ + [ + 42909, + 42909 + ], + "valid" + ], + [ + [ + 42910, + 42910 + ], + "mapped", + [ + 42911 + ] + ], + [ + [ + 42911, + 42911 + ], + "valid" + ], + [ + [ + 42912, + 42912 + ], + "mapped", + [ + 42913 + ] + ], + [ + [ + 42913, + 42913 + ], + "valid" + ], + [ + [ + 42914, + 42914 + ], + "mapped", + [ + 42915 + ] + ], + [ + [ + 42915, + 42915 + ], + "valid" + ], + [ + [ + 42916, + 42916 + ], + "mapped", + [ + 42917 + ] + ], + [ + [ + 42917, + 42917 + ], + "valid" + ], + [ + [ + 42918, + 42918 + ], + "mapped", + [ + 42919 + ] + ], + [ + [ + 42919, + 42919 + ], + "valid" + ], + [ + [ + 42920, + 42920 + ], + "mapped", + [ + 42921 + ] + ], + [ + [ + 42921, + 42921 + ], + "valid" + ], + [ + [ + 42922, + 42922 + ], + "mapped", + [ + 614 + ] + ], + [ + [ + 42923, + 42923 + ], + "mapped", + [ + 604 + ] + ], + [ + [ + 42924, + 42924 + ], + "mapped", + [ + 609 + ] + ], + [ + [ + 42925, + 42925 + ], + "mapped", + [ + 620 + ] + ], + [ + [ + 42926, + 42927 + ], + "disallowed" + ], + [ + [ + 42928, + 42928 + ], + "mapped", + [ + 670 + ] + ], + [ + [ + 42929, + 42929 + ], + "mapped", + [ + 647 + ] + ], + [ + [ + 42930, + 42930 + ], + "mapped", + [ + 669 + ] + ], + [ + [ + 42931, + 42931 + ], + "mapped", + [ + 43859 + ] + ], + [ + [ + 42932, + 42932 + ], + "mapped", + [ + 42933 + ] + ], + [ + [ + 42933, + 42933 + ], + "valid" + ], + [ + [ + 42934, + 42934 + ], + "mapped", + [ + 42935 + ] + ], + [ + [ + 42935, + 42935 + ], + "valid" + ], + [ + [ + 42936, + 42998 + ], + "disallowed" + ], + [ + [ + 42999, + 42999 + ], + "valid" + ], + [ + [ + 43000, + 43000 + ], + "mapped", + [ + 295 + ] + ], + [ + [ + 43001, + 43001 + ], + "mapped", + [ + 339 + ] + ], + [ + [ + 43002, + 43002 + ], + "valid" + ], + [ + [ + 43003, + 43007 + ], + "valid" + ], + [ + [ + 43008, + 43047 + ], + "valid" + ], + [ + [ + 43048, + 43051 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 43052, + 43055 + ], + "disallowed" + ], + [ + [ + 43056, + 43065 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 43066, + 43071 + ], + "disallowed" + ], + [ + [ + 43072, + 43123 + ], + "valid" + ], + [ + [ + 43124, + 43127 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 43128, + 43135 + ], + "disallowed" + ], + [ + [ + 43136, + 43204 + ], + "valid" + ], + [ + [ + 43205, + 43213 + ], + "disallowed" + ], + [ + [ + 43214, + 43215 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 43216, + 43225 + ], + "valid" + ], + [ + [ + 43226, + 43231 + ], + "disallowed" + ], + [ + [ + 43232, + 43255 + ], + "valid" + ], + [ + [ + 43256, + 43258 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 43259, + 43259 + ], + "valid" + ], + [ + [ + 43260, + 43260 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 43261, + 43261 + ], + "valid" + ], + [ + [ + 43262, + 43263 + ], + "disallowed" + ], + [ + [ + 43264, + 43309 + ], + "valid" + ], + [ + [ + 43310, + 43311 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 43312, + 43347 + ], + "valid" + ], + [ + [ + 43348, + 43358 + ], + "disallowed" + ], + [ + [ + 43359, + 43359 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 43360, + 43388 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 43389, + 43391 + ], + "disallowed" + ], + [ + [ + 43392, + 43456 + ], + "valid" + ], + [ + [ + 43457, + 43469 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 43470, + 43470 + ], + "disallowed" + ], + [ + [ + 43471, + 43481 + ], + "valid" + ], + [ + [ + 43482, + 43485 + ], + "disallowed" + ], + [ + [ + 43486, + 43487 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 43488, + 43518 + ], + "valid" + ], + [ + [ + 43519, + 43519 + ], + "disallowed" + ], + [ + [ + 43520, + 43574 + ], + "valid" + ], + [ + [ + 43575, + 43583 + ], + "disallowed" + ], + [ + [ + 43584, + 43597 + ], + "valid" + ], + [ + [ + 43598, + 43599 + ], + "disallowed" + ], + [ + [ + 43600, + 43609 + ], + "valid" + ], + [ + [ + 43610, + 43611 + ], + "disallowed" + ], + [ + [ + 43612, + 43615 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 43616, + 43638 + ], + "valid" + ], + [ + [ + 43639, + 43641 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 43642, + 43643 + ], + "valid" + ], + [ + [ + 43644, + 43647 + ], + "valid" + ], + [ + [ + 43648, + 43714 + ], + "valid" + ], + [ + [ + 43715, + 43738 + ], + "disallowed" + ], + [ + [ + 43739, + 43741 + ], + "valid" + ], + [ + [ + 43742, + 43743 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 43744, + 43759 + ], + "valid" + ], + [ + [ + 43760, + 43761 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 43762, + 43766 + ], + "valid" + ], + [ + [ + 43767, + 43776 + ], + "disallowed" + ], + [ + [ + 43777, + 43782 + ], + "valid" + ], + [ + [ + 43783, + 43784 + ], + "disallowed" + ], + [ + [ + 43785, + 43790 + ], + "valid" + ], + [ + [ + 43791, + 43792 + ], + "disallowed" + ], + [ + [ + 43793, + 43798 + ], + "valid" + ], + [ + [ + 43799, + 43807 + ], + "disallowed" + ], + [ + [ + 43808, + 43814 + ], + "valid" + ], + [ + [ + 43815, + 43815 + ], + "disallowed" + ], + [ + [ + 43816, + 43822 + ], + "valid" + ], + [ + [ + 43823, + 43823 + ], + "disallowed" + ], + [ + [ + 43824, + 43866 + ], + "valid" + ], + [ + [ + 43867, + 43867 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 43868, + 43868 + ], + "mapped", + [ + 42791 + ] + ], + [ + [ + 43869, + 43869 + ], + "mapped", + [ + 43831 + ] + ], + [ + [ + 43870, + 43870 + ], + "mapped", + [ + 619 + ] + ], + [ + [ + 43871, + 43871 + ], + "mapped", + [ + 43858 + ] + ], + [ + [ + 43872, + 43875 + ], + "valid" + ], + [ + [ + 43876, + 43877 + ], + "valid" + ], + [ + [ + 43878, + 43887 + ], + "disallowed" + ], + [ + [ + 43888, + 43888 + ], + "mapped", + [ + 5024 + ] + ], + [ + [ + 43889, + 43889 + ], + "mapped", + [ + 5025 + ] + ], + [ + [ + 43890, + 43890 + ], + "mapped", + [ + 5026 + ] + ], + [ + [ + 43891, + 43891 + ], + "mapped", + [ + 5027 + ] + ], + [ + [ + 43892, + 43892 + ], + "mapped", + [ + 5028 + ] + ], + [ + [ + 43893, + 43893 + ], + "mapped", + [ + 5029 + ] + ], + [ + [ + 43894, + 43894 + ], + "mapped", + [ + 5030 + ] + ], + [ + [ + 43895, + 43895 + ], + "mapped", + [ + 5031 + ] + ], + [ + [ + 43896, + 43896 + ], + "mapped", + [ + 5032 + ] + ], + [ + [ + 43897, + 43897 + ], + "mapped", + [ + 5033 + ] + ], + [ + [ + 43898, + 43898 + ], + "mapped", + [ + 5034 + ] + ], + [ + [ + 43899, + 43899 + ], + "mapped", + [ + 5035 + ] + ], + [ + [ + 43900, + 43900 + ], + "mapped", + [ + 5036 + ] + ], + [ + [ + 43901, + 43901 + ], + "mapped", + [ + 5037 + ] + ], + [ + [ + 43902, + 43902 + ], + "mapped", + [ + 5038 + ] + ], + [ + [ + 43903, + 43903 + ], + "mapped", + [ + 5039 + ] + ], + [ + [ + 43904, + 43904 + ], + "mapped", + [ + 5040 + ] + ], + [ + [ + 43905, + 43905 + ], + "mapped", + [ + 5041 + ] + ], + [ + [ + 43906, + 43906 + ], + "mapped", + [ + 5042 + ] + ], + [ + [ + 43907, + 43907 + ], + "mapped", + [ + 5043 + ] + ], + [ + [ + 43908, + 43908 + ], + "mapped", + [ + 5044 + ] + ], + [ + [ + 43909, + 43909 + ], + "mapped", + [ + 5045 + ] + ], + [ + [ + 43910, + 43910 + ], + "mapped", + [ + 5046 + ] + ], + [ + [ + 43911, + 43911 + ], + "mapped", + [ + 5047 + ] + ], + [ + [ + 43912, + 43912 + ], + "mapped", + [ + 5048 + ] + ], + [ + [ + 43913, + 43913 + ], + "mapped", + [ + 5049 + ] + ], + [ + [ + 43914, + 43914 + ], + "mapped", + [ + 5050 + ] + ], + [ + [ + 43915, + 43915 + ], + "mapped", + [ + 5051 + ] + ], + [ + [ + 43916, + 43916 + ], + "mapped", + [ + 5052 + ] + ], + [ + [ + 43917, + 43917 + ], + "mapped", + [ + 5053 + ] + ], + [ + [ + 43918, + 43918 + ], + "mapped", + [ + 5054 + ] + ], + [ + [ + 43919, + 43919 + ], + "mapped", + [ + 5055 + ] + ], + [ + [ + 43920, + 43920 + ], + "mapped", + [ + 5056 + ] + ], + [ + [ + 43921, + 43921 + ], + "mapped", + [ + 5057 + ] + ], + [ + [ + 43922, + 43922 + ], + "mapped", + [ + 5058 + ] + ], + [ + [ + 43923, + 43923 + ], + "mapped", + [ + 5059 + ] + ], + [ + [ + 43924, + 43924 + ], + "mapped", + [ + 5060 + ] + ], + [ + [ + 43925, + 43925 + ], + "mapped", + [ + 5061 + ] + ], + [ + [ + 43926, + 43926 + ], + "mapped", + [ + 5062 + ] + ], + [ + [ + 43927, + 43927 + ], + "mapped", + [ + 5063 + ] + ], + [ + [ + 43928, + 43928 + ], + "mapped", + [ + 5064 + ] + ], + [ + [ + 43929, + 43929 + ], + "mapped", + [ + 5065 + ] + ], + [ + [ + 43930, + 43930 + ], + "mapped", + [ + 5066 + ] + ], + [ + [ + 43931, + 43931 + ], + "mapped", + [ + 5067 + ] + ], + [ + [ + 43932, + 43932 + ], + "mapped", + [ + 5068 + ] + ], + [ + [ + 43933, + 43933 + ], + "mapped", + [ + 5069 + ] + ], + [ + [ + 43934, + 43934 + ], + "mapped", + [ + 5070 + ] + ], + [ + [ + 43935, + 43935 + ], + "mapped", + [ + 5071 + ] + ], + [ + [ + 43936, + 43936 + ], + "mapped", + [ + 5072 + ] + ], + [ + [ + 43937, + 43937 + ], + "mapped", + [ + 5073 + ] + ], + [ + [ + 43938, + 43938 + ], + "mapped", + [ + 5074 + ] + ], + [ + [ + 43939, + 43939 + ], + "mapped", + [ + 5075 + ] + ], + [ + [ + 43940, + 43940 + ], + "mapped", + [ + 5076 + ] + ], + [ + [ + 43941, + 43941 + ], + "mapped", + [ + 5077 + ] + ], + [ + [ + 43942, + 43942 + ], + "mapped", + [ + 5078 + ] + ], + [ + [ + 43943, + 43943 + ], + "mapped", + [ + 5079 + ] + ], + [ + [ + 43944, + 43944 + ], + "mapped", + [ + 5080 + ] + ], + [ + [ + 43945, + 43945 + ], + "mapped", + [ + 5081 + ] + ], + [ + [ + 43946, + 43946 + ], + "mapped", + [ + 5082 + ] + ], + [ + [ + 43947, + 43947 + ], + "mapped", + [ + 5083 + ] + ], + [ + [ + 43948, + 43948 + ], + "mapped", + [ + 5084 + ] + ], + [ + [ + 43949, + 43949 + ], + "mapped", + [ + 5085 + ] + ], + [ + [ + 43950, + 43950 + ], + "mapped", + [ + 5086 + ] + ], + [ + [ + 43951, + 43951 + ], + "mapped", + [ + 5087 + ] + ], + [ + [ + 43952, + 43952 + ], + "mapped", + [ + 5088 + ] + ], + [ + [ + 43953, + 43953 + ], + "mapped", + [ + 5089 + ] + ], + [ + [ + 43954, + 43954 + ], + "mapped", + [ + 5090 + ] + ], + [ + [ + 43955, + 43955 + ], + "mapped", + [ + 5091 + ] + ], + [ + [ + 43956, + 43956 + ], + "mapped", + [ + 5092 + ] + ], + [ + [ + 43957, + 43957 + ], + "mapped", + [ + 5093 + ] + ], + [ + [ + 43958, + 43958 + ], + "mapped", + [ + 5094 + ] + ], + [ + [ + 43959, + 43959 + ], + "mapped", + [ + 5095 + ] + ], + [ + [ + 43960, + 43960 + ], + "mapped", + [ + 5096 + ] + ], + [ + [ + 43961, + 43961 + ], + "mapped", + [ + 5097 + ] + ], + [ + [ + 43962, + 43962 + ], + "mapped", + [ + 5098 + ] + ], + [ + [ + 43963, + 43963 + ], + "mapped", + [ + 5099 + ] + ], + [ + [ + 43964, + 43964 + ], + "mapped", + [ + 5100 + ] + ], + [ + [ + 43965, + 43965 + ], + "mapped", + [ + 5101 + ] + ], + [ + [ + 43966, + 43966 + ], + "mapped", + [ + 5102 + ] + ], + [ + [ + 43967, + 43967 + ], + "mapped", + [ + 5103 + ] + ], + [ + [ + 43968, + 44010 + ], + "valid" + ], + [ + [ + 44011, + 44011 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 44012, + 44013 + ], + "valid" + ], + [ + [ + 44014, + 44015 + ], + "disallowed" + ], + [ + [ + 44016, + 44025 + ], + "valid" + ], + [ + [ + 44026, + 44031 + ], + "disallowed" + ], + [ + [ + 44032, + 55203 + ], + "valid" + ], + [ + [ + 55204, + 55215 + ], + "disallowed" + ], + [ + [ + 55216, + 55238 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 55239, + 55242 + ], + "disallowed" + ], + [ + [ + 55243, + 55291 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 55292, + 55295 + ], + "disallowed" + ], + [ + [ + 55296, + 57343 + ], + "disallowed" + ], + [ + [ + 57344, + 63743 + ], + "disallowed" + ], + [ + [ + 63744, + 63744 + ], + "mapped", + [ + 35912 + ] + ], + [ + [ + 63745, + 63745 + ], + "mapped", + [ + 26356 + ] + ], + [ + [ + 63746, + 63746 + ], + "mapped", + [ + 36554 + ] + ], + [ + [ + 63747, + 63747 + ], + "mapped", + [ + 36040 + ] + ], + [ + [ + 63748, + 63748 + ], + "mapped", + [ + 28369 + ] + ], + [ + [ + 63749, + 63749 + ], + "mapped", + [ + 20018 + ] + ], + [ + [ + 63750, + 63750 + ], + "mapped", + [ + 21477 + ] + ], + [ + [ + 63751, + 63752 + ], + "mapped", + [ + 40860 + ] + ], + [ + [ + 63753, + 63753 + ], + "mapped", + [ + 22865 + ] + ], + [ + [ + 63754, + 63754 + ], + "mapped", + [ + 37329 + ] + ], + [ + [ + 63755, + 63755 + ], + "mapped", + [ + 21895 + ] + ], + [ + [ + 63756, + 63756 + ], + "mapped", + [ + 22856 + ] + ], + [ + [ + 63757, + 63757 + ], + "mapped", + [ + 25078 + ] + ], + [ + [ + 63758, + 63758 + ], + "mapped", + [ + 30313 + ] + ], + [ + [ + 63759, + 63759 + ], + "mapped", + [ + 32645 + ] + ], + [ + [ + 63760, + 63760 + ], + "mapped", + [ + 34367 + ] + ], + [ + [ + 63761, + 63761 + ], + "mapped", + [ + 34746 + ] + ], + [ + [ + 63762, + 63762 + ], + "mapped", + [ + 35064 + ] + ], + [ + [ + 63763, + 63763 + ], + "mapped", + [ + 37007 + ] + ], + [ + [ + 63764, + 63764 + ], + "mapped", + [ + 27138 + ] + ], + [ + [ + 63765, + 63765 + ], + "mapped", + [ + 27931 + ] + ], + [ + [ + 63766, + 63766 + ], + "mapped", + [ + 28889 + ] + ], + [ + [ + 63767, + 63767 + ], + "mapped", + [ + 29662 + ] + ], + [ + [ + 63768, + 63768 + ], + "mapped", + [ + 33853 + ] + ], + [ + [ + 63769, + 63769 + ], + "mapped", + [ + 37226 + ] + ], + [ + [ + 63770, + 63770 + ], + "mapped", + [ + 39409 + ] + ], + [ + [ + 63771, + 63771 + ], + "mapped", + [ + 20098 + ] + ], + [ + [ + 63772, + 63772 + ], + "mapped", + [ + 21365 + ] + ], + [ + [ + 63773, + 63773 + ], + "mapped", + [ + 27396 + ] + ], + [ + [ + 63774, + 63774 + ], + "mapped", + [ + 29211 + ] + ], + [ + [ + 63775, + 63775 + ], + "mapped", + [ + 34349 + ] + ], + [ + [ + 63776, + 63776 + ], + "mapped", + [ + 40478 + ] + ], + [ + [ + 63777, + 63777 + ], + "mapped", + [ + 23888 + ] + ], + [ + [ + 63778, + 63778 + ], + "mapped", + [ + 28651 + ] + ], + [ + [ + 63779, + 63779 + ], + "mapped", + [ + 34253 + ] + ], + [ + [ + 63780, + 63780 + ], + "mapped", + [ + 35172 + ] + ], + [ + [ + 63781, + 63781 + ], + "mapped", + [ + 25289 + ] + ], + [ + [ + 63782, + 63782 + ], + "mapped", + [ + 33240 + ] + ], + [ + [ + 63783, + 63783 + ], + "mapped", + [ + 34847 + ] + ], + [ + [ + 63784, + 63784 + ], + "mapped", + [ + 24266 + ] + ], + [ + [ + 63785, + 63785 + ], + "mapped", + [ + 26391 + ] + ], + [ + [ + 63786, + 63786 + ], + "mapped", + [ + 28010 + ] + ], + [ + [ + 63787, + 63787 + ], + "mapped", + [ + 29436 + ] + ], + [ + [ + 63788, + 63788 + ], + "mapped", + [ + 37070 + ] + ], + [ + [ + 63789, + 63789 + ], + "mapped", + [ + 20358 + ] + ], + [ + [ + 63790, + 63790 + ], + "mapped", + [ + 20919 + ] + ], + [ + [ + 63791, + 63791 + ], + "mapped", + [ + 21214 + ] + ], + [ + [ + 63792, + 63792 + ], + "mapped", + [ + 25796 + ] + ], + [ + [ + 63793, + 63793 + ], + "mapped", + [ + 27347 + ] + ], + [ + [ + 63794, + 63794 + ], + "mapped", + [ + 29200 + ] + ], + [ + [ + 63795, + 63795 + ], + "mapped", + [ + 30439 + ] + ], + [ + [ + 63796, + 63796 + ], + "mapped", + [ + 32769 + ] + ], + [ + [ + 63797, + 63797 + ], + "mapped", + [ + 34310 + ] + ], + [ + [ + 63798, + 63798 + ], + "mapped", + [ + 34396 + ] + ], + [ + [ + 63799, + 63799 + ], + "mapped", + [ + 36335 + ] + ], + [ + [ + 63800, + 63800 + ], + "mapped", + [ + 38706 + ] + ], + [ + [ + 63801, + 63801 + ], + "mapped", + [ + 39791 + ] + ], + [ + [ + 63802, + 63802 + ], + "mapped", + [ + 40442 + ] + ], + [ + [ + 63803, + 63803 + ], + "mapped", + [ + 30860 + ] + ], + [ + [ + 63804, + 63804 + ], + "mapped", + [ + 31103 + ] + ], + [ + [ + 63805, + 63805 + ], + "mapped", + [ + 32160 + ] + ], + [ + [ + 63806, + 63806 + ], + "mapped", + [ + 33737 + ] + ], + [ + [ + 63807, + 63807 + ], + "mapped", + [ + 37636 + ] + ], + [ + [ + 63808, + 63808 + ], + "mapped", + [ + 40575 + ] + ], + [ + [ + 63809, + 63809 + ], + "mapped", + [ + 35542 + ] + ], + [ + [ + 63810, + 63810 + ], + "mapped", + [ + 22751 + ] + ], + [ + [ + 63811, + 63811 + ], + "mapped", + [ + 24324 + ] + ], + [ + [ + 63812, + 63812 + ], + "mapped", + [ + 31840 + ] + ], + [ + [ + 63813, + 63813 + ], + "mapped", + [ + 32894 + ] + ], + [ + [ + 63814, + 63814 + ], + "mapped", + [ + 29282 + ] + ], + [ + [ + 63815, + 63815 + ], + "mapped", + [ + 30922 + ] + ], + [ + [ + 63816, + 63816 + ], + "mapped", + [ + 36034 + ] + ], + [ + [ + 63817, + 63817 + ], + "mapped", + [ + 38647 + ] + ], + [ + [ + 63818, + 63818 + ], + "mapped", + [ + 22744 + ] + ], + [ + [ + 63819, + 63819 + ], + "mapped", + [ + 23650 + ] + ], + [ + [ + 63820, + 63820 + ], + "mapped", + [ + 27155 + ] + ], + [ + [ + 63821, + 63821 + ], + "mapped", + [ + 28122 + ] + ], + [ + [ + 63822, + 63822 + ], + "mapped", + [ + 28431 + ] + ], + [ + [ + 63823, + 63823 + ], + "mapped", + [ + 32047 + ] + ], + [ + [ + 63824, + 63824 + ], + "mapped", + [ + 32311 + ] + ], + [ + [ + 63825, + 63825 + ], + "mapped", + [ + 38475 + ] + ], + [ + [ + 63826, + 63826 + ], + "mapped", + [ + 21202 + ] + ], + [ + [ + 63827, + 63827 + ], + "mapped", + [ + 32907 + ] + ], + [ + [ + 63828, + 63828 + ], + "mapped", + [ + 20956 + ] + ], + [ + [ + 63829, + 63829 + ], + "mapped", + [ + 20940 + ] + ], + [ + [ + 63830, + 63830 + ], + "mapped", + [ + 31260 + ] + ], + [ + [ + 63831, + 63831 + ], + "mapped", + [ + 32190 + ] + ], + [ + [ + 63832, + 63832 + ], + "mapped", + [ + 33777 + ] + ], + [ + [ + 63833, + 63833 + ], + "mapped", + [ + 38517 + ] + ], + [ + [ + 63834, + 63834 + ], + "mapped", + [ + 35712 + ] + ], + [ + [ + 63835, + 63835 + ], + "mapped", + [ + 25295 + ] + ], + [ + [ + 63836, + 63836 + ], + "mapped", + [ + 27138 + ] + ], + [ + [ + 63837, + 63837 + ], + "mapped", + [ + 35582 + ] + ], + [ + [ + 63838, + 63838 + ], + "mapped", + [ + 20025 + ] + ], + [ + [ + 63839, + 63839 + ], + "mapped", + [ + 23527 + ] + ], + [ + [ + 63840, + 63840 + ], + "mapped", + [ + 24594 + ] + ], + [ + [ + 63841, + 63841 + ], + "mapped", + [ + 29575 + ] + ], + [ + [ + 63842, + 63842 + ], + "mapped", + [ + 30064 + ] + ], + [ + [ + 63843, + 63843 + ], + "mapped", + [ + 21271 + ] + ], + [ + [ + 63844, + 63844 + ], + "mapped", + [ + 30971 + ] + ], + [ + [ + 63845, + 63845 + ], + "mapped", + [ + 20415 + ] + ], + [ + [ + 63846, + 63846 + ], + "mapped", + [ + 24489 + ] + ], + [ + [ + 63847, + 63847 + ], + "mapped", + [ + 19981 + ] + ], + [ + [ + 63848, + 63848 + ], + "mapped", + [ + 27852 + ] + ], + [ + [ + 63849, + 63849 + ], + "mapped", + [ + 25976 + ] + ], + [ + [ + 63850, + 63850 + ], + "mapped", + [ + 32034 + ] + ], + [ + [ + 63851, + 63851 + ], + "mapped", + [ + 21443 + ] + ], + [ + [ + 63852, + 63852 + ], + "mapped", + [ + 22622 + ] + ], + [ + [ + 63853, + 63853 + ], + "mapped", + [ + 30465 + ] + ], + [ + [ + 63854, + 63854 + ], + "mapped", + [ + 33865 + ] + ], + [ + [ + 63855, + 63855 + ], + "mapped", + [ + 35498 + ] + ], + [ + [ + 63856, + 63856 + ], + "mapped", + [ + 27578 + ] + ], + [ + [ + 63857, + 63857 + ], + "mapped", + [ + 36784 + ] + ], + [ + [ + 63858, + 63858 + ], + "mapped", + [ + 27784 + ] + ], + [ + [ + 63859, + 63859 + ], + "mapped", + [ + 25342 + ] + ], + [ + [ + 63860, + 63860 + ], + "mapped", + [ + 33509 + ] + ], + [ + [ + 63861, + 63861 + ], + "mapped", + [ + 25504 + ] + ], + [ + [ + 63862, + 63862 + ], + "mapped", + [ + 30053 + ] + ], + [ + [ + 63863, + 63863 + ], + "mapped", + [ + 20142 + ] + ], + [ + [ + 63864, + 63864 + ], + "mapped", + [ + 20841 + ] + ], + [ + [ + 63865, + 63865 + ], + "mapped", + [ + 20937 + ] + ], + [ + [ + 63866, + 63866 + ], + "mapped", + [ + 26753 + ] + ], + [ + [ + 63867, + 63867 + ], + "mapped", + [ + 31975 + ] + ], + [ + [ + 63868, + 63868 + ], + "mapped", + [ + 33391 + ] + ], + [ + [ + 63869, + 63869 + ], + "mapped", + [ + 35538 + ] + ], + [ + [ + 63870, + 63870 + ], + "mapped", + [ + 37327 + ] + ], + [ + [ + 63871, + 63871 + ], + "mapped", + [ + 21237 + ] + ], + [ + [ + 63872, + 63872 + ], + "mapped", + [ + 21570 + ] + ], + [ + [ + 63873, + 63873 + ], + "mapped", + [ + 22899 + ] + ], + [ + [ + 63874, + 63874 + ], + "mapped", + [ + 24300 + ] + ], + [ + [ + 63875, + 63875 + ], + "mapped", + [ + 26053 + ] + ], + [ + [ + 63876, + 63876 + ], + "mapped", + [ + 28670 + ] + ], + [ + [ + 63877, + 63877 + ], + "mapped", + [ + 31018 + ] + ], + [ + [ + 63878, + 63878 + ], + "mapped", + [ + 38317 + ] + ], + [ + [ + 63879, + 63879 + ], + "mapped", + [ + 39530 + ] + ], + [ + [ + 63880, + 63880 + ], + "mapped", + [ + 40599 + ] + ], + [ + [ + 63881, + 63881 + ], + "mapped", + [ + 40654 + ] + ], + [ + [ + 63882, + 63882 + ], + "mapped", + [ + 21147 + ] + ], + [ + [ + 63883, + 63883 + ], + "mapped", + [ + 26310 + ] + ], + [ + [ + 63884, + 63884 + ], + "mapped", + [ + 27511 + ] + ], + [ + [ + 63885, + 63885 + ], + "mapped", + [ + 36706 + ] + ], + [ + [ + 63886, + 63886 + ], + "mapped", + [ + 24180 + ] + ], + [ + [ + 63887, + 63887 + ], + "mapped", + [ + 24976 + ] + ], + [ + [ + 63888, + 63888 + ], + "mapped", + [ + 25088 + ] + ], + [ + [ + 63889, + 63889 + ], + "mapped", + [ + 25754 + ] + ], + [ + [ + 63890, + 63890 + ], + "mapped", + [ + 28451 + ] + ], + [ + [ + 63891, + 63891 + ], + "mapped", + [ + 29001 + ] + ], + [ + [ + 63892, + 63892 + ], + "mapped", + [ + 29833 + ] + ], + [ + [ + 63893, + 63893 + ], + "mapped", + [ + 31178 + ] + ], + [ + [ + 63894, + 63894 + ], + "mapped", + [ + 32244 + ] + ], + [ + [ + 63895, + 63895 + ], + "mapped", + [ + 32879 + ] + ], + [ + [ + 63896, + 63896 + ], + "mapped", + [ + 36646 + ] + ], + [ + [ + 63897, + 63897 + ], + "mapped", + [ + 34030 + ] + ], + [ + [ + 63898, + 63898 + ], + "mapped", + [ + 36899 + ] + ], + [ + [ + 63899, + 63899 + ], + "mapped", + [ + 37706 + ] + ], + [ + [ + 63900, + 63900 + ], + "mapped", + [ + 21015 + ] + ], + [ + [ + 63901, + 63901 + ], + "mapped", + [ + 21155 + ] + ], + [ + [ + 63902, + 63902 + ], + "mapped", + [ + 21693 + ] + ], + [ + [ + 63903, + 63903 + ], + "mapped", + [ + 28872 + ] + ], + [ + [ + 63904, + 63904 + ], + "mapped", + [ + 35010 + ] + ], + [ + [ + 63905, + 63905 + ], + "mapped", + [ + 35498 + ] + ], + [ + [ + 63906, + 63906 + ], + "mapped", + [ + 24265 + ] + ], + [ + [ + 63907, + 63907 + ], + "mapped", + [ + 24565 + ] + ], + [ + [ + 63908, + 63908 + ], + "mapped", + [ + 25467 + ] + ], + [ + [ + 63909, + 63909 + ], + "mapped", + [ + 27566 + ] + ], + [ + [ + 63910, + 63910 + ], + "mapped", + [ + 31806 + ] + ], + [ + [ + 63911, + 63911 + ], + "mapped", + [ + 29557 + ] + ], + [ + [ + 63912, + 63912 + ], + "mapped", + [ + 20196 + ] + ], + [ + [ + 63913, + 63913 + ], + "mapped", + [ + 22265 + ] + ], + [ + [ + 63914, + 63914 + ], + "mapped", + [ + 23527 + ] + ], + [ + [ + 63915, + 63915 + ], + "mapped", + [ + 23994 + ] + ], + [ + [ + 63916, + 63916 + ], + "mapped", + [ + 24604 + ] + ], + [ + [ + 63917, + 63917 + ], + "mapped", + [ + 29618 + ] + ], + [ + [ + 63918, + 63918 + ], + "mapped", + [ + 29801 + ] + ], + [ + [ + 63919, + 63919 + ], + "mapped", + [ + 32666 + ] + ], + [ + [ + 63920, + 63920 + ], + "mapped", + [ + 32838 + ] + ], + [ + [ + 63921, + 63921 + ], + "mapped", + [ + 37428 + ] + ], + [ + [ + 63922, + 63922 + ], + "mapped", + [ + 38646 + ] + ], + [ + [ + 63923, + 63923 + ], + "mapped", + [ + 38728 + ] + ], + [ + [ + 63924, + 63924 + ], + "mapped", + [ + 38936 + ] + ], + [ + [ + 63925, + 63925 + ], + "mapped", + [ + 20363 + ] + ], + [ + [ + 63926, + 63926 + ], + "mapped", + [ + 31150 + ] + ], + [ + [ + 63927, + 63927 + ], + "mapped", + [ + 37300 + ] + ], + [ + [ + 63928, + 63928 + ], + "mapped", + [ + 38584 + ] + ], + [ + [ + 63929, + 63929 + ], + "mapped", + [ + 24801 + ] + ], + [ + [ + 63930, + 63930 + ], + "mapped", + [ + 20102 + ] + ], + [ + [ + 63931, + 63931 + ], + "mapped", + [ + 20698 + ] + ], + [ + [ + 63932, + 63932 + ], + "mapped", + [ + 23534 + ] + ], + [ + [ + 63933, + 63933 + ], + "mapped", + [ + 23615 + ] + ], + [ + [ + 63934, + 63934 + ], + "mapped", + [ + 26009 + ] + ], + [ + [ + 63935, + 63935 + ], + "mapped", + [ + 27138 + ] + ], + [ + [ + 63936, + 63936 + ], + "mapped", + [ + 29134 + ] + ], + [ + [ + 63937, + 63937 + ], + "mapped", + [ + 30274 + ] + ], + [ + [ + 63938, + 63938 + ], + "mapped", + [ + 34044 + ] + ], + [ + [ + 63939, + 63939 + ], + "mapped", + [ + 36988 + ] + ], + [ + [ + 63940, + 63940 + ], + "mapped", + [ + 40845 + ] + ], + [ + [ + 63941, + 63941 + ], + "mapped", + [ + 26248 + ] + ], + [ + [ + 63942, + 63942 + ], + "mapped", + [ + 38446 + ] + ], + [ + [ + 63943, + 63943 + ], + "mapped", + [ + 21129 + ] + ], + [ + [ + 63944, + 63944 + ], + "mapped", + [ + 26491 + ] + ], + [ + [ + 63945, + 63945 + ], + "mapped", + [ + 26611 + ] + ], + [ + [ + 63946, + 63946 + ], + "mapped", + [ + 27969 + ] + ], + [ + [ + 63947, + 63947 + ], + "mapped", + [ + 28316 + ] + ], + [ + [ + 63948, + 63948 + ], + "mapped", + [ + 29705 + ] + ], + [ + [ + 63949, + 63949 + ], + "mapped", + [ + 30041 + ] + ], + [ + [ + 63950, + 63950 + ], + "mapped", + [ + 30827 + ] + ], + [ + [ + 63951, + 63951 + ], + "mapped", + [ + 32016 + ] + ], + [ + [ + 63952, + 63952 + ], + "mapped", + [ + 39006 + ] + ], + [ + [ + 63953, + 63953 + ], + "mapped", + [ + 20845 + ] + ], + [ + [ + 63954, + 63954 + ], + "mapped", + [ + 25134 + ] + ], + [ + [ + 63955, + 63955 + ], + "mapped", + [ + 38520 + ] + ], + [ + [ + 63956, + 63956 + ], + "mapped", + [ + 20523 + ] + ], + [ + [ + 63957, + 63957 + ], + "mapped", + [ + 23833 + ] + ], + [ + [ + 63958, + 63958 + ], + "mapped", + [ + 28138 + ] + ], + [ + [ + 63959, + 63959 + ], + "mapped", + [ + 36650 + ] + ], + [ + [ + 63960, + 63960 + ], + "mapped", + [ + 24459 + ] + ], + [ + [ + 63961, + 63961 + ], + "mapped", + [ + 24900 + ] + ], + [ + [ + 63962, + 63962 + ], + "mapped", + [ + 26647 + ] + ], + [ + [ + 63963, + 63963 + ], + "mapped", + [ + 29575 + ] + ], + [ + [ + 63964, + 63964 + ], + "mapped", + [ + 38534 + ] + ], + [ + [ + 63965, + 63965 + ], + "mapped", + [ + 21033 + ] + ], + [ + [ + 63966, + 63966 + ], + "mapped", + [ + 21519 + ] + ], + [ + [ + 63967, + 63967 + ], + "mapped", + [ + 23653 + ] + ], + [ + [ + 63968, + 63968 + ], + "mapped", + [ + 26131 + ] + ], + [ + [ + 63969, + 63969 + ], + "mapped", + [ + 26446 + ] + ], + [ + [ + 63970, + 63970 + ], + "mapped", + [ + 26792 + ] + ], + [ + [ + 63971, + 63971 + ], + "mapped", + [ + 27877 + ] + ], + [ + [ + 63972, + 63972 + ], + "mapped", + [ + 29702 + ] + ], + [ + [ + 63973, + 63973 + ], + "mapped", + [ + 30178 + ] + ], + [ + [ + 63974, + 63974 + ], + "mapped", + [ + 32633 + ] + ], + [ + [ + 63975, + 63975 + ], + "mapped", + [ + 35023 + ] + ], + [ + [ + 63976, + 63976 + ], + "mapped", + [ + 35041 + ] + ], + [ + [ + 63977, + 63977 + ], + "mapped", + [ + 37324 + ] + ], + [ + [ + 63978, + 63978 + ], + "mapped", + [ + 38626 + ] + ], + [ + [ + 63979, + 63979 + ], + "mapped", + [ + 21311 + ] + ], + [ + [ + 63980, + 63980 + ], + "mapped", + [ + 28346 + ] + ], + [ + [ + 63981, + 63981 + ], + "mapped", + [ + 21533 + ] + ], + [ + [ + 63982, + 63982 + ], + "mapped", + [ + 29136 + ] + ], + [ + [ + 63983, + 63983 + ], + "mapped", + [ + 29848 + ] + ], + [ + [ + 63984, + 63984 + ], + "mapped", + [ + 34298 + ] + ], + [ + [ + 63985, + 63985 + ], + "mapped", + [ + 38563 + ] + ], + [ + [ + 63986, + 63986 + ], + "mapped", + [ + 40023 + ] + ], + [ + [ + 63987, + 63987 + ], + "mapped", + [ + 40607 + ] + ], + [ + [ + 63988, + 63988 + ], + "mapped", + [ + 26519 + ] + ], + [ + [ + 63989, + 63989 + ], + "mapped", + [ + 28107 + ] + ], + [ + [ + 63990, + 63990 + ], + "mapped", + [ + 33256 + ] + ], + [ + [ + 63991, + 63991 + ], + "mapped", + [ + 31435 + ] + ], + [ + [ + 63992, + 63992 + ], + "mapped", + [ + 31520 + ] + ], + [ + [ + 63993, + 63993 + ], + "mapped", + [ + 31890 + ] + ], + [ + [ + 63994, + 63994 + ], + "mapped", + [ + 29376 + ] + ], + [ + [ + 63995, + 63995 + ], + "mapped", + [ + 28825 + ] + ], + [ + [ + 63996, + 63996 + ], + "mapped", + [ + 35672 + ] + ], + [ + [ + 63997, + 63997 + ], + "mapped", + [ + 20160 + ] + ], + [ + [ + 63998, + 63998 + ], + "mapped", + [ + 33590 + ] + ], + [ + [ + 63999, + 63999 + ], + "mapped", + [ + 21050 + ] + ], + [ + [ + 64000, + 64000 + ], + "mapped", + [ + 20999 + ] + ], + [ + [ + 64001, + 64001 + ], + "mapped", + [ + 24230 + ] + ], + [ + [ + 64002, + 64002 + ], + "mapped", + [ + 25299 + ] + ], + [ + [ + 64003, + 64003 + ], + "mapped", + [ + 31958 + ] + ], + [ + [ + 64004, + 64004 + ], + "mapped", + [ + 23429 + ] + ], + [ + [ + 64005, + 64005 + ], + "mapped", + [ + 27934 + ] + ], + [ + [ + 64006, + 64006 + ], + "mapped", + [ + 26292 + ] + ], + [ + [ + 64007, + 64007 + ], + "mapped", + [ + 36667 + ] + ], + [ + [ + 64008, + 64008 + ], + "mapped", + [ + 34892 + ] + ], + [ + [ + 64009, + 64009 + ], + "mapped", + [ + 38477 + ] + ], + [ + [ + 64010, + 64010 + ], + "mapped", + [ + 35211 + ] + ], + [ + [ + 64011, + 64011 + ], + "mapped", + [ + 24275 + ] + ], + [ + [ + 64012, + 64012 + ], + "mapped", + [ + 20800 + ] + ], + [ + [ + 64013, + 64013 + ], + "mapped", + [ + 21952 + ] + ], + [ + [ + 64014, + 64015 + ], + "valid" + ], + [ + [ + 64016, + 64016 + ], + "mapped", + [ + 22618 + ] + ], + [ + [ + 64017, + 64017 + ], + "valid" + ], + [ + [ + 64018, + 64018 + ], + "mapped", + [ + 26228 + ] + ], + [ + [ + 64019, + 64020 + ], + "valid" + ], + [ + [ + 64021, + 64021 + ], + "mapped", + [ + 20958 + ] + ], + [ + [ + 64022, + 64022 + ], + "mapped", + [ + 29482 + ] + ], + [ + [ + 64023, + 64023 + ], + "mapped", + [ + 30410 + ] + ], + [ + [ + 64024, + 64024 + ], + "mapped", + [ + 31036 + ] + ], + [ + [ + 64025, + 64025 + ], + "mapped", + [ + 31070 + ] + ], + [ + [ + 64026, + 64026 + ], + "mapped", + [ + 31077 + ] + ], + [ + [ + 64027, + 64027 + ], + "mapped", + [ + 31119 + ] + ], + [ + [ + 64028, + 64028 + ], + "mapped", + [ + 38742 + ] + ], + [ + [ + 64029, + 64029 + ], + "mapped", + [ + 31934 + ] + ], + [ + [ + 64030, + 64030 + ], + "mapped", + [ + 32701 + ] + ], + [ + [ + 64031, + 64031 + ], + "valid" + ], + [ + [ + 64032, + 64032 + ], + "mapped", + [ + 34322 + ] + ], + [ + [ + 64033, + 64033 + ], + "valid" + ], + [ + [ + 64034, + 64034 + ], + "mapped", + [ + 35576 + ] + ], + [ + [ + 64035, + 64036 + ], + "valid" + ], + [ + [ + 64037, + 64037 + ], + "mapped", + [ + 36920 + ] + ], + [ + [ + 64038, + 64038 + ], + "mapped", + [ + 37117 + ] + ], + [ + [ + 64039, + 64041 + ], + "valid" + ], + [ + [ + 64042, + 64042 + ], + "mapped", + [ + 39151 + ] + ], + [ + [ + 64043, + 64043 + ], + "mapped", + [ + 39164 + ] + ], + [ + [ + 64044, + 64044 + ], + "mapped", + [ + 39208 + ] + ], + [ + [ + 64045, + 64045 + ], + "mapped", + [ + 40372 + ] + ], + [ + [ + 64046, + 64046 + ], + "mapped", + [ + 37086 + ] + ], + [ + [ + 64047, + 64047 + ], + "mapped", + [ + 38583 + ] + ], + [ + [ + 64048, + 64048 + ], + "mapped", + [ + 20398 + ] + ], + [ + [ + 64049, + 64049 + ], + "mapped", + [ + 20711 + ] + ], + [ + [ + 64050, + 64050 + ], + "mapped", + [ + 20813 + ] + ], + [ + [ + 64051, + 64051 + ], + "mapped", + [ + 21193 + ] + ], + [ + [ + 64052, + 64052 + ], + "mapped", + [ + 21220 + ] + ], + [ + [ + 64053, + 64053 + ], + "mapped", + [ + 21329 + ] + ], + [ + [ + 64054, + 64054 + ], + "mapped", + [ + 21917 + ] + ], + [ + [ + 64055, + 64055 + ], + "mapped", + [ + 22022 + ] + ], + [ + [ + 64056, + 64056 + ], + "mapped", + [ + 22120 + ] + ], + [ + [ + 64057, + 64057 + ], + "mapped", + [ + 22592 + ] + ], + [ + [ + 64058, + 64058 + ], + "mapped", + [ + 22696 + ] + ], + [ + [ + 64059, + 64059 + ], + "mapped", + [ + 23652 + ] + ], + [ + [ + 64060, + 64060 + ], + "mapped", + [ + 23662 + ] + ], + [ + [ + 64061, + 64061 + ], + "mapped", + [ + 24724 + ] + ], + [ + [ + 64062, + 64062 + ], + "mapped", + [ + 24936 + ] + ], + [ + [ + 64063, + 64063 + ], + "mapped", + [ + 24974 + ] + ], + [ + [ + 64064, + 64064 + ], + "mapped", + [ + 25074 + ] + ], + [ + [ + 64065, + 64065 + ], + "mapped", + [ + 25935 + ] + ], + [ + [ + 64066, + 64066 + ], + "mapped", + [ + 26082 + ] + ], + [ + [ + 64067, + 64067 + ], + "mapped", + [ + 26257 + ] + ], + [ + [ + 64068, + 64068 + ], + "mapped", + [ + 26757 + ] + ], + [ + [ + 64069, + 64069 + ], + "mapped", + [ + 28023 + ] + ], + [ + [ + 64070, + 64070 + ], + "mapped", + [ + 28186 + ] + ], + [ + [ + 64071, + 64071 + ], + "mapped", + [ + 28450 + ] + ], + [ + [ + 64072, + 64072 + ], + "mapped", + [ + 29038 + ] + ], + [ + [ + 64073, + 64073 + ], + "mapped", + [ + 29227 + ] + ], + [ + [ + 64074, + 64074 + ], + "mapped", + [ + 29730 + ] + ], + [ + [ + 64075, + 64075 + ], + "mapped", + [ + 30865 + ] + ], + [ + [ + 64076, + 64076 + ], + "mapped", + [ + 31038 + ] + ], + [ + [ + 64077, + 64077 + ], + "mapped", + [ + 31049 + ] + ], + [ + [ + 64078, + 64078 + ], + "mapped", + [ + 31048 + ] + ], + [ + [ + 64079, + 64079 + ], + "mapped", + [ + 31056 + ] + ], + [ + [ + 64080, + 64080 + ], + "mapped", + [ + 31062 + ] + ], + [ + [ + 64081, + 64081 + ], + "mapped", + [ + 31069 + ] + ], + [ + [ + 64082, + 64082 + ], + "mapped", + [ + 31117 + ] + ], + [ + [ + 64083, + 64083 + ], + "mapped", + [ + 31118 + ] + ], + [ + [ + 64084, + 64084 + ], + "mapped", + [ + 31296 + ] + ], + [ + [ + 64085, + 64085 + ], + "mapped", + [ + 31361 + ] + ], + [ + [ + 64086, + 64086 + ], + "mapped", + [ + 31680 + ] + ], + [ + [ + 64087, + 64087 + ], + "mapped", + [ + 32244 + ] + ], + [ + [ + 64088, + 64088 + ], + "mapped", + [ + 32265 + ] + ], + [ + [ + 64089, + 64089 + ], + "mapped", + [ + 32321 + ] + ], + [ + [ + 64090, + 64090 + ], + "mapped", + [ + 32626 + ] + ], + [ + [ + 64091, + 64091 + ], + "mapped", + [ + 32773 + ] + ], + [ + [ + 64092, + 64092 + ], + "mapped", + [ + 33261 + ] + ], + [ + [ + 64093, + 64094 + ], + "mapped", + [ + 33401 + ] + ], + [ + [ + 64095, + 64095 + ], + "mapped", + [ + 33879 + ] + ], + [ + [ + 64096, + 64096 + ], + "mapped", + [ + 35088 + ] + ], + [ + [ + 64097, + 64097 + ], + "mapped", + [ + 35222 + ] + ], + [ + [ + 64098, + 64098 + ], + "mapped", + [ + 35585 + ] + ], + [ + [ + 64099, + 64099 + ], + "mapped", + [ + 35641 + ] + ], + [ + [ + 64100, + 64100 + ], + "mapped", + [ + 36051 + ] + ], + [ + [ + 64101, + 64101 + ], + "mapped", + [ + 36104 + ] + ], + [ + [ + 64102, + 64102 + ], + "mapped", + [ + 36790 + ] + ], + [ + [ + 64103, + 64103 + ], + "mapped", + [ + 36920 + ] + ], + [ + [ + 64104, + 64104 + ], + "mapped", + [ + 38627 + ] + ], + [ + [ + 64105, + 64105 + ], + "mapped", + [ + 38911 + ] + ], + [ + [ + 64106, + 64106 + ], + "mapped", + [ + 38971 + ] + ], + [ + [ + 64107, + 64107 + ], + "mapped", + [ + 24693 + ] + ], + [ + [ + 64108, + 64108 + ], + "mapped", + [ + 148206 + ] + ], + [ + [ + 64109, + 64109 + ], + "mapped", + [ + 33304 + ] + ], + [ + [ + 64110, + 64111 + ], + "disallowed" + ], + [ + [ + 64112, + 64112 + ], + "mapped", + [ + 20006 + ] + ], + [ + [ + 64113, + 64113 + ], + "mapped", + [ + 20917 + ] + ], + [ + [ + 64114, + 64114 + ], + "mapped", + [ + 20840 + ] + ], + [ + [ + 64115, + 64115 + ], + "mapped", + [ + 20352 + ] + ], + [ + [ + 64116, + 64116 + ], + "mapped", + [ + 20805 + ] + ], + [ + [ + 64117, + 64117 + ], + "mapped", + [ + 20864 + ] + ], + [ + [ + 64118, + 64118 + ], + "mapped", + [ + 21191 + ] + ], + [ + [ + 64119, + 64119 + ], + "mapped", + [ + 21242 + ] + ], + [ + [ + 64120, + 64120 + ], + "mapped", + [ + 21917 + ] + ], + [ + [ + 64121, + 64121 + ], + "mapped", + [ + 21845 + ] + ], + [ + [ + 64122, + 64122 + ], + "mapped", + [ + 21913 + ] + ], + [ + [ + 64123, + 64123 + ], + "mapped", + [ + 21986 + ] + ], + [ + [ + 64124, + 64124 + ], + "mapped", + [ + 22618 + ] + ], + [ + [ + 64125, + 64125 + ], + "mapped", + [ + 22707 + ] + ], + [ + [ + 64126, + 64126 + ], + "mapped", + [ + 22852 + ] + ], + [ + [ + 64127, + 64127 + ], + "mapped", + [ + 22868 + ] + ], + [ + [ + 64128, + 64128 + ], + "mapped", + [ + 23138 + ] + ], + [ + [ + 64129, + 64129 + ], + "mapped", + [ + 23336 + ] + ], + [ + [ + 64130, + 64130 + ], + "mapped", + [ + 24274 + ] + ], + [ + [ + 64131, + 64131 + ], + "mapped", + [ + 24281 + ] + ], + [ + [ + 64132, + 64132 + ], + "mapped", + [ + 24425 + ] + ], + [ + [ + 64133, + 64133 + ], + "mapped", + [ + 24493 + ] + ], + [ + [ + 64134, + 64134 + ], + "mapped", + [ + 24792 + ] + ], + [ + [ + 64135, + 64135 + ], + "mapped", + [ + 24910 + ] + ], + [ + [ + 64136, + 64136 + ], + "mapped", + [ + 24840 + ] + ], + [ + [ + 64137, + 64137 + ], + "mapped", + [ + 24974 + ] + ], + [ + [ + 64138, + 64138 + ], + "mapped", + [ + 24928 + ] + ], + [ + [ + 64139, + 64139 + ], + "mapped", + [ + 25074 + ] + ], + [ + [ + 64140, + 64140 + ], + "mapped", + [ + 25140 + ] + ], + [ + [ + 64141, + 64141 + ], + "mapped", + [ + 25540 + ] + ], + [ + [ + 64142, + 64142 + ], + "mapped", + [ + 25628 + ] + ], + [ + [ + 64143, + 64143 + ], + "mapped", + [ + 25682 + ] + ], + [ + [ + 64144, + 64144 + ], + "mapped", + [ + 25942 + ] + ], + [ + [ + 64145, + 64145 + ], + "mapped", + [ + 26228 + ] + ], + [ + [ + 64146, + 64146 + ], + "mapped", + [ + 26391 + ] + ], + [ + [ + 64147, + 64147 + ], + "mapped", + [ + 26395 + ] + ], + [ + [ + 64148, + 64148 + ], + "mapped", + [ + 26454 + ] + ], + [ + [ + 64149, + 64149 + ], + "mapped", + [ + 27513 + ] + ], + [ + [ + 64150, + 64150 + ], + "mapped", + [ + 27578 + ] + ], + [ + [ + 64151, + 64151 + ], + "mapped", + [ + 27969 + ] + ], + [ + [ + 64152, + 64152 + ], + "mapped", + [ + 28379 + ] + ], + [ + [ + 64153, + 64153 + ], + "mapped", + [ + 28363 + ] + ], + [ + [ + 64154, + 64154 + ], + "mapped", + [ + 28450 + ] + ], + [ + [ + 64155, + 64155 + ], + "mapped", + [ + 28702 + ] + ], + [ + [ + 64156, + 64156 + ], + "mapped", + [ + 29038 + ] + ], + [ + [ + 64157, + 64157 + ], + "mapped", + [ + 30631 + ] + ], + [ + [ + 64158, + 64158 + ], + "mapped", + [ + 29237 + ] + ], + [ + [ + 64159, + 64159 + ], + "mapped", + [ + 29359 + ] + ], + [ + [ + 64160, + 64160 + ], + "mapped", + [ + 29482 + ] + ], + [ + [ + 64161, + 64161 + ], + "mapped", + [ + 29809 + ] + ], + [ + [ + 64162, + 64162 + ], + "mapped", + [ + 29958 + ] + ], + [ + [ + 64163, + 64163 + ], + "mapped", + [ + 30011 + ] + ], + [ + [ + 64164, + 64164 + ], + "mapped", + [ + 30237 + ] + ], + [ + [ + 64165, + 64165 + ], + "mapped", + [ + 30239 + ] + ], + [ + [ + 64166, + 64166 + ], + "mapped", + [ + 30410 + ] + ], + [ + [ + 64167, + 64167 + ], + "mapped", + [ + 30427 + ] + ], + [ + [ + 64168, + 64168 + ], + "mapped", + [ + 30452 + ] + ], + [ + [ + 64169, + 64169 + ], + "mapped", + [ + 30538 + ] + ], + [ + [ + 64170, + 64170 + ], + "mapped", + [ + 30528 + ] + ], + [ + [ + 64171, + 64171 + ], + "mapped", + [ + 30924 + ] + ], + [ + [ + 64172, + 64172 + ], + "mapped", + [ + 31409 + ] + ], + [ + [ + 64173, + 64173 + ], + "mapped", + [ + 31680 + ] + ], + [ + [ + 64174, + 64174 + ], + "mapped", + [ + 31867 + ] + ], + [ + [ + 64175, + 64175 + ], + "mapped", + [ + 32091 + ] + ], + [ + [ + 64176, + 64176 + ], + "mapped", + [ + 32244 + ] + ], + [ + [ + 64177, + 64177 + ], + "mapped", + [ + 32574 + ] + ], + [ + [ + 64178, + 64178 + ], + "mapped", + [ + 32773 + ] + ], + [ + [ + 64179, + 64179 + ], + "mapped", + [ + 33618 + ] + ], + [ + [ + 64180, + 64180 + ], + "mapped", + [ + 33775 + ] + ], + [ + [ + 64181, + 64181 + ], + "mapped", + [ + 34681 + ] + ], + [ + [ + 64182, + 64182 + ], + "mapped", + [ + 35137 + ] + ], + [ + [ + 64183, + 64183 + ], + "mapped", + [ + 35206 + ] + ], + [ + [ + 64184, + 64184 + ], + "mapped", + [ + 35222 + ] + ], + [ + [ + 64185, + 64185 + ], + "mapped", + [ + 35519 + ] + ], + [ + [ + 64186, + 64186 + ], + "mapped", + [ + 35576 + ] + ], + [ + [ + 64187, + 64187 + ], + "mapped", + [ + 35531 + ] + ], + [ + [ + 64188, + 64188 + ], + "mapped", + [ + 35585 + ] + ], + [ + [ + 64189, + 64189 + ], + "mapped", + [ + 35582 + ] + ], + [ + [ + 64190, + 64190 + ], + "mapped", + [ + 35565 + ] + ], + [ + [ + 64191, + 64191 + ], + "mapped", + [ + 35641 + ] + ], + [ + [ + 64192, + 64192 + ], + "mapped", + [ + 35722 + ] + ], + [ + [ + 64193, + 64193 + ], + "mapped", + [ + 36104 + ] + ], + [ + [ + 64194, + 64194 + ], + "mapped", + [ + 36664 + ] + ], + [ + [ + 64195, + 64195 + ], + "mapped", + [ + 36978 + ] + ], + [ + [ + 64196, + 64196 + ], + "mapped", + [ + 37273 + ] + ], + [ + [ + 64197, + 64197 + ], + "mapped", + [ + 37494 + ] + ], + [ + [ + 64198, + 64198 + ], + "mapped", + [ + 38524 + ] + ], + [ + [ + 64199, + 64199 + ], + "mapped", + [ + 38627 + ] + ], + [ + [ + 64200, + 64200 + ], + "mapped", + [ + 38742 + ] + ], + [ + [ + 64201, + 64201 + ], + "mapped", + [ + 38875 + ] + ], + [ + [ + 64202, + 64202 + ], + "mapped", + [ + 38911 + ] + ], + [ + [ + 64203, + 64203 + ], + "mapped", + [ + 38923 + ] + ], + [ + [ + 64204, + 64204 + ], + "mapped", + [ + 38971 + ] + ], + [ + [ + 64205, + 64205 + ], + "mapped", + [ + 39698 + ] + ], + [ + [ + 64206, + 64206 + ], + "mapped", + [ + 40860 + ] + ], + [ + [ + 64207, + 64207 + ], + "mapped", + [ + 141386 + ] + ], + [ + [ + 64208, + 64208 + ], + "mapped", + [ + 141380 + ] + ], + [ + [ + 64209, + 64209 + ], + "mapped", + [ + 144341 + ] + ], + [ + [ + 64210, + 64210 + ], + "mapped", + [ + 15261 + ] + ], + [ + [ + 64211, + 64211 + ], + "mapped", + [ + 16408 + ] + ], + [ + [ + 64212, + 64212 + ], + "mapped", + [ + 16441 + ] + ], + [ + [ + 64213, + 64213 + ], + "mapped", + [ + 152137 + ] + ], + [ + [ + 64214, + 64214 + ], + "mapped", + [ + 154832 + ] + ], + [ + [ + 64215, + 64215 + ], + "mapped", + [ + 163539 + ] + ], + [ + [ + 64216, + 64216 + ], + "mapped", + [ + 40771 + ] + ], + [ + [ + 64217, + 64217 + ], + "mapped", + [ + 40846 + ] + ], + [ + [ + 64218, + 64255 + ], + "disallowed" + ], + [ + [ + 64256, + 64256 + ], + "mapped", + [ + 102, + 102 + ] + ], + [ + [ + 64257, + 64257 + ], + "mapped", + [ + 102, + 105 + ] + ], + [ + [ + 64258, + 64258 + ], + "mapped", + [ + 102, + 108 + ] + ], + [ + [ + 64259, + 64259 + ], + "mapped", + [ + 102, + 102, + 105 + ] + ], + [ + [ + 64260, + 64260 + ], + "mapped", + [ + 102, + 102, + 108 + ] + ], + [ + [ + 64261, + 64262 + ], + "mapped", + [ + 115, + 116 + ] + ], + [ + [ + 64263, + 64274 + ], + "disallowed" + ], + [ + [ + 64275, + 64275 + ], + "mapped", + [ + 1396, + 1398 + ] + ], + [ + [ + 64276, + 64276 + ], + "mapped", + [ + 1396, + 1381 + ] + ], + [ + [ + 64277, + 64277 + ], + "mapped", + [ + 1396, + 1387 + ] + ], + [ + [ + 64278, + 64278 + ], + "mapped", + [ + 1406, + 1398 + ] + ], + [ + [ + 64279, + 64279 + ], + "mapped", + [ + 1396, + 1389 + ] + ], + [ + [ + 64280, + 64284 + ], + "disallowed" + ], + [ + [ + 64285, + 64285 + ], + "mapped", + [ + 1497, + 1460 + ] + ], + [ + [ + 64286, + 64286 + ], + "valid" + ], + [ + [ + 64287, + 64287 + ], + "mapped", + [ + 1522, + 1463 + ] + ], + [ + [ + 64288, + 64288 + ], + "mapped", + [ + 1506 + ] + ], + [ + [ + 64289, + 64289 + ], + "mapped", + [ + 1488 + ] + ], + [ + [ + 64290, + 64290 + ], + "mapped", + [ + 1491 + ] + ], + [ + [ + 64291, + 64291 + ], + "mapped", + [ + 1492 + ] + ], + [ + [ + 64292, + 64292 + ], + "mapped", + [ + 1499 + ] + ], + [ + [ + 64293, + 64293 + ], + "mapped", + [ + 1500 + ] + ], + [ + [ + 64294, + 64294 + ], + "mapped", + [ + 1501 + ] + ], + [ + [ + 64295, + 64295 + ], + "mapped", + [ + 1512 + ] + ], + [ + [ + 64296, + 64296 + ], + "mapped", + [ + 1514 + ] + ], + [ + [ + 64297, + 64297 + ], + "disallowed_STD3_mapped", + [ + 43 + ] + ], + [ + [ + 64298, + 64298 + ], + "mapped", + [ + 1513, + 1473 + ] + ], + [ + [ + 64299, + 64299 + ], + "mapped", + [ + 1513, + 1474 + ] + ], + [ + [ + 64300, + 64300 + ], + "mapped", + [ + 1513, + 1468, + 1473 + ] + ], + [ + [ + 64301, + 64301 + ], + "mapped", + [ + 1513, + 1468, + 1474 + ] + ], + [ + [ + 64302, + 64302 + ], + "mapped", + [ + 1488, + 1463 + ] + ], + [ + [ + 64303, + 64303 + ], + "mapped", + [ + 1488, + 1464 + ] + ], + [ + [ + 64304, + 64304 + ], + "mapped", + [ + 1488, + 1468 + ] + ], + [ + [ + 64305, + 64305 + ], + "mapped", + [ + 1489, + 1468 + ] + ], + [ + [ + 64306, + 64306 + ], + "mapped", + [ + 1490, + 1468 + ] + ], + [ + [ + 64307, + 64307 + ], + "mapped", + [ + 1491, + 1468 + ] + ], + [ + [ + 64308, + 64308 + ], + "mapped", + [ + 1492, + 1468 + ] + ], + [ + [ + 64309, + 64309 + ], + "mapped", + [ + 1493, + 1468 + ] + ], + [ + [ + 64310, + 64310 + ], + "mapped", + [ + 1494, + 1468 + ] + ], + [ + [ + 64311, + 64311 + ], + "disallowed" + ], + [ + [ + 64312, + 64312 + ], + "mapped", + [ + 1496, + 1468 + ] + ], + [ + [ + 64313, + 64313 + ], + "mapped", + [ + 1497, + 1468 + ] + ], + [ + [ + 64314, + 64314 + ], + "mapped", + [ + 1498, + 1468 + ] + ], + [ + [ + 64315, + 64315 + ], + "mapped", + [ + 1499, + 1468 + ] + ], + [ + [ + 64316, + 64316 + ], + "mapped", + [ + 1500, + 1468 + ] + ], + [ + [ + 64317, + 64317 + ], + "disallowed" + ], + [ + [ + 64318, + 64318 + ], + "mapped", + [ + 1502, + 1468 + ] + ], + [ + [ + 64319, + 64319 + ], + "disallowed" + ], + [ + [ + 64320, + 64320 + ], + "mapped", + [ + 1504, + 1468 + ] + ], + [ + [ + 64321, + 64321 + ], + "mapped", + [ + 1505, + 1468 + ] + ], + [ + [ + 64322, + 64322 + ], + "disallowed" + ], + [ + [ + 64323, + 64323 + ], + "mapped", + [ + 1507, + 1468 + ] + ], + [ + [ + 64324, + 64324 + ], + "mapped", + [ + 1508, + 1468 + ] + ], + [ + [ + 64325, + 64325 + ], + "disallowed" + ], + [ + [ + 64326, + 64326 + ], + "mapped", + [ + 1510, + 1468 + ] + ], + [ + [ + 64327, + 64327 + ], + "mapped", + [ + 1511, + 1468 + ] + ], + [ + [ + 64328, + 64328 + ], + "mapped", + [ + 1512, + 1468 + ] + ], + [ + [ + 64329, + 64329 + ], + "mapped", + [ + 1513, + 1468 + ] + ], + [ + [ + 64330, + 64330 + ], + "mapped", + [ + 1514, + 1468 + ] + ], + [ + [ + 64331, + 64331 + ], + "mapped", + [ + 1493, + 1465 + ] + ], + [ + [ + 64332, + 64332 + ], + "mapped", + [ + 1489, + 1471 + ] + ], + [ + [ + 64333, + 64333 + ], + "mapped", + [ + 1499, + 1471 + ] + ], + [ + [ + 64334, + 64334 + ], + "mapped", + [ + 1508, + 1471 + ] + ], + [ + [ + 64335, + 64335 + ], + "mapped", + [ + 1488, + 1500 + ] + ], + [ + [ + 64336, + 64337 + ], + "mapped", + [ + 1649 + ] + ], + [ + [ + 64338, + 64341 + ], + "mapped", + [ + 1659 + ] + ], + [ + [ + 64342, + 64345 + ], + "mapped", + [ + 1662 + ] + ], + [ + [ + 64346, + 64349 + ], + "mapped", + [ + 1664 + ] + ], + [ + [ + 64350, + 64353 + ], + "mapped", + [ + 1658 + ] + ], + [ + [ + 64354, + 64357 + ], + "mapped", + [ + 1663 + ] + ], + [ + [ + 64358, + 64361 + ], + "mapped", + [ + 1657 + ] + ], + [ + [ + 64362, + 64365 + ], + "mapped", + [ + 1700 + ] + ], + [ + [ + 64366, + 64369 + ], + "mapped", + [ + 1702 + ] + ], + [ + [ + 64370, + 64373 + ], + "mapped", + [ + 1668 + ] + ], + [ + [ + 64374, + 64377 + ], + "mapped", + [ + 1667 + ] + ], + [ + [ + 64378, + 64381 + ], + "mapped", + [ + 1670 + ] + ], + [ + [ + 64382, + 64385 + ], + "mapped", + [ + 1671 + ] + ], + [ + [ + 64386, + 64387 + ], + "mapped", + [ + 1677 + ] + ], + [ + [ + 64388, + 64389 + ], + "mapped", + [ + 1676 + ] + ], + [ + [ + 64390, + 64391 + ], + "mapped", + [ + 1678 + ] + ], + [ + [ + 64392, + 64393 + ], + "mapped", + [ + 1672 + ] + ], + [ + [ + 64394, + 64395 + ], + "mapped", + [ + 1688 + ] + ], + [ + [ + 64396, + 64397 + ], + "mapped", + [ + 1681 + ] + ], + [ + [ + 64398, + 64401 + ], + "mapped", + [ + 1705 + ] + ], + [ + [ + 64402, + 64405 + ], + "mapped", + [ + 1711 + ] + ], + [ + [ + 64406, + 64409 + ], + "mapped", + [ + 1715 + ] + ], + [ + [ + 64410, + 64413 + ], + "mapped", + [ + 1713 + ] + ], + [ + [ + 64414, + 64415 + ], + "mapped", + [ + 1722 + ] + ], + [ + [ + 64416, + 64419 + ], + "mapped", + [ + 1723 + ] + ], + [ + [ + 64420, + 64421 + ], + "mapped", + [ + 1728 + ] + ], + [ + [ + 64422, + 64425 + ], + "mapped", + [ + 1729 + ] + ], + [ + [ + 64426, + 64429 + ], + "mapped", + [ + 1726 + ] + ], + [ + [ + 64430, + 64431 + ], + "mapped", + [ + 1746 + ] + ], + [ + [ + 64432, + 64433 + ], + "mapped", + [ + 1747 + ] + ], + [ + [ + 64434, + 64449 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 64450, + 64466 + ], + "disallowed" + ], + [ + [ + 64467, + 64470 + ], + "mapped", + [ + 1709 + ] + ], + [ + [ + 64471, + 64472 + ], + "mapped", + [ + 1735 + ] + ], + [ + [ + 64473, + 64474 + ], + "mapped", + [ + 1734 + ] + ], + [ + [ + 64475, + 64476 + ], + "mapped", + [ + 1736 + ] + ], + [ + [ + 64477, + 64477 + ], + "mapped", + [ + 1735, + 1652 + ] + ], + [ + [ + 64478, + 64479 + ], + "mapped", + [ + 1739 + ] + ], + [ + [ + 64480, + 64481 + ], + "mapped", + [ + 1733 + ] + ], + [ + [ + 64482, + 64483 + ], + "mapped", + [ + 1737 + ] + ], + [ + [ + 64484, + 64487 + ], + "mapped", + [ + 1744 + ] + ], + [ + [ + 64488, + 64489 + ], + "mapped", + [ + 1609 + ] + ], + [ + [ + 64490, + 64491 + ], + "mapped", + [ + 1574, + 1575 + ] + ], + [ + [ + 64492, + 64493 + ], + "mapped", + [ + 1574, + 1749 + ] + ], + [ + [ + 64494, + 64495 + ], + "mapped", + [ + 1574, + 1608 + ] + ], + [ + [ + 64496, + 64497 + ], + "mapped", + [ + 1574, + 1735 + ] + ], + [ + [ + 64498, + 64499 + ], + "mapped", + [ + 1574, + 1734 + ] + ], + [ + [ + 64500, + 64501 + ], + "mapped", + [ + 1574, + 1736 + ] + ], + [ + [ + 64502, + 64504 + ], + "mapped", + [ + 1574, + 1744 + ] + ], + [ + [ + 64505, + 64507 + ], + "mapped", + [ + 1574, + 1609 + ] + ], + [ + [ + 64508, + 64511 + ], + "mapped", + [ + 1740 + ] + ], + [ + [ + 64512, + 64512 + ], + "mapped", + [ + 1574, + 1580 + ] + ], + [ + [ + 64513, + 64513 + ], + "mapped", + [ + 1574, + 1581 + ] + ], + [ + [ + 64514, + 64514 + ], + "mapped", + [ + 1574, + 1605 + ] + ], + [ + [ + 64515, + 64515 + ], + "mapped", + [ + 1574, + 1609 + ] + ], + [ + [ + 64516, + 64516 + ], + "mapped", + [ + 1574, + 1610 + ] + ], + [ + [ + 64517, + 64517 + ], + "mapped", + [ + 1576, + 1580 + ] + ], + [ + [ + 64518, + 64518 + ], + "mapped", + [ + 1576, + 1581 + ] + ], + [ + [ + 64519, + 64519 + ], + "mapped", + [ + 1576, + 1582 + ] + ], + [ + [ + 64520, + 64520 + ], + "mapped", + [ + 1576, + 1605 + ] + ], + [ + [ + 64521, + 64521 + ], + "mapped", + [ + 1576, + 1609 + ] + ], + [ + [ + 64522, + 64522 + ], + "mapped", + [ + 1576, + 1610 + ] + ], + [ + [ + 64523, + 64523 + ], + "mapped", + [ + 1578, + 1580 + ] + ], + [ + [ + 64524, + 64524 + ], + "mapped", + [ + 1578, + 1581 + ] + ], + [ + [ + 64525, + 64525 + ], + "mapped", + [ + 1578, + 1582 + ] + ], + [ + [ + 64526, + 64526 + ], + "mapped", + [ + 1578, + 1605 + ] + ], + [ + [ + 64527, + 64527 + ], + "mapped", + [ + 1578, + 1609 + ] + ], + [ + [ + 64528, + 64528 + ], + "mapped", + [ + 1578, + 1610 + ] + ], + [ + [ + 64529, + 64529 + ], + "mapped", + [ + 1579, + 1580 + ] + ], + [ + [ + 64530, + 64530 + ], + "mapped", + [ + 1579, + 1605 + ] + ], + [ + [ + 64531, + 64531 + ], + "mapped", + [ + 1579, + 1609 + ] + ], + [ + [ + 64532, + 64532 + ], + "mapped", + [ + 1579, + 1610 + ] + ], + [ + [ + 64533, + 64533 + ], + "mapped", + [ + 1580, + 1581 + ] + ], + [ + [ + 64534, + 64534 + ], + "mapped", + [ + 1580, + 1605 + ] + ], + [ + [ + 64535, + 64535 + ], + "mapped", + [ + 1581, + 1580 + ] + ], + [ + [ + 64536, + 64536 + ], + "mapped", + [ + 1581, + 1605 + ] + ], + [ + [ + 64537, + 64537 + ], + "mapped", + [ + 1582, + 1580 + ] + ], + [ + [ + 64538, + 64538 + ], + "mapped", + [ + 1582, + 1581 + ] + ], + [ + [ + 64539, + 64539 + ], + "mapped", + [ + 1582, + 1605 + ] + ], + [ + [ + 64540, + 64540 + ], + "mapped", + [ + 1587, + 1580 + ] + ], + [ + [ + 64541, + 64541 + ], + "mapped", + [ + 1587, + 1581 + ] + ], + [ + [ + 64542, + 64542 + ], + "mapped", + [ + 1587, + 1582 + ] + ], + [ + [ + 64543, + 64543 + ], + "mapped", + [ + 1587, + 1605 + ] + ], + [ + [ + 64544, + 64544 + ], + "mapped", + [ + 1589, + 1581 + ] + ], + [ + [ + 64545, + 64545 + ], + "mapped", + [ + 1589, + 1605 + ] + ], + [ + [ + 64546, + 64546 + ], + "mapped", + [ + 1590, + 1580 + ] + ], + [ + [ + 64547, + 64547 + ], + "mapped", + [ + 1590, + 1581 + ] + ], + [ + [ + 64548, + 64548 + ], + "mapped", + [ + 1590, + 1582 + ] + ], + [ + [ + 64549, + 64549 + ], + "mapped", + [ + 1590, + 1605 + ] + ], + [ + [ + 64550, + 64550 + ], + "mapped", + [ + 1591, + 1581 + ] + ], + [ + [ + 64551, + 64551 + ], + "mapped", + [ + 1591, + 1605 + ] + ], + [ + [ + 64552, + 64552 + ], + "mapped", + [ + 1592, + 1605 + ] + ], + [ + [ + 64553, + 64553 + ], + "mapped", + [ + 1593, + 1580 + ] + ], + [ + [ + 64554, + 64554 + ], + "mapped", + [ + 1593, + 1605 + ] + ], + [ + [ + 64555, + 64555 + ], + "mapped", + [ + 1594, + 1580 + ] + ], + [ + [ + 64556, + 64556 + ], + "mapped", + [ + 1594, + 1605 + ] + ], + [ + [ + 64557, + 64557 + ], + "mapped", + [ + 1601, + 1580 + ] + ], + [ + [ + 64558, + 64558 + ], + "mapped", + [ + 1601, + 1581 + ] + ], + [ + [ + 64559, + 64559 + ], + "mapped", + [ + 1601, + 1582 + ] + ], + [ + [ + 64560, + 64560 + ], + "mapped", + [ + 1601, + 1605 + ] + ], + [ + [ + 64561, + 64561 + ], + "mapped", + [ + 1601, + 1609 + ] + ], + [ + [ + 64562, + 64562 + ], + "mapped", + [ + 1601, + 1610 + ] + ], + [ + [ + 64563, + 64563 + ], + "mapped", + [ + 1602, + 1581 + ] + ], + [ + [ + 64564, + 64564 + ], + "mapped", + [ + 1602, + 1605 + ] + ], + [ + [ + 64565, + 64565 + ], + "mapped", + [ + 1602, + 1609 + ] + ], + [ + [ + 64566, + 64566 + ], + "mapped", + [ + 1602, + 1610 + ] + ], + [ + [ + 64567, + 64567 + ], + "mapped", + [ + 1603, + 1575 + ] + ], + [ + [ + 64568, + 64568 + ], + "mapped", + [ + 1603, + 1580 + ] + ], + [ + [ + 64569, + 64569 + ], + "mapped", + [ + 1603, + 1581 + ] + ], + [ + [ + 64570, + 64570 + ], + "mapped", + [ + 1603, + 1582 + ] + ], + [ + [ + 64571, + 64571 + ], + "mapped", + [ + 1603, + 1604 + ] + ], + [ + [ + 64572, + 64572 + ], + "mapped", + [ + 1603, + 1605 + ] + ], + [ + [ + 64573, + 64573 + ], + "mapped", + [ + 1603, + 1609 + ] + ], + [ + [ + 64574, + 64574 + ], + "mapped", + [ + 1603, + 1610 + ] + ], + [ + [ + 64575, + 64575 + ], + "mapped", + [ + 1604, + 1580 + ] + ], + [ + [ + 64576, + 64576 + ], + "mapped", + [ + 1604, + 1581 + ] + ], + [ + [ + 64577, + 64577 + ], + "mapped", + [ + 1604, + 1582 + ] + ], + [ + [ + 64578, + 64578 + ], + "mapped", + [ + 1604, + 1605 + ] + ], + [ + [ + 64579, + 64579 + ], + "mapped", + [ + 1604, + 1609 + ] + ], + [ + [ + 64580, + 64580 + ], + "mapped", + [ + 1604, + 1610 + ] + ], + [ + [ + 64581, + 64581 + ], + "mapped", + [ + 1605, + 1580 + ] + ], + [ + [ + 64582, + 64582 + ], + "mapped", + [ + 1605, + 1581 + ] + ], + [ + [ + 64583, + 64583 + ], + "mapped", + [ + 1605, + 1582 + ] + ], + [ + [ + 64584, + 64584 + ], + "mapped", + [ + 1605, + 1605 + ] + ], + [ + [ + 64585, + 64585 + ], + "mapped", + [ + 1605, + 1609 + ] + ], + [ + [ + 64586, + 64586 + ], + "mapped", + [ + 1605, + 1610 + ] + ], + [ + [ + 64587, + 64587 + ], + "mapped", + [ + 1606, + 1580 + ] + ], + [ + [ + 64588, + 64588 + ], + "mapped", + [ + 1606, + 1581 + ] + ], + [ + [ + 64589, + 64589 + ], + "mapped", + [ + 1606, + 1582 + ] + ], + [ + [ + 64590, + 64590 + ], + "mapped", + [ + 1606, + 1605 + ] + ], + [ + [ + 64591, + 64591 + ], + "mapped", + [ + 1606, + 1609 + ] + ], + [ + [ + 64592, + 64592 + ], + "mapped", + [ + 1606, + 1610 + ] + ], + [ + [ + 64593, + 64593 + ], + "mapped", + [ + 1607, + 1580 + ] + ], + [ + [ + 64594, + 64594 + ], + "mapped", + [ + 1607, + 1605 + ] + ], + [ + [ + 64595, + 64595 + ], + "mapped", + [ + 1607, + 1609 + ] + ], + [ + [ + 64596, + 64596 + ], + "mapped", + [ + 1607, + 1610 + ] + ], + [ + [ + 64597, + 64597 + ], + "mapped", + [ + 1610, + 1580 + ] + ], + [ + [ + 64598, + 64598 + ], + "mapped", + [ + 1610, + 1581 + ] + ], + [ + [ + 64599, + 64599 + ], + "mapped", + [ + 1610, + 1582 + ] + ], + [ + [ + 64600, + 64600 + ], + "mapped", + [ + 1610, + 1605 + ] + ], + [ + [ + 64601, + 64601 + ], + "mapped", + [ + 1610, + 1609 + ] + ], + [ + [ + 64602, + 64602 + ], + "mapped", + [ + 1610, + 1610 + ] + ], + [ + [ + 64603, + 64603 + ], + "mapped", + [ + 1584, + 1648 + ] + ], + [ + [ + 64604, + 64604 + ], + "mapped", + [ + 1585, + 1648 + ] + ], + [ + [ + 64605, + 64605 + ], + "mapped", + [ + 1609, + 1648 + ] + ], + [ + [ + 64606, + 64606 + ], + "disallowed_STD3_mapped", + [ + 32, + 1612, + 1617 + ] + ], + [ + [ + 64607, + 64607 + ], + "disallowed_STD3_mapped", + [ + 32, + 1613, + 1617 + ] + ], + [ + [ + 64608, + 64608 + ], + "disallowed_STD3_mapped", + [ + 32, + 1614, + 1617 + ] + ], + [ + [ + 64609, + 64609 + ], + "disallowed_STD3_mapped", + [ + 32, + 1615, + 1617 + ] + ], + [ + [ + 64610, + 64610 + ], + "disallowed_STD3_mapped", + [ + 32, + 1616, + 1617 + ] + ], + [ + [ + 64611, + 64611 + ], + "disallowed_STD3_mapped", + [ + 32, + 1617, + 1648 + ] + ], + [ + [ + 64612, + 64612 + ], + "mapped", + [ + 1574, + 1585 + ] + ], + [ + [ + 64613, + 64613 + ], + "mapped", + [ + 1574, + 1586 + ] + ], + [ + [ + 64614, + 64614 + ], + "mapped", + [ + 1574, + 1605 + ] + ], + [ + [ + 64615, + 64615 + ], + "mapped", + [ + 1574, + 1606 + ] + ], + [ + [ + 64616, + 64616 + ], + "mapped", + [ + 1574, + 1609 + ] + ], + [ + [ + 64617, + 64617 + ], + "mapped", + [ + 1574, + 1610 + ] + ], + [ + [ + 64618, + 64618 + ], + "mapped", + [ + 1576, + 1585 + ] + ], + [ + [ + 64619, + 64619 + ], + "mapped", + [ + 1576, + 1586 + ] + ], + [ + [ + 64620, + 64620 + ], + "mapped", + [ + 1576, + 1605 + ] + ], + [ + [ + 64621, + 64621 + ], + "mapped", + [ + 1576, + 1606 + ] + ], + [ + [ + 64622, + 64622 + ], + "mapped", + [ + 1576, + 1609 + ] + ], + [ + [ + 64623, + 64623 + ], + "mapped", + [ + 1576, + 1610 + ] + ], + [ + [ + 64624, + 64624 + ], + "mapped", + [ + 1578, + 1585 + ] + ], + [ + [ + 64625, + 64625 + ], + "mapped", + [ + 1578, + 1586 + ] + ], + [ + [ + 64626, + 64626 + ], + "mapped", + [ + 1578, + 1605 + ] + ], + [ + [ + 64627, + 64627 + ], + "mapped", + [ + 1578, + 1606 + ] + ], + [ + [ + 64628, + 64628 + ], + "mapped", + [ + 1578, + 1609 + ] + ], + [ + [ + 64629, + 64629 + ], + "mapped", + [ + 1578, + 1610 + ] + ], + [ + [ + 64630, + 64630 + ], + "mapped", + [ + 1579, + 1585 + ] + ], + [ + [ + 64631, + 64631 + ], + "mapped", + [ + 1579, + 1586 + ] + ], + [ + [ + 64632, + 64632 + ], + "mapped", + [ + 1579, + 1605 + ] + ], + [ + [ + 64633, + 64633 + ], + "mapped", + [ + 1579, + 1606 + ] + ], + [ + [ + 64634, + 64634 + ], + "mapped", + [ + 1579, + 1609 + ] + ], + [ + [ + 64635, + 64635 + ], + "mapped", + [ + 1579, + 1610 + ] + ], + [ + [ + 64636, + 64636 + ], + "mapped", + [ + 1601, + 1609 + ] + ], + [ + [ + 64637, + 64637 + ], + "mapped", + [ + 1601, + 1610 + ] + ], + [ + [ + 64638, + 64638 + ], + "mapped", + [ + 1602, + 1609 + ] + ], + [ + [ + 64639, + 64639 + ], + "mapped", + [ + 1602, + 1610 + ] + ], + [ + [ + 64640, + 64640 + ], + "mapped", + [ + 1603, + 1575 + ] + ], + [ + [ + 64641, + 64641 + ], + "mapped", + [ + 1603, + 1604 + ] + ], + [ + [ + 64642, + 64642 + ], + "mapped", + [ + 1603, + 1605 + ] + ], + [ + [ + 64643, + 64643 + ], + "mapped", + [ + 1603, + 1609 + ] + ], + [ + [ + 64644, + 64644 + ], + "mapped", + [ + 1603, + 1610 + ] + ], + [ + [ + 64645, + 64645 + ], + "mapped", + [ + 1604, + 1605 + ] + ], + [ + [ + 64646, + 64646 + ], + "mapped", + [ + 1604, + 1609 + ] + ], + [ + [ + 64647, + 64647 + ], + "mapped", + [ + 1604, + 1610 + ] + ], + [ + [ + 64648, + 64648 + ], + "mapped", + [ + 1605, + 1575 + ] + ], + [ + [ + 64649, + 64649 + ], + "mapped", + [ + 1605, + 1605 + ] + ], + [ + [ + 64650, + 64650 + ], + "mapped", + [ + 1606, + 1585 + ] + ], + [ + [ + 64651, + 64651 + ], + "mapped", + [ + 1606, + 1586 + ] + ], + [ + [ + 64652, + 64652 + ], + "mapped", + [ + 1606, + 1605 + ] + ], + [ + [ + 64653, + 64653 + ], + "mapped", + [ + 1606, + 1606 + ] + ], + [ + [ + 64654, + 64654 + ], + "mapped", + [ + 1606, + 1609 + ] + ], + [ + [ + 64655, + 64655 + ], + "mapped", + [ + 1606, + 1610 + ] + ], + [ + [ + 64656, + 64656 + ], + "mapped", + [ + 1609, + 1648 + ] + ], + [ + [ + 64657, + 64657 + ], + "mapped", + [ + 1610, + 1585 + ] + ], + [ + [ + 64658, + 64658 + ], + "mapped", + [ + 1610, + 1586 + ] + ], + [ + [ + 64659, + 64659 + ], + "mapped", + [ + 1610, + 1605 + ] + ], + [ + [ + 64660, + 64660 + ], + "mapped", + [ + 1610, + 1606 + ] + ], + [ + [ + 64661, + 64661 + ], + "mapped", + [ + 1610, + 1609 + ] + ], + [ + [ + 64662, + 64662 + ], + "mapped", + [ + 1610, + 1610 + ] + ], + [ + [ + 64663, + 64663 + ], + "mapped", + [ + 1574, + 1580 + ] + ], + [ + [ + 64664, + 64664 + ], + "mapped", + [ + 1574, + 1581 + ] + ], + [ + [ + 64665, + 64665 + ], + "mapped", + [ + 1574, + 1582 + ] + ], + [ + [ + 64666, + 64666 + ], + "mapped", + [ + 1574, + 1605 + ] + ], + [ + [ + 64667, + 64667 + ], + "mapped", + [ + 1574, + 1607 + ] + ], + [ + [ + 64668, + 64668 + ], + "mapped", + [ + 1576, + 1580 + ] + ], + [ + [ + 64669, + 64669 + ], + "mapped", + [ + 1576, + 1581 + ] + ], + [ + [ + 64670, + 64670 + ], + "mapped", + [ + 1576, + 1582 + ] + ], + [ + [ + 64671, + 64671 + ], + "mapped", + [ + 1576, + 1605 + ] + ], + [ + [ + 64672, + 64672 + ], + "mapped", + [ + 1576, + 1607 + ] + ], + [ + [ + 64673, + 64673 + ], + "mapped", + [ + 1578, + 1580 + ] + ], + [ + [ + 64674, + 64674 + ], + "mapped", + [ + 1578, + 1581 + ] + ], + [ + [ + 64675, + 64675 + ], + "mapped", + [ + 1578, + 1582 + ] + ], + [ + [ + 64676, + 64676 + ], + "mapped", + [ + 1578, + 1605 + ] + ], + [ + [ + 64677, + 64677 + ], + "mapped", + [ + 1578, + 1607 + ] + ], + [ + [ + 64678, + 64678 + ], + "mapped", + [ + 1579, + 1605 + ] + ], + [ + [ + 64679, + 64679 + ], + "mapped", + [ + 1580, + 1581 + ] + ], + [ + [ + 64680, + 64680 + ], + "mapped", + [ + 1580, + 1605 + ] + ], + [ + [ + 64681, + 64681 + ], + "mapped", + [ + 1581, + 1580 + ] + ], + [ + [ + 64682, + 64682 + ], + "mapped", + [ + 1581, + 1605 + ] + ], + [ + [ + 64683, + 64683 + ], + "mapped", + [ + 1582, + 1580 + ] + ], + [ + [ + 64684, + 64684 + ], + "mapped", + [ + 1582, + 1605 + ] + ], + [ + [ + 64685, + 64685 + ], + "mapped", + [ + 1587, + 1580 + ] + ], + [ + [ + 64686, + 64686 + ], + "mapped", + [ + 1587, + 1581 + ] + ], + [ + [ + 64687, + 64687 + ], + "mapped", + [ + 1587, + 1582 + ] + ], + [ + [ + 64688, + 64688 + ], + "mapped", + [ + 1587, + 1605 + ] + ], + [ + [ + 64689, + 64689 + ], + "mapped", + [ + 1589, + 1581 + ] + ], + [ + [ + 64690, + 64690 + ], + "mapped", + [ + 1589, + 1582 + ] + ], + [ + [ + 64691, + 64691 + ], + "mapped", + [ + 1589, + 1605 + ] + ], + [ + [ + 64692, + 64692 + ], + "mapped", + [ + 1590, + 1580 + ] + ], + [ + [ + 64693, + 64693 + ], + "mapped", + [ + 1590, + 1581 + ] + ], + [ + [ + 64694, + 64694 + ], + "mapped", + [ + 1590, + 1582 + ] + ], + [ + [ + 64695, + 64695 + ], + "mapped", + [ + 1590, + 1605 + ] + ], + [ + [ + 64696, + 64696 + ], + "mapped", + [ + 1591, + 1581 + ] + ], + [ + [ + 64697, + 64697 + ], + "mapped", + [ + 1592, + 1605 + ] + ], + [ + [ + 64698, + 64698 + ], + "mapped", + [ + 1593, + 1580 + ] + ], + [ + [ + 64699, + 64699 + ], + "mapped", + [ + 1593, + 1605 + ] + ], + [ + [ + 64700, + 64700 + ], + "mapped", + [ + 1594, + 1580 + ] + ], + [ + [ + 64701, + 64701 + ], + "mapped", + [ + 1594, + 1605 + ] + ], + [ + [ + 64702, + 64702 + ], + "mapped", + [ + 1601, + 1580 + ] + ], + [ + [ + 64703, + 64703 + ], + "mapped", + [ + 1601, + 1581 + ] + ], + [ + [ + 64704, + 64704 + ], + "mapped", + [ + 1601, + 1582 + ] + ], + [ + [ + 64705, + 64705 + ], + "mapped", + [ + 1601, + 1605 + ] + ], + [ + [ + 64706, + 64706 + ], + "mapped", + [ + 1602, + 1581 + ] + ], + [ + [ + 64707, + 64707 + ], + "mapped", + [ + 1602, + 1605 + ] + ], + [ + [ + 64708, + 64708 + ], + "mapped", + [ + 1603, + 1580 + ] + ], + [ + [ + 64709, + 64709 + ], + "mapped", + [ + 1603, + 1581 + ] + ], + [ + [ + 64710, + 64710 + ], + "mapped", + [ + 1603, + 1582 + ] + ], + [ + [ + 64711, + 64711 + ], + "mapped", + [ + 1603, + 1604 + ] + ], + [ + [ + 64712, + 64712 + ], + "mapped", + [ + 1603, + 1605 + ] + ], + [ + [ + 64713, + 64713 + ], + "mapped", + [ + 1604, + 1580 + ] + ], + [ + [ + 64714, + 64714 + ], + "mapped", + [ + 1604, + 1581 + ] + ], + [ + [ + 64715, + 64715 + ], + "mapped", + [ + 1604, + 1582 + ] + ], + [ + [ + 64716, + 64716 + ], + "mapped", + [ + 1604, + 1605 + ] + ], + [ + [ + 64717, + 64717 + ], + "mapped", + [ + 1604, + 1607 + ] + ], + [ + [ + 64718, + 64718 + ], + "mapped", + [ + 1605, + 1580 + ] + ], + [ + [ + 64719, + 64719 + ], + "mapped", + [ + 1605, + 1581 + ] + ], + [ + [ + 64720, + 64720 + ], + "mapped", + [ + 1605, + 1582 + ] + ], + [ + [ + 64721, + 64721 + ], + "mapped", + [ + 1605, + 1605 + ] + ], + [ + [ + 64722, + 64722 + ], + "mapped", + [ + 1606, + 1580 + ] + ], + [ + [ + 64723, + 64723 + ], + "mapped", + [ + 1606, + 1581 + ] + ], + [ + [ + 64724, + 64724 + ], + "mapped", + [ + 1606, + 1582 + ] + ], + [ + [ + 64725, + 64725 + ], + "mapped", + [ + 1606, + 1605 + ] + ], + [ + [ + 64726, + 64726 + ], + "mapped", + [ + 1606, + 1607 + ] + ], + [ + [ + 64727, + 64727 + ], + "mapped", + [ + 1607, + 1580 + ] + ], + [ + [ + 64728, + 64728 + ], + "mapped", + [ + 1607, + 1605 + ] + ], + [ + [ + 64729, + 64729 + ], + "mapped", + [ + 1607, + 1648 + ] + ], + [ + [ + 64730, + 64730 + ], + "mapped", + [ + 1610, + 1580 + ] + ], + [ + [ + 64731, + 64731 + ], + "mapped", + [ + 1610, + 1581 + ] + ], + [ + [ + 64732, + 64732 + ], + "mapped", + [ + 1610, + 1582 + ] + ], + [ + [ + 64733, + 64733 + ], + "mapped", + [ + 1610, + 1605 + ] + ], + [ + [ + 64734, + 64734 + ], + "mapped", + [ + 1610, + 1607 + ] + ], + [ + [ + 64735, + 64735 + ], + "mapped", + [ + 1574, + 1605 + ] + ], + [ + [ + 64736, + 64736 + ], + "mapped", + [ + 1574, + 1607 + ] + ], + [ + [ + 64737, + 64737 + ], + "mapped", + [ + 1576, + 1605 + ] + ], + [ + [ + 64738, + 64738 + ], + "mapped", + [ + 1576, + 1607 + ] + ], + [ + [ + 64739, + 64739 + ], + "mapped", + [ + 1578, + 1605 + ] + ], + [ + [ + 64740, + 64740 + ], + "mapped", + [ + 1578, + 1607 + ] + ], + [ + [ + 64741, + 64741 + ], + "mapped", + [ + 1579, + 1605 + ] + ], + [ + [ + 64742, + 64742 + ], + "mapped", + [ + 1579, + 1607 + ] + ], + [ + [ + 64743, + 64743 + ], + "mapped", + [ + 1587, + 1605 + ] + ], + [ + [ + 64744, + 64744 + ], + "mapped", + [ + 1587, + 1607 + ] + ], + [ + [ + 64745, + 64745 + ], + "mapped", + [ + 1588, + 1605 + ] + ], + [ + [ + 64746, + 64746 + ], + "mapped", + [ + 1588, + 1607 + ] + ], + [ + [ + 64747, + 64747 + ], + "mapped", + [ + 1603, + 1604 + ] + ], + [ + [ + 64748, + 64748 + ], + "mapped", + [ + 1603, + 1605 + ] + ], + [ + [ + 64749, + 64749 + ], + "mapped", + [ + 1604, + 1605 + ] + ], + [ + [ + 64750, + 64750 + ], + "mapped", + [ + 1606, + 1605 + ] + ], + [ + [ + 64751, + 64751 + ], + "mapped", + [ + 1606, + 1607 + ] + ], + [ + [ + 64752, + 64752 + ], + "mapped", + [ + 1610, + 1605 + ] + ], + [ + [ + 64753, + 64753 + ], + "mapped", + [ + 1610, + 1607 + ] + ], + [ + [ + 64754, + 64754 + ], + "mapped", + [ + 1600, + 1614, + 1617 + ] + ], + [ + [ + 64755, + 64755 + ], + "mapped", + [ + 1600, + 1615, + 1617 + ] + ], + [ + [ + 64756, + 64756 + ], + "mapped", + [ + 1600, + 1616, + 1617 + ] + ], + [ + [ + 64757, + 64757 + ], + "mapped", + [ + 1591, + 1609 + ] + ], + [ + [ + 64758, + 64758 + ], + "mapped", + [ + 1591, + 1610 + ] + ], + [ + [ + 64759, + 64759 + ], + "mapped", + [ + 1593, + 1609 + ] + ], + [ + [ + 64760, + 64760 + ], + "mapped", + [ + 1593, + 1610 + ] + ], + [ + [ + 64761, + 64761 + ], + "mapped", + [ + 1594, + 1609 + ] + ], + [ + [ + 64762, + 64762 + ], + "mapped", + [ + 1594, + 1610 + ] + ], + [ + [ + 64763, + 64763 + ], + "mapped", + [ + 1587, + 1609 + ] + ], + [ + [ + 64764, + 64764 + ], + "mapped", + [ + 1587, + 1610 + ] + ], + [ + [ + 64765, + 64765 + ], + "mapped", + [ + 1588, + 1609 + ] + ], + [ + [ + 64766, + 64766 + ], + "mapped", + [ + 1588, + 1610 + ] + ], + [ + [ + 64767, + 64767 + ], + "mapped", + [ + 1581, + 1609 + ] + ], + [ + [ + 64768, + 64768 + ], + "mapped", + [ + 1581, + 1610 + ] + ], + [ + [ + 64769, + 64769 + ], + "mapped", + [ + 1580, + 1609 + ] + ], + [ + [ + 64770, + 64770 + ], + "mapped", + [ + 1580, + 1610 + ] + ], + [ + [ + 64771, + 64771 + ], + "mapped", + [ + 1582, + 1609 + ] + ], + [ + [ + 64772, + 64772 + ], + "mapped", + [ + 1582, + 1610 + ] + ], + [ + [ + 64773, + 64773 + ], + "mapped", + [ + 1589, + 1609 + ] + ], + [ + [ + 64774, + 64774 + ], + "mapped", + [ + 1589, + 1610 + ] + ], + [ + [ + 64775, + 64775 + ], + "mapped", + [ + 1590, + 1609 + ] + ], + [ + [ + 64776, + 64776 + ], + "mapped", + [ + 1590, + 1610 + ] + ], + [ + [ + 64777, + 64777 + ], + "mapped", + [ + 1588, + 1580 + ] + ], + [ + [ + 64778, + 64778 + ], + "mapped", + [ + 1588, + 1581 + ] + ], + [ + [ + 64779, + 64779 + ], + "mapped", + [ + 1588, + 1582 + ] + ], + [ + [ + 64780, + 64780 + ], + "mapped", + [ + 1588, + 1605 + ] + ], + [ + [ + 64781, + 64781 + ], + "mapped", + [ + 1588, + 1585 + ] + ], + [ + [ + 64782, + 64782 + ], + "mapped", + [ + 1587, + 1585 + ] + ], + [ + [ + 64783, + 64783 + ], + "mapped", + [ + 1589, + 1585 + ] + ], + [ + [ + 64784, + 64784 + ], + "mapped", + [ + 1590, + 1585 + ] + ], + [ + [ + 64785, + 64785 + ], + "mapped", + [ + 1591, + 1609 + ] + ], + [ + [ + 64786, + 64786 + ], + "mapped", + [ + 1591, + 1610 + ] + ], + [ + [ + 64787, + 64787 + ], + "mapped", + [ + 1593, + 1609 + ] + ], + [ + [ + 64788, + 64788 + ], + "mapped", + [ + 1593, + 1610 + ] + ], + [ + [ + 64789, + 64789 + ], + "mapped", + [ + 1594, + 1609 + ] + ], + [ + [ + 64790, + 64790 + ], + "mapped", + [ + 1594, + 1610 + ] + ], + [ + [ + 64791, + 64791 + ], + "mapped", + [ + 1587, + 1609 + ] + ], + [ + [ + 64792, + 64792 + ], + "mapped", + [ + 1587, + 1610 + ] + ], + [ + [ + 64793, + 64793 + ], + "mapped", + [ + 1588, + 1609 + ] + ], + [ + [ + 64794, + 64794 + ], + "mapped", + [ + 1588, + 1610 + ] + ], + [ + [ + 64795, + 64795 + ], + "mapped", + [ + 1581, + 1609 + ] + ], + [ + [ + 64796, + 64796 + ], + "mapped", + [ + 1581, + 1610 + ] + ], + [ + [ + 64797, + 64797 + ], + "mapped", + [ + 1580, + 1609 + ] + ], + [ + [ + 64798, + 64798 + ], + "mapped", + [ + 1580, + 1610 + ] + ], + [ + [ + 64799, + 64799 + ], + "mapped", + [ + 1582, + 1609 + ] + ], + [ + [ + 64800, + 64800 + ], + "mapped", + [ + 1582, + 1610 + ] + ], + [ + [ + 64801, + 64801 + ], + "mapped", + [ + 1589, + 1609 + ] + ], + [ + [ + 64802, + 64802 + ], + "mapped", + [ + 1589, + 1610 + ] + ], + [ + [ + 64803, + 64803 + ], + "mapped", + [ + 1590, + 1609 + ] + ], + [ + [ + 64804, + 64804 + ], + "mapped", + [ + 1590, + 1610 + ] + ], + [ + [ + 64805, + 64805 + ], + "mapped", + [ + 1588, + 1580 + ] + ], + [ + [ + 64806, + 64806 + ], + "mapped", + [ + 1588, + 1581 + ] + ], + [ + [ + 64807, + 64807 + ], + "mapped", + [ + 1588, + 1582 + ] + ], + [ + [ + 64808, + 64808 + ], + "mapped", + [ + 1588, + 1605 + ] + ], + [ + [ + 64809, + 64809 + ], + "mapped", + [ + 1588, + 1585 + ] + ], + [ + [ + 64810, + 64810 + ], + "mapped", + [ + 1587, + 1585 + ] + ], + [ + [ + 64811, + 64811 + ], + "mapped", + [ + 1589, + 1585 + ] + ], + [ + [ + 64812, + 64812 + ], + "mapped", + [ + 1590, + 1585 + ] + ], + [ + [ + 64813, + 64813 + ], + "mapped", + [ + 1588, + 1580 + ] + ], + [ + [ + 64814, + 64814 + ], + "mapped", + [ + 1588, + 1581 + ] + ], + [ + [ + 64815, + 64815 + ], + "mapped", + [ + 1588, + 1582 + ] + ], + [ + [ + 64816, + 64816 + ], + "mapped", + [ + 1588, + 1605 + ] + ], + [ + [ + 64817, + 64817 + ], + "mapped", + [ + 1587, + 1607 + ] + ], + [ + [ + 64818, + 64818 + ], + "mapped", + [ + 1588, + 1607 + ] + ], + [ + [ + 64819, + 64819 + ], + "mapped", + [ + 1591, + 1605 + ] + ], + [ + [ + 64820, + 64820 + ], + "mapped", + [ + 1587, + 1580 + ] + ], + [ + [ + 64821, + 64821 + ], + "mapped", + [ + 1587, + 1581 + ] + ], + [ + [ + 64822, + 64822 + ], + "mapped", + [ + 1587, + 1582 + ] + ], + [ + [ + 64823, + 64823 + ], + "mapped", + [ + 1588, + 1580 + ] + ], + [ + [ + 64824, + 64824 + ], + "mapped", + [ + 1588, + 1581 + ] + ], + [ + [ + 64825, + 64825 + ], + "mapped", + [ + 1588, + 1582 + ] + ], + [ + [ + 64826, + 64826 + ], + "mapped", + [ + 1591, + 1605 + ] + ], + [ + [ + 64827, + 64827 + ], + "mapped", + [ + 1592, + 1605 + ] + ], + [ + [ + 64828, + 64829 + ], + "mapped", + [ + 1575, + 1611 + ] + ], + [ + [ + 64830, + 64831 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 64832, + 64847 + ], + "disallowed" + ], + [ + [ + 64848, + 64848 + ], + "mapped", + [ + 1578, + 1580, + 1605 + ] + ], + [ + [ + 64849, + 64850 + ], + "mapped", + [ + 1578, + 1581, + 1580 + ] + ], + [ + [ + 64851, + 64851 + ], + "mapped", + [ + 1578, + 1581, + 1605 + ] + ], + [ + [ + 64852, + 64852 + ], + "mapped", + [ + 1578, + 1582, + 1605 + ] + ], + [ + [ + 64853, + 64853 + ], + "mapped", + [ + 1578, + 1605, + 1580 + ] + ], + [ + [ + 64854, + 64854 + ], + "mapped", + [ + 1578, + 1605, + 1581 + ] + ], + [ + [ + 64855, + 64855 + ], + "mapped", + [ + 1578, + 1605, + 1582 + ] + ], + [ + [ + 64856, + 64857 + ], + "mapped", + [ + 1580, + 1605, + 1581 + ] + ], + [ + [ + 64858, + 64858 + ], + "mapped", + [ + 1581, + 1605, + 1610 + ] + ], + [ + [ + 64859, + 64859 + ], + "mapped", + [ + 1581, + 1605, + 1609 + ] + ], + [ + [ + 64860, + 64860 + ], + "mapped", + [ + 1587, + 1581, + 1580 + ] + ], + [ + [ + 64861, + 64861 + ], + "mapped", + [ + 1587, + 1580, + 1581 + ] + ], + [ + [ + 64862, + 64862 + ], + "mapped", + [ + 1587, + 1580, + 1609 + ] + ], + [ + [ + 64863, + 64864 + ], + "mapped", + [ + 1587, + 1605, + 1581 + ] + ], + [ + [ + 64865, + 64865 + ], + "mapped", + [ + 1587, + 1605, + 1580 + ] + ], + [ + [ + 64866, + 64867 + ], + "mapped", + [ + 1587, + 1605, + 1605 + ] + ], + [ + [ + 64868, + 64869 + ], + "mapped", + [ + 1589, + 1581, + 1581 + ] + ], + [ + [ + 64870, + 64870 + ], + "mapped", + [ + 1589, + 1605, + 1605 + ] + ], + [ + [ + 64871, + 64872 + ], + "mapped", + [ + 1588, + 1581, + 1605 + ] + ], + [ + [ + 64873, + 64873 + ], + "mapped", + [ + 1588, + 1580, + 1610 + ] + ], + [ + [ + 64874, + 64875 + ], + "mapped", + [ + 1588, + 1605, + 1582 + ] + ], + [ + [ + 64876, + 64877 + ], + "mapped", + [ + 1588, + 1605, + 1605 + ] + ], + [ + [ + 64878, + 64878 + ], + "mapped", + [ + 1590, + 1581, + 1609 + ] + ], + [ + [ + 64879, + 64880 + ], + "mapped", + [ + 1590, + 1582, + 1605 + ] + ], + [ + [ + 64881, + 64882 + ], + "mapped", + [ + 1591, + 1605, + 1581 + ] + ], + [ + [ + 64883, + 64883 + ], + "mapped", + [ + 1591, + 1605, + 1605 + ] + ], + [ + [ + 64884, + 64884 + ], + "mapped", + [ + 1591, + 1605, + 1610 + ] + ], + [ + [ + 64885, + 64885 + ], + "mapped", + [ + 1593, + 1580, + 1605 + ] + ], + [ + [ + 64886, + 64887 + ], + "mapped", + [ + 1593, + 1605, + 1605 + ] + ], + [ + [ + 64888, + 64888 + ], + "mapped", + [ + 1593, + 1605, + 1609 + ] + ], + [ + [ + 64889, + 64889 + ], + "mapped", + [ + 1594, + 1605, + 1605 + ] + ], + [ + [ + 64890, + 64890 + ], + "mapped", + [ + 1594, + 1605, + 1610 + ] + ], + [ + [ + 64891, + 64891 + ], + "mapped", + [ + 1594, + 1605, + 1609 + ] + ], + [ + [ + 64892, + 64893 + ], + "mapped", + [ + 1601, + 1582, + 1605 + ] + ], + [ + [ + 64894, + 64894 + ], + "mapped", + [ + 1602, + 1605, + 1581 + ] + ], + [ + [ + 64895, + 64895 + ], + "mapped", + [ + 1602, + 1605, + 1605 + ] + ], + [ + [ + 64896, + 64896 + ], + "mapped", + [ + 1604, + 1581, + 1605 + ] + ], + [ + [ + 64897, + 64897 + ], + "mapped", + [ + 1604, + 1581, + 1610 + ] + ], + [ + [ + 64898, + 64898 + ], + "mapped", + [ + 1604, + 1581, + 1609 + ] + ], + [ + [ + 64899, + 64900 + ], + "mapped", + [ + 1604, + 1580, + 1580 + ] + ], + [ + [ + 64901, + 64902 + ], + "mapped", + [ + 1604, + 1582, + 1605 + ] + ], + [ + [ + 64903, + 64904 + ], + "mapped", + [ + 1604, + 1605, + 1581 + ] + ], + [ + [ + 64905, + 64905 + ], + "mapped", + [ + 1605, + 1581, + 1580 + ] + ], + [ + [ + 64906, + 64906 + ], + "mapped", + [ + 1605, + 1581, + 1605 + ] + ], + [ + [ + 64907, + 64907 + ], + "mapped", + [ + 1605, + 1581, + 1610 + ] + ], + [ + [ + 64908, + 64908 + ], + "mapped", + [ + 1605, + 1580, + 1581 + ] + ], + [ + [ + 64909, + 64909 + ], + "mapped", + [ + 1605, + 1580, + 1605 + ] + ], + [ + [ + 64910, + 64910 + ], + "mapped", + [ + 1605, + 1582, + 1580 + ] + ], + [ + [ + 64911, + 64911 + ], + "mapped", + [ + 1605, + 1582, + 1605 + ] + ], + [ + [ + 64912, + 64913 + ], + "disallowed" + ], + [ + [ + 64914, + 64914 + ], + "mapped", + [ + 1605, + 1580, + 1582 + ] + ], + [ + [ + 64915, + 64915 + ], + "mapped", + [ + 1607, + 1605, + 1580 + ] + ], + [ + [ + 64916, + 64916 + ], + "mapped", + [ + 1607, + 1605, + 1605 + ] + ], + [ + [ + 64917, + 64917 + ], + "mapped", + [ + 1606, + 1581, + 1605 + ] + ], + [ + [ + 64918, + 64918 + ], + "mapped", + [ + 1606, + 1581, + 1609 + ] + ], + [ + [ + 64919, + 64920 + ], + "mapped", + [ + 1606, + 1580, + 1605 + ] + ], + [ + [ + 64921, + 64921 + ], + "mapped", + [ + 1606, + 1580, + 1609 + ] + ], + [ + [ + 64922, + 64922 + ], + "mapped", + [ + 1606, + 1605, + 1610 + ] + ], + [ + [ + 64923, + 64923 + ], + "mapped", + [ + 1606, + 1605, + 1609 + ] + ], + [ + [ + 64924, + 64925 + ], + "mapped", + [ + 1610, + 1605, + 1605 + ] + ], + [ + [ + 64926, + 64926 + ], + "mapped", + [ + 1576, + 1582, + 1610 + ] + ], + [ + [ + 64927, + 64927 + ], + "mapped", + [ + 1578, + 1580, + 1610 + ] + ], + [ + [ + 64928, + 64928 + ], + "mapped", + [ + 1578, + 1580, + 1609 + ] + ], + [ + [ + 64929, + 64929 + ], + "mapped", + [ + 1578, + 1582, + 1610 + ] + ], + [ + [ + 64930, + 64930 + ], + "mapped", + [ + 1578, + 1582, + 1609 + ] + ], + [ + [ + 64931, + 64931 + ], + "mapped", + [ + 1578, + 1605, + 1610 + ] + ], + [ + [ + 64932, + 64932 + ], + "mapped", + [ + 1578, + 1605, + 1609 + ] + ], + [ + [ + 64933, + 64933 + ], + "mapped", + [ + 1580, + 1605, + 1610 + ] + ], + [ + [ + 64934, + 64934 + ], + "mapped", + [ + 1580, + 1581, + 1609 + ] + ], + [ + [ + 64935, + 64935 + ], + "mapped", + [ + 1580, + 1605, + 1609 + ] + ], + [ + [ + 64936, + 64936 + ], + "mapped", + [ + 1587, + 1582, + 1609 + ] + ], + [ + [ + 64937, + 64937 + ], + "mapped", + [ + 1589, + 1581, + 1610 + ] + ], + [ + [ + 64938, + 64938 + ], + "mapped", + [ + 1588, + 1581, + 1610 + ] + ], + [ + [ + 64939, + 64939 + ], + "mapped", + [ + 1590, + 1581, + 1610 + ] + ], + [ + [ + 64940, + 64940 + ], + "mapped", + [ + 1604, + 1580, + 1610 + ] + ], + [ + [ + 64941, + 64941 + ], + "mapped", + [ + 1604, + 1605, + 1610 + ] + ], + [ + [ + 64942, + 64942 + ], + "mapped", + [ + 1610, + 1581, + 1610 + ] + ], + [ + [ + 64943, + 64943 + ], + "mapped", + [ + 1610, + 1580, + 1610 + ] + ], + [ + [ + 64944, + 64944 + ], + "mapped", + [ + 1610, + 1605, + 1610 + ] + ], + [ + [ + 64945, + 64945 + ], + "mapped", + [ + 1605, + 1605, + 1610 + ] + ], + [ + [ + 64946, + 64946 + ], + "mapped", + [ + 1602, + 1605, + 1610 + ] + ], + [ + [ + 64947, + 64947 + ], + "mapped", + [ + 1606, + 1581, + 1610 + ] + ], + [ + [ + 64948, + 64948 + ], + "mapped", + [ + 1602, + 1605, + 1581 + ] + ], + [ + [ + 64949, + 64949 + ], + "mapped", + [ + 1604, + 1581, + 1605 + ] + ], + [ + [ + 64950, + 64950 + ], + "mapped", + [ + 1593, + 1605, + 1610 + ] + ], + [ + [ + 64951, + 64951 + ], + "mapped", + [ + 1603, + 1605, + 1610 + ] + ], + [ + [ + 64952, + 64952 + ], + "mapped", + [ + 1606, + 1580, + 1581 + ] + ], + [ + [ + 64953, + 64953 + ], + "mapped", + [ + 1605, + 1582, + 1610 + ] + ], + [ + [ + 64954, + 64954 + ], + "mapped", + [ + 1604, + 1580, + 1605 + ] + ], + [ + [ + 64955, + 64955 + ], + "mapped", + [ + 1603, + 1605, + 1605 + ] + ], + [ + [ + 64956, + 64956 + ], + "mapped", + [ + 1604, + 1580, + 1605 + ] + ], + [ + [ + 64957, + 64957 + ], + "mapped", + [ + 1606, + 1580, + 1581 + ] + ], + [ + [ + 64958, + 64958 + ], + "mapped", + [ + 1580, + 1581, + 1610 + ] + ], + [ + [ + 64959, + 64959 + ], + "mapped", + [ + 1581, + 1580, + 1610 + ] + ], + [ + [ + 64960, + 64960 + ], + "mapped", + [ + 1605, + 1580, + 1610 + ] + ], + [ + [ + 64961, + 64961 + ], + "mapped", + [ + 1601, + 1605, + 1610 + ] + ], + [ + [ + 64962, + 64962 + ], + "mapped", + [ + 1576, + 1581, + 1610 + ] + ], + [ + [ + 64963, + 64963 + ], + "mapped", + [ + 1603, + 1605, + 1605 + ] + ], + [ + [ + 64964, + 64964 + ], + "mapped", + [ + 1593, + 1580, + 1605 + ] + ], + [ + [ + 64965, + 64965 + ], + "mapped", + [ + 1589, + 1605, + 1605 + ] + ], + [ + [ + 64966, + 64966 + ], + "mapped", + [ + 1587, + 1582, + 1610 + ] + ], + [ + [ + 64967, + 64967 + ], + "mapped", + [ + 1606, + 1580, + 1610 + ] + ], + [ + [ + 64968, + 64975 + ], + "disallowed" + ], + [ + [ + 64976, + 65007 + ], + "disallowed" + ], + [ + [ + 65008, + 65008 + ], + "mapped", + [ + 1589, + 1604, + 1746 + ] + ], + [ + [ + 65009, + 65009 + ], + "mapped", + [ + 1602, + 1604, + 1746 + ] + ], + [ + [ + 65010, + 65010 + ], + "mapped", + [ + 1575, + 1604, + 1604, + 1607 + ] + ], + [ + [ + 65011, + 65011 + ], + "mapped", + [ + 1575, + 1603, + 1576, + 1585 + ] + ], + [ + [ + 65012, + 65012 + ], + "mapped", + [ + 1605, + 1581, + 1605, + 1583 + ] + ], + [ + [ + 65013, + 65013 + ], + "mapped", + [ + 1589, + 1604, + 1593, + 1605 + ] + ], + [ + [ + 65014, + 65014 + ], + "mapped", + [ + 1585, + 1587, + 1608, + 1604 + ] + ], + [ + [ + 65015, + 65015 + ], + "mapped", + [ + 1593, + 1604, + 1610, + 1607 + ] + ], + [ + [ + 65016, + 65016 + ], + "mapped", + [ + 1608, + 1587, + 1604, + 1605 + ] + ], + [ + [ + 65017, + 65017 + ], + "mapped", + [ + 1589, + 1604, + 1609 + ] + ], + [ + [ + 65018, + 65018 + ], + "disallowed_STD3_mapped", + [ + 1589, + 1604, + 1609, + 32, + 1575, + 1604, + 1604, + 1607, + 32, + 1593, + 1604, + 1610, + 1607, + 32, + 1608, + 1587, + 1604, + 1605 + ] + ], + [ + [ + 65019, + 65019 + ], + "disallowed_STD3_mapped", + [ + 1580, + 1604, + 32, + 1580, + 1604, + 1575, + 1604, + 1607 + ] + ], + [ + [ + 65020, + 65020 + ], + "mapped", + [ + 1585, + 1740, + 1575, + 1604 + ] + ], + [ + [ + 65021, + 65021 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 65022, + 65023 + ], + "disallowed" + ], + [ + [ + 65024, + 65039 + ], + "ignored" + ], + [ + [ + 65040, + 65040 + ], + "disallowed_STD3_mapped", + [ + 44 + ] + ], + [ + [ + 65041, + 65041 + ], + "mapped", + [ + 12289 + ] + ], + [ + [ + 65042, + 65042 + ], + "disallowed" + ], + [ + [ + 65043, + 65043 + ], + "disallowed_STD3_mapped", + [ + 58 + ] + ], + [ + [ + 65044, + 65044 + ], + "disallowed_STD3_mapped", + [ + 59 + ] + ], + [ + [ + 65045, + 65045 + ], + "disallowed_STD3_mapped", + [ + 33 + ] + ], + [ + [ + 65046, + 65046 + ], + "disallowed_STD3_mapped", + [ + 63 + ] + ], + [ + [ + 65047, + 65047 + ], + "mapped", + [ + 12310 + ] + ], + [ + [ + 65048, + 65048 + ], + "mapped", + [ + 12311 + ] + ], + [ + [ + 65049, + 65049 + ], + "disallowed" + ], + [ + [ + 65050, + 65055 + ], + "disallowed" + ], + [ + [ + 65056, + 65059 + ], + "valid" + ], + [ + [ + 65060, + 65062 + ], + "valid" + ], + [ + [ + 65063, + 65069 + ], + "valid" + ], + [ + [ + 65070, + 65071 + ], + "valid" + ], + [ + [ + 65072, + 65072 + ], + "disallowed" + ], + [ + [ + 65073, + 65073 + ], + "mapped", + [ + 8212 + ] + ], + [ + [ + 65074, + 65074 + ], + "mapped", + [ + 8211 + ] + ], + [ + [ + 65075, + 65076 + ], + "disallowed_STD3_mapped", + [ + 95 + ] + ], + [ + [ + 65077, + 65077 + ], + "disallowed_STD3_mapped", + [ + 40 + ] + ], + [ + [ + 65078, + 65078 + ], + "disallowed_STD3_mapped", + [ + 41 + ] + ], + [ + [ + 65079, + 65079 + ], + "disallowed_STD3_mapped", + [ + 123 + ] + ], + [ + [ + 65080, + 65080 + ], + "disallowed_STD3_mapped", + [ + 125 + ] + ], + [ + [ + 65081, + 65081 + ], + "mapped", + [ + 12308 + ] + ], + [ + [ + 65082, + 65082 + ], + "mapped", + [ + 12309 + ] + ], + [ + [ + 65083, + 65083 + ], + "mapped", + [ + 12304 + ] + ], + [ + [ + 65084, + 65084 + ], + "mapped", + [ + 12305 + ] + ], + [ + [ + 65085, + 65085 + ], + "mapped", + [ + 12298 + ] + ], + [ + [ + 65086, + 65086 + ], + "mapped", + [ + 12299 + ] + ], + [ + [ + 65087, + 65087 + ], + "mapped", + [ + 12296 + ] + ], + [ + [ + 65088, + 65088 + ], + "mapped", + [ + 12297 + ] + ], + [ + [ + 65089, + 65089 + ], + "mapped", + [ + 12300 + ] + ], + [ + [ + 65090, + 65090 + ], + "mapped", + [ + 12301 + ] + ], + [ + [ + 65091, + 65091 + ], + "mapped", + [ + 12302 + ] + ], + [ + [ + 65092, + 65092 + ], + "mapped", + [ + 12303 + ] + ], + [ + [ + 65093, + 65094 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 65095, + 65095 + ], + "disallowed_STD3_mapped", + [ + 91 + ] + ], + [ + [ + 65096, + 65096 + ], + "disallowed_STD3_mapped", + [ + 93 + ] + ], + [ + [ + 65097, + 65100 + ], + "disallowed_STD3_mapped", + [ + 32, + 773 + ] + ], + [ + [ + 65101, + 65103 + ], + "disallowed_STD3_mapped", + [ + 95 + ] + ], + [ + [ + 65104, + 65104 + ], + "disallowed_STD3_mapped", + [ + 44 + ] + ], + [ + [ + 65105, + 65105 + ], + "mapped", + [ + 12289 + ] + ], + [ + [ + 65106, + 65106 + ], + "disallowed" + ], + [ + [ + 65107, + 65107 + ], + "disallowed" + ], + [ + [ + 65108, + 65108 + ], + "disallowed_STD3_mapped", + [ + 59 + ] + ], + [ + [ + 65109, + 65109 + ], + "disallowed_STD3_mapped", + [ + 58 + ] + ], + [ + [ + 65110, + 65110 + ], + "disallowed_STD3_mapped", + [ + 63 + ] + ], + [ + [ + 65111, + 65111 + ], + "disallowed_STD3_mapped", + [ + 33 + ] + ], + [ + [ + 65112, + 65112 + ], + "mapped", + [ + 8212 + ] + ], + [ + [ + 65113, + 65113 + ], + "disallowed_STD3_mapped", + [ + 40 + ] + ], + [ + [ + 65114, + 65114 + ], + "disallowed_STD3_mapped", + [ + 41 + ] + ], + [ + [ + 65115, + 65115 + ], + "disallowed_STD3_mapped", + [ + 123 + ] + ], + [ + [ + 65116, + 65116 + ], + "disallowed_STD3_mapped", + [ + 125 + ] + ], + [ + [ + 65117, + 65117 + ], + "mapped", + [ + 12308 + ] + ], + [ + [ + 65118, + 65118 + ], + "mapped", + [ + 12309 + ] + ], + [ + [ + 65119, + 65119 + ], + "disallowed_STD3_mapped", + [ + 35 + ] + ], + [ + [ + 65120, + 65120 + ], + "disallowed_STD3_mapped", + [ + 38 + ] + ], + [ + [ + 65121, + 65121 + ], + "disallowed_STD3_mapped", + [ + 42 + ] + ], + [ + [ + 65122, + 65122 + ], + "disallowed_STD3_mapped", + [ + 43 + ] + ], + [ + [ + 65123, + 65123 + ], + "mapped", + [ + 45 + ] + ], + [ + [ + 65124, + 65124 + ], + "disallowed_STD3_mapped", + [ + 60 + ] + ], + [ + [ + 65125, + 65125 + ], + "disallowed_STD3_mapped", + [ + 62 + ] + ], + [ + [ + 65126, + 65126 + ], + "disallowed_STD3_mapped", + [ + 61 + ] + ], + [ + [ + 65127, + 65127 + ], + "disallowed" + ], + [ + [ + 65128, + 65128 + ], + "disallowed_STD3_mapped", + [ + 92 + ] + ], + [ + [ + 65129, + 65129 + ], + "disallowed_STD3_mapped", + [ + 36 + ] + ], + [ + [ + 65130, + 65130 + ], + "disallowed_STD3_mapped", + [ + 37 + ] + ], + [ + [ + 65131, + 65131 + ], + "disallowed_STD3_mapped", + [ + 64 + ] + ], + [ + [ + 65132, + 65135 + ], + "disallowed" + ], + [ + [ + 65136, + 65136 + ], + "disallowed_STD3_mapped", + [ + 32, + 1611 + ] + ], + [ + [ + 65137, + 65137 + ], + "mapped", + [ + 1600, + 1611 + ] + ], + [ + [ + 65138, + 65138 + ], + "disallowed_STD3_mapped", + [ + 32, + 1612 + ] + ], + [ + [ + 65139, + 65139 + ], + "valid" + ], + [ + [ + 65140, + 65140 + ], + "disallowed_STD3_mapped", + [ + 32, + 1613 + ] + ], + [ + [ + 65141, + 65141 + ], + "disallowed" + ], + [ + [ + 65142, + 65142 + ], + "disallowed_STD3_mapped", + [ + 32, + 1614 + ] + ], + [ + [ + 65143, + 65143 + ], + "mapped", + [ + 1600, + 1614 + ] + ], + [ + [ + 65144, + 65144 + ], + "disallowed_STD3_mapped", + [ + 32, + 1615 + ] + ], + [ + [ + 65145, + 65145 + ], + "mapped", + [ + 1600, + 1615 + ] + ], + [ + [ + 65146, + 65146 + ], + "disallowed_STD3_mapped", + [ + 32, + 1616 + ] + ], + [ + [ + 65147, + 65147 + ], + "mapped", + [ + 1600, + 1616 + ] + ], + [ + [ + 65148, + 65148 + ], + "disallowed_STD3_mapped", + [ + 32, + 1617 + ] + ], + [ + [ + 65149, + 65149 + ], + "mapped", + [ + 1600, + 1617 + ] + ], + [ + [ + 65150, + 65150 + ], + "disallowed_STD3_mapped", + [ + 32, + 1618 + ] + ], + [ + [ + 65151, + 65151 + ], + "mapped", + [ + 1600, + 1618 + ] + ], + [ + [ + 65152, + 65152 + ], + "mapped", + [ + 1569 + ] + ], + [ + [ + 65153, + 65154 + ], + "mapped", + [ + 1570 + ] + ], + [ + [ + 65155, + 65156 + ], + "mapped", + [ + 1571 + ] + ], + [ + [ + 65157, + 65158 + ], + "mapped", + [ + 1572 + ] + ], + [ + [ + 65159, + 65160 + ], + "mapped", + [ + 1573 + ] + ], + [ + [ + 65161, + 65164 + ], + "mapped", + [ + 1574 + ] + ], + [ + [ + 65165, + 65166 + ], + "mapped", + [ + 1575 + ] + ], + [ + [ + 65167, + 65170 + ], + "mapped", + [ + 1576 + ] + ], + [ + [ + 65171, + 65172 + ], + "mapped", + [ + 1577 + ] + ], + [ + [ + 65173, + 65176 + ], + "mapped", + [ + 1578 + ] + ], + [ + [ + 65177, + 65180 + ], + "mapped", + [ + 1579 + ] + ], + [ + [ + 65181, + 65184 + ], + "mapped", + [ + 1580 + ] + ], + [ + [ + 65185, + 65188 + ], + "mapped", + [ + 1581 + ] + ], + [ + [ + 65189, + 65192 + ], + "mapped", + [ + 1582 + ] + ], + [ + [ + 65193, + 65194 + ], + "mapped", + [ + 1583 + ] + ], + [ + [ + 65195, + 65196 + ], + "mapped", + [ + 1584 + ] + ], + [ + [ + 65197, + 65198 + ], + "mapped", + [ + 1585 + ] + ], + [ + [ + 65199, + 65200 + ], + "mapped", + [ + 1586 + ] + ], + [ + [ + 65201, + 65204 + ], + "mapped", + [ + 1587 + ] + ], + [ + [ + 65205, + 65208 + ], + "mapped", + [ + 1588 + ] + ], + [ + [ + 65209, + 65212 + ], + "mapped", + [ + 1589 + ] + ], + [ + [ + 65213, + 65216 + ], + "mapped", + [ + 1590 + ] + ], + [ + [ + 65217, + 65220 + ], + "mapped", + [ + 1591 + ] + ], + [ + [ + 65221, + 65224 + ], + "mapped", + [ + 1592 + ] + ], + [ + [ + 65225, + 65228 + ], + "mapped", + [ + 1593 + ] + ], + [ + [ + 65229, + 65232 + ], + "mapped", + [ + 1594 + ] + ], + [ + [ + 65233, + 65236 + ], + "mapped", + [ + 1601 + ] + ], + [ + [ + 65237, + 65240 + ], + "mapped", + [ + 1602 + ] + ], + [ + [ + 65241, + 65244 + ], + "mapped", + [ + 1603 + ] + ], + [ + [ + 65245, + 65248 + ], + "mapped", + [ + 1604 + ] + ], + [ + [ + 65249, + 65252 + ], + "mapped", + [ + 1605 + ] + ], + [ + [ + 65253, + 65256 + ], + "mapped", + [ + 1606 + ] + ], + [ + [ + 65257, + 65260 + ], + "mapped", + [ + 1607 + ] + ], + [ + [ + 65261, + 65262 + ], + "mapped", + [ + 1608 + ] + ], + [ + [ + 65263, + 65264 + ], + "mapped", + [ + 1609 + ] + ], + [ + [ + 65265, + 65268 + ], + "mapped", + [ + 1610 + ] + ], + [ + [ + 65269, + 65270 + ], + "mapped", + [ + 1604, + 1570 + ] + ], + [ + [ + 65271, + 65272 + ], + "mapped", + [ + 1604, + 1571 + ] + ], + [ + [ + 65273, + 65274 + ], + "mapped", + [ + 1604, + 1573 + ] + ], + [ + [ + 65275, + 65276 + ], + "mapped", + [ + 1604, + 1575 + ] + ], + [ + [ + 65277, + 65278 + ], + "disallowed" + ], + [ + [ + 65279, + 65279 + ], + "ignored" + ], + [ + [ + 65280, + 65280 + ], + "disallowed" + ], + [ + [ + 65281, + 65281 + ], + "disallowed_STD3_mapped", + [ + 33 + ] + ], + [ + [ + 65282, + 65282 + ], + "disallowed_STD3_mapped", + [ + 34 + ] + ], + [ + [ + 65283, + 65283 + ], + "disallowed_STD3_mapped", + [ + 35 + ] + ], + [ + [ + 65284, + 65284 + ], + "disallowed_STD3_mapped", + [ + 36 + ] + ], + [ + [ + 65285, + 65285 + ], + "disallowed_STD3_mapped", + [ + 37 + ] + ], + [ + [ + 65286, + 65286 + ], + "disallowed_STD3_mapped", + [ + 38 + ] + ], + [ + [ + 65287, + 65287 + ], + "disallowed_STD3_mapped", + [ + 39 + ] + ], + [ + [ + 65288, + 65288 + ], + "disallowed_STD3_mapped", + [ + 40 + ] + ], + [ + [ + 65289, + 65289 + ], + "disallowed_STD3_mapped", + [ + 41 + ] + ], + [ + [ + 65290, + 65290 + ], + "disallowed_STD3_mapped", + [ + 42 + ] + ], + [ + [ + 65291, + 65291 + ], + "disallowed_STD3_mapped", + [ + 43 + ] + ], + [ + [ + 65292, + 65292 + ], + "disallowed_STD3_mapped", + [ + 44 + ] + ], + [ + [ + 65293, + 65293 + ], + "mapped", + [ + 45 + ] + ], + [ + [ + 65294, + 65294 + ], + "mapped", + [ + 46 + ] + ], + [ + [ + 65295, + 65295 + ], + "disallowed_STD3_mapped", + [ + 47 + ] + ], + [ + [ + 65296, + 65296 + ], + "mapped", + [ + 48 + ] + ], + [ + [ + 65297, + 65297 + ], + "mapped", + [ + 49 + ] + ], + [ + [ + 65298, + 65298 + ], + "mapped", + [ + 50 + ] + ], + [ + [ + 65299, + 65299 + ], + "mapped", + [ + 51 + ] + ], + [ + [ + 65300, + 65300 + ], + "mapped", + [ + 52 + ] + ], + [ + [ + 65301, + 65301 + ], + "mapped", + [ + 53 + ] + ], + [ + [ + 65302, + 65302 + ], + "mapped", + [ + 54 + ] + ], + [ + [ + 65303, + 65303 + ], + "mapped", + [ + 55 + ] + ], + [ + [ + 65304, + 65304 + ], + "mapped", + [ + 56 + ] + ], + [ + [ + 65305, + 65305 + ], + "mapped", + [ + 57 + ] + ], + [ + [ + 65306, + 65306 + ], + "disallowed_STD3_mapped", + [ + 58 + ] + ], + [ + [ + 65307, + 65307 + ], + "disallowed_STD3_mapped", + [ + 59 + ] + ], + [ + [ + 65308, + 65308 + ], + "disallowed_STD3_mapped", + [ + 60 + ] + ], + [ + [ + 65309, + 65309 + ], + "disallowed_STD3_mapped", + [ + 61 + ] + ], + [ + [ + 65310, + 65310 + ], + "disallowed_STD3_mapped", + [ + 62 + ] + ], + [ + [ + 65311, + 65311 + ], + "disallowed_STD3_mapped", + [ + 63 + ] + ], + [ + [ + 65312, + 65312 + ], + "disallowed_STD3_mapped", + [ + 64 + ] + ], + [ + [ + 65313, + 65313 + ], + "mapped", + [ + 97 + ] + ], + [ + [ + 65314, + 65314 + ], + "mapped", + [ + 98 + ] + ], + [ + [ + 65315, + 65315 + ], + "mapped", + [ + 99 + ] + ], + [ + [ + 65316, + 65316 + ], + "mapped", + [ + 100 + ] + ], + [ + [ + 65317, + 65317 + ], + "mapped", + [ + 101 + ] + ], + [ + [ + 65318, + 65318 + ], + "mapped", + [ + 102 + ] + ], + [ + [ + 65319, + 65319 + ], + "mapped", + [ + 103 + ] + ], + [ + [ + 65320, + 65320 + ], + "mapped", + [ + 104 + ] + ], + [ + [ + 65321, + 65321 + ], + "mapped", + [ + 105 + ] + ], + [ + [ + 65322, + 65322 + ], + "mapped", + [ + 106 + ] + ], + [ + [ + 65323, + 65323 + ], + "mapped", + [ + 107 + ] + ], + [ + [ + 65324, + 65324 + ], + "mapped", + [ + 108 + ] + ], + [ + [ + 65325, + 65325 + ], + "mapped", + [ + 109 + ] + ], + [ + [ + 65326, + 65326 + ], + "mapped", + [ + 110 + ] + ], + [ + [ + 65327, + 65327 + ], + "mapped", + [ + 111 + ] + ], + [ + [ + 65328, + 65328 + ], + "mapped", + [ + 112 + ] + ], + [ + [ + 65329, + 65329 + ], + "mapped", + [ + 113 + ] + ], + [ + [ + 65330, + 65330 + ], + "mapped", + [ + 114 + ] + ], + [ + [ + 65331, + 65331 + ], + "mapped", + [ + 115 + ] + ], + [ + [ + 65332, + 65332 + ], + "mapped", + [ + 116 + ] + ], + [ + [ + 65333, + 65333 + ], + "mapped", + [ + 117 + ] + ], + [ + [ + 65334, + 65334 + ], + "mapped", + [ + 118 + ] + ], + [ + [ + 65335, + 65335 + ], + "mapped", + [ + 119 + ] + ], + [ + [ + 65336, + 65336 + ], + "mapped", + [ + 120 + ] + ], + [ + [ + 65337, + 65337 + ], + "mapped", + [ + 121 + ] + ], + [ + [ + 65338, + 65338 + ], + "mapped", + [ + 122 + ] + ], + [ + [ + 65339, + 65339 + ], + "disallowed_STD3_mapped", + [ + 91 + ] + ], + [ + [ + 65340, + 65340 + ], + "disallowed_STD3_mapped", + [ + 92 + ] + ], + [ + [ + 65341, + 65341 + ], + "disallowed_STD3_mapped", + [ + 93 + ] + ], + [ + [ + 65342, + 65342 + ], + "disallowed_STD3_mapped", + [ + 94 + ] + ], + [ + [ + 65343, + 65343 + ], + "disallowed_STD3_mapped", + [ + 95 + ] + ], + [ + [ + 65344, + 65344 + ], + "disallowed_STD3_mapped", + [ + 96 + ] + ], + [ + [ + 65345, + 65345 + ], + "mapped", + [ + 97 + ] + ], + [ + [ + 65346, + 65346 + ], + "mapped", + [ + 98 + ] + ], + [ + [ + 65347, + 65347 + ], + "mapped", + [ + 99 + ] + ], + [ + [ + 65348, + 65348 + ], + "mapped", + [ + 100 + ] + ], + [ + [ + 65349, + 65349 + ], + "mapped", + [ + 101 + ] + ], + [ + [ + 65350, + 65350 + ], + "mapped", + [ + 102 + ] + ], + [ + [ + 65351, + 65351 + ], + "mapped", + [ + 103 + ] + ], + [ + [ + 65352, + 65352 + ], + "mapped", + [ + 104 + ] + ], + [ + [ + 65353, + 65353 + ], + "mapped", + [ + 105 + ] + ], + [ + [ + 65354, + 65354 + ], + "mapped", + [ + 106 + ] + ], + [ + [ + 65355, + 65355 + ], + "mapped", + [ + 107 + ] + ], + [ + [ + 65356, + 65356 + ], + "mapped", + [ + 108 + ] + ], + [ + [ + 65357, + 65357 + ], + "mapped", + [ + 109 + ] + ], + [ + [ + 65358, + 65358 + ], + "mapped", + [ + 110 + ] + ], + [ + [ + 65359, + 65359 + ], + "mapped", + [ + 111 + ] + ], + [ + [ + 65360, + 65360 + ], + "mapped", + [ + 112 + ] + ], + [ + [ + 65361, + 65361 + ], + "mapped", + [ + 113 + ] + ], + [ + [ + 65362, + 65362 + ], + "mapped", + [ + 114 + ] + ], + [ + [ + 65363, + 65363 + ], + "mapped", + [ + 115 + ] + ], + [ + [ + 65364, + 65364 + ], + "mapped", + [ + 116 + ] + ], + [ + [ + 65365, + 65365 + ], + "mapped", + [ + 117 + ] + ], + [ + [ + 65366, + 65366 + ], + "mapped", + [ + 118 + ] + ], + [ + [ + 65367, + 65367 + ], + "mapped", + [ + 119 + ] + ], + [ + [ + 65368, + 65368 + ], + "mapped", + [ + 120 + ] + ], + [ + [ + 65369, + 65369 + ], + "mapped", + [ + 121 + ] + ], + [ + [ + 65370, + 65370 + ], + "mapped", + [ + 122 + ] + ], + [ + [ + 65371, + 65371 + ], + "disallowed_STD3_mapped", + [ + 123 + ] + ], + [ + [ + 65372, + 65372 + ], + "disallowed_STD3_mapped", + [ + 124 + ] + ], + [ + [ + 65373, + 65373 + ], + "disallowed_STD3_mapped", + [ + 125 + ] + ], + [ + [ + 65374, + 65374 + ], + "disallowed_STD3_mapped", + [ + 126 + ] + ], + [ + [ + 65375, + 65375 + ], + "mapped", + [ + 10629 + ] + ], + [ + [ + 65376, + 65376 + ], + "mapped", + [ + 10630 + ] + ], + [ + [ + 65377, + 65377 + ], + "mapped", + [ + 46 + ] + ], + [ + [ + 65378, + 65378 + ], + "mapped", + [ + 12300 + ] + ], + [ + [ + 65379, + 65379 + ], + "mapped", + [ + 12301 + ] + ], + [ + [ + 65380, + 65380 + ], + "mapped", + [ + 12289 + ] + ], + [ + [ + 65381, + 65381 + ], + "mapped", + [ + 12539 + ] + ], + [ + [ + 65382, + 65382 + ], + "mapped", + [ + 12530 + ] + ], + [ + [ + 65383, + 65383 + ], + "mapped", + [ + 12449 + ] + ], + [ + [ + 65384, + 65384 + ], + "mapped", + [ + 12451 + ] + ], + [ + [ + 65385, + 65385 + ], + "mapped", + [ + 12453 + ] + ], + [ + [ + 65386, + 65386 + ], + "mapped", + [ + 12455 + ] + ], + [ + [ + 65387, + 65387 + ], + "mapped", + [ + 12457 + ] + ], + [ + [ + 65388, + 65388 + ], + "mapped", + [ + 12515 + ] + ], + [ + [ + 65389, + 65389 + ], + "mapped", + [ + 12517 + ] + ], + [ + [ + 65390, + 65390 + ], + "mapped", + [ + 12519 + ] + ], + [ + [ + 65391, + 65391 + ], + "mapped", + [ + 12483 + ] + ], + [ + [ + 65392, + 65392 + ], + "mapped", + [ + 12540 + ] + ], + [ + [ + 65393, + 65393 + ], + "mapped", + [ + 12450 + ] + ], + [ + [ + 65394, + 65394 + ], + "mapped", + [ + 12452 + ] + ], + [ + [ + 65395, + 65395 + ], + "mapped", + [ + 12454 + ] + ], + [ + [ + 65396, + 65396 + ], + "mapped", + [ + 12456 + ] + ], + [ + [ + 65397, + 65397 + ], + "mapped", + [ + 12458 + ] + ], + [ + [ + 65398, + 65398 + ], + "mapped", + [ + 12459 + ] + ], + [ + [ + 65399, + 65399 + ], + "mapped", + [ + 12461 + ] + ], + [ + [ + 65400, + 65400 + ], + "mapped", + [ + 12463 + ] + ], + [ + [ + 65401, + 65401 + ], + "mapped", + [ + 12465 + ] + ], + [ + [ + 65402, + 65402 + ], + "mapped", + [ + 12467 + ] + ], + [ + [ + 65403, + 65403 + ], + "mapped", + [ + 12469 + ] + ], + [ + [ + 65404, + 65404 + ], + "mapped", + [ + 12471 + ] + ], + [ + [ + 65405, + 65405 + ], + "mapped", + [ + 12473 + ] + ], + [ + [ + 65406, + 65406 + ], + "mapped", + [ + 12475 + ] + ], + [ + [ + 65407, + 65407 + ], + "mapped", + [ + 12477 + ] + ], + [ + [ + 65408, + 65408 + ], + "mapped", + [ + 12479 + ] + ], + [ + [ + 65409, + 65409 + ], + "mapped", + [ + 12481 + ] + ], + [ + [ + 65410, + 65410 + ], + "mapped", + [ + 12484 + ] + ], + [ + [ + 65411, + 65411 + ], + "mapped", + [ + 12486 + ] + ], + [ + [ + 65412, + 65412 + ], + "mapped", + [ + 12488 + ] + ], + [ + [ + 65413, + 65413 + ], + "mapped", + [ + 12490 + ] + ], + [ + [ + 65414, + 65414 + ], + "mapped", + [ + 12491 + ] + ], + [ + [ + 65415, + 65415 + ], + "mapped", + [ + 12492 + ] + ], + [ + [ + 65416, + 65416 + ], + "mapped", + [ + 12493 + ] + ], + [ + [ + 65417, + 65417 + ], + "mapped", + [ + 12494 + ] + ], + [ + [ + 65418, + 65418 + ], + "mapped", + [ + 12495 + ] + ], + [ + [ + 65419, + 65419 + ], + "mapped", + [ + 12498 + ] + ], + [ + [ + 65420, + 65420 + ], + "mapped", + [ + 12501 + ] + ], + [ + [ + 65421, + 65421 + ], + "mapped", + [ + 12504 + ] + ], + [ + [ + 65422, + 65422 + ], + "mapped", + [ + 12507 + ] + ], + [ + [ + 65423, + 65423 + ], + "mapped", + [ + 12510 + ] + ], + [ + [ + 65424, + 65424 + ], + "mapped", + [ + 12511 + ] + ], + [ + [ + 65425, + 65425 + ], + "mapped", + [ + 12512 + ] + ], + [ + [ + 65426, + 65426 + ], + "mapped", + [ + 12513 + ] + ], + [ + [ + 65427, + 65427 + ], + "mapped", + [ + 12514 + ] + ], + [ + [ + 65428, + 65428 + ], + "mapped", + [ + 12516 + ] + ], + [ + [ + 65429, + 65429 + ], + "mapped", + [ + 12518 + ] + ], + [ + [ + 65430, + 65430 + ], + "mapped", + [ + 12520 + ] + ], + [ + [ + 65431, + 65431 + ], + "mapped", + [ + 12521 + ] + ], + [ + [ + 65432, + 65432 + ], + "mapped", + [ + 12522 + ] + ], + [ + [ + 65433, + 65433 + ], + "mapped", + [ + 12523 + ] + ], + [ + [ + 65434, + 65434 + ], + "mapped", + [ + 12524 + ] + ], + [ + [ + 65435, + 65435 + ], + "mapped", + [ + 12525 + ] + ], + [ + [ + 65436, + 65436 + ], + "mapped", + [ + 12527 + ] + ], + [ + [ + 65437, + 65437 + ], + "mapped", + [ + 12531 + ] + ], + [ + [ + 65438, + 65438 + ], + "mapped", + [ + 12441 + ] + ], + [ + [ + 65439, + 65439 + ], + "mapped", + [ + 12442 + ] + ], + [ + [ + 65440, + 65440 + ], + "disallowed" + ], + [ + [ + 65441, + 65441 + ], + "mapped", + [ + 4352 + ] + ], + [ + [ + 65442, + 65442 + ], + "mapped", + [ + 4353 + ] + ], + [ + [ + 65443, + 65443 + ], + "mapped", + [ + 4522 + ] + ], + [ + [ + 65444, + 65444 + ], + "mapped", + [ + 4354 + ] + ], + [ + [ + 65445, + 65445 + ], + "mapped", + [ + 4524 + ] + ], + [ + [ + 65446, + 65446 + ], + "mapped", + [ + 4525 + ] + ], + [ + [ + 65447, + 65447 + ], + "mapped", + [ + 4355 + ] + ], + [ + [ + 65448, + 65448 + ], + "mapped", + [ + 4356 + ] + ], + [ + [ + 65449, + 65449 + ], + "mapped", + [ + 4357 + ] + ], + [ + [ + 65450, + 65450 + ], + "mapped", + [ + 4528 + ] + ], + [ + [ + 65451, + 65451 + ], + "mapped", + [ + 4529 + ] + ], + [ + [ + 65452, + 65452 + ], + "mapped", + [ + 4530 + ] + ], + [ + [ + 65453, + 65453 + ], + "mapped", + [ + 4531 + ] + ], + [ + [ + 65454, + 65454 + ], + "mapped", + [ + 4532 + ] + ], + [ + [ + 65455, + 65455 + ], + "mapped", + [ + 4533 + ] + ], + [ + [ + 65456, + 65456 + ], + "mapped", + [ + 4378 + ] + ], + [ + [ + 65457, + 65457 + ], + "mapped", + [ + 4358 + ] + ], + [ + [ + 65458, + 65458 + ], + "mapped", + [ + 4359 + ] + ], + [ + [ + 65459, + 65459 + ], + "mapped", + [ + 4360 + ] + ], + [ + [ + 65460, + 65460 + ], + "mapped", + [ + 4385 + ] + ], + [ + [ + 65461, + 65461 + ], + "mapped", + [ + 4361 + ] + ], + [ + [ + 65462, + 65462 + ], + "mapped", + [ + 4362 + ] + ], + [ + [ + 65463, + 65463 + ], + "mapped", + [ + 4363 + ] + ], + [ + [ + 65464, + 65464 + ], + "mapped", + [ + 4364 + ] + ], + [ + [ + 65465, + 65465 + ], + "mapped", + [ + 4365 + ] + ], + [ + [ + 65466, + 65466 + ], + "mapped", + [ + 4366 + ] + ], + [ + [ + 65467, + 65467 + ], + "mapped", + [ + 4367 + ] + ], + [ + [ + 65468, + 65468 + ], + "mapped", + [ + 4368 + ] + ], + [ + [ + 65469, + 65469 + ], + "mapped", + [ + 4369 + ] + ], + [ + [ + 65470, + 65470 + ], + "mapped", + [ + 4370 + ] + ], + [ + [ + 65471, + 65473 + ], + "disallowed" + ], + [ + [ + 65474, + 65474 + ], + "mapped", + [ + 4449 + ] + ], + [ + [ + 65475, + 65475 + ], + "mapped", + [ + 4450 + ] + ], + [ + [ + 65476, + 65476 + ], + "mapped", + [ + 4451 + ] + ], + [ + [ + 65477, + 65477 + ], + "mapped", + [ + 4452 + ] + ], + [ + [ + 65478, + 65478 + ], + "mapped", + [ + 4453 + ] + ], + [ + [ + 65479, + 65479 + ], + "mapped", + [ + 4454 + ] + ], + [ + [ + 65480, + 65481 + ], + "disallowed" + ], + [ + [ + 65482, + 65482 + ], + "mapped", + [ + 4455 + ] + ], + [ + [ + 65483, + 65483 + ], + "mapped", + [ + 4456 + ] + ], + [ + [ + 65484, + 65484 + ], + "mapped", + [ + 4457 + ] + ], + [ + [ + 65485, + 65485 + ], + "mapped", + [ + 4458 + ] + ], + [ + [ + 65486, + 65486 + ], + "mapped", + [ + 4459 + ] + ], + [ + [ + 65487, + 65487 + ], + "mapped", + [ + 4460 + ] + ], + [ + [ + 65488, + 65489 + ], + "disallowed" + ], + [ + [ + 65490, + 65490 + ], + "mapped", + [ + 4461 + ] + ], + [ + [ + 65491, + 65491 + ], + "mapped", + [ + 4462 + ] + ], + [ + [ + 65492, + 65492 + ], + "mapped", + [ + 4463 + ] + ], + [ + [ + 65493, + 65493 + ], + "mapped", + [ + 4464 + ] + ], + [ + [ + 65494, + 65494 + ], + "mapped", + [ + 4465 + ] + ], + [ + [ + 65495, + 65495 + ], + "mapped", + [ + 4466 + ] + ], + [ + [ + 65496, + 65497 + ], + "disallowed" + ], + [ + [ + 65498, + 65498 + ], + "mapped", + [ + 4467 + ] + ], + [ + [ + 65499, + 65499 + ], + "mapped", + [ + 4468 + ] + ], + [ + [ + 65500, + 65500 + ], + "mapped", + [ + 4469 + ] + ], + [ + [ + 65501, + 65503 + ], + "disallowed" + ], + [ + [ + 65504, + 65504 + ], + "mapped", + [ + 162 + ] + ], + [ + [ + 65505, + 65505 + ], + "mapped", + [ + 163 + ] + ], + [ + [ + 65506, + 65506 + ], + "mapped", + [ + 172 + ] + ], + [ + [ + 65507, + 65507 + ], + "disallowed_STD3_mapped", + [ + 32, + 772 + ] + ], + [ + [ + 65508, + 65508 + ], + "mapped", + [ + 166 + ] + ], + [ + [ + 65509, + 65509 + ], + "mapped", + [ + 165 + ] + ], + [ + [ + 65510, + 65510 + ], + "mapped", + [ + 8361 + ] + ], + [ + [ + 65511, + 65511 + ], + "disallowed" + ], + [ + [ + 65512, + 65512 + ], + "mapped", + [ + 9474 + ] + ], + [ + [ + 65513, + 65513 + ], + "mapped", + [ + 8592 + ] + ], + [ + [ + 65514, + 65514 + ], + "mapped", + [ + 8593 + ] + ], + [ + [ + 65515, + 65515 + ], + "mapped", + [ + 8594 + ] + ], + [ + [ + 65516, + 65516 + ], + "mapped", + [ + 8595 + ] + ], + [ + [ + 65517, + 65517 + ], + "mapped", + [ + 9632 + ] + ], + [ + [ + 65518, + 65518 + ], + "mapped", + [ + 9675 + ] + ], + [ + [ + 65519, + 65528 + ], + "disallowed" + ], + [ + [ + 65529, + 65531 + ], + "disallowed" + ], + [ + [ + 65532, + 65532 + ], + "disallowed" + ], + [ + [ + 65533, + 65533 + ], + "disallowed" + ], + [ + [ + 65534, + 65535 + ], + "disallowed" + ], + [ + [ + 65536, + 65547 + ], + "valid" + ], + [ + [ + 65548, + 65548 + ], + "disallowed" + ], + [ + [ + 65549, + 65574 + ], + "valid" + ], + [ + [ + 65575, + 65575 + ], + "disallowed" + ], + [ + [ + 65576, + 65594 + ], + "valid" + ], + [ + [ + 65595, + 65595 + ], + "disallowed" + ], + [ + [ + 65596, + 65597 + ], + "valid" + ], + [ + [ + 65598, + 65598 + ], + "disallowed" + ], + [ + [ + 65599, + 65613 + ], + "valid" + ], + [ + [ + 65614, + 65615 + ], + "disallowed" + ], + [ + [ + 65616, + 65629 + ], + "valid" + ], + [ + [ + 65630, + 65663 + ], + "disallowed" + ], + [ + [ + 65664, + 65786 + ], + "valid" + ], + [ + [ + 65787, + 65791 + ], + "disallowed" + ], + [ + [ + 65792, + 65794 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 65795, + 65798 + ], + "disallowed" + ], + [ + [ + 65799, + 65843 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 65844, + 65846 + ], + "disallowed" + ], + [ + [ + 65847, + 65855 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 65856, + 65930 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 65931, + 65932 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 65933, + 65935 + ], + "disallowed" + ], + [ + [ + 65936, + 65947 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 65948, + 65951 + ], + "disallowed" + ], + [ + [ + 65952, + 65952 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 65953, + 65999 + ], + "disallowed" + ], + [ + [ + 66000, + 66044 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 66045, + 66045 + ], + "valid" + ], + [ + [ + 66046, + 66175 + ], + "disallowed" + ], + [ + [ + 66176, + 66204 + ], + "valid" + ], + [ + [ + 66205, + 66207 + ], + "disallowed" + ], + [ + [ + 66208, + 66256 + ], + "valid" + ], + [ + [ + 66257, + 66271 + ], + "disallowed" + ], + [ + [ + 66272, + 66272 + ], + "valid" + ], + [ + [ + 66273, + 66299 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 66300, + 66303 + ], + "disallowed" + ], + [ + [ + 66304, + 66334 + ], + "valid" + ], + [ + [ + 66335, + 66335 + ], + "valid" + ], + [ + [ + 66336, + 66339 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 66340, + 66351 + ], + "disallowed" + ], + [ + [ + 66352, + 66368 + ], + "valid" + ], + [ + [ + 66369, + 66369 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 66370, + 66377 + ], + "valid" + ], + [ + [ + 66378, + 66378 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 66379, + 66383 + ], + "disallowed" + ], + [ + [ + 66384, + 66426 + ], + "valid" + ], + [ + [ + 66427, + 66431 + ], + "disallowed" + ], + [ + [ + 66432, + 66461 + ], + "valid" + ], + [ + [ + 66462, + 66462 + ], + "disallowed" + ], + [ + [ + 66463, + 66463 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 66464, + 66499 + ], + "valid" + ], + [ + [ + 66500, + 66503 + ], + "disallowed" + ], + [ + [ + 66504, + 66511 + ], + "valid" + ], + [ + [ + 66512, + 66517 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 66518, + 66559 + ], + "disallowed" + ], + [ + [ + 66560, + 66560 + ], + "mapped", + [ + 66600 + ] + ], + [ + [ + 66561, + 66561 + ], + "mapped", + [ + 66601 + ] + ], + [ + [ + 66562, + 66562 + ], + "mapped", + [ + 66602 + ] + ], + [ + [ + 66563, + 66563 + ], + "mapped", + [ + 66603 + ] + ], + [ + [ + 66564, + 66564 + ], + "mapped", + [ + 66604 + ] + ], + [ + [ + 66565, + 66565 + ], + "mapped", + [ + 66605 + ] + ], + [ + [ + 66566, + 66566 + ], + "mapped", + [ + 66606 + ] + ], + [ + [ + 66567, + 66567 + ], + "mapped", + [ + 66607 + ] + ], + [ + [ + 66568, + 66568 + ], + "mapped", + [ + 66608 + ] + ], + [ + [ + 66569, + 66569 + ], + "mapped", + [ + 66609 + ] + ], + [ + [ + 66570, + 66570 + ], + "mapped", + [ + 66610 + ] + ], + [ + [ + 66571, + 66571 + ], + "mapped", + [ + 66611 + ] + ], + [ + [ + 66572, + 66572 + ], + "mapped", + [ + 66612 + ] + ], + [ + [ + 66573, + 66573 + ], + "mapped", + [ + 66613 + ] + ], + [ + [ + 66574, + 66574 + ], + "mapped", + [ + 66614 + ] + ], + [ + [ + 66575, + 66575 + ], + "mapped", + [ + 66615 + ] + ], + [ + [ + 66576, + 66576 + ], + "mapped", + [ + 66616 + ] + ], + [ + [ + 66577, + 66577 + ], + "mapped", + [ + 66617 + ] + ], + [ + [ + 66578, + 66578 + ], + "mapped", + [ + 66618 + ] + ], + [ + [ + 66579, + 66579 + ], + "mapped", + [ + 66619 + ] + ], + [ + [ + 66580, + 66580 + ], + "mapped", + [ + 66620 + ] + ], + [ + [ + 66581, + 66581 + ], + "mapped", + [ + 66621 + ] + ], + [ + [ + 66582, + 66582 + ], + "mapped", + [ + 66622 + ] + ], + [ + [ + 66583, + 66583 + ], + "mapped", + [ + 66623 + ] + ], + [ + [ + 66584, + 66584 + ], + "mapped", + [ + 66624 + ] + ], + [ + [ + 66585, + 66585 + ], + "mapped", + [ + 66625 + ] + ], + [ + [ + 66586, + 66586 + ], + "mapped", + [ + 66626 + ] + ], + [ + [ + 66587, + 66587 + ], + "mapped", + [ + 66627 + ] + ], + [ + [ + 66588, + 66588 + ], + "mapped", + [ + 66628 + ] + ], + [ + [ + 66589, + 66589 + ], + "mapped", + [ + 66629 + ] + ], + [ + [ + 66590, + 66590 + ], + "mapped", + [ + 66630 + ] + ], + [ + [ + 66591, + 66591 + ], + "mapped", + [ + 66631 + ] + ], + [ + [ + 66592, + 66592 + ], + "mapped", + [ + 66632 + ] + ], + [ + [ + 66593, + 66593 + ], + "mapped", + [ + 66633 + ] + ], + [ + [ + 66594, + 66594 + ], + "mapped", + [ + 66634 + ] + ], + [ + [ + 66595, + 66595 + ], + "mapped", + [ + 66635 + ] + ], + [ + [ + 66596, + 66596 + ], + "mapped", + [ + 66636 + ] + ], + [ + [ + 66597, + 66597 + ], + "mapped", + [ + 66637 + ] + ], + [ + [ + 66598, + 66598 + ], + "mapped", + [ + 66638 + ] + ], + [ + [ + 66599, + 66599 + ], + "mapped", + [ + 66639 + ] + ], + [ + [ + 66600, + 66637 + ], + "valid" + ], + [ + [ + 66638, + 66717 + ], + "valid" + ], + [ + [ + 66718, + 66719 + ], + "disallowed" + ], + [ + [ + 66720, + 66729 + ], + "valid" + ], + [ + [ + 66730, + 66815 + ], + "disallowed" + ], + [ + [ + 66816, + 66855 + ], + "valid" + ], + [ + [ + 66856, + 66863 + ], + "disallowed" + ], + [ + [ + 66864, + 66915 + ], + "valid" + ], + [ + [ + 66916, + 66926 + ], + "disallowed" + ], + [ + [ + 66927, + 66927 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 66928, + 67071 + ], + "disallowed" + ], + [ + [ + 67072, + 67382 + ], + "valid" + ], + [ + [ + 67383, + 67391 + ], + "disallowed" + ], + [ + [ + 67392, + 67413 + ], + "valid" + ], + [ + [ + 67414, + 67423 + ], + "disallowed" + ], + [ + [ + 67424, + 67431 + ], + "valid" + ], + [ + [ + 67432, + 67583 + ], + "disallowed" + ], + [ + [ + 67584, + 67589 + ], + "valid" + ], + [ + [ + 67590, + 67591 + ], + "disallowed" + ], + [ + [ + 67592, + 67592 + ], + "valid" + ], + [ + [ + 67593, + 67593 + ], + "disallowed" + ], + [ + [ + 67594, + 67637 + ], + "valid" + ], + [ + [ + 67638, + 67638 + ], + "disallowed" + ], + [ + [ + 67639, + 67640 + ], + "valid" + ], + [ + [ + 67641, + 67643 + ], + "disallowed" + ], + [ + [ + 67644, + 67644 + ], + "valid" + ], + [ + [ + 67645, + 67646 + ], + "disallowed" + ], + [ + [ + 67647, + 67647 + ], + "valid" + ], + [ + [ + 67648, + 67669 + ], + "valid" + ], + [ + [ + 67670, + 67670 + ], + "disallowed" + ], + [ + [ + 67671, + 67679 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 67680, + 67702 + ], + "valid" + ], + [ + [ + 67703, + 67711 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 67712, + 67742 + ], + "valid" + ], + [ + [ + 67743, + 67750 + ], + "disallowed" + ], + [ + [ + 67751, + 67759 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 67760, + 67807 + ], + "disallowed" + ], + [ + [ + 67808, + 67826 + ], + "valid" + ], + [ + [ + 67827, + 67827 + ], + "disallowed" + ], + [ + [ + 67828, + 67829 + ], + "valid" + ], + [ + [ + 67830, + 67834 + ], + "disallowed" + ], + [ + [ + 67835, + 67839 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 67840, + 67861 + ], + "valid" + ], + [ + [ + 67862, + 67865 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 67866, + 67867 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 67868, + 67870 + ], + "disallowed" + ], + [ + [ + 67871, + 67871 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 67872, + 67897 + ], + "valid" + ], + [ + [ + 67898, + 67902 + ], + "disallowed" + ], + [ + [ + 67903, + 67903 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 67904, + 67967 + ], + "disallowed" + ], + [ + [ + 67968, + 68023 + ], + "valid" + ], + [ + [ + 68024, + 68027 + ], + "disallowed" + ], + [ + [ + 68028, + 68029 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 68030, + 68031 + ], + "valid" + ], + [ + [ + 68032, + 68047 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 68048, + 68049 + ], + "disallowed" + ], + [ + [ + 68050, + 68095 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 68096, + 68099 + ], + "valid" + ], + [ + [ + 68100, + 68100 + ], + "disallowed" + ], + [ + [ + 68101, + 68102 + ], + "valid" + ], + [ + [ + 68103, + 68107 + ], + "disallowed" + ], + [ + [ + 68108, + 68115 + ], + "valid" + ], + [ + [ + 68116, + 68116 + ], + "disallowed" + ], + [ + [ + 68117, + 68119 + ], + "valid" + ], + [ + [ + 68120, + 68120 + ], + "disallowed" + ], + [ + [ + 68121, + 68147 + ], + "valid" + ], + [ + [ + 68148, + 68151 + ], + "disallowed" + ], + [ + [ + 68152, + 68154 + ], + "valid" + ], + [ + [ + 68155, + 68158 + ], + "disallowed" + ], + [ + [ + 68159, + 68159 + ], + "valid" + ], + [ + [ + 68160, + 68167 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 68168, + 68175 + ], + "disallowed" + ], + [ + [ + 68176, + 68184 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 68185, + 68191 + ], + "disallowed" + ], + [ + [ + 68192, + 68220 + ], + "valid" + ], + [ + [ + 68221, + 68223 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 68224, + 68252 + ], + "valid" + ], + [ + [ + 68253, + 68255 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 68256, + 68287 + ], + "disallowed" + ], + [ + [ + 68288, + 68295 + ], + "valid" + ], + [ + [ + 68296, + 68296 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 68297, + 68326 + ], + "valid" + ], + [ + [ + 68327, + 68330 + ], + "disallowed" + ], + [ + [ + 68331, + 68342 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 68343, + 68351 + ], + "disallowed" + ], + [ + [ + 68352, + 68405 + ], + "valid" + ], + [ + [ + 68406, + 68408 + ], + "disallowed" + ], + [ + [ + 68409, + 68415 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 68416, + 68437 + ], + "valid" + ], + [ + [ + 68438, + 68439 + ], + "disallowed" + ], + [ + [ + 68440, + 68447 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 68448, + 68466 + ], + "valid" + ], + [ + [ + 68467, + 68471 + ], + "disallowed" + ], + [ + [ + 68472, + 68479 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 68480, + 68497 + ], + "valid" + ], + [ + [ + 68498, + 68504 + ], + "disallowed" + ], + [ + [ + 68505, + 68508 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 68509, + 68520 + ], + "disallowed" + ], + [ + [ + 68521, + 68527 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 68528, + 68607 + ], + "disallowed" + ], + [ + [ + 68608, + 68680 + ], + "valid" + ], + [ + [ + 68681, + 68735 + ], + "disallowed" + ], + [ + [ + 68736, + 68736 + ], + "mapped", + [ + 68800 + ] + ], + [ + [ + 68737, + 68737 + ], + "mapped", + [ + 68801 + ] + ], + [ + [ + 68738, + 68738 + ], + "mapped", + [ + 68802 + ] + ], + [ + [ + 68739, + 68739 + ], + "mapped", + [ + 68803 + ] + ], + [ + [ + 68740, + 68740 + ], + "mapped", + [ + 68804 + ] + ], + [ + [ + 68741, + 68741 + ], + "mapped", + [ + 68805 + ] + ], + [ + [ + 68742, + 68742 + ], + "mapped", + [ + 68806 + ] + ], + [ + [ + 68743, + 68743 + ], + "mapped", + [ + 68807 + ] + ], + [ + [ + 68744, + 68744 + ], + "mapped", + [ + 68808 + ] + ], + [ + [ + 68745, + 68745 + ], + "mapped", + [ + 68809 + ] + ], + [ + [ + 68746, + 68746 + ], + "mapped", + [ + 68810 + ] + ], + [ + [ + 68747, + 68747 + ], + "mapped", + [ + 68811 + ] + ], + [ + [ + 68748, + 68748 + ], + "mapped", + [ + 68812 + ] + ], + [ + [ + 68749, + 68749 + ], + "mapped", + [ + 68813 + ] + ], + [ + [ + 68750, + 68750 + ], + "mapped", + [ + 68814 + ] + ], + [ + [ + 68751, + 68751 + ], + "mapped", + [ + 68815 + ] + ], + [ + [ + 68752, + 68752 + ], + "mapped", + [ + 68816 + ] + ], + [ + [ + 68753, + 68753 + ], + "mapped", + [ + 68817 + ] + ], + [ + [ + 68754, + 68754 + ], + "mapped", + [ + 68818 + ] + ], + [ + [ + 68755, + 68755 + ], + "mapped", + [ + 68819 + ] + ], + [ + [ + 68756, + 68756 + ], + "mapped", + [ + 68820 + ] + ], + [ + [ + 68757, + 68757 + ], + "mapped", + [ + 68821 + ] + ], + [ + [ + 68758, + 68758 + ], + "mapped", + [ + 68822 + ] + ], + [ + [ + 68759, + 68759 + ], + "mapped", + [ + 68823 + ] + ], + [ + [ + 68760, + 68760 + ], + "mapped", + [ + 68824 + ] + ], + [ + [ + 68761, + 68761 + ], + "mapped", + [ + 68825 + ] + ], + [ + [ + 68762, + 68762 + ], + "mapped", + [ + 68826 + ] + ], + [ + [ + 68763, + 68763 + ], + "mapped", + [ + 68827 + ] + ], + [ + [ + 68764, + 68764 + ], + "mapped", + [ + 68828 + ] + ], + [ + [ + 68765, + 68765 + ], + "mapped", + [ + 68829 + ] + ], + [ + [ + 68766, + 68766 + ], + "mapped", + [ + 68830 + ] + ], + [ + [ + 68767, + 68767 + ], + "mapped", + [ + 68831 + ] + ], + [ + [ + 68768, + 68768 + ], + "mapped", + [ + 68832 + ] + ], + [ + [ + 68769, + 68769 + ], + "mapped", + [ + 68833 + ] + ], + [ + [ + 68770, + 68770 + ], + "mapped", + [ + 68834 + ] + ], + [ + [ + 68771, + 68771 + ], + "mapped", + [ + 68835 + ] + ], + [ + [ + 68772, + 68772 + ], + "mapped", + [ + 68836 + ] + ], + [ + [ + 68773, + 68773 + ], + "mapped", + [ + 68837 + ] + ], + [ + [ + 68774, + 68774 + ], + "mapped", + [ + 68838 + ] + ], + [ + [ + 68775, + 68775 + ], + "mapped", + [ + 68839 + ] + ], + [ + [ + 68776, + 68776 + ], + "mapped", + [ + 68840 + ] + ], + [ + [ + 68777, + 68777 + ], + "mapped", + [ + 68841 + ] + ], + [ + [ + 68778, + 68778 + ], + "mapped", + [ + 68842 + ] + ], + [ + [ + 68779, + 68779 + ], + "mapped", + [ + 68843 + ] + ], + [ + [ + 68780, + 68780 + ], + "mapped", + [ + 68844 + ] + ], + [ + [ + 68781, + 68781 + ], + "mapped", + [ + 68845 + ] + ], + [ + [ + 68782, + 68782 + ], + "mapped", + [ + 68846 + ] + ], + [ + [ + 68783, + 68783 + ], + "mapped", + [ + 68847 + ] + ], + [ + [ + 68784, + 68784 + ], + "mapped", + [ + 68848 + ] + ], + [ + [ + 68785, + 68785 + ], + "mapped", + [ + 68849 + ] + ], + [ + [ + 68786, + 68786 + ], + "mapped", + [ + 68850 + ] + ], + [ + [ + 68787, + 68799 + ], + "disallowed" + ], + [ + [ + 68800, + 68850 + ], + "valid" + ], + [ + [ + 68851, + 68857 + ], + "disallowed" + ], + [ + [ + 68858, + 68863 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 68864, + 69215 + ], + "disallowed" + ], + [ + [ + 69216, + 69246 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 69247, + 69631 + ], + "disallowed" + ], + [ + [ + 69632, + 69702 + ], + "valid" + ], + [ + [ + 69703, + 69709 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 69710, + 69713 + ], + "disallowed" + ], + [ + [ + 69714, + 69733 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 69734, + 69743 + ], + "valid" + ], + [ + [ + 69744, + 69758 + ], + "disallowed" + ], + [ + [ + 69759, + 69759 + ], + "valid" + ], + [ + [ + 69760, + 69818 + ], + "valid" + ], + [ + [ + 69819, + 69820 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 69821, + 69821 + ], + "disallowed" + ], + [ + [ + 69822, + 69825 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 69826, + 69839 + ], + "disallowed" + ], + [ + [ + 69840, + 69864 + ], + "valid" + ], + [ + [ + 69865, + 69871 + ], + "disallowed" + ], + [ + [ + 69872, + 69881 + ], + "valid" + ], + [ + [ + 69882, + 69887 + ], + "disallowed" + ], + [ + [ + 69888, + 69940 + ], + "valid" + ], + [ + [ + 69941, + 69941 + ], + "disallowed" + ], + [ + [ + 69942, + 69951 + ], + "valid" + ], + [ + [ + 69952, + 69955 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 69956, + 69967 + ], + "disallowed" + ], + [ + [ + 69968, + 70003 + ], + "valid" + ], + [ + [ + 70004, + 70005 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 70006, + 70006 + ], + "valid" + ], + [ + [ + 70007, + 70015 + ], + "disallowed" + ], + [ + [ + 70016, + 70084 + ], + "valid" + ], + [ + [ + 70085, + 70088 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 70089, + 70089 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 70090, + 70092 + ], + "valid" + ], + [ + [ + 70093, + 70093 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 70094, + 70095 + ], + "disallowed" + ], + [ + [ + 70096, + 70105 + ], + "valid" + ], + [ + [ + 70106, + 70106 + ], + "valid" + ], + [ + [ + 70107, + 70107 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 70108, + 70108 + ], + "valid" + ], + [ + [ + 70109, + 70111 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 70112, + 70112 + ], + "disallowed" + ], + [ + [ + 70113, + 70132 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 70133, + 70143 + ], + "disallowed" + ], + [ + [ + 70144, + 70161 + ], + "valid" + ], + [ + [ + 70162, + 70162 + ], + "disallowed" + ], + [ + [ + 70163, + 70199 + ], + "valid" + ], + [ + [ + 70200, + 70205 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 70206, + 70271 + ], + "disallowed" + ], + [ + [ + 70272, + 70278 + ], + "valid" + ], + [ + [ + 70279, + 70279 + ], + "disallowed" + ], + [ + [ + 70280, + 70280 + ], + "valid" + ], + [ + [ + 70281, + 70281 + ], + "disallowed" + ], + [ + [ + 70282, + 70285 + ], + "valid" + ], + [ + [ + 70286, + 70286 + ], + "disallowed" + ], + [ + [ + 70287, + 70301 + ], + "valid" + ], + [ + [ + 70302, + 70302 + ], + "disallowed" + ], + [ + [ + 70303, + 70312 + ], + "valid" + ], + [ + [ + 70313, + 70313 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 70314, + 70319 + ], + "disallowed" + ], + [ + [ + 70320, + 70378 + ], + "valid" + ], + [ + [ + 70379, + 70383 + ], + "disallowed" + ], + [ + [ + 70384, + 70393 + ], + "valid" + ], + [ + [ + 70394, + 70399 + ], + "disallowed" + ], + [ + [ + 70400, + 70400 + ], + "valid" + ], + [ + [ + 70401, + 70403 + ], + "valid" + ], + [ + [ + 70404, + 70404 + ], + "disallowed" + ], + [ + [ + 70405, + 70412 + ], + "valid" + ], + [ + [ + 70413, + 70414 + ], + "disallowed" + ], + [ + [ + 70415, + 70416 + ], + "valid" + ], + [ + [ + 70417, + 70418 + ], + "disallowed" + ], + [ + [ + 70419, + 70440 + ], + "valid" + ], + [ + [ + 70441, + 70441 + ], + "disallowed" + ], + [ + [ + 70442, + 70448 + ], + "valid" + ], + [ + [ + 70449, + 70449 + ], + "disallowed" + ], + [ + [ + 70450, + 70451 + ], + "valid" + ], + [ + [ + 70452, + 70452 + ], + "disallowed" + ], + [ + [ + 70453, + 70457 + ], + "valid" + ], + [ + [ + 70458, + 70459 + ], + "disallowed" + ], + [ + [ + 70460, + 70468 + ], + "valid" + ], + [ + [ + 70469, + 70470 + ], + "disallowed" + ], + [ + [ + 70471, + 70472 + ], + "valid" + ], + [ + [ + 70473, + 70474 + ], + "disallowed" + ], + [ + [ + 70475, + 70477 + ], + "valid" + ], + [ + [ + 70478, + 70479 + ], + "disallowed" + ], + [ + [ + 70480, + 70480 + ], + "valid" + ], + [ + [ + 70481, + 70486 + ], + "disallowed" + ], + [ + [ + 70487, + 70487 + ], + "valid" + ], + [ + [ + 70488, + 70492 + ], + "disallowed" + ], + [ + [ + 70493, + 70499 + ], + "valid" + ], + [ + [ + 70500, + 70501 + ], + "disallowed" + ], + [ + [ + 70502, + 70508 + ], + "valid" + ], + [ + [ + 70509, + 70511 + ], + "disallowed" + ], + [ + [ + 70512, + 70516 + ], + "valid" + ], + [ + [ + 70517, + 70783 + ], + "disallowed" + ], + [ + [ + 70784, + 70853 + ], + "valid" + ], + [ + [ + 70854, + 70854 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 70855, + 70855 + ], + "valid" + ], + [ + [ + 70856, + 70863 + ], + "disallowed" + ], + [ + [ + 70864, + 70873 + ], + "valid" + ], + [ + [ + 70874, + 71039 + ], + "disallowed" + ], + [ + [ + 71040, + 71093 + ], + "valid" + ], + [ + [ + 71094, + 71095 + ], + "disallowed" + ], + [ + [ + 71096, + 71104 + ], + "valid" + ], + [ + [ + 71105, + 71113 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 71114, + 71127 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 71128, + 71133 + ], + "valid" + ], + [ + [ + 71134, + 71167 + ], + "disallowed" + ], + [ + [ + 71168, + 71232 + ], + "valid" + ], + [ + [ + 71233, + 71235 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 71236, + 71236 + ], + "valid" + ], + [ + [ + 71237, + 71247 + ], + "disallowed" + ], + [ + [ + 71248, + 71257 + ], + "valid" + ], + [ + [ + 71258, + 71295 + ], + "disallowed" + ], + [ + [ + 71296, + 71351 + ], + "valid" + ], + [ + [ + 71352, + 71359 + ], + "disallowed" + ], + [ + [ + 71360, + 71369 + ], + "valid" + ], + [ + [ + 71370, + 71423 + ], + "disallowed" + ], + [ + [ + 71424, + 71449 + ], + "valid" + ], + [ + [ + 71450, + 71452 + ], + "disallowed" + ], + [ + [ + 71453, + 71467 + ], + "valid" + ], + [ + [ + 71468, + 71471 + ], + "disallowed" + ], + [ + [ + 71472, + 71481 + ], + "valid" + ], + [ + [ + 71482, + 71487 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 71488, + 71839 + ], + "disallowed" + ], + [ + [ + 71840, + 71840 + ], + "mapped", + [ + 71872 + ] + ], + [ + [ + 71841, + 71841 + ], + "mapped", + [ + 71873 + ] + ], + [ + [ + 71842, + 71842 + ], + "mapped", + [ + 71874 + ] + ], + [ + [ + 71843, + 71843 + ], + "mapped", + [ + 71875 + ] + ], + [ + [ + 71844, + 71844 + ], + "mapped", + [ + 71876 + ] + ], + [ + [ + 71845, + 71845 + ], + "mapped", + [ + 71877 + ] + ], + [ + [ + 71846, + 71846 + ], + "mapped", + [ + 71878 + ] + ], + [ + [ + 71847, + 71847 + ], + "mapped", + [ + 71879 + ] + ], + [ + [ + 71848, + 71848 + ], + "mapped", + [ + 71880 + ] + ], + [ + [ + 71849, + 71849 + ], + "mapped", + [ + 71881 + ] + ], + [ + [ + 71850, + 71850 + ], + "mapped", + [ + 71882 + ] + ], + [ + [ + 71851, + 71851 + ], + "mapped", + [ + 71883 + ] + ], + [ + [ + 71852, + 71852 + ], + "mapped", + [ + 71884 + ] + ], + [ + [ + 71853, + 71853 + ], + "mapped", + [ + 71885 + ] + ], + [ + [ + 71854, + 71854 + ], + "mapped", + [ + 71886 + ] + ], + [ + [ + 71855, + 71855 + ], + "mapped", + [ + 71887 + ] + ], + [ + [ + 71856, + 71856 + ], + "mapped", + [ + 71888 + ] + ], + [ + [ + 71857, + 71857 + ], + "mapped", + [ + 71889 + ] + ], + [ + [ + 71858, + 71858 + ], + "mapped", + [ + 71890 + ] + ], + [ + [ + 71859, + 71859 + ], + "mapped", + [ + 71891 + ] + ], + [ + [ + 71860, + 71860 + ], + "mapped", + [ + 71892 + ] + ], + [ + [ + 71861, + 71861 + ], + "mapped", + [ + 71893 + ] + ], + [ + [ + 71862, + 71862 + ], + "mapped", + [ + 71894 + ] + ], + [ + [ + 71863, + 71863 + ], + "mapped", + [ + 71895 + ] + ], + [ + [ + 71864, + 71864 + ], + "mapped", + [ + 71896 + ] + ], + [ + [ + 71865, + 71865 + ], + "mapped", + [ + 71897 + ] + ], + [ + [ + 71866, + 71866 + ], + "mapped", + [ + 71898 + ] + ], + [ + [ + 71867, + 71867 + ], + "mapped", + [ + 71899 + ] + ], + [ + [ + 71868, + 71868 + ], + "mapped", + [ + 71900 + ] + ], + [ + [ + 71869, + 71869 + ], + "mapped", + [ + 71901 + ] + ], + [ + [ + 71870, + 71870 + ], + "mapped", + [ + 71902 + ] + ], + [ + [ + 71871, + 71871 + ], + "mapped", + [ + 71903 + ] + ], + [ + [ + 71872, + 71913 + ], + "valid" + ], + [ + [ + 71914, + 71922 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 71923, + 71934 + ], + "disallowed" + ], + [ + [ + 71935, + 71935 + ], + "valid" + ], + [ + [ + 71936, + 72383 + ], + "disallowed" + ], + [ + [ + 72384, + 72440 + ], + "valid" + ], + [ + [ + 72441, + 73727 + ], + "disallowed" + ], + [ + [ + 73728, + 74606 + ], + "valid" + ], + [ + [ + 74607, + 74648 + ], + "valid" + ], + [ + [ + 74649, + 74649 + ], + "valid" + ], + [ + [ + 74650, + 74751 + ], + "disallowed" + ], + [ + [ + 74752, + 74850 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 74851, + 74862 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 74863, + 74863 + ], + "disallowed" + ], + [ + [ + 74864, + 74867 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 74868, + 74868 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 74869, + 74879 + ], + "disallowed" + ], + [ + [ + 74880, + 75075 + ], + "valid" + ], + [ + [ + 75076, + 77823 + ], + "disallowed" + ], + [ + [ + 77824, + 78894 + ], + "valid" + ], + [ + [ + 78895, + 82943 + ], + "disallowed" + ], + [ + [ + 82944, + 83526 + ], + "valid" + ], + [ + [ + 83527, + 92159 + ], + "disallowed" + ], + [ + [ + 92160, + 92728 + ], + "valid" + ], + [ + [ + 92729, + 92735 + ], + "disallowed" + ], + [ + [ + 92736, + 92766 + ], + "valid" + ], + [ + [ + 92767, + 92767 + ], + "disallowed" + ], + [ + [ + 92768, + 92777 + ], + "valid" + ], + [ + [ + 92778, + 92781 + ], + "disallowed" + ], + [ + [ + 92782, + 92783 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 92784, + 92879 + ], + "disallowed" + ], + [ + [ + 92880, + 92909 + ], + "valid" + ], + [ + [ + 92910, + 92911 + ], + "disallowed" + ], + [ + [ + 92912, + 92916 + ], + "valid" + ], + [ + [ + 92917, + 92917 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 92918, + 92927 + ], + "disallowed" + ], + [ + [ + 92928, + 92982 + ], + "valid" + ], + [ + [ + 92983, + 92991 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 92992, + 92995 + ], + "valid" + ], + [ + [ + 92996, + 92997 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 92998, + 93007 + ], + "disallowed" + ], + [ + [ + 93008, + 93017 + ], + "valid" + ], + [ + [ + 93018, + 93018 + ], + "disallowed" + ], + [ + [ + 93019, + 93025 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 93026, + 93026 + ], + "disallowed" + ], + [ + [ + 93027, + 93047 + ], + "valid" + ], + [ + [ + 93048, + 93052 + ], + "disallowed" + ], + [ + [ + 93053, + 93071 + ], + "valid" + ], + [ + [ + 93072, + 93951 + ], + "disallowed" + ], + [ + [ + 93952, + 94020 + ], + "valid" + ], + [ + [ + 94021, + 94031 + ], + "disallowed" + ], + [ + [ + 94032, + 94078 + ], + "valid" + ], + [ + [ + 94079, + 94094 + ], + "disallowed" + ], + [ + [ + 94095, + 94111 + ], + "valid" + ], + [ + [ + 94112, + 110591 + ], + "disallowed" + ], + [ + [ + 110592, + 110593 + ], + "valid" + ], + [ + [ + 110594, + 113663 + ], + "disallowed" + ], + [ + [ + 113664, + 113770 + ], + "valid" + ], + [ + [ + 113771, + 113775 + ], + "disallowed" + ], + [ + [ + 113776, + 113788 + ], + "valid" + ], + [ + [ + 113789, + 113791 + ], + "disallowed" + ], + [ + [ + 113792, + 113800 + ], + "valid" + ], + [ + [ + 113801, + 113807 + ], + "disallowed" + ], + [ + [ + 113808, + 113817 + ], + "valid" + ], + [ + [ + 113818, + 113819 + ], + "disallowed" + ], + [ + [ + 113820, + 113820 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 113821, + 113822 + ], + "valid" + ], + [ + [ + 113823, + 113823 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 113824, + 113827 + ], + "ignored" + ], + [ + [ + 113828, + 118783 + ], + "disallowed" + ], + [ + [ + 118784, + 119029 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 119030, + 119039 + ], + "disallowed" + ], + [ + [ + 119040, + 119078 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 119079, + 119080 + ], + "disallowed" + ], + [ + [ + 119081, + 119081 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 119082, + 119133 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 119134, + 119134 + ], + "mapped", + [ + 119127, + 119141 + ] + ], + [ + [ + 119135, + 119135 + ], + "mapped", + [ + 119128, + 119141 + ] + ], + [ + [ + 119136, + 119136 + ], + "mapped", + [ + 119128, + 119141, + 119150 + ] + ], + [ + [ + 119137, + 119137 + ], + "mapped", + [ + 119128, + 119141, + 119151 + ] + ], + [ + [ + 119138, + 119138 + ], + "mapped", + [ + 119128, + 119141, + 119152 + ] + ], + [ + [ + 119139, + 119139 + ], + "mapped", + [ + 119128, + 119141, + 119153 + ] + ], + [ + [ + 119140, + 119140 + ], + "mapped", + [ + 119128, + 119141, + 119154 + ] + ], + [ + [ + 119141, + 119154 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 119155, + 119162 + ], + "disallowed" + ], + [ + [ + 119163, + 119226 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 119227, + 119227 + ], + "mapped", + [ + 119225, + 119141 + ] + ], + [ + [ + 119228, + 119228 + ], + "mapped", + [ + 119226, + 119141 + ] + ], + [ + [ + 119229, + 119229 + ], + "mapped", + [ + 119225, + 119141, + 119150 + ] + ], + [ + [ + 119230, + 119230 + ], + "mapped", + [ + 119226, + 119141, + 119150 + ] + ], + [ + [ + 119231, + 119231 + ], + "mapped", + [ + 119225, + 119141, + 119151 + ] + ], + [ + [ + 119232, + 119232 + ], + "mapped", + [ + 119226, + 119141, + 119151 + ] + ], + [ + [ + 119233, + 119261 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 119262, + 119272 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 119273, + 119295 + ], + "disallowed" + ], + [ + [ + 119296, + 119365 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 119366, + 119551 + ], + "disallowed" + ], + [ + [ + 119552, + 119638 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 119639, + 119647 + ], + "disallowed" + ], + [ + [ + 119648, + 119665 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 119666, + 119807 + ], + "disallowed" + ], + [ + [ + 119808, + 119808 + ], + "mapped", + [ + 97 + ] + ], + [ + [ + 119809, + 119809 + ], + "mapped", + [ + 98 + ] + ], + [ + [ + 119810, + 119810 + ], + "mapped", + [ + 99 + ] + ], + [ + [ + 119811, + 119811 + ], + "mapped", + [ + 100 + ] + ], + [ + [ + 119812, + 119812 + ], + "mapped", + [ + 101 + ] + ], + [ + [ + 119813, + 119813 + ], + "mapped", + [ + 102 + ] + ], + [ + [ + 119814, + 119814 + ], + "mapped", + [ + 103 + ] + ], + [ + [ + 119815, + 119815 + ], + "mapped", + [ + 104 + ] + ], + [ + [ + 119816, + 119816 + ], + "mapped", + [ + 105 + ] + ], + [ + [ + 119817, + 119817 + ], + "mapped", + [ + 106 + ] + ], + [ + [ + 119818, + 119818 + ], + "mapped", + [ + 107 + ] + ], + [ + [ + 119819, + 119819 + ], + "mapped", + [ + 108 + ] + ], + [ + [ + 119820, + 119820 + ], + "mapped", + [ + 109 + ] + ], + [ + [ + 119821, + 119821 + ], + "mapped", + [ + 110 + ] + ], + [ + [ + 119822, + 119822 + ], + "mapped", + [ + 111 + ] + ], + [ + [ + 119823, + 119823 + ], + "mapped", + [ + 112 + ] + ], + [ + [ + 119824, + 119824 + ], + "mapped", + [ + 113 + ] + ], + [ + [ + 119825, + 119825 + ], + "mapped", + [ + 114 + ] + ], + [ + [ + 119826, + 119826 + ], + "mapped", + [ + 115 + ] + ], + [ + [ + 119827, + 119827 + ], + "mapped", + [ + 116 + ] + ], + [ + [ + 119828, + 119828 + ], + "mapped", + [ + 117 + ] + ], + [ + [ + 119829, + 119829 + ], + "mapped", + [ + 118 + ] + ], + [ + [ + 119830, + 119830 + ], + "mapped", + [ + 119 + ] + ], + [ + [ + 119831, + 119831 + ], + "mapped", + [ + 120 + ] + ], + [ + [ + 119832, + 119832 + ], + "mapped", + [ + 121 + ] + ], + [ + [ + 119833, + 119833 + ], + "mapped", + [ + 122 + ] + ], + [ + [ + 119834, + 119834 + ], + "mapped", + [ + 97 + ] + ], + [ + [ + 119835, + 119835 + ], + "mapped", + [ + 98 + ] + ], + [ + [ + 119836, + 119836 + ], + "mapped", + [ + 99 + ] + ], + [ + [ + 119837, + 119837 + ], + "mapped", + [ + 100 + ] + ], + [ + [ + 119838, + 119838 + ], + "mapped", + [ + 101 + ] + ], + [ + [ + 119839, + 119839 + ], + "mapped", + [ + 102 + ] + ], + [ + [ + 119840, + 119840 + ], + "mapped", + [ + 103 + ] + ], + [ + [ + 119841, + 119841 + ], + "mapped", + [ + 104 + ] + ], + [ + [ + 119842, + 119842 + ], + "mapped", + [ + 105 + ] + ], + [ + [ + 119843, + 119843 + ], + "mapped", + [ + 106 + ] + ], + [ + [ + 119844, + 119844 + ], + "mapped", + [ + 107 + ] + ], + [ + [ + 119845, + 119845 + ], + "mapped", + [ + 108 + ] + ], + [ + [ + 119846, + 119846 + ], + "mapped", + [ + 109 + ] + ], + [ + [ + 119847, + 119847 + ], + "mapped", + [ + 110 + ] + ], + [ + [ + 119848, + 119848 + ], + "mapped", + [ + 111 + ] + ], + [ + [ + 119849, + 119849 + ], + "mapped", + [ + 112 + ] + ], + [ + [ + 119850, + 119850 + ], + "mapped", + [ + 113 + ] + ], + [ + [ + 119851, + 119851 + ], + "mapped", + [ + 114 + ] + ], + [ + [ + 119852, + 119852 + ], + "mapped", + [ + 115 + ] + ], + [ + [ + 119853, + 119853 + ], + "mapped", + [ + 116 + ] + ], + [ + [ + 119854, + 119854 + ], + "mapped", + [ + 117 + ] + ], + [ + [ + 119855, + 119855 + ], + "mapped", + [ + 118 + ] + ], + [ + [ + 119856, + 119856 + ], + "mapped", + [ + 119 + ] + ], + [ + [ + 119857, + 119857 + ], + "mapped", + [ + 120 + ] + ], + [ + [ + 119858, + 119858 + ], + "mapped", + [ + 121 + ] + ], + [ + [ + 119859, + 119859 + ], + "mapped", + [ + 122 + ] + ], + [ + [ + 119860, + 119860 + ], + "mapped", + [ + 97 + ] + ], + [ + [ + 119861, + 119861 + ], + "mapped", + [ + 98 + ] + ], + [ + [ + 119862, + 119862 + ], + "mapped", + [ + 99 + ] + ], + [ + [ + 119863, + 119863 + ], + "mapped", + [ + 100 + ] + ], + [ + [ + 119864, + 119864 + ], + "mapped", + [ + 101 + ] + ], + [ + [ + 119865, + 119865 + ], + "mapped", + [ + 102 + ] + ], + [ + [ + 119866, + 119866 + ], + "mapped", + [ + 103 + ] + ], + [ + [ + 119867, + 119867 + ], + "mapped", + [ + 104 + ] + ], + [ + [ + 119868, + 119868 + ], + "mapped", + [ + 105 + ] + ], + [ + [ + 119869, + 119869 + ], + "mapped", + [ + 106 + ] + ], + [ + [ + 119870, + 119870 + ], + "mapped", + [ + 107 + ] + ], + [ + [ + 119871, + 119871 + ], + "mapped", + [ + 108 + ] + ], + [ + [ + 119872, + 119872 + ], + "mapped", + [ + 109 + ] + ], + [ + [ + 119873, + 119873 + ], + "mapped", + [ + 110 + ] + ], + [ + [ + 119874, + 119874 + ], + "mapped", + [ + 111 + ] + ], + [ + [ + 119875, + 119875 + ], + "mapped", + [ + 112 + ] + ], + [ + [ + 119876, + 119876 + ], + "mapped", + [ + 113 + ] + ], + [ + [ + 119877, + 119877 + ], + "mapped", + [ + 114 + ] + ], + [ + [ + 119878, + 119878 + ], + "mapped", + [ + 115 + ] + ], + [ + [ + 119879, + 119879 + ], + "mapped", + [ + 116 + ] + ], + [ + [ + 119880, + 119880 + ], + "mapped", + [ + 117 + ] + ], + [ + [ + 119881, + 119881 + ], + "mapped", + [ + 118 + ] + ], + [ + [ + 119882, + 119882 + ], + "mapped", + [ + 119 + ] + ], + [ + [ + 119883, + 119883 + ], + "mapped", + [ + 120 + ] + ], + [ + [ + 119884, + 119884 + ], + "mapped", + [ + 121 + ] + ], + [ + [ + 119885, + 119885 + ], + "mapped", + [ + 122 + ] + ], + [ + [ + 119886, + 119886 + ], + "mapped", + [ + 97 + ] + ], + [ + [ + 119887, + 119887 + ], + "mapped", + [ + 98 + ] + ], + [ + [ + 119888, + 119888 + ], + "mapped", + [ + 99 + ] + ], + [ + [ + 119889, + 119889 + ], + "mapped", + [ + 100 + ] + ], + [ + [ + 119890, + 119890 + ], + "mapped", + [ + 101 + ] + ], + [ + [ + 119891, + 119891 + ], + "mapped", + [ + 102 + ] + ], + [ + [ + 119892, + 119892 + ], + "mapped", + [ + 103 + ] + ], + [ + [ + 119893, + 119893 + ], + "disallowed" + ], + [ + [ + 119894, + 119894 + ], + "mapped", + [ + 105 + ] + ], + [ + [ + 119895, + 119895 + ], + "mapped", + [ + 106 + ] + ], + [ + [ + 119896, + 119896 + ], + "mapped", + [ + 107 + ] + ], + [ + [ + 119897, + 119897 + ], + "mapped", + [ + 108 + ] + ], + [ + [ + 119898, + 119898 + ], + "mapped", + [ + 109 + ] + ], + [ + [ + 119899, + 119899 + ], + "mapped", + [ + 110 + ] + ], + [ + [ + 119900, + 119900 + ], + "mapped", + [ + 111 + ] + ], + [ + [ + 119901, + 119901 + ], + "mapped", + [ + 112 + ] + ], + [ + [ + 119902, + 119902 + ], + "mapped", + [ + 113 + ] + ], + [ + [ + 119903, + 119903 + ], + "mapped", + [ + 114 + ] + ], + [ + [ + 119904, + 119904 + ], + "mapped", + [ + 115 + ] + ], + [ + [ + 119905, + 119905 + ], + "mapped", + [ + 116 + ] + ], + [ + [ + 119906, + 119906 + ], + "mapped", + [ + 117 + ] + ], + [ + [ + 119907, + 119907 + ], + "mapped", + [ + 118 + ] + ], + [ + [ + 119908, + 119908 + ], + "mapped", + [ + 119 + ] + ], + [ + [ + 119909, + 119909 + ], + "mapped", + [ + 120 + ] + ], + [ + [ + 119910, + 119910 + ], + "mapped", + [ + 121 + ] + ], + [ + [ + 119911, + 119911 + ], + "mapped", + [ + 122 + ] + ], + [ + [ + 119912, + 119912 + ], + "mapped", + [ + 97 + ] + ], + [ + [ + 119913, + 119913 + ], + "mapped", + [ + 98 + ] + ], + [ + [ + 119914, + 119914 + ], + "mapped", + [ + 99 + ] + ], + [ + [ + 119915, + 119915 + ], + "mapped", + [ + 100 + ] + ], + [ + [ + 119916, + 119916 + ], + "mapped", + [ + 101 + ] + ], + [ + [ + 119917, + 119917 + ], + "mapped", + [ + 102 + ] + ], + [ + [ + 119918, + 119918 + ], + "mapped", + [ + 103 + ] + ], + [ + [ + 119919, + 119919 + ], + "mapped", + [ + 104 + ] + ], + [ + [ + 119920, + 119920 + ], + "mapped", + [ + 105 + ] + ], + [ + [ + 119921, + 119921 + ], + "mapped", + [ + 106 + ] + ], + [ + [ + 119922, + 119922 + ], + "mapped", + [ + 107 + ] + ], + [ + [ + 119923, + 119923 + ], + "mapped", + [ + 108 + ] + ], + [ + [ + 119924, + 119924 + ], + "mapped", + [ + 109 + ] + ], + [ + [ + 119925, + 119925 + ], + "mapped", + [ + 110 + ] + ], + [ + [ + 119926, + 119926 + ], + "mapped", + [ + 111 + ] + ], + [ + [ + 119927, + 119927 + ], + "mapped", + [ + 112 + ] + ], + [ + [ + 119928, + 119928 + ], + "mapped", + [ + 113 + ] + ], + [ + [ + 119929, + 119929 + ], + "mapped", + [ + 114 + ] + ], + [ + [ + 119930, + 119930 + ], + "mapped", + [ + 115 + ] + ], + [ + [ + 119931, + 119931 + ], + "mapped", + [ + 116 + ] + ], + [ + [ + 119932, + 119932 + ], + "mapped", + [ + 117 + ] + ], + [ + [ + 119933, + 119933 + ], + "mapped", + [ + 118 + ] + ], + [ + [ + 119934, + 119934 + ], + "mapped", + [ + 119 + ] + ], + [ + [ + 119935, + 119935 + ], + "mapped", + [ + 120 + ] + ], + [ + [ + 119936, + 119936 + ], + "mapped", + [ + 121 + ] + ], + [ + [ + 119937, + 119937 + ], + "mapped", + [ + 122 + ] + ], + [ + [ + 119938, + 119938 + ], + "mapped", + [ + 97 + ] + ], + [ + [ + 119939, + 119939 + ], + "mapped", + [ + 98 + ] + ], + [ + [ + 119940, + 119940 + ], + "mapped", + [ + 99 + ] + ], + [ + [ + 119941, + 119941 + ], + "mapped", + [ + 100 + ] + ], + [ + [ + 119942, + 119942 + ], + "mapped", + [ + 101 + ] + ], + [ + [ + 119943, + 119943 + ], + "mapped", + [ + 102 + ] + ], + [ + [ + 119944, + 119944 + ], + "mapped", + [ + 103 + ] + ], + [ + [ + 119945, + 119945 + ], + "mapped", + [ + 104 + ] + ], + [ + [ + 119946, + 119946 + ], + "mapped", + [ + 105 + ] + ], + [ + [ + 119947, + 119947 + ], + "mapped", + [ + 106 + ] + ], + [ + [ + 119948, + 119948 + ], + "mapped", + [ + 107 + ] + ], + [ + [ + 119949, + 119949 + ], + "mapped", + [ + 108 + ] + ], + [ + [ + 119950, + 119950 + ], + "mapped", + [ + 109 + ] + ], + [ + [ + 119951, + 119951 + ], + "mapped", + [ + 110 + ] + ], + [ + [ + 119952, + 119952 + ], + "mapped", + [ + 111 + ] + ], + [ + [ + 119953, + 119953 + ], + "mapped", + [ + 112 + ] + ], + [ + [ + 119954, + 119954 + ], + "mapped", + [ + 113 + ] + ], + [ + [ + 119955, + 119955 + ], + "mapped", + [ + 114 + ] + ], + [ + [ + 119956, + 119956 + ], + "mapped", + [ + 115 + ] + ], + [ + [ + 119957, + 119957 + ], + "mapped", + [ + 116 + ] + ], + [ + [ + 119958, + 119958 + ], + "mapped", + [ + 117 + ] + ], + [ + [ + 119959, + 119959 + ], + "mapped", + [ + 118 + ] + ], + [ + [ + 119960, + 119960 + ], + "mapped", + [ + 119 + ] + ], + [ + [ + 119961, + 119961 + ], + "mapped", + [ + 120 + ] + ], + [ + [ + 119962, + 119962 + ], + "mapped", + [ + 121 + ] + ], + [ + [ + 119963, + 119963 + ], + "mapped", + [ + 122 + ] + ], + [ + [ + 119964, + 119964 + ], + "mapped", + [ + 97 + ] + ], + [ + [ + 119965, + 119965 + ], + "disallowed" + ], + [ + [ + 119966, + 119966 + ], + "mapped", + [ + 99 + ] + ], + [ + [ + 119967, + 119967 + ], + "mapped", + [ + 100 + ] + ], + [ + [ + 119968, + 119969 + ], + "disallowed" + ], + [ + [ + 119970, + 119970 + ], + "mapped", + [ + 103 + ] + ], + [ + [ + 119971, + 119972 + ], + "disallowed" + ], + [ + [ + 119973, + 119973 + ], + "mapped", + [ + 106 + ] + ], + [ + [ + 119974, + 119974 + ], + "mapped", + [ + 107 + ] + ], + [ + [ + 119975, + 119976 + ], + "disallowed" + ], + [ + [ + 119977, + 119977 + ], + "mapped", + [ + 110 + ] + ], + [ + [ + 119978, + 119978 + ], + "mapped", + [ + 111 + ] + ], + [ + [ + 119979, + 119979 + ], + "mapped", + [ + 112 + ] + ], + [ + [ + 119980, + 119980 + ], + "mapped", + [ + 113 + ] + ], + [ + [ + 119981, + 119981 + ], + "disallowed" + ], + [ + [ + 119982, + 119982 + ], + "mapped", + [ + 115 + ] + ], + [ + [ + 119983, + 119983 + ], + "mapped", + [ + 116 + ] + ], + [ + [ + 119984, + 119984 + ], + "mapped", + [ + 117 + ] + ], + [ + [ + 119985, + 119985 + ], + "mapped", + [ + 118 + ] + ], + [ + [ + 119986, + 119986 + ], + "mapped", + [ + 119 + ] + ], + [ + [ + 119987, + 119987 + ], + "mapped", + [ + 120 + ] + ], + [ + [ + 119988, + 119988 + ], + "mapped", + [ + 121 + ] + ], + [ + [ + 119989, + 119989 + ], + "mapped", + [ + 122 + ] + ], + [ + [ + 119990, + 119990 + ], + "mapped", + [ + 97 + ] + ], + [ + [ + 119991, + 119991 + ], + "mapped", + [ + 98 + ] + ], + [ + [ + 119992, + 119992 + ], + "mapped", + [ + 99 + ] + ], + [ + [ + 119993, + 119993 + ], + "mapped", + [ + 100 + ] + ], + [ + [ + 119994, + 119994 + ], + "disallowed" + ], + [ + [ + 119995, + 119995 + ], + "mapped", + [ + 102 + ] + ], + [ + [ + 119996, + 119996 + ], + "disallowed" + ], + [ + [ + 119997, + 119997 + ], + "mapped", + [ + 104 + ] + ], + [ + [ + 119998, + 119998 + ], + "mapped", + [ + 105 + ] + ], + [ + [ + 119999, + 119999 + ], + "mapped", + [ + 106 + ] + ], + [ + [ + 120000, + 120000 + ], + "mapped", + [ + 107 + ] + ], + [ + [ + 120001, + 120001 + ], + "mapped", + [ + 108 + ] + ], + [ + [ + 120002, + 120002 + ], + "mapped", + [ + 109 + ] + ], + [ + [ + 120003, + 120003 + ], + "mapped", + [ + 110 + ] + ], + [ + [ + 120004, + 120004 + ], + "disallowed" + ], + [ + [ + 120005, + 120005 + ], + "mapped", + [ + 112 + ] + ], + [ + [ + 120006, + 120006 + ], + "mapped", + [ + 113 + ] + ], + [ + [ + 120007, + 120007 + ], + "mapped", + [ + 114 + ] + ], + [ + [ + 120008, + 120008 + ], + "mapped", + [ + 115 + ] + ], + [ + [ + 120009, + 120009 + ], + "mapped", + [ + 116 + ] + ], + [ + [ + 120010, + 120010 + ], + "mapped", + [ + 117 + ] + ], + [ + [ + 120011, + 120011 + ], + "mapped", + [ + 118 + ] + ], + [ + [ + 120012, + 120012 + ], + "mapped", + [ + 119 + ] + ], + [ + [ + 120013, + 120013 + ], + "mapped", + [ + 120 + ] + ], + [ + [ + 120014, + 120014 + ], + "mapped", + [ + 121 + ] + ], + [ + [ + 120015, + 120015 + ], + "mapped", + [ + 122 + ] + ], + [ + [ + 120016, + 120016 + ], + "mapped", + [ + 97 + ] + ], + [ + [ + 120017, + 120017 + ], + "mapped", + [ + 98 + ] + ], + [ + [ + 120018, + 120018 + ], + "mapped", + [ + 99 + ] + ], + [ + [ + 120019, + 120019 + ], + "mapped", + [ + 100 + ] + ], + [ + [ + 120020, + 120020 + ], + "mapped", + [ + 101 + ] + ], + [ + [ + 120021, + 120021 + ], + "mapped", + [ + 102 + ] + ], + [ + [ + 120022, + 120022 + ], + "mapped", + [ + 103 + ] + ], + [ + [ + 120023, + 120023 + ], + "mapped", + [ + 104 + ] + ], + [ + [ + 120024, + 120024 + ], + "mapped", + [ + 105 + ] + ], + [ + [ + 120025, + 120025 + ], + "mapped", + [ + 106 + ] + ], + [ + [ + 120026, + 120026 + ], + "mapped", + [ + 107 + ] + ], + [ + [ + 120027, + 120027 + ], + "mapped", + [ + 108 + ] + ], + [ + [ + 120028, + 120028 + ], + "mapped", + [ + 109 + ] + ], + [ + [ + 120029, + 120029 + ], + "mapped", + [ + 110 + ] + ], + [ + [ + 120030, + 120030 + ], + "mapped", + [ + 111 + ] + ], + [ + [ + 120031, + 120031 + ], + "mapped", + [ + 112 + ] + ], + [ + [ + 120032, + 120032 + ], + "mapped", + [ + 113 + ] + ], + [ + [ + 120033, + 120033 + ], + "mapped", + [ + 114 + ] + ], + [ + [ + 120034, + 120034 + ], + "mapped", + [ + 115 + ] + ], + [ + [ + 120035, + 120035 + ], + "mapped", + [ + 116 + ] + ], + [ + [ + 120036, + 120036 + ], + "mapped", + [ + 117 + ] + ], + [ + [ + 120037, + 120037 + ], + "mapped", + [ + 118 + ] + ], + [ + [ + 120038, + 120038 + ], + "mapped", + [ + 119 + ] + ], + [ + [ + 120039, + 120039 + ], + "mapped", + [ + 120 + ] + ], + [ + [ + 120040, + 120040 + ], + "mapped", + [ + 121 + ] + ], + [ + [ + 120041, + 120041 + ], + "mapped", + [ + 122 + ] + ], + [ + [ + 120042, + 120042 + ], + "mapped", + [ + 97 + ] + ], + [ + [ + 120043, + 120043 + ], + "mapped", + [ + 98 + ] + ], + [ + [ + 120044, + 120044 + ], + "mapped", + [ + 99 + ] + ], + [ + [ + 120045, + 120045 + ], + "mapped", + [ + 100 + ] + ], + [ + [ + 120046, + 120046 + ], + "mapped", + [ + 101 + ] + ], + [ + [ + 120047, + 120047 + ], + "mapped", + [ + 102 + ] + ], + [ + [ + 120048, + 120048 + ], + "mapped", + [ + 103 + ] + ], + [ + [ + 120049, + 120049 + ], + "mapped", + [ + 104 + ] + ], + [ + [ + 120050, + 120050 + ], + "mapped", + [ + 105 + ] + ], + [ + [ + 120051, + 120051 + ], + "mapped", + [ + 106 + ] + ], + [ + [ + 120052, + 120052 + ], + "mapped", + [ + 107 + ] + ], + [ + [ + 120053, + 120053 + ], + "mapped", + [ + 108 + ] + ], + [ + [ + 120054, + 120054 + ], + "mapped", + [ + 109 + ] + ], + [ + [ + 120055, + 120055 + ], + "mapped", + [ + 110 + ] + ], + [ + [ + 120056, + 120056 + ], + "mapped", + [ + 111 + ] + ], + [ + [ + 120057, + 120057 + ], + "mapped", + [ + 112 + ] + ], + [ + [ + 120058, + 120058 + ], + "mapped", + [ + 113 + ] + ], + [ + [ + 120059, + 120059 + ], + "mapped", + [ + 114 + ] + ], + [ + [ + 120060, + 120060 + ], + "mapped", + [ + 115 + ] + ], + [ + [ + 120061, + 120061 + ], + "mapped", + [ + 116 + ] + ], + [ + [ + 120062, + 120062 + ], + "mapped", + [ + 117 + ] + ], + [ + [ + 120063, + 120063 + ], + "mapped", + [ + 118 + ] + ], + [ + [ + 120064, + 120064 + ], + "mapped", + [ + 119 + ] + ], + [ + [ + 120065, + 120065 + ], + "mapped", + [ + 120 + ] + ], + [ + [ + 120066, + 120066 + ], + "mapped", + [ + 121 + ] + ], + [ + [ + 120067, + 120067 + ], + "mapped", + [ + 122 + ] + ], + [ + [ + 120068, + 120068 + ], + "mapped", + [ + 97 + ] + ], + [ + [ + 120069, + 120069 + ], + "mapped", + [ + 98 + ] + ], + [ + [ + 120070, + 120070 + ], + "disallowed" + ], + [ + [ + 120071, + 120071 + ], + "mapped", + [ + 100 + ] + ], + [ + [ + 120072, + 120072 + ], + "mapped", + [ + 101 + ] + ], + [ + [ + 120073, + 120073 + ], + "mapped", + [ + 102 + ] + ], + [ + [ + 120074, + 120074 + ], + "mapped", + [ + 103 + ] + ], + [ + [ + 120075, + 120076 + ], + "disallowed" + ], + [ + [ + 120077, + 120077 + ], + "mapped", + [ + 106 + ] + ], + [ + [ + 120078, + 120078 + ], + "mapped", + [ + 107 + ] + ], + [ + [ + 120079, + 120079 + ], + "mapped", + [ + 108 + ] + ], + [ + [ + 120080, + 120080 + ], + "mapped", + [ + 109 + ] + ], + [ + [ + 120081, + 120081 + ], + "mapped", + [ + 110 + ] + ], + [ + [ + 120082, + 120082 + ], + "mapped", + [ + 111 + ] + ], + [ + [ + 120083, + 120083 + ], + "mapped", + [ + 112 + ] + ], + [ + [ + 120084, + 120084 + ], + "mapped", + [ + 113 + ] + ], + [ + [ + 120085, + 120085 + ], + "disallowed" + ], + [ + [ + 120086, + 120086 + ], + "mapped", + [ + 115 + ] + ], + [ + [ + 120087, + 120087 + ], + "mapped", + [ + 116 + ] + ], + [ + [ + 120088, + 120088 + ], + "mapped", + [ + 117 + ] + ], + [ + [ + 120089, + 120089 + ], + "mapped", + [ + 118 + ] + ], + [ + [ + 120090, + 120090 + ], + "mapped", + [ + 119 + ] + ], + [ + [ + 120091, + 120091 + ], + "mapped", + [ + 120 + ] + ], + [ + [ + 120092, + 120092 + ], + "mapped", + [ + 121 + ] + ], + [ + [ + 120093, + 120093 + ], + "disallowed" + ], + [ + [ + 120094, + 120094 + ], + "mapped", + [ + 97 + ] + ], + [ + [ + 120095, + 120095 + ], + "mapped", + [ + 98 + ] + ], + [ + [ + 120096, + 120096 + ], + "mapped", + [ + 99 + ] + ], + [ + [ + 120097, + 120097 + ], + "mapped", + [ + 100 + ] + ], + [ + [ + 120098, + 120098 + ], + "mapped", + [ + 101 + ] + ], + [ + [ + 120099, + 120099 + ], + "mapped", + [ + 102 + ] + ], + [ + [ + 120100, + 120100 + ], + "mapped", + [ + 103 + ] + ], + [ + [ + 120101, + 120101 + ], + "mapped", + [ + 104 + ] + ], + [ + [ + 120102, + 120102 + ], + "mapped", + [ + 105 + ] + ], + [ + [ + 120103, + 120103 + ], + "mapped", + [ + 106 + ] + ], + [ + [ + 120104, + 120104 + ], + "mapped", + [ + 107 + ] + ], + [ + [ + 120105, + 120105 + ], + "mapped", + [ + 108 + ] + ], + [ + [ + 120106, + 120106 + ], + "mapped", + [ + 109 + ] + ], + [ + [ + 120107, + 120107 + ], + "mapped", + [ + 110 + ] + ], + [ + [ + 120108, + 120108 + ], + "mapped", + [ + 111 + ] + ], + [ + [ + 120109, + 120109 + ], + "mapped", + [ + 112 + ] + ], + [ + [ + 120110, + 120110 + ], + "mapped", + [ + 113 + ] + ], + [ + [ + 120111, + 120111 + ], + "mapped", + [ + 114 + ] + ], + [ + [ + 120112, + 120112 + ], + "mapped", + [ + 115 + ] + ], + [ + [ + 120113, + 120113 + ], + "mapped", + [ + 116 + ] + ], + [ + [ + 120114, + 120114 + ], + "mapped", + [ + 117 + ] + ], + [ + [ + 120115, + 120115 + ], + "mapped", + [ + 118 + ] + ], + [ + [ + 120116, + 120116 + ], + "mapped", + [ + 119 + ] + ], + [ + [ + 120117, + 120117 + ], + "mapped", + [ + 120 + ] + ], + [ + [ + 120118, + 120118 + ], + "mapped", + [ + 121 + ] + ], + [ + [ + 120119, + 120119 + ], + "mapped", + [ + 122 + ] + ], + [ + [ + 120120, + 120120 + ], + "mapped", + [ + 97 + ] + ], + [ + [ + 120121, + 120121 + ], + "mapped", + [ + 98 + ] + ], + [ + [ + 120122, + 120122 + ], + "disallowed" + ], + [ + [ + 120123, + 120123 + ], + "mapped", + [ + 100 + ] + ], + [ + [ + 120124, + 120124 + ], + "mapped", + [ + 101 + ] + ], + [ + [ + 120125, + 120125 + ], + "mapped", + [ + 102 + ] + ], + [ + [ + 120126, + 120126 + ], + "mapped", + [ + 103 + ] + ], + [ + [ + 120127, + 120127 + ], + "disallowed" + ], + [ + [ + 120128, + 120128 + ], + "mapped", + [ + 105 + ] + ], + [ + [ + 120129, + 120129 + ], + "mapped", + [ + 106 + ] + ], + [ + [ + 120130, + 120130 + ], + "mapped", + [ + 107 + ] + ], + [ + [ + 120131, + 120131 + ], + "mapped", + [ + 108 + ] + ], + [ + [ + 120132, + 120132 + ], + "mapped", + [ + 109 + ] + ], + [ + [ + 120133, + 120133 + ], + "disallowed" + ], + [ + [ + 120134, + 120134 + ], + "mapped", + [ + 111 + ] + ], + [ + [ + 120135, + 120137 + ], + "disallowed" + ], + [ + [ + 120138, + 120138 + ], + "mapped", + [ + 115 + ] + ], + [ + [ + 120139, + 120139 + ], + "mapped", + [ + 116 + ] + ], + [ + [ + 120140, + 120140 + ], + "mapped", + [ + 117 + ] + ], + [ + [ + 120141, + 120141 + ], + "mapped", + [ + 118 + ] + ], + [ + [ + 120142, + 120142 + ], + "mapped", + [ + 119 + ] + ], + [ + [ + 120143, + 120143 + ], + "mapped", + [ + 120 + ] + ], + [ + [ + 120144, + 120144 + ], + "mapped", + [ + 121 + ] + ], + [ + [ + 120145, + 120145 + ], + "disallowed" + ], + [ + [ + 120146, + 120146 + ], + "mapped", + [ + 97 + ] + ], + [ + [ + 120147, + 120147 + ], + "mapped", + [ + 98 + ] + ], + [ + [ + 120148, + 120148 + ], + "mapped", + [ + 99 + ] + ], + [ + [ + 120149, + 120149 + ], + "mapped", + [ + 100 + ] + ], + [ + [ + 120150, + 120150 + ], + "mapped", + [ + 101 + ] + ], + [ + [ + 120151, + 120151 + ], + "mapped", + [ + 102 + ] + ], + [ + [ + 120152, + 120152 + ], + "mapped", + [ + 103 + ] + ], + [ + [ + 120153, + 120153 + ], + "mapped", + [ + 104 + ] + ], + [ + [ + 120154, + 120154 + ], + "mapped", + [ + 105 + ] + ], + [ + [ + 120155, + 120155 + ], + "mapped", + [ + 106 + ] + ], + [ + [ + 120156, + 120156 + ], + "mapped", + [ + 107 + ] + ], + [ + [ + 120157, + 120157 + ], + "mapped", + [ + 108 + ] + ], + [ + [ + 120158, + 120158 + ], + "mapped", + [ + 109 + ] + ], + [ + [ + 120159, + 120159 + ], + "mapped", + [ + 110 + ] + ], + [ + [ + 120160, + 120160 + ], + "mapped", + [ + 111 + ] + ], + [ + [ + 120161, + 120161 + ], + "mapped", + [ + 112 + ] + ], + [ + [ + 120162, + 120162 + ], + "mapped", + [ + 113 + ] + ], + [ + [ + 120163, + 120163 + ], + "mapped", + [ + 114 + ] + ], + [ + [ + 120164, + 120164 + ], + "mapped", + [ + 115 + ] + ], + [ + [ + 120165, + 120165 + ], + "mapped", + [ + 116 + ] + ], + [ + [ + 120166, + 120166 + ], + "mapped", + [ + 117 + ] + ], + [ + [ + 120167, + 120167 + ], + "mapped", + [ + 118 + ] + ], + [ + [ + 120168, + 120168 + ], + "mapped", + [ + 119 + ] + ], + [ + [ + 120169, + 120169 + ], + "mapped", + [ + 120 + ] + ], + [ + [ + 120170, + 120170 + ], + "mapped", + [ + 121 + ] + ], + [ + [ + 120171, + 120171 + ], + "mapped", + [ + 122 + ] + ], + [ + [ + 120172, + 120172 + ], + "mapped", + [ + 97 + ] + ], + [ + [ + 120173, + 120173 + ], + "mapped", + [ + 98 + ] + ], + [ + [ + 120174, + 120174 + ], + "mapped", + [ + 99 + ] + ], + [ + [ + 120175, + 120175 + ], + "mapped", + [ + 100 + ] + ], + [ + [ + 120176, + 120176 + ], + "mapped", + [ + 101 + ] + ], + [ + [ + 120177, + 120177 + ], + "mapped", + [ + 102 + ] + ], + [ + [ + 120178, + 120178 + ], + "mapped", + [ + 103 + ] + ], + [ + [ + 120179, + 120179 + ], + "mapped", + [ + 104 + ] + ], + [ + [ + 120180, + 120180 + ], + "mapped", + [ + 105 + ] + ], + [ + [ + 120181, + 120181 + ], + "mapped", + [ + 106 + ] + ], + [ + [ + 120182, + 120182 + ], + "mapped", + [ + 107 + ] + ], + [ + [ + 120183, + 120183 + ], + "mapped", + [ + 108 + ] + ], + [ + [ + 120184, + 120184 + ], + "mapped", + [ + 109 + ] + ], + [ + [ + 120185, + 120185 + ], + "mapped", + [ + 110 + ] + ], + [ + [ + 120186, + 120186 + ], + "mapped", + [ + 111 + ] + ], + [ + [ + 120187, + 120187 + ], + "mapped", + [ + 112 + ] + ], + [ + [ + 120188, + 120188 + ], + "mapped", + [ + 113 + ] + ], + [ + [ + 120189, + 120189 + ], + "mapped", + [ + 114 + ] + ], + [ + [ + 120190, + 120190 + ], + "mapped", + [ + 115 + ] + ], + [ + [ + 120191, + 120191 + ], + "mapped", + [ + 116 + ] + ], + [ + [ + 120192, + 120192 + ], + "mapped", + [ + 117 + ] + ], + [ + [ + 120193, + 120193 + ], + "mapped", + [ + 118 + ] + ], + [ + [ + 120194, + 120194 + ], + "mapped", + [ + 119 + ] + ], + [ + [ + 120195, + 120195 + ], + "mapped", + [ + 120 + ] + ], + [ + [ + 120196, + 120196 + ], + "mapped", + [ + 121 + ] + ], + [ + [ + 120197, + 120197 + ], + "mapped", + [ + 122 + ] + ], + [ + [ + 120198, + 120198 + ], + "mapped", + [ + 97 + ] + ], + [ + [ + 120199, + 120199 + ], + "mapped", + [ + 98 + ] + ], + [ + [ + 120200, + 120200 + ], + "mapped", + [ + 99 + ] + ], + [ + [ + 120201, + 120201 + ], + "mapped", + [ + 100 + ] + ], + [ + [ + 120202, + 120202 + ], + "mapped", + [ + 101 + ] + ], + [ + [ + 120203, + 120203 + ], + "mapped", + [ + 102 + ] + ], + [ + [ + 120204, + 120204 + ], + "mapped", + [ + 103 + ] + ], + [ + [ + 120205, + 120205 + ], + "mapped", + [ + 104 + ] + ], + [ + [ + 120206, + 120206 + ], + "mapped", + [ + 105 + ] + ], + [ + [ + 120207, + 120207 + ], + "mapped", + [ + 106 + ] + ], + [ + [ + 120208, + 120208 + ], + "mapped", + [ + 107 + ] + ], + [ + [ + 120209, + 120209 + ], + "mapped", + [ + 108 + ] + ], + [ + [ + 120210, + 120210 + ], + "mapped", + [ + 109 + ] + ], + [ + [ + 120211, + 120211 + ], + "mapped", + [ + 110 + ] + ], + [ + [ + 120212, + 120212 + ], + "mapped", + [ + 111 + ] + ], + [ + [ + 120213, + 120213 + ], + "mapped", + [ + 112 + ] + ], + [ + [ + 120214, + 120214 + ], + "mapped", + [ + 113 + ] + ], + [ + [ + 120215, + 120215 + ], + "mapped", + [ + 114 + ] + ], + [ + [ + 120216, + 120216 + ], + "mapped", + [ + 115 + ] + ], + [ + [ + 120217, + 120217 + ], + "mapped", + [ + 116 + ] + ], + [ + [ + 120218, + 120218 + ], + "mapped", + [ + 117 + ] + ], + [ + [ + 120219, + 120219 + ], + "mapped", + [ + 118 + ] + ], + [ + [ + 120220, + 120220 + ], + "mapped", + [ + 119 + ] + ], + [ + [ + 120221, + 120221 + ], + "mapped", + [ + 120 + ] + ], + [ + [ + 120222, + 120222 + ], + "mapped", + [ + 121 + ] + ], + [ + [ + 120223, + 120223 + ], + "mapped", + [ + 122 + ] + ], + [ + [ + 120224, + 120224 + ], + "mapped", + [ + 97 + ] + ], + [ + [ + 120225, + 120225 + ], + "mapped", + [ + 98 + ] + ], + [ + [ + 120226, + 120226 + ], + "mapped", + [ + 99 + ] + ], + [ + [ + 120227, + 120227 + ], + "mapped", + [ + 100 + ] + ], + [ + [ + 120228, + 120228 + ], + "mapped", + [ + 101 + ] + ], + [ + [ + 120229, + 120229 + ], + "mapped", + [ + 102 + ] + ], + [ + [ + 120230, + 120230 + ], + "mapped", + [ + 103 + ] + ], + [ + [ + 120231, + 120231 + ], + "mapped", + [ + 104 + ] + ], + [ + [ + 120232, + 120232 + ], + "mapped", + [ + 105 + ] + ], + [ + [ + 120233, + 120233 + ], + "mapped", + [ + 106 + ] + ], + [ + [ + 120234, + 120234 + ], + "mapped", + [ + 107 + ] + ], + [ + [ + 120235, + 120235 + ], + "mapped", + [ + 108 + ] + ], + [ + [ + 120236, + 120236 + ], + "mapped", + [ + 109 + ] + ], + [ + [ + 120237, + 120237 + ], + "mapped", + [ + 110 + ] + ], + [ + [ + 120238, + 120238 + ], + "mapped", + [ + 111 + ] + ], + [ + [ + 120239, + 120239 + ], + "mapped", + [ + 112 + ] + ], + [ + [ + 120240, + 120240 + ], + "mapped", + [ + 113 + ] + ], + [ + [ + 120241, + 120241 + ], + "mapped", + [ + 114 + ] + ], + [ + [ + 120242, + 120242 + ], + "mapped", + [ + 115 + ] + ], + [ + [ + 120243, + 120243 + ], + "mapped", + [ + 116 + ] + ], + [ + [ + 120244, + 120244 + ], + "mapped", + [ + 117 + ] + ], + [ + [ + 120245, + 120245 + ], + "mapped", + [ + 118 + ] + ], + [ + [ + 120246, + 120246 + ], + "mapped", + [ + 119 + ] + ], + [ + [ + 120247, + 120247 + ], + "mapped", + [ + 120 + ] + ], + [ + [ + 120248, + 120248 + ], + "mapped", + [ + 121 + ] + ], + [ + [ + 120249, + 120249 + ], + "mapped", + [ + 122 + ] + ], + [ + [ + 120250, + 120250 + ], + "mapped", + [ + 97 + ] + ], + [ + [ + 120251, + 120251 + ], + "mapped", + [ + 98 + ] + ], + [ + [ + 120252, + 120252 + ], + "mapped", + [ + 99 + ] + ], + [ + [ + 120253, + 120253 + ], + "mapped", + [ + 100 + ] + ], + [ + [ + 120254, + 120254 + ], + "mapped", + [ + 101 + ] + ], + [ + [ + 120255, + 120255 + ], + "mapped", + [ + 102 + ] + ], + [ + [ + 120256, + 120256 + ], + "mapped", + [ + 103 + ] + ], + [ + [ + 120257, + 120257 + ], + "mapped", + [ + 104 + ] + ], + [ + [ + 120258, + 120258 + ], + "mapped", + [ + 105 + ] + ], + [ + [ + 120259, + 120259 + ], + "mapped", + [ + 106 + ] + ], + [ + [ + 120260, + 120260 + ], + "mapped", + [ + 107 + ] + ], + [ + [ + 120261, + 120261 + ], + "mapped", + [ + 108 + ] + ], + [ + [ + 120262, + 120262 + ], + "mapped", + [ + 109 + ] + ], + [ + [ + 120263, + 120263 + ], + "mapped", + [ + 110 + ] + ], + [ + [ + 120264, + 120264 + ], + "mapped", + [ + 111 + ] + ], + [ + [ + 120265, + 120265 + ], + "mapped", + [ + 112 + ] + ], + [ + [ + 120266, + 120266 + ], + "mapped", + [ + 113 + ] + ], + [ + [ + 120267, + 120267 + ], + "mapped", + [ + 114 + ] + ], + [ + [ + 120268, + 120268 + ], + "mapped", + [ + 115 + ] + ], + [ + [ + 120269, + 120269 + ], + "mapped", + [ + 116 + ] + ], + [ + [ + 120270, + 120270 + ], + "mapped", + [ + 117 + ] + ], + [ + [ + 120271, + 120271 + ], + "mapped", + [ + 118 + ] + ], + [ + [ + 120272, + 120272 + ], + "mapped", + [ + 119 + ] + ], + [ + [ + 120273, + 120273 + ], + "mapped", + [ + 120 + ] + ], + [ + [ + 120274, + 120274 + ], + "mapped", + [ + 121 + ] + ], + [ + [ + 120275, + 120275 + ], + "mapped", + [ + 122 + ] + ], + [ + [ + 120276, + 120276 + ], + "mapped", + [ + 97 + ] + ], + [ + [ + 120277, + 120277 + ], + "mapped", + [ + 98 + ] + ], + [ + [ + 120278, + 120278 + ], + "mapped", + [ + 99 + ] + ], + [ + [ + 120279, + 120279 + ], + "mapped", + [ + 100 + ] + ], + [ + [ + 120280, + 120280 + ], + "mapped", + [ + 101 + ] + ], + [ + [ + 120281, + 120281 + ], + "mapped", + [ + 102 + ] + ], + [ + [ + 120282, + 120282 + ], + "mapped", + [ + 103 + ] + ], + [ + [ + 120283, + 120283 + ], + "mapped", + [ + 104 + ] + ], + [ + [ + 120284, + 120284 + ], + "mapped", + [ + 105 + ] + ], + [ + [ + 120285, + 120285 + ], + "mapped", + [ + 106 + ] + ], + [ + [ + 120286, + 120286 + ], + "mapped", + [ + 107 + ] + ], + [ + [ + 120287, + 120287 + ], + "mapped", + [ + 108 + ] + ], + [ + [ + 120288, + 120288 + ], + "mapped", + [ + 109 + ] + ], + [ + [ + 120289, + 120289 + ], + "mapped", + [ + 110 + ] + ], + [ + [ + 120290, + 120290 + ], + "mapped", + [ + 111 + ] + ], + [ + [ + 120291, + 120291 + ], + "mapped", + [ + 112 + ] + ], + [ + [ + 120292, + 120292 + ], + "mapped", + [ + 113 + ] + ], + [ + [ + 120293, + 120293 + ], + "mapped", + [ + 114 + ] + ], + [ + [ + 120294, + 120294 + ], + "mapped", + [ + 115 + ] + ], + [ + [ + 120295, + 120295 + ], + "mapped", + [ + 116 + ] + ], + [ + [ + 120296, + 120296 + ], + "mapped", + [ + 117 + ] + ], + [ + [ + 120297, + 120297 + ], + "mapped", + [ + 118 + ] + ], + [ + [ + 120298, + 120298 + ], + "mapped", + [ + 119 + ] + ], + [ + [ + 120299, + 120299 + ], + "mapped", + [ + 120 + ] + ], + [ + [ + 120300, + 120300 + ], + "mapped", + [ + 121 + ] + ], + [ + [ + 120301, + 120301 + ], + "mapped", + [ + 122 + ] + ], + [ + [ + 120302, + 120302 + ], + "mapped", + [ + 97 + ] + ], + [ + [ + 120303, + 120303 + ], + "mapped", + [ + 98 + ] + ], + [ + [ + 120304, + 120304 + ], + "mapped", + [ + 99 + ] + ], + [ + [ + 120305, + 120305 + ], + "mapped", + [ + 100 + ] + ], + [ + [ + 120306, + 120306 + ], + "mapped", + [ + 101 + ] + ], + [ + [ + 120307, + 120307 + ], + "mapped", + [ + 102 + ] + ], + [ + [ + 120308, + 120308 + ], + "mapped", + [ + 103 + ] + ], + [ + [ + 120309, + 120309 + ], + "mapped", + [ + 104 + ] + ], + [ + [ + 120310, + 120310 + ], + "mapped", + [ + 105 + ] + ], + [ + [ + 120311, + 120311 + ], + "mapped", + [ + 106 + ] + ], + [ + [ + 120312, + 120312 + ], + "mapped", + [ + 107 + ] + ], + [ + [ + 120313, + 120313 + ], + "mapped", + [ + 108 + ] + ], + [ + [ + 120314, + 120314 + ], + "mapped", + [ + 109 + ] + ], + [ + [ + 120315, + 120315 + ], + "mapped", + [ + 110 + ] + ], + [ + [ + 120316, + 120316 + ], + "mapped", + [ + 111 + ] + ], + [ + [ + 120317, + 120317 + ], + "mapped", + [ + 112 + ] + ], + [ + [ + 120318, + 120318 + ], + "mapped", + [ + 113 + ] + ], + [ + [ + 120319, + 120319 + ], + "mapped", + [ + 114 + ] + ], + [ + [ + 120320, + 120320 + ], + "mapped", + [ + 115 + ] + ], + [ + [ + 120321, + 120321 + ], + "mapped", + [ + 116 + ] + ], + [ + [ + 120322, + 120322 + ], + "mapped", + [ + 117 + ] + ], + [ + [ + 120323, + 120323 + ], + "mapped", + [ + 118 + ] + ], + [ + [ + 120324, + 120324 + ], + "mapped", + [ + 119 + ] + ], + [ + [ + 120325, + 120325 + ], + "mapped", + [ + 120 + ] + ], + [ + [ + 120326, + 120326 + ], + "mapped", + [ + 121 + ] + ], + [ + [ + 120327, + 120327 + ], + "mapped", + [ + 122 + ] + ], + [ + [ + 120328, + 120328 + ], + "mapped", + [ + 97 + ] + ], + [ + [ + 120329, + 120329 + ], + "mapped", + [ + 98 + ] + ], + [ + [ + 120330, + 120330 + ], + "mapped", + [ + 99 + ] + ], + [ + [ + 120331, + 120331 + ], + "mapped", + [ + 100 + ] + ], + [ + [ + 120332, + 120332 + ], + "mapped", + [ + 101 + ] + ], + [ + [ + 120333, + 120333 + ], + "mapped", + [ + 102 + ] + ], + [ + [ + 120334, + 120334 + ], + "mapped", + [ + 103 + ] + ], + [ + [ + 120335, + 120335 + ], + "mapped", + [ + 104 + ] + ], + [ + [ + 120336, + 120336 + ], + "mapped", + [ + 105 + ] + ], + [ + [ + 120337, + 120337 + ], + "mapped", + [ + 106 + ] + ], + [ + [ + 120338, + 120338 + ], + "mapped", + [ + 107 + ] + ], + [ + [ + 120339, + 120339 + ], + "mapped", + [ + 108 + ] + ], + [ + [ + 120340, + 120340 + ], + "mapped", + [ + 109 + ] + ], + [ + [ + 120341, + 120341 + ], + "mapped", + [ + 110 + ] + ], + [ + [ + 120342, + 120342 + ], + "mapped", + [ + 111 + ] + ], + [ + [ + 120343, + 120343 + ], + "mapped", + [ + 112 + ] + ], + [ + [ + 120344, + 120344 + ], + "mapped", + [ + 113 + ] + ], + [ + [ + 120345, + 120345 + ], + "mapped", + [ + 114 + ] + ], + [ + [ + 120346, + 120346 + ], + "mapped", + [ + 115 + ] + ], + [ + [ + 120347, + 120347 + ], + "mapped", + [ + 116 + ] + ], + [ + [ + 120348, + 120348 + ], + "mapped", + [ + 117 + ] + ], + [ + [ + 120349, + 120349 + ], + "mapped", + [ + 118 + ] + ], + [ + [ + 120350, + 120350 + ], + "mapped", + [ + 119 + ] + ], + [ + [ + 120351, + 120351 + ], + "mapped", + [ + 120 + ] + ], + [ + [ + 120352, + 120352 + ], + "mapped", + [ + 121 + ] + ], + [ + [ + 120353, + 120353 + ], + "mapped", + [ + 122 + ] + ], + [ + [ + 120354, + 120354 + ], + "mapped", + [ + 97 + ] + ], + [ + [ + 120355, + 120355 + ], + "mapped", + [ + 98 + ] + ], + [ + [ + 120356, + 120356 + ], + "mapped", + [ + 99 + ] + ], + [ + [ + 120357, + 120357 + ], + "mapped", + [ + 100 + ] + ], + [ + [ + 120358, + 120358 + ], + "mapped", + [ + 101 + ] + ], + [ + [ + 120359, + 120359 + ], + "mapped", + [ + 102 + ] + ], + [ + [ + 120360, + 120360 + ], + "mapped", + [ + 103 + ] + ], + [ + [ + 120361, + 120361 + ], + "mapped", + [ + 104 + ] + ], + [ + [ + 120362, + 120362 + ], + "mapped", + [ + 105 + ] + ], + [ + [ + 120363, + 120363 + ], + "mapped", + [ + 106 + ] + ], + [ + [ + 120364, + 120364 + ], + "mapped", + [ + 107 + ] + ], + [ + [ + 120365, + 120365 + ], + "mapped", + [ + 108 + ] + ], + [ + [ + 120366, + 120366 + ], + "mapped", + [ + 109 + ] + ], + [ + [ + 120367, + 120367 + ], + "mapped", + [ + 110 + ] + ], + [ + [ + 120368, + 120368 + ], + "mapped", + [ + 111 + ] + ], + [ + [ + 120369, + 120369 + ], + "mapped", + [ + 112 + ] + ], + [ + [ + 120370, + 120370 + ], + "mapped", + [ + 113 + ] + ], + [ + [ + 120371, + 120371 + ], + "mapped", + [ + 114 + ] + ], + [ + [ + 120372, + 120372 + ], + "mapped", + [ + 115 + ] + ], + [ + [ + 120373, + 120373 + ], + "mapped", + [ + 116 + ] + ], + [ + [ + 120374, + 120374 + ], + "mapped", + [ + 117 + ] + ], + [ + [ + 120375, + 120375 + ], + "mapped", + [ + 118 + ] + ], + [ + [ + 120376, + 120376 + ], + "mapped", + [ + 119 + ] + ], + [ + [ + 120377, + 120377 + ], + "mapped", + [ + 120 + ] + ], + [ + [ + 120378, + 120378 + ], + "mapped", + [ + 121 + ] + ], + [ + [ + 120379, + 120379 + ], + "mapped", + [ + 122 + ] + ], + [ + [ + 120380, + 120380 + ], + "mapped", + [ + 97 + ] + ], + [ + [ + 120381, + 120381 + ], + "mapped", + [ + 98 + ] + ], + [ + [ + 120382, + 120382 + ], + "mapped", + [ + 99 + ] + ], + [ + [ + 120383, + 120383 + ], + "mapped", + [ + 100 + ] + ], + [ + [ + 120384, + 120384 + ], + "mapped", + [ + 101 + ] + ], + [ + [ + 120385, + 120385 + ], + "mapped", + [ + 102 + ] + ], + [ + [ + 120386, + 120386 + ], + "mapped", + [ + 103 + ] + ], + [ + [ + 120387, + 120387 + ], + "mapped", + [ + 104 + ] + ], + [ + [ + 120388, + 120388 + ], + "mapped", + [ + 105 + ] + ], + [ + [ + 120389, + 120389 + ], + "mapped", + [ + 106 + ] + ], + [ + [ + 120390, + 120390 + ], + "mapped", + [ + 107 + ] + ], + [ + [ + 120391, + 120391 + ], + "mapped", + [ + 108 + ] + ], + [ + [ + 120392, + 120392 + ], + "mapped", + [ + 109 + ] + ], + [ + [ + 120393, + 120393 + ], + "mapped", + [ + 110 + ] + ], + [ + [ + 120394, + 120394 + ], + "mapped", + [ + 111 + ] + ], + [ + [ + 120395, + 120395 + ], + "mapped", + [ + 112 + ] + ], + [ + [ + 120396, + 120396 + ], + "mapped", + [ + 113 + ] + ], + [ + [ + 120397, + 120397 + ], + "mapped", + [ + 114 + ] + ], + [ + [ + 120398, + 120398 + ], + "mapped", + [ + 115 + ] + ], + [ + [ + 120399, + 120399 + ], + "mapped", + [ + 116 + ] + ], + [ + [ + 120400, + 120400 + ], + "mapped", + [ + 117 + ] + ], + [ + [ + 120401, + 120401 + ], + "mapped", + [ + 118 + ] + ], + [ + [ + 120402, + 120402 + ], + "mapped", + [ + 119 + ] + ], + [ + [ + 120403, + 120403 + ], + "mapped", + [ + 120 + ] + ], + [ + [ + 120404, + 120404 + ], + "mapped", + [ + 121 + ] + ], + [ + [ + 120405, + 120405 + ], + "mapped", + [ + 122 + ] + ], + [ + [ + 120406, + 120406 + ], + "mapped", + [ + 97 + ] + ], + [ + [ + 120407, + 120407 + ], + "mapped", + [ + 98 + ] + ], + [ + [ + 120408, + 120408 + ], + "mapped", + [ + 99 + ] + ], + [ + [ + 120409, + 120409 + ], + "mapped", + [ + 100 + ] + ], + [ + [ + 120410, + 120410 + ], + "mapped", + [ + 101 + ] + ], + [ + [ + 120411, + 120411 + ], + "mapped", + [ + 102 + ] + ], + [ + [ + 120412, + 120412 + ], + "mapped", + [ + 103 + ] + ], + [ + [ + 120413, + 120413 + ], + "mapped", + [ + 104 + ] + ], + [ + [ + 120414, + 120414 + ], + "mapped", + [ + 105 + ] + ], + [ + [ + 120415, + 120415 + ], + "mapped", + [ + 106 + ] + ], + [ + [ + 120416, + 120416 + ], + "mapped", + [ + 107 + ] + ], + [ + [ + 120417, + 120417 + ], + "mapped", + [ + 108 + ] + ], + [ + [ + 120418, + 120418 + ], + "mapped", + [ + 109 + ] + ], + [ + [ + 120419, + 120419 + ], + "mapped", + [ + 110 + ] + ], + [ + [ + 120420, + 120420 + ], + "mapped", + [ + 111 + ] + ], + [ + [ + 120421, + 120421 + ], + "mapped", + [ + 112 + ] + ], + [ + [ + 120422, + 120422 + ], + "mapped", + [ + 113 + ] + ], + [ + [ + 120423, + 120423 + ], + "mapped", + [ + 114 + ] + ], + [ + [ + 120424, + 120424 + ], + "mapped", + [ + 115 + ] + ], + [ + [ + 120425, + 120425 + ], + "mapped", + [ + 116 + ] + ], + [ + [ + 120426, + 120426 + ], + "mapped", + [ + 117 + ] + ], + [ + [ + 120427, + 120427 + ], + "mapped", + [ + 118 + ] + ], + [ + [ + 120428, + 120428 + ], + "mapped", + [ + 119 + ] + ], + [ + [ + 120429, + 120429 + ], + "mapped", + [ + 120 + ] + ], + [ + [ + 120430, + 120430 + ], + "mapped", + [ + 121 + ] + ], + [ + [ + 120431, + 120431 + ], + "mapped", + [ + 122 + ] + ], + [ + [ + 120432, + 120432 + ], + "mapped", + [ + 97 + ] + ], + [ + [ + 120433, + 120433 + ], + "mapped", + [ + 98 + ] + ], + [ + [ + 120434, + 120434 + ], + "mapped", + [ + 99 + ] + ], + [ + [ + 120435, + 120435 + ], + "mapped", + [ + 100 + ] + ], + [ + [ + 120436, + 120436 + ], + "mapped", + [ + 101 + ] + ], + [ + [ + 120437, + 120437 + ], + "mapped", + [ + 102 + ] + ], + [ + [ + 120438, + 120438 + ], + "mapped", + [ + 103 + ] + ], + [ + [ + 120439, + 120439 + ], + "mapped", + [ + 104 + ] + ], + [ + [ + 120440, + 120440 + ], + "mapped", + [ + 105 + ] + ], + [ + [ + 120441, + 120441 + ], + "mapped", + [ + 106 + ] + ], + [ + [ + 120442, + 120442 + ], + "mapped", + [ + 107 + ] + ], + [ + [ + 120443, + 120443 + ], + "mapped", + [ + 108 + ] + ], + [ + [ + 120444, + 120444 + ], + "mapped", + [ + 109 + ] + ], + [ + [ + 120445, + 120445 + ], + "mapped", + [ + 110 + ] + ], + [ + [ + 120446, + 120446 + ], + "mapped", + [ + 111 + ] + ], + [ + [ + 120447, + 120447 + ], + "mapped", + [ + 112 + ] + ], + [ + [ + 120448, + 120448 + ], + "mapped", + [ + 113 + ] + ], + [ + [ + 120449, + 120449 + ], + "mapped", + [ + 114 + ] + ], + [ + [ + 120450, + 120450 + ], + "mapped", + [ + 115 + ] + ], + [ + [ + 120451, + 120451 + ], + "mapped", + [ + 116 + ] + ], + [ + [ + 120452, + 120452 + ], + "mapped", + [ + 117 + ] + ], + [ + [ + 120453, + 120453 + ], + "mapped", + [ + 118 + ] + ], + [ + [ + 120454, + 120454 + ], + "mapped", + [ + 119 + ] + ], + [ + [ + 120455, + 120455 + ], + "mapped", + [ + 120 + ] + ], + [ + [ + 120456, + 120456 + ], + "mapped", + [ + 121 + ] + ], + [ + [ + 120457, + 120457 + ], + "mapped", + [ + 122 + ] + ], + [ + [ + 120458, + 120458 + ], + "mapped", + [ + 97 + ] + ], + [ + [ + 120459, + 120459 + ], + "mapped", + [ + 98 + ] + ], + [ + [ + 120460, + 120460 + ], + "mapped", + [ + 99 + ] + ], + [ + [ + 120461, + 120461 + ], + "mapped", + [ + 100 + ] + ], + [ + [ + 120462, + 120462 + ], + "mapped", + [ + 101 + ] + ], + [ + [ + 120463, + 120463 + ], + "mapped", + [ + 102 + ] + ], + [ + [ + 120464, + 120464 + ], + "mapped", + [ + 103 + ] + ], + [ + [ + 120465, + 120465 + ], + "mapped", + [ + 104 + ] + ], + [ + [ + 120466, + 120466 + ], + "mapped", + [ + 105 + ] + ], + [ + [ + 120467, + 120467 + ], + "mapped", + [ + 106 + ] + ], + [ + [ + 120468, + 120468 + ], + "mapped", + [ + 107 + ] + ], + [ + [ + 120469, + 120469 + ], + "mapped", + [ + 108 + ] + ], + [ + [ + 120470, + 120470 + ], + "mapped", + [ + 109 + ] + ], + [ + [ + 120471, + 120471 + ], + "mapped", + [ + 110 + ] + ], + [ + [ + 120472, + 120472 + ], + "mapped", + [ + 111 + ] + ], + [ + [ + 120473, + 120473 + ], + "mapped", + [ + 112 + ] + ], + [ + [ + 120474, + 120474 + ], + "mapped", + [ + 113 + ] + ], + [ + [ + 120475, + 120475 + ], + "mapped", + [ + 114 + ] + ], + [ + [ + 120476, + 120476 + ], + "mapped", + [ + 115 + ] + ], + [ + [ + 120477, + 120477 + ], + "mapped", + [ + 116 + ] + ], + [ + [ + 120478, + 120478 + ], + "mapped", + [ + 117 + ] + ], + [ + [ + 120479, + 120479 + ], + "mapped", + [ + 118 + ] + ], + [ + [ + 120480, + 120480 + ], + "mapped", + [ + 119 + ] + ], + [ + [ + 120481, + 120481 + ], + "mapped", + [ + 120 + ] + ], + [ + [ + 120482, + 120482 + ], + "mapped", + [ + 121 + ] + ], + [ + [ + 120483, + 120483 + ], + "mapped", + [ + 122 + ] + ], + [ + [ + 120484, + 120484 + ], + "mapped", + [ + 305 + ] + ], + [ + [ + 120485, + 120485 + ], + "mapped", + [ + 567 + ] + ], + [ + [ + 120486, + 120487 + ], + "disallowed" + ], + [ + [ + 120488, + 120488 + ], + "mapped", + [ + 945 + ] + ], + [ + [ + 120489, + 120489 + ], + "mapped", + [ + 946 + ] + ], + [ + [ + 120490, + 120490 + ], + "mapped", + [ + 947 + ] + ], + [ + [ + 120491, + 120491 + ], + "mapped", + [ + 948 + ] + ], + [ + [ + 120492, + 120492 + ], + "mapped", + [ + 949 + ] + ], + [ + [ + 120493, + 120493 + ], + "mapped", + [ + 950 + ] + ], + [ + [ + 120494, + 120494 + ], + "mapped", + [ + 951 + ] + ], + [ + [ + 120495, + 120495 + ], + "mapped", + [ + 952 + ] + ], + [ + [ + 120496, + 120496 + ], + "mapped", + [ + 953 + ] + ], + [ + [ + 120497, + 120497 + ], + "mapped", + [ + 954 + ] + ], + [ + [ + 120498, + 120498 + ], + "mapped", + [ + 955 + ] + ], + [ + [ + 120499, + 120499 + ], + "mapped", + [ + 956 + ] + ], + [ + [ + 120500, + 120500 + ], + "mapped", + [ + 957 + ] + ], + [ + [ + 120501, + 120501 + ], + "mapped", + [ + 958 + ] + ], + [ + [ + 120502, + 120502 + ], + "mapped", + [ + 959 + ] + ], + [ + [ + 120503, + 120503 + ], + "mapped", + [ + 960 + ] + ], + [ + [ + 120504, + 120504 + ], + "mapped", + [ + 961 + ] + ], + [ + [ + 120505, + 120505 + ], + "mapped", + [ + 952 + ] + ], + [ + [ + 120506, + 120506 + ], + "mapped", + [ + 963 + ] + ], + [ + [ + 120507, + 120507 + ], + "mapped", + [ + 964 + ] + ], + [ + [ + 120508, + 120508 + ], + "mapped", + [ + 965 + ] + ], + [ + [ + 120509, + 120509 + ], + "mapped", + [ + 966 + ] + ], + [ + [ + 120510, + 120510 + ], + "mapped", + [ + 967 + ] + ], + [ + [ + 120511, + 120511 + ], + "mapped", + [ + 968 + ] + ], + [ + [ + 120512, + 120512 + ], + "mapped", + [ + 969 + ] + ], + [ + [ + 120513, + 120513 + ], + "mapped", + [ + 8711 + ] + ], + [ + [ + 120514, + 120514 + ], + "mapped", + [ + 945 + ] + ], + [ + [ + 120515, + 120515 + ], + "mapped", + [ + 946 + ] + ], + [ + [ + 120516, + 120516 + ], + "mapped", + [ + 947 + ] + ], + [ + [ + 120517, + 120517 + ], + "mapped", + [ + 948 + ] + ], + [ + [ + 120518, + 120518 + ], + "mapped", + [ + 949 + ] + ], + [ + [ + 120519, + 120519 + ], + "mapped", + [ + 950 + ] + ], + [ + [ + 120520, + 120520 + ], + "mapped", + [ + 951 + ] + ], + [ + [ + 120521, + 120521 + ], + "mapped", + [ + 952 + ] + ], + [ + [ + 120522, + 120522 + ], + "mapped", + [ + 953 + ] + ], + [ + [ + 120523, + 120523 + ], + "mapped", + [ + 954 + ] + ], + [ + [ + 120524, + 120524 + ], + "mapped", + [ + 955 + ] + ], + [ + [ + 120525, + 120525 + ], + "mapped", + [ + 956 + ] + ], + [ + [ + 120526, + 120526 + ], + "mapped", + [ + 957 + ] + ], + [ + [ + 120527, + 120527 + ], + "mapped", + [ + 958 + ] + ], + [ + [ + 120528, + 120528 + ], + "mapped", + [ + 959 + ] + ], + [ + [ + 120529, + 120529 + ], + "mapped", + [ + 960 + ] + ], + [ + [ + 120530, + 120530 + ], + "mapped", + [ + 961 + ] + ], + [ + [ + 120531, + 120532 + ], + "mapped", + [ + 963 + ] + ], + [ + [ + 120533, + 120533 + ], + "mapped", + [ + 964 + ] + ], + [ + [ + 120534, + 120534 + ], + "mapped", + [ + 965 + ] + ], + [ + [ + 120535, + 120535 + ], + "mapped", + [ + 966 + ] + ], + [ + [ + 120536, + 120536 + ], + "mapped", + [ + 967 + ] + ], + [ + [ + 120537, + 120537 + ], + "mapped", + [ + 968 + ] + ], + [ + [ + 120538, + 120538 + ], + "mapped", + [ + 969 + ] + ], + [ + [ + 120539, + 120539 + ], + "mapped", + [ + 8706 + ] + ], + [ + [ + 120540, + 120540 + ], + "mapped", + [ + 949 + ] + ], + [ + [ + 120541, + 120541 + ], + "mapped", + [ + 952 + ] + ], + [ + [ + 120542, + 120542 + ], + "mapped", + [ + 954 + ] + ], + [ + [ + 120543, + 120543 + ], + "mapped", + [ + 966 + ] + ], + [ + [ + 120544, + 120544 + ], + "mapped", + [ + 961 + ] + ], + [ + [ + 120545, + 120545 + ], + "mapped", + [ + 960 + ] + ], + [ + [ + 120546, + 120546 + ], + "mapped", + [ + 945 + ] + ], + [ + [ + 120547, + 120547 + ], + "mapped", + [ + 946 + ] + ], + [ + [ + 120548, + 120548 + ], + "mapped", + [ + 947 + ] + ], + [ + [ + 120549, + 120549 + ], + "mapped", + [ + 948 + ] + ], + [ + [ + 120550, + 120550 + ], + "mapped", + [ + 949 + ] + ], + [ + [ + 120551, + 120551 + ], + "mapped", + [ + 950 + ] + ], + [ + [ + 120552, + 120552 + ], + "mapped", + [ + 951 + ] + ], + [ + [ + 120553, + 120553 + ], + "mapped", + [ + 952 + ] + ], + [ + [ + 120554, + 120554 + ], + "mapped", + [ + 953 + ] + ], + [ + [ + 120555, + 120555 + ], + "mapped", + [ + 954 + ] + ], + [ + [ + 120556, + 120556 + ], + "mapped", + [ + 955 + ] + ], + [ + [ + 120557, + 120557 + ], + "mapped", + [ + 956 + ] + ], + [ + [ + 120558, + 120558 + ], + "mapped", + [ + 957 + ] + ], + [ + [ + 120559, + 120559 + ], + "mapped", + [ + 958 + ] + ], + [ + [ + 120560, + 120560 + ], + "mapped", + [ + 959 + ] + ], + [ + [ + 120561, + 120561 + ], + "mapped", + [ + 960 + ] + ], + [ + [ + 120562, + 120562 + ], + "mapped", + [ + 961 + ] + ], + [ + [ + 120563, + 120563 + ], + "mapped", + [ + 952 + ] + ], + [ + [ + 120564, + 120564 + ], + "mapped", + [ + 963 + ] + ], + [ + [ + 120565, + 120565 + ], + "mapped", + [ + 964 + ] + ], + [ + [ + 120566, + 120566 + ], + "mapped", + [ + 965 + ] + ], + [ + [ + 120567, + 120567 + ], + "mapped", + [ + 966 + ] + ], + [ + [ + 120568, + 120568 + ], + "mapped", + [ + 967 + ] + ], + [ + [ + 120569, + 120569 + ], + "mapped", + [ + 968 + ] + ], + [ + [ + 120570, + 120570 + ], + "mapped", + [ + 969 + ] + ], + [ + [ + 120571, + 120571 + ], + "mapped", + [ + 8711 + ] + ], + [ + [ + 120572, + 120572 + ], + "mapped", + [ + 945 + ] + ], + [ + [ + 120573, + 120573 + ], + "mapped", + [ + 946 + ] + ], + [ + [ + 120574, + 120574 + ], + "mapped", + [ + 947 + ] + ], + [ + [ + 120575, + 120575 + ], + "mapped", + [ + 948 + ] + ], + [ + [ + 120576, + 120576 + ], + "mapped", + [ + 949 + ] + ], + [ + [ + 120577, + 120577 + ], + "mapped", + [ + 950 + ] + ], + [ + [ + 120578, + 120578 + ], + "mapped", + [ + 951 + ] + ], + [ + [ + 120579, + 120579 + ], + "mapped", + [ + 952 + ] + ], + [ + [ + 120580, + 120580 + ], + "mapped", + [ + 953 + ] + ], + [ + [ + 120581, + 120581 + ], + "mapped", + [ + 954 + ] + ], + [ + [ + 120582, + 120582 + ], + "mapped", + [ + 955 + ] + ], + [ + [ + 120583, + 120583 + ], + "mapped", + [ + 956 + ] + ], + [ + [ + 120584, + 120584 + ], + "mapped", + [ + 957 + ] + ], + [ + [ + 120585, + 120585 + ], + "mapped", + [ + 958 + ] + ], + [ + [ + 120586, + 120586 + ], + "mapped", + [ + 959 + ] + ], + [ + [ + 120587, + 120587 + ], + "mapped", + [ + 960 + ] + ], + [ + [ + 120588, + 120588 + ], + "mapped", + [ + 961 + ] + ], + [ + [ + 120589, + 120590 + ], + "mapped", + [ + 963 + ] + ], + [ + [ + 120591, + 120591 + ], + "mapped", + [ + 964 + ] + ], + [ + [ + 120592, + 120592 + ], + "mapped", + [ + 965 + ] + ], + [ + [ + 120593, + 120593 + ], + "mapped", + [ + 966 + ] + ], + [ + [ + 120594, + 120594 + ], + "mapped", + [ + 967 + ] + ], + [ + [ + 120595, + 120595 + ], + "mapped", + [ + 968 + ] + ], + [ + [ + 120596, + 120596 + ], + "mapped", + [ + 969 + ] + ], + [ + [ + 120597, + 120597 + ], + "mapped", + [ + 8706 + ] + ], + [ + [ + 120598, + 120598 + ], + "mapped", + [ + 949 + ] + ], + [ + [ + 120599, + 120599 + ], + "mapped", + [ + 952 + ] + ], + [ + [ + 120600, + 120600 + ], + "mapped", + [ + 954 + ] + ], + [ + [ + 120601, + 120601 + ], + "mapped", + [ + 966 + ] + ], + [ + [ + 120602, + 120602 + ], + "mapped", + [ + 961 + ] + ], + [ + [ + 120603, + 120603 + ], + "mapped", + [ + 960 + ] + ], + [ + [ + 120604, + 120604 + ], + "mapped", + [ + 945 + ] + ], + [ + [ + 120605, + 120605 + ], + "mapped", + [ + 946 + ] + ], + [ + [ + 120606, + 120606 + ], + "mapped", + [ + 947 + ] + ], + [ + [ + 120607, + 120607 + ], + "mapped", + [ + 948 + ] + ], + [ + [ + 120608, + 120608 + ], + "mapped", + [ + 949 + ] + ], + [ + [ + 120609, + 120609 + ], + "mapped", + [ + 950 + ] + ], + [ + [ + 120610, + 120610 + ], + "mapped", + [ + 951 + ] + ], + [ + [ + 120611, + 120611 + ], + "mapped", + [ + 952 + ] + ], + [ + [ + 120612, + 120612 + ], + "mapped", + [ + 953 + ] + ], + [ + [ + 120613, + 120613 + ], + "mapped", + [ + 954 + ] + ], + [ + [ + 120614, + 120614 + ], + "mapped", + [ + 955 + ] + ], + [ + [ + 120615, + 120615 + ], + "mapped", + [ + 956 + ] + ], + [ + [ + 120616, + 120616 + ], + "mapped", + [ + 957 + ] + ], + [ + [ + 120617, + 120617 + ], + "mapped", + [ + 958 + ] + ], + [ + [ + 120618, + 120618 + ], + "mapped", + [ + 959 + ] + ], + [ + [ + 120619, + 120619 + ], + "mapped", + [ + 960 + ] + ], + [ + [ + 120620, + 120620 + ], + "mapped", + [ + 961 + ] + ], + [ + [ + 120621, + 120621 + ], + "mapped", + [ + 952 + ] + ], + [ + [ + 120622, + 120622 + ], + "mapped", + [ + 963 + ] + ], + [ + [ + 120623, + 120623 + ], + "mapped", + [ + 964 + ] + ], + [ + [ + 120624, + 120624 + ], + "mapped", + [ + 965 + ] + ], + [ + [ + 120625, + 120625 + ], + "mapped", + [ + 966 + ] + ], + [ + [ + 120626, + 120626 + ], + "mapped", + [ + 967 + ] + ], + [ + [ + 120627, + 120627 + ], + "mapped", + [ + 968 + ] + ], + [ + [ + 120628, + 120628 + ], + "mapped", + [ + 969 + ] + ], + [ + [ + 120629, + 120629 + ], + "mapped", + [ + 8711 + ] + ], + [ + [ + 120630, + 120630 + ], + "mapped", + [ + 945 + ] + ], + [ + [ + 120631, + 120631 + ], + "mapped", + [ + 946 + ] + ], + [ + [ + 120632, + 120632 + ], + "mapped", + [ + 947 + ] + ], + [ + [ + 120633, + 120633 + ], + "mapped", + [ + 948 + ] + ], + [ + [ + 120634, + 120634 + ], + "mapped", + [ + 949 + ] + ], + [ + [ + 120635, + 120635 + ], + "mapped", + [ + 950 + ] + ], + [ + [ + 120636, + 120636 + ], + "mapped", + [ + 951 + ] + ], + [ + [ + 120637, + 120637 + ], + "mapped", + [ + 952 + ] + ], + [ + [ + 120638, + 120638 + ], + "mapped", + [ + 953 + ] + ], + [ + [ + 120639, + 120639 + ], + "mapped", + [ + 954 + ] + ], + [ + [ + 120640, + 120640 + ], + "mapped", + [ + 955 + ] + ], + [ + [ + 120641, + 120641 + ], + "mapped", + [ + 956 + ] + ], + [ + [ + 120642, + 120642 + ], + "mapped", + [ + 957 + ] + ], + [ + [ + 120643, + 120643 + ], + "mapped", + [ + 958 + ] + ], + [ + [ + 120644, + 120644 + ], + "mapped", + [ + 959 + ] + ], + [ + [ + 120645, + 120645 + ], + "mapped", + [ + 960 + ] + ], + [ + [ + 120646, + 120646 + ], + "mapped", + [ + 961 + ] + ], + [ + [ + 120647, + 120648 + ], + "mapped", + [ + 963 + ] + ], + [ + [ + 120649, + 120649 + ], + "mapped", + [ + 964 + ] + ], + [ + [ + 120650, + 120650 + ], + "mapped", + [ + 965 + ] + ], + [ + [ + 120651, + 120651 + ], + "mapped", + [ + 966 + ] + ], + [ + [ + 120652, + 120652 + ], + "mapped", + [ + 967 + ] + ], + [ + [ + 120653, + 120653 + ], + "mapped", + [ + 968 + ] + ], + [ + [ + 120654, + 120654 + ], + "mapped", + [ + 969 + ] + ], + [ + [ + 120655, + 120655 + ], + "mapped", + [ + 8706 + ] + ], + [ + [ + 120656, + 120656 + ], + "mapped", + [ + 949 + ] + ], + [ + [ + 120657, + 120657 + ], + "mapped", + [ + 952 + ] + ], + [ + [ + 120658, + 120658 + ], + "mapped", + [ + 954 + ] + ], + [ + [ + 120659, + 120659 + ], + "mapped", + [ + 966 + ] + ], + [ + [ + 120660, + 120660 + ], + "mapped", + [ + 961 + ] + ], + [ + [ + 120661, + 120661 + ], + "mapped", + [ + 960 + ] + ], + [ + [ + 120662, + 120662 + ], + "mapped", + [ + 945 + ] + ], + [ + [ + 120663, + 120663 + ], + "mapped", + [ + 946 + ] + ], + [ + [ + 120664, + 120664 + ], + "mapped", + [ + 947 + ] + ], + [ + [ + 120665, + 120665 + ], + "mapped", + [ + 948 + ] + ], + [ + [ + 120666, + 120666 + ], + "mapped", + [ + 949 + ] + ], + [ + [ + 120667, + 120667 + ], + "mapped", + [ + 950 + ] + ], + [ + [ + 120668, + 120668 + ], + "mapped", + [ + 951 + ] + ], + [ + [ + 120669, + 120669 + ], + "mapped", + [ + 952 + ] + ], + [ + [ + 120670, + 120670 + ], + "mapped", + [ + 953 + ] + ], + [ + [ + 120671, + 120671 + ], + "mapped", + [ + 954 + ] + ], + [ + [ + 120672, + 120672 + ], + "mapped", + [ + 955 + ] + ], + [ + [ + 120673, + 120673 + ], + "mapped", + [ + 956 + ] + ], + [ + [ + 120674, + 120674 + ], + "mapped", + [ + 957 + ] + ], + [ + [ + 120675, + 120675 + ], + "mapped", + [ + 958 + ] + ], + [ + [ + 120676, + 120676 + ], + "mapped", + [ + 959 + ] + ], + [ + [ + 120677, + 120677 + ], + "mapped", + [ + 960 + ] + ], + [ + [ + 120678, + 120678 + ], + "mapped", + [ + 961 + ] + ], + [ + [ + 120679, + 120679 + ], + "mapped", + [ + 952 + ] + ], + [ + [ + 120680, + 120680 + ], + "mapped", + [ + 963 + ] + ], + [ + [ + 120681, + 120681 + ], + "mapped", + [ + 964 + ] + ], + [ + [ + 120682, + 120682 + ], + "mapped", + [ + 965 + ] + ], + [ + [ + 120683, + 120683 + ], + "mapped", + [ + 966 + ] + ], + [ + [ + 120684, + 120684 + ], + "mapped", + [ + 967 + ] + ], + [ + [ + 120685, + 120685 + ], + "mapped", + [ + 968 + ] + ], + [ + [ + 120686, + 120686 + ], + "mapped", + [ + 969 + ] + ], + [ + [ + 120687, + 120687 + ], + "mapped", + [ + 8711 + ] + ], + [ + [ + 120688, + 120688 + ], + "mapped", + [ + 945 + ] + ], + [ + [ + 120689, + 120689 + ], + "mapped", + [ + 946 + ] + ], + [ + [ + 120690, + 120690 + ], + "mapped", + [ + 947 + ] + ], + [ + [ + 120691, + 120691 + ], + "mapped", + [ + 948 + ] + ], + [ + [ + 120692, + 120692 + ], + "mapped", + [ + 949 + ] + ], + [ + [ + 120693, + 120693 + ], + "mapped", + [ + 950 + ] + ], + [ + [ + 120694, + 120694 + ], + "mapped", + [ + 951 + ] + ], + [ + [ + 120695, + 120695 + ], + "mapped", + [ + 952 + ] + ], + [ + [ + 120696, + 120696 + ], + "mapped", + [ + 953 + ] + ], + [ + [ + 120697, + 120697 + ], + "mapped", + [ + 954 + ] + ], + [ + [ + 120698, + 120698 + ], + "mapped", + [ + 955 + ] + ], + [ + [ + 120699, + 120699 + ], + "mapped", + [ + 956 + ] + ], + [ + [ + 120700, + 120700 + ], + "mapped", + [ + 957 + ] + ], + [ + [ + 120701, + 120701 + ], + "mapped", + [ + 958 + ] + ], + [ + [ + 120702, + 120702 + ], + "mapped", + [ + 959 + ] + ], + [ + [ + 120703, + 120703 + ], + "mapped", + [ + 960 + ] + ], + [ + [ + 120704, + 120704 + ], + "mapped", + [ + 961 + ] + ], + [ + [ + 120705, + 120706 + ], + "mapped", + [ + 963 + ] + ], + [ + [ + 120707, + 120707 + ], + "mapped", + [ + 964 + ] + ], + [ + [ + 120708, + 120708 + ], + "mapped", + [ + 965 + ] + ], + [ + [ + 120709, + 120709 + ], + "mapped", + [ + 966 + ] + ], + [ + [ + 120710, + 120710 + ], + "mapped", + [ + 967 + ] + ], + [ + [ + 120711, + 120711 + ], + "mapped", + [ + 968 + ] + ], + [ + [ + 120712, + 120712 + ], + "mapped", + [ + 969 + ] + ], + [ + [ + 120713, + 120713 + ], + "mapped", + [ + 8706 + ] + ], + [ + [ + 120714, + 120714 + ], + "mapped", + [ + 949 + ] + ], + [ + [ + 120715, + 120715 + ], + "mapped", + [ + 952 + ] + ], + [ + [ + 120716, + 120716 + ], + "mapped", + [ + 954 + ] + ], + [ + [ + 120717, + 120717 + ], + "mapped", + [ + 966 + ] + ], + [ + [ + 120718, + 120718 + ], + "mapped", + [ + 961 + ] + ], + [ + [ + 120719, + 120719 + ], + "mapped", + [ + 960 + ] + ], + [ + [ + 120720, + 120720 + ], + "mapped", + [ + 945 + ] + ], + [ + [ + 120721, + 120721 + ], + "mapped", + [ + 946 + ] + ], + [ + [ + 120722, + 120722 + ], + "mapped", + [ + 947 + ] + ], + [ + [ + 120723, + 120723 + ], + "mapped", + [ + 948 + ] + ], + [ + [ + 120724, + 120724 + ], + "mapped", + [ + 949 + ] + ], + [ + [ + 120725, + 120725 + ], + "mapped", + [ + 950 + ] + ], + [ + [ + 120726, + 120726 + ], + "mapped", + [ + 951 + ] + ], + [ + [ + 120727, + 120727 + ], + "mapped", + [ + 952 + ] + ], + [ + [ + 120728, + 120728 + ], + "mapped", + [ + 953 + ] + ], + [ + [ + 120729, + 120729 + ], + "mapped", + [ + 954 + ] + ], + [ + [ + 120730, + 120730 + ], + "mapped", + [ + 955 + ] + ], + [ + [ + 120731, + 120731 + ], + "mapped", + [ + 956 + ] + ], + [ + [ + 120732, + 120732 + ], + "mapped", + [ + 957 + ] + ], + [ + [ + 120733, + 120733 + ], + "mapped", + [ + 958 + ] + ], + [ + [ + 120734, + 120734 + ], + "mapped", + [ + 959 + ] + ], + [ + [ + 120735, + 120735 + ], + "mapped", + [ + 960 + ] + ], + [ + [ + 120736, + 120736 + ], + "mapped", + [ + 961 + ] + ], + [ + [ + 120737, + 120737 + ], + "mapped", + [ + 952 + ] + ], + [ + [ + 120738, + 120738 + ], + "mapped", + [ + 963 + ] + ], + [ + [ + 120739, + 120739 + ], + "mapped", + [ + 964 + ] + ], + [ + [ + 120740, + 120740 + ], + "mapped", + [ + 965 + ] + ], + [ + [ + 120741, + 120741 + ], + "mapped", + [ + 966 + ] + ], + [ + [ + 120742, + 120742 + ], + "mapped", + [ + 967 + ] + ], + [ + [ + 120743, + 120743 + ], + "mapped", + [ + 968 + ] + ], + [ + [ + 120744, + 120744 + ], + "mapped", + [ + 969 + ] + ], + [ + [ + 120745, + 120745 + ], + "mapped", + [ + 8711 + ] + ], + [ + [ + 120746, + 120746 + ], + "mapped", + [ + 945 + ] + ], + [ + [ + 120747, + 120747 + ], + "mapped", + [ + 946 + ] + ], + [ + [ + 120748, + 120748 + ], + "mapped", + [ + 947 + ] + ], + [ + [ + 120749, + 120749 + ], + "mapped", + [ + 948 + ] + ], + [ + [ + 120750, + 120750 + ], + "mapped", + [ + 949 + ] + ], + [ + [ + 120751, + 120751 + ], + "mapped", + [ + 950 + ] + ], + [ + [ + 120752, + 120752 + ], + "mapped", + [ + 951 + ] + ], + [ + [ + 120753, + 120753 + ], + "mapped", + [ + 952 + ] + ], + [ + [ + 120754, + 120754 + ], + "mapped", + [ + 953 + ] + ], + [ + [ + 120755, + 120755 + ], + "mapped", + [ + 954 + ] + ], + [ + [ + 120756, + 120756 + ], + "mapped", + [ + 955 + ] + ], + [ + [ + 120757, + 120757 + ], + "mapped", + [ + 956 + ] + ], + [ + [ + 120758, + 120758 + ], + "mapped", + [ + 957 + ] + ], + [ + [ + 120759, + 120759 + ], + "mapped", + [ + 958 + ] + ], + [ + [ + 120760, + 120760 + ], + "mapped", + [ + 959 + ] + ], + [ + [ + 120761, + 120761 + ], + "mapped", + [ + 960 + ] + ], + [ + [ + 120762, + 120762 + ], + "mapped", + [ + 961 + ] + ], + [ + [ + 120763, + 120764 + ], + "mapped", + [ + 963 + ] + ], + [ + [ + 120765, + 120765 + ], + "mapped", + [ + 964 + ] + ], + [ + [ + 120766, + 120766 + ], + "mapped", + [ + 965 + ] + ], + [ + [ + 120767, + 120767 + ], + "mapped", + [ + 966 + ] + ], + [ + [ + 120768, + 120768 + ], + "mapped", + [ + 967 + ] + ], + [ + [ + 120769, + 120769 + ], + "mapped", + [ + 968 + ] + ], + [ + [ + 120770, + 120770 + ], + "mapped", + [ + 969 + ] + ], + [ + [ + 120771, + 120771 + ], + "mapped", + [ + 8706 + ] + ], + [ + [ + 120772, + 120772 + ], + "mapped", + [ + 949 + ] + ], + [ + [ + 120773, + 120773 + ], + "mapped", + [ + 952 + ] + ], + [ + [ + 120774, + 120774 + ], + "mapped", + [ + 954 + ] + ], + [ + [ + 120775, + 120775 + ], + "mapped", + [ + 966 + ] + ], + [ + [ + 120776, + 120776 + ], + "mapped", + [ + 961 + ] + ], + [ + [ + 120777, + 120777 + ], + "mapped", + [ + 960 + ] + ], + [ + [ + 120778, + 120779 + ], + "mapped", + [ + 989 + ] + ], + [ + [ + 120780, + 120781 + ], + "disallowed" + ], + [ + [ + 120782, + 120782 + ], + "mapped", + [ + 48 + ] + ], + [ + [ + 120783, + 120783 + ], + "mapped", + [ + 49 + ] + ], + [ + [ + 120784, + 120784 + ], + "mapped", + [ + 50 + ] + ], + [ + [ + 120785, + 120785 + ], + "mapped", + [ + 51 + ] + ], + [ + [ + 120786, + 120786 + ], + "mapped", + [ + 52 + ] + ], + [ + [ + 120787, + 120787 + ], + "mapped", + [ + 53 + ] + ], + [ + [ + 120788, + 120788 + ], + "mapped", + [ + 54 + ] + ], + [ + [ + 120789, + 120789 + ], + "mapped", + [ + 55 + ] + ], + [ + [ + 120790, + 120790 + ], + "mapped", + [ + 56 + ] + ], + [ + [ + 120791, + 120791 + ], + "mapped", + [ + 57 + ] + ], + [ + [ + 120792, + 120792 + ], + "mapped", + [ + 48 + ] + ], + [ + [ + 120793, + 120793 + ], + "mapped", + [ + 49 + ] + ], + [ + [ + 120794, + 120794 + ], + "mapped", + [ + 50 + ] + ], + [ + [ + 120795, + 120795 + ], + "mapped", + [ + 51 + ] + ], + [ + [ + 120796, + 120796 + ], + "mapped", + [ + 52 + ] + ], + [ + [ + 120797, + 120797 + ], + "mapped", + [ + 53 + ] + ], + [ + [ + 120798, + 120798 + ], + "mapped", + [ + 54 + ] + ], + [ + [ + 120799, + 120799 + ], + "mapped", + [ + 55 + ] + ], + [ + [ + 120800, + 120800 + ], + "mapped", + [ + 56 + ] + ], + [ + [ + 120801, + 120801 + ], + "mapped", + [ + 57 + ] + ], + [ + [ + 120802, + 120802 + ], + "mapped", + [ + 48 + ] + ], + [ + [ + 120803, + 120803 + ], + "mapped", + [ + 49 + ] + ], + [ + [ + 120804, + 120804 + ], + "mapped", + [ + 50 + ] + ], + [ + [ + 120805, + 120805 + ], + "mapped", + [ + 51 + ] + ], + [ + [ + 120806, + 120806 + ], + "mapped", + [ + 52 + ] + ], + [ + [ + 120807, + 120807 + ], + "mapped", + [ + 53 + ] + ], + [ + [ + 120808, + 120808 + ], + "mapped", + [ + 54 + ] + ], + [ + [ + 120809, + 120809 + ], + "mapped", + [ + 55 + ] + ], + [ + [ + 120810, + 120810 + ], + "mapped", + [ + 56 + ] + ], + [ + [ + 120811, + 120811 + ], + "mapped", + [ + 57 + ] + ], + [ + [ + 120812, + 120812 + ], + "mapped", + [ + 48 + ] + ], + [ + [ + 120813, + 120813 + ], + "mapped", + [ + 49 + ] + ], + [ + [ + 120814, + 120814 + ], + "mapped", + [ + 50 + ] + ], + [ + [ + 120815, + 120815 + ], + "mapped", + [ + 51 + ] + ], + [ + [ + 120816, + 120816 + ], + "mapped", + [ + 52 + ] + ], + [ + [ + 120817, + 120817 + ], + "mapped", + [ + 53 + ] + ], + [ + [ + 120818, + 120818 + ], + "mapped", + [ + 54 + ] + ], + [ + [ + 120819, + 120819 + ], + "mapped", + [ + 55 + ] + ], + [ + [ + 120820, + 120820 + ], + "mapped", + [ + 56 + ] + ], + [ + [ + 120821, + 120821 + ], + "mapped", + [ + 57 + ] + ], + [ + [ + 120822, + 120822 + ], + "mapped", + [ + 48 + ] + ], + [ + [ + 120823, + 120823 + ], + "mapped", + [ + 49 + ] + ], + [ + [ + 120824, + 120824 + ], + "mapped", + [ + 50 + ] + ], + [ + [ + 120825, + 120825 + ], + "mapped", + [ + 51 + ] + ], + [ + [ + 120826, + 120826 + ], + "mapped", + [ + 52 + ] + ], + [ + [ + 120827, + 120827 + ], + "mapped", + [ + 53 + ] + ], + [ + [ + 120828, + 120828 + ], + "mapped", + [ + 54 + ] + ], + [ + [ + 120829, + 120829 + ], + "mapped", + [ + 55 + ] + ], + [ + [ + 120830, + 120830 + ], + "mapped", + [ + 56 + ] + ], + [ + [ + 120831, + 120831 + ], + "mapped", + [ + 57 + ] + ], + [ + [ + 120832, + 121343 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 121344, + 121398 + ], + "valid" + ], + [ + [ + 121399, + 121402 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 121403, + 121452 + ], + "valid" + ], + [ + [ + 121453, + 121460 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 121461, + 121461 + ], + "valid" + ], + [ + [ + 121462, + 121475 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 121476, + 121476 + ], + "valid" + ], + [ + [ + 121477, + 121483 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 121484, + 121498 + ], + "disallowed" + ], + [ + [ + 121499, + 121503 + ], + "valid" + ], + [ + [ + 121504, + 121504 + ], + "disallowed" + ], + [ + [ + 121505, + 121519 + ], + "valid" + ], + [ + [ + 121520, + 124927 + ], + "disallowed" + ], + [ + [ + 124928, + 125124 + ], + "valid" + ], + [ + [ + 125125, + 125126 + ], + "disallowed" + ], + [ + [ + 125127, + 125135 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 125136, + 125142 + ], + "valid" + ], + [ + [ + 125143, + 126463 + ], + "disallowed" + ], + [ + [ + 126464, + 126464 + ], + "mapped", + [ + 1575 + ] + ], + [ + [ + 126465, + 126465 + ], + "mapped", + [ + 1576 + ] + ], + [ + [ + 126466, + 126466 + ], + "mapped", + [ + 1580 + ] + ], + [ + [ + 126467, + 126467 + ], + "mapped", + [ + 1583 + ] + ], + [ + [ + 126468, + 126468 + ], + "disallowed" + ], + [ + [ + 126469, + 126469 + ], + "mapped", + [ + 1608 + ] + ], + [ + [ + 126470, + 126470 + ], + "mapped", + [ + 1586 + ] + ], + [ + [ + 126471, + 126471 + ], + "mapped", + [ + 1581 + ] + ], + [ + [ + 126472, + 126472 + ], + "mapped", + [ + 1591 + ] + ], + [ + [ + 126473, + 126473 + ], + "mapped", + [ + 1610 + ] + ], + [ + [ + 126474, + 126474 + ], + "mapped", + [ + 1603 + ] + ], + [ + [ + 126475, + 126475 + ], + "mapped", + [ + 1604 + ] + ], + [ + [ + 126476, + 126476 + ], + "mapped", + [ + 1605 + ] + ], + [ + [ + 126477, + 126477 + ], + "mapped", + [ + 1606 + ] + ], + [ + [ + 126478, + 126478 + ], + "mapped", + [ + 1587 + ] + ], + [ + [ + 126479, + 126479 + ], + "mapped", + [ + 1593 + ] + ], + [ + [ + 126480, + 126480 + ], + "mapped", + [ + 1601 + ] + ], + [ + [ + 126481, + 126481 + ], + "mapped", + [ + 1589 + ] + ], + [ + [ + 126482, + 126482 + ], + "mapped", + [ + 1602 + ] + ], + [ + [ + 126483, + 126483 + ], + "mapped", + [ + 1585 + ] + ], + [ + [ + 126484, + 126484 + ], + "mapped", + [ + 1588 + ] + ], + [ + [ + 126485, + 126485 + ], + "mapped", + [ + 1578 + ] + ], + [ + [ + 126486, + 126486 + ], + "mapped", + [ + 1579 + ] + ], + [ + [ + 126487, + 126487 + ], + "mapped", + [ + 1582 + ] + ], + [ + [ + 126488, + 126488 + ], + "mapped", + [ + 1584 + ] + ], + [ + [ + 126489, + 126489 + ], + "mapped", + [ + 1590 + ] + ], + [ + [ + 126490, + 126490 + ], + "mapped", + [ + 1592 + ] + ], + [ + [ + 126491, + 126491 + ], + "mapped", + [ + 1594 + ] + ], + [ + [ + 126492, + 126492 + ], + "mapped", + [ + 1646 + ] + ], + [ + [ + 126493, + 126493 + ], + "mapped", + [ + 1722 + ] + ], + [ + [ + 126494, + 126494 + ], + "mapped", + [ + 1697 + ] + ], + [ + [ + 126495, + 126495 + ], + "mapped", + [ + 1647 + ] + ], + [ + [ + 126496, + 126496 + ], + "disallowed" + ], + [ + [ + 126497, + 126497 + ], + "mapped", + [ + 1576 + ] + ], + [ + [ + 126498, + 126498 + ], + "mapped", + [ + 1580 + ] + ], + [ + [ + 126499, + 126499 + ], + "disallowed" + ], + [ + [ + 126500, + 126500 + ], + "mapped", + [ + 1607 + ] + ], + [ + [ + 126501, + 126502 + ], + "disallowed" + ], + [ + [ + 126503, + 126503 + ], + "mapped", + [ + 1581 + ] + ], + [ + [ + 126504, + 126504 + ], + "disallowed" + ], + [ + [ + 126505, + 126505 + ], + "mapped", + [ + 1610 + ] + ], + [ + [ + 126506, + 126506 + ], + "mapped", + [ + 1603 + ] + ], + [ + [ + 126507, + 126507 + ], + "mapped", + [ + 1604 + ] + ], + [ + [ + 126508, + 126508 + ], + "mapped", + [ + 1605 + ] + ], + [ + [ + 126509, + 126509 + ], + "mapped", + [ + 1606 + ] + ], + [ + [ + 126510, + 126510 + ], + "mapped", + [ + 1587 + ] + ], + [ + [ + 126511, + 126511 + ], + "mapped", + [ + 1593 + ] + ], + [ + [ + 126512, + 126512 + ], + "mapped", + [ + 1601 + ] + ], + [ + [ + 126513, + 126513 + ], + "mapped", + [ + 1589 + ] + ], + [ + [ + 126514, + 126514 + ], + "mapped", + [ + 1602 + ] + ], + [ + [ + 126515, + 126515 + ], + "disallowed" + ], + [ + [ + 126516, + 126516 + ], + "mapped", + [ + 1588 + ] + ], + [ + [ + 126517, + 126517 + ], + "mapped", + [ + 1578 + ] + ], + [ + [ + 126518, + 126518 + ], + "mapped", + [ + 1579 + ] + ], + [ + [ + 126519, + 126519 + ], + "mapped", + [ + 1582 + ] + ], + [ + [ + 126520, + 126520 + ], + "disallowed" + ], + [ + [ + 126521, + 126521 + ], + "mapped", + [ + 1590 + ] + ], + [ + [ + 126522, + 126522 + ], + "disallowed" + ], + [ + [ + 126523, + 126523 + ], + "mapped", + [ + 1594 + ] + ], + [ + [ + 126524, + 126529 + ], + "disallowed" + ], + [ + [ + 126530, + 126530 + ], + "mapped", + [ + 1580 + ] + ], + [ + [ + 126531, + 126534 + ], + "disallowed" + ], + [ + [ + 126535, + 126535 + ], + "mapped", + [ + 1581 + ] + ], + [ + [ + 126536, + 126536 + ], + "disallowed" + ], + [ + [ + 126537, + 126537 + ], + "mapped", + [ + 1610 + ] + ], + [ + [ + 126538, + 126538 + ], + "disallowed" + ], + [ + [ + 126539, + 126539 + ], + "mapped", + [ + 1604 + ] + ], + [ + [ + 126540, + 126540 + ], + "disallowed" + ], + [ + [ + 126541, + 126541 + ], + "mapped", + [ + 1606 + ] + ], + [ + [ + 126542, + 126542 + ], + "mapped", + [ + 1587 + ] + ], + [ + [ + 126543, + 126543 + ], + "mapped", + [ + 1593 + ] + ], + [ + [ + 126544, + 126544 + ], + "disallowed" + ], + [ + [ + 126545, + 126545 + ], + "mapped", + [ + 1589 + ] + ], + [ + [ + 126546, + 126546 + ], + "mapped", + [ + 1602 + ] + ], + [ + [ + 126547, + 126547 + ], + "disallowed" + ], + [ + [ + 126548, + 126548 + ], + "mapped", + [ + 1588 + ] + ], + [ + [ + 126549, + 126550 + ], + "disallowed" + ], + [ + [ + 126551, + 126551 + ], + "mapped", + [ + 1582 + ] + ], + [ + [ + 126552, + 126552 + ], + "disallowed" + ], + [ + [ + 126553, + 126553 + ], + "mapped", + [ + 1590 + ] + ], + [ + [ + 126554, + 126554 + ], + "disallowed" + ], + [ + [ + 126555, + 126555 + ], + "mapped", + [ + 1594 + ] + ], + [ + [ + 126556, + 126556 + ], + "disallowed" + ], + [ + [ + 126557, + 126557 + ], + "mapped", + [ + 1722 + ] + ], + [ + [ + 126558, + 126558 + ], + "disallowed" + ], + [ + [ + 126559, + 126559 + ], + "mapped", + [ + 1647 + ] + ], + [ + [ + 126560, + 126560 + ], + "disallowed" + ], + [ + [ + 126561, + 126561 + ], + "mapped", + [ + 1576 + ] + ], + [ + [ + 126562, + 126562 + ], + "mapped", + [ + 1580 + ] + ], + [ + [ + 126563, + 126563 + ], + "disallowed" + ], + [ + [ + 126564, + 126564 + ], + "mapped", + [ + 1607 + ] + ], + [ + [ + 126565, + 126566 + ], + "disallowed" + ], + [ + [ + 126567, + 126567 + ], + "mapped", + [ + 1581 + ] + ], + [ + [ + 126568, + 126568 + ], + "mapped", + [ + 1591 + ] + ], + [ + [ + 126569, + 126569 + ], + "mapped", + [ + 1610 + ] + ], + [ + [ + 126570, + 126570 + ], + "mapped", + [ + 1603 + ] + ], + [ + [ + 126571, + 126571 + ], + "disallowed" + ], + [ + [ + 126572, + 126572 + ], + "mapped", + [ + 1605 + ] + ], + [ + [ + 126573, + 126573 + ], + "mapped", + [ + 1606 + ] + ], + [ + [ + 126574, + 126574 + ], + "mapped", + [ + 1587 + ] + ], + [ + [ + 126575, + 126575 + ], + "mapped", + [ + 1593 + ] + ], + [ + [ + 126576, + 126576 + ], + "mapped", + [ + 1601 + ] + ], + [ + [ + 126577, + 126577 + ], + "mapped", + [ + 1589 + ] + ], + [ + [ + 126578, + 126578 + ], + "mapped", + [ + 1602 + ] + ], + [ + [ + 126579, + 126579 + ], + "disallowed" + ], + [ + [ + 126580, + 126580 + ], + "mapped", + [ + 1588 + ] + ], + [ + [ + 126581, + 126581 + ], + "mapped", + [ + 1578 + ] + ], + [ + [ + 126582, + 126582 + ], + "mapped", + [ + 1579 + ] + ], + [ + [ + 126583, + 126583 + ], + "mapped", + [ + 1582 + ] + ], + [ + [ + 126584, + 126584 + ], + "disallowed" + ], + [ + [ + 126585, + 126585 + ], + "mapped", + [ + 1590 + ] + ], + [ + [ + 126586, + 126586 + ], + "mapped", + [ + 1592 + ] + ], + [ + [ + 126587, + 126587 + ], + "mapped", + [ + 1594 + ] + ], + [ + [ + 126588, + 126588 + ], + "mapped", + [ + 1646 + ] + ], + [ + [ + 126589, + 126589 + ], + "disallowed" + ], + [ + [ + 126590, + 126590 + ], + "mapped", + [ + 1697 + ] + ], + [ + [ + 126591, + 126591 + ], + "disallowed" + ], + [ + [ + 126592, + 126592 + ], + "mapped", + [ + 1575 + ] + ], + [ + [ + 126593, + 126593 + ], + "mapped", + [ + 1576 + ] + ], + [ + [ + 126594, + 126594 + ], + "mapped", + [ + 1580 + ] + ], + [ + [ + 126595, + 126595 + ], + "mapped", + [ + 1583 + ] + ], + [ + [ + 126596, + 126596 + ], + "mapped", + [ + 1607 + ] + ], + [ + [ + 126597, + 126597 + ], + "mapped", + [ + 1608 + ] + ], + [ + [ + 126598, + 126598 + ], + "mapped", + [ + 1586 + ] + ], + [ + [ + 126599, + 126599 + ], + "mapped", + [ + 1581 + ] + ], + [ + [ + 126600, + 126600 + ], + "mapped", + [ + 1591 + ] + ], + [ + [ + 126601, + 126601 + ], + "mapped", + [ + 1610 + ] + ], + [ + [ + 126602, + 126602 + ], + "disallowed" + ], + [ + [ + 126603, + 126603 + ], + "mapped", + [ + 1604 + ] + ], + [ + [ + 126604, + 126604 + ], + "mapped", + [ + 1605 + ] + ], + [ + [ + 126605, + 126605 + ], + "mapped", + [ + 1606 + ] + ], + [ + [ + 126606, + 126606 + ], + "mapped", + [ + 1587 + ] + ], + [ + [ + 126607, + 126607 + ], + "mapped", + [ + 1593 + ] + ], + [ + [ + 126608, + 126608 + ], + "mapped", + [ + 1601 + ] + ], + [ + [ + 126609, + 126609 + ], + "mapped", + [ + 1589 + ] + ], + [ + [ + 126610, + 126610 + ], + "mapped", + [ + 1602 + ] + ], + [ + [ + 126611, + 126611 + ], + "mapped", + [ + 1585 + ] + ], + [ + [ + 126612, + 126612 + ], + "mapped", + [ + 1588 + ] + ], + [ + [ + 126613, + 126613 + ], + "mapped", + [ + 1578 + ] + ], + [ + [ + 126614, + 126614 + ], + "mapped", + [ + 1579 + ] + ], + [ + [ + 126615, + 126615 + ], + "mapped", + [ + 1582 + ] + ], + [ + [ + 126616, + 126616 + ], + "mapped", + [ + 1584 + ] + ], + [ + [ + 126617, + 126617 + ], + "mapped", + [ + 1590 + ] + ], + [ + [ + 126618, + 126618 + ], + "mapped", + [ + 1592 + ] + ], + [ + [ + 126619, + 126619 + ], + "mapped", + [ + 1594 + ] + ], + [ + [ + 126620, + 126624 + ], + "disallowed" + ], + [ + [ + 126625, + 126625 + ], + "mapped", + [ + 1576 + ] + ], + [ + [ + 126626, + 126626 + ], + "mapped", + [ + 1580 + ] + ], + [ + [ + 126627, + 126627 + ], + "mapped", + [ + 1583 + ] + ], + [ + [ + 126628, + 126628 + ], + "disallowed" + ], + [ + [ + 126629, + 126629 + ], + "mapped", + [ + 1608 + ] + ], + [ + [ + 126630, + 126630 + ], + "mapped", + [ + 1586 + ] + ], + [ + [ + 126631, + 126631 + ], + "mapped", + [ + 1581 + ] + ], + [ + [ + 126632, + 126632 + ], + "mapped", + [ + 1591 + ] + ], + [ + [ + 126633, + 126633 + ], + "mapped", + [ + 1610 + ] + ], + [ + [ + 126634, + 126634 + ], + "disallowed" + ], + [ + [ + 126635, + 126635 + ], + "mapped", + [ + 1604 + ] + ], + [ + [ + 126636, + 126636 + ], + "mapped", + [ + 1605 + ] + ], + [ + [ + 126637, + 126637 + ], + "mapped", + [ + 1606 + ] + ], + [ + [ + 126638, + 126638 + ], + "mapped", + [ + 1587 + ] + ], + [ + [ + 126639, + 126639 + ], + "mapped", + [ + 1593 + ] + ], + [ + [ + 126640, + 126640 + ], + "mapped", + [ + 1601 + ] + ], + [ + [ + 126641, + 126641 + ], + "mapped", + [ + 1589 + ] + ], + [ + [ + 126642, + 126642 + ], + "mapped", + [ + 1602 + ] + ], + [ + [ + 126643, + 126643 + ], + "mapped", + [ + 1585 + ] + ], + [ + [ + 126644, + 126644 + ], + "mapped", + [ + 1588 + ] + ], + [ + [ + 126645, + 126645 + ], + "mapped", + [ + 1578 + ] + ], + [ + [ + 126646, + 126646 + ], + "mapped", + [ + 1579 + ] + ], + [ + [ + 126647, + 126647 + ], + "mapped", + [ + 1582 + ] + ], + [ + [ + 126648, + 126648 + ], + "mapped", + [ + 1584 + ] + ], + [ + [ + 126649, + 126649 + ], + "mapped", + [ + 1590 + ] + ], + [ + [ + 126650, + 126650 + ], + "mapped", + [ + 1592 + ] + ], + [ + [ + 126651, + 126651 + ], + "mapped", + [ + 1594 + ] + ], + [ + [ + 126652, + 126703 + ], + "disallowed" + ], + [ + [ + 126704, + 126705 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 126706, + 126975 + ], + "disallowed" + ], + [ + [ + 126976, + 127019 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 127020, + 127023 + ], + "disallowed" + ], + [ + [ + 127024, + 127123 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 127124, + 127135 + ], + "disallowed" + ], + [ + [ + 127136, + 127150 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 127151, + 127152 + ], + "disallowed" + ], + [ + [ + 127153, + 127166 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 127167, + 127167 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 127168, + 127168 + ], + "disallowed" + ], + [ + [ + 127169, + 127183 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 127184, + 127184 + ], + "disallowed" + ], + [ + [ + 127185, + 127199 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 127200, + 127221 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 127222, + 127231 + ], + "disallowed" + ], + [ + [ + 127232, + 127232 + ], + "disallowed" + ], + [ + [ + 127233, + 127233 + ], + "disallowed_STD3_mapped", + [ + 48, + 44 + ] + ], + [ + [ + 127234, + 127234 + ], + "disallowed_STD3_mapped", + [ + 49, + 44 + ] + ], + [ + [ + 127235, + 127235 + ], + "disallowed_STD3_mapped", + [ + 50, + 44 + ] + ], + [ + [ + 127236, + 127236 + ], + "disallowed_STD3_mapped", + [ + 51, + 44 + ] + ], + [ + [ + 127237, + 127237 + ], + "disallowed_STD3_mapped", + [ + 52, + 44 + ] + ], + [ + [ + 127238, + 127238 + ], + "disallowed_STD3_mapped", + [ + 53, + 44 + ] + ], + [ + [ + 127239, + 127239 + ], + "disallowed_STD3_mapped", + [ + 54, + 44 + ] + ], + [ + [ + 127240, + 127240 + ], + "disallowed_STD3_mapped", + [ + 55, + 44 + ] + ], + [ + [ + 127241, + 127241 + ], + "disallowed_STD3_mapped", + [ + 56, + 44 + ] + ], + [ + [ + 127242, + 127242 + ], + "disallowed_STD3_mapped", + [ + 57, + 44 + ] + ], + [ + [ + 127243, + 127244 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 127245, + 127247 + ], + "disallowed" + ], + [ + [ + 127248, + 127248 + ], + "disallowed_STD3_mapped", + [ + 40, + 97, + 41 + ] + ], + [ + [ + 127249, + 127249 + ], + "disallowed_STD3_mapped", + [ + 40, + 98, + 41 + ] + ], + [ + [ + 127250, + 127250 + ], + "disallowed_STD3_mapped", + [ + 40, + 99, + 41 + ] + ], + [ + [ + 127251, + 127251 + ], + "disallowed_STD3_mapped", + [ + 40, + 100, + 41 + ] + ], + [ + [ + 127252, + 127252 + ], + "disallowed_STD3_mapped", + [ + 40, + 101, + 41 + ] + ], + [ + [ + 127253, + 127253 + ], + "disallowed_STD3_mapped", + [ + 40, + 102, + 41 + ] + ], + [ + [ + 127254, + 127254 + ], + "disallowed_STD3_mapped", + [ + 40, + 103, + 41 + ] + ], + [ + [ + 127255, + 127255 + ], + "disallowed_STD3_mapped", + [ + 40, + 104, + 41 + ] + ], + [ + [ + 127256, + 127256 + ], + "disallowed_STD3_mapped", + [ + 40, + 105, + 41 + ] + ], + [ + [ + 127257, + 127257 + ], + "disallowed_STD3_mapped", + [ + 40, + 106, + 41 + ] + ], + [ + [ + 127258, + 127258 + ], + "disallowed_STD3_mapped", + [ + 40, + 107, + 41 + ] + ], + [ + [ + 127259, + 127259 + ], + "disallowed_STD3_mapped", + [ + 40, + 108, + 41 + ] + ], + [ + [ + 127260, + 127260 + ], + "disallowed_STD3_mapped", + [ + 40, + 109, + 41 + ] + ], + [ + [ + 127261, + 127261 + ], + "disallowed_STD3_mapped", + [ + 40, + 110, + 41 + ] + ], + [ + [ + 127262, + 127262 + ], + "disallowed_STD3_mapped", + [ + 40, + 111, + 41 + ] + ], + [ + [ + 127263, + 127263 + ], + "disallowed_STD3_mapped", + [ + 40, + 112, + 41 + ] + ], + [ + [ + 127264, + 127264 + ], + "disallowed_STD3_mapped", + [ + 40, + 113, + 41 + ] + ], + [ + [ + 127265, + 127265 + ], + "disallowed_STD3_mapped", + [ + 40, + 114, + 41 + ] + ], + [ + [ + 127266, + 127266 + ], + "disallowed_STD3_mapped", + [ + 40, + 115, + 41 + ] + ], + [ + [ + 127267, + 127267 + ], + "disallowed_STD3_mapped", + [ + 40, + 116, + 41 + ] + ], + [ + [ + 127268, + 127268 + ], + "disallowed_STD3_mapped", + [ + 40, + 117, + 41 + ] + ], + [ + [ + 127269, + 127269 + ], + "disallowed_STD3_mapped", + [ + 40, + 118, + 41 + ] + ], + [ + [ + 127270, + 127270 + ], + "disallowed_STD3_mapped", + [ + 40, + 119, + 41 + ] + ], + [ + [ + 127271, + 127271 + ], + "disallowed_STD3_mapped", + [ + 40, + 120, + 41 + ] + ], + [ + [ + 127272, + 127272 + ], + "disallowed_STD3_mapped", + [ + 40, + 121, + 41 + ] + ], + [ + [ + 127273, + 127273 + ], + "disallowed_STD3_mapped", + [ + 40, + 122, + 41 + ] + ], + [ + [ + 127274, + 127274 + ], + "mapped", + [ + 12308, + 115, + 12309 + ] + ], + [ + [ + 127275, + 127275 + ], + "mapped", + [ + 99 + ] + ], + [ + [ + 127276, + 127276 + ], + "mapped", + [ + 114 + ] + ], + [ + [ + 127277, + 127277 + ], + "mapped", + [ + 99, + 100 + ] + ], + [ + [ + 127278, + 127278 + ], + "mapped", + [ + 119, + 122 + ] + ], + [ + [ + 127279, + 127279 + ], + "disallowed" + ], + [ + [ + 127280, + 127280 + ], + "mapped", + [ + 97 + ] + ], + [ + [ + 127281, + 127281 + ], + "mapped", + [ + 98 + ] + ], + [ + [ + 127282, + 127282 + ], + "mapped", + [ + 99 + ] + ], + [ + [ + 127283, + 127283 + ], + "mapped", + [ + 100 + ] + ], + [ + [ + 127284, + 127284 + ], + "mapped", + [ + 101 + ] + ], + [ + [ + 127285, + 127285 + ], + "mapped", + [ + 102 + ] + ], + [ + [ + 127286, + 127286 + ], + "mapped", + [ + 103 + ] + ], + [ + [ + 127287, + 127287 + ], + "mapped", + [ + 104 + ] + ], + [ + [ + 127288, + 127288 + ], + "mapped", + [ + 105 + ] + ], + [ + [ + 127289, + 127289 + ], + "mapped", + [ + 106 + ] + ], + [ + [ + 127290, + 127290 + ], + "mapped", + [ + 107 + ] + ], + [ + [ + 127291, + 127291 + ], + "mapped", + [ + 108 + ] + ], + [ + [ + 127292, + 127292 + ], + "mapped", + [ + 109 + ] + ], + [ + [ + 127293, + 127293 + ], + "mapped", + [ + 110 + ] + ], + [ + [ + 127294, + 127294 + ], + "mapped", + [ + 111 + ] + ], + [ + [ + 127295, + 127295 + ], + "mapped", + [ + 112 + ] + ], + [ + [ + 127296, + 127296 + ], + "mapped", + [ + 113 + ] + ], + [ + [ + 127297, + 127297 + ], + "mapped", + [ + 114 + ] + ], + [ + [ + 127298, + 127298 + ], + "mapped", + [ + 115 + ] + ], + [ + [ + 127299, + 127299 + ], + "mapped", + [ + 116 + ] + ], + [ + [ + 127300, + 127300 + ], + "mapped", + [ + 117 + ] + ], + [ + [ + 127301, + 127301 + ], + "mapped", + [ + 118 + ] + ], + [ + [ + 127302, + 127302 + ], + "mapped", + [ + 119 + ] + ], + [ + [ + 127303, + 127303 + ], + "mapped", + [ + 120 + ] + ], + [ + [ + 127304, + 127304 + ], + "mapped", + [ + 121 + ] + ], + [ + [ + 127305, + 127305 + ], + "mapped", + [ + 122 + ] + ], + [ + [ + 127306, + 127306 + ], + "mapped", + [ + 104, + 118 + ] + ], + [ + [ + 127307, + 127307 + ], + "mapped", + [ + 109, + 118 + ] + ], + [ + [ + 127308, + 127308 + ], + "mapped", + [ + 115, + 100 + ] + ], + [ + [ + 127309, + 127309 + ], + "mapped", + [ + 115, + 115 + ] + ], + [ + [ + 127310, + 127310 + ], + "mapped", + [ + 112, + 112, + 118 + ] + ], + [ + [ + 127311, + 127311 + ], + "mapped", + [ + 119, + 99 + ] + ], + [ + [ + 127312, + 127318 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 127319, + 127319 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 127320, + 127326 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 127327, + 127327 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 127328, + 127337 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 127338, + 127338 + ], + "mapped", + [ + 109, + 99 + ] + ], + [ + [ + 127339, + 127339 + ], + "mapped", + [ + 109, + 100 + ] + ], + [ + [ + 127340, + 127343 + ], + "disallowed" + ], + [ + [ + 127344, + 127352 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 127353, + 127353 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 127354, + 127354 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 127355, + 127356 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 127357, + 127358 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 127359, + 127359 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 127360, + 127369 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 127370, + 127373 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 127374, + 127375 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 127376, + 127376 + ], + "mapped", + [ + 100, + 106 + ] + ], + [ + [ + 127377, + 127386 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 127387, + 127461 + ], + "disallowed" + ], + [ + [ + 127462, + 127487 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 127488, + 127488 + ], + "mapped", + [ + 12411, + 12363 + ] + ], + [ + [ + 127489, + 127489 + ], + "mapped", + [ + 12467, + 12467 + ] + ], + [ + [ + 127490, + 127490 + ], + "mapped", + [ + 12469 + ] + ], + [ + [ + 127491, + 127503 + ], + "disallowed" + ], + [ + [ + 127504, + 127504 + ], + "mapped", + [ + 25163 + ] + ], + [ + [ + 127505, + 127505 + ], + "mapped", + [ + 23383 + ] + ], + [ + [ + 127506, + 127506 + ], + "mapped", + [ + 21452 + ] + ], + [ + [ + 127507, + 127507 + ], + "mapped", + [ + 12487 + ] + ], + [ + [ + 127508, + 127508 + ], + "mapped", + [ + 20108 + ] + ], + [ + [ + 127509, + 127509 + ], + "mapped", + [ + 22810 + ] + ], + [ + [ + 127510, + 127510 + ], + "mapped", + [ + 35299 + ] + ], + [ + [ + 127511, + 127511 + ], + "mapped", + [ + 22825 + ] + ], + [ + [ + 127512, + 127512 + ], + "mapped", + [ + 20132 + ] + ], + [ + [ + 127513, + 127513 + ], + "mapped", + [ + 26144 + ] + ], + [ + [ + 127514, + 127514 + ], + "mapped", + [ + 28961 + ] + ], + [ + [ + 127515, + 127515 + ], + "mapped", + [ + 26009 + ] + ], + [ + [ + 127516, + 127516 + ], + "mapped", + [ + 21069 + ] + ], + [ + [ + 127517, + 127517 + ], + "mapped", + [ + 24460 + ] + ], + [ + [ + 127518, + 127518 + ], + "mapped", + [ + 20877 + ] + ], + [ + [ + 127519, + 127519 + ], + "mapped", + [ + 26032 + ] + ], + [ + [ + 127520, + 127520 + ], + "mapped", + [ + 21021 + ] + ], + [ + [ + 127521, + 127521 + ], + "mapped", + [ + 32066 + ] + ], + [ + [ + 127522, + 127522 + ], + "mapped", + [ + 29983 + ] + ], + [ + [ + 127523, + 127523 + ], + "mapped", + [ + 36009 + ] + ], + [ + [ + 127524, + 127524 + ], + "mapped", + [ + 22768 + ] + ], + [ + [ + 127525, + 127525 + ], + "mapped", + [ + 21561 + ] + ], + [ + [ + 127526, + 127526 + ], + "mapped", + [ + 28436 + ] + ], + [ + [ + 127527, + 127527 + ], + "mapped", + [ + 25237 + ] + ], + [ + [ + 127528, + 127528 + ], + "mapped", + [ + 25429 + ] + ], + [ + [ + 127529, + 127529 + ], + "mapped", + [ + 19968 + ] + ], + [ + [ + 127530, + 127530 + ], + "mapped", + [ + 19977 + ] + ], + [ + [ + 127531, + 127531 + ], + "mapped", + [ + 36938 + ] + ], + [ + [ + 127532, + 127532 + ], + "mapped", + [ + 24038 + ] + ], + [ + [ + 127533, + 127533 + ], + "mapped", + [ + 20013 + ] + ], + [ + [ + 127534, + 127534 + ], + "mapped", + [ + 21491 + ] + ], + [ + [ + 127535, + 127535 + ], + "mapped", + [ + 25351 + ] + ], + [ + [ + 127536, + 127536 + ], + "mapped", + [ + 36208 + ] + ], + [ + [ + 127537, + 127537 + ], + "mapped", + [ + 25171 + ] + ], + [ + [ + 127538, + 127538 + ], + "mapped", + [ + 31105 + ] + ], + [ + [ + 127539, + 127539 + ], + "mapped", + [ + 31354 + ] + ], + [ + [ + 127540, + 127540 + ], + "mapped", + [ + 21512 + ] + ], + [ + [ + 127541, + 127541 + ], + "mapped", + [ + 28288 + ] + ], + [ + [ + 127542, + 127542 + ], + "mapped", + [ + 26377 + ] + ], + [ + [ + 127543, + 127543 + ], + "mapped", + [ + 26376 + ] + ], + [ + [ + 127544, + 127544 + ], + "mapped", + [ + 30003 + ] + ], + [ + [ + 127545, + 127545 + ], + "mapped", + [ + 21106 + ] + ], + [ + [ + 127546, + 127546 + ], + "mapped", + [ + 21942 + ] + ], + [ + [ + 127547, + 127551 + ], + "disallowed" + ], + [ + [ + 127552, + 127552 + ], + "mapped", + [ + 12308, + 26412, + 12309 + ] + ], + [ + [ + 127553, + 127553 + ], + "mapped", + [ + 12308, + 19977, + 12309 + ] + ], + [ + [ + 127554, + 127554 + ], + "mapped", + [ + 12308, + 20108, + 12309 + ] + ], + [ + [ + 127555, + 127555 + ], + "mapped", + [ + 12308, + 23433, + 12309 + ] + ], + [ + [ + 127556, + 127556 + ], + "mapped", + [ + 12308, + 28857, + 12309 + ] + ], + [ + [ + 127557, + 127557 + ], + "mapped", + [ + 12308, + 25171, + 12309 + ] + ], + [ + [ + 127558, + 127558 + ], + "mapped", + [ + 12308, + 30423, + 12309 + ] + ], + [ + [ + 127559, + 127559 + ], + "mapped", + [ + 12308, + 21213, + 12309 + ] + ], + [ + [ + 127560, + 127560 + ], + "mapped", + [ + 12308, + 25943, + 12309 + ] + ], + [ + [ + 127561, + 127567 + ], + "disallowed" + ], + [ + [ + 127568, + 127568 + ], + "mapped", + [ + 24471 + ] + ], + [ + [ + 127569, + 127569 + ], + "mapped", + [ + 21487 + ] + ], + [ + [ + 127570, + 127743 + ], + "disallowed" + ], + [ + [ + 127744, + 127776 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 127777, + 127788 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 127789, + 127791 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 127792, + 127797 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 127798, + 127798 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 127799, + 127868 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 127869, + 127869 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 127870, + 127871 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 127872, + 127891 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 127892, + 127903 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 127904, + 127940 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 127941, + 127941 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 127942, + 127946 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 127947, + 127950 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 127951, + 127955 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 127956, + 127967 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 127968, + 127984 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 127985, + 127991 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 127992, + 127999 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 128000, + 128062 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 128063, + 128063 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 128064, + 128064 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 128065, + 128065 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 128066, + 128247 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 128248, + 128248 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 128249, + 128252 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 128253, + 128254 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 128255, + 128255 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 128256, + 128317 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 128318, + 128319 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 128320, + 128323 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 128324, + 128330 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 128331, + 128335 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 128336, + 128359 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 128360, + 128377 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 128378, + 128378 + ], + "disallowed" + ], + [ + [ + 128379, + 128419 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 128420, + 128420 + ], + "disallowed" + ], + [ + [ + 128421, + 128506 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 128507, + 128511 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 128512, + 128512 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 128513, + 128528 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 128529, + 128529 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 128530, + 128532 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 128533, + 128533 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 128534, + 128534 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 128535, + 128535 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 128536, + 128536 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 128537, + 128537 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 128538, + 128538 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 128539, + 128539 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 128540, + 128542 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 128543, + 128543 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 128544, + 128549 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 128550, + 128551 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 128552, + 128555 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 128556, + 128556 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 128557, + 128557 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 128558, + 128559 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 128560, + 128563 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 128564, + 128564 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 128565, + 128576 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 128577, + 128578 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 128579, + 128580 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 128581, + 128591 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 128592, + 128639 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 128640, + 128709 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 128710, + 128719 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 128720, + 128720 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 128721, + 128735 + ], + "disallowed" + ], + [ + [ + 128736, + 128748 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 128749, + 128751 + ], + "disallowed" + ], + [ + [ + 128752, + 128755 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 128756, + 128767 + ], + "disallowed" + ], + [ + [ + 128768, + 128883 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 128884, + 128895 + ], + "disallowed" + ], + [ + [ + 128896, + 128980 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 128981, + 129023 + ], + "disallowed" + ], + [ + [ + 129024, + 129035 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 129036, + 129039 + ], + "disallowed" + ], + [ + [ + 129040, + 129095 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 129096, + 129103 + ], + "disallowed" + ], + [ + [ + 129104, + 129113 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 129114, + 129119 + ], + "disallowed" + ], + [ + [ + 129120, + 129159 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 129160, + 129167 + ], + "disallowed" + ], + [ + [ + 129168, + 129197 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 129198, + 129295 + ], + "disallowed" + ], + [ + [ + 129296, + 129304 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 129305, + 129407 + ], + "disallowed" + ], + [ + [ + 129408, + 129412 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 129413, + 129471 + ], + "disallowed" + ], + [ + [ + 129472, + 129472 + ], + "valid", + [ + ], + "NV8" + ], + [ + [ + 129473, + 131069 + ], + "disallowed" + ], + [ + [ + 131070, + 131071 + ], + "disallowed" + ], + [ + [ + 131072, + 173782 + ], + "valid" + ], + [ + [ + 173783, + 173823 + ], + "disallowed" + ], + [ + [ + 173824, + 177972 + ], + "valid" + ], + [ + [ + 177973, + 177983 + ], + "disallowed" + ], + [ + [ + 177984, + 178205 + ], + "valid" + ], + [ + [ + 178206, + 178207 + ], + "disallowed" + ], + [ + [ + 178208, + 183969 + ], + "valid" + ], + [ + [ + 183970, + 194559 + ], + "disallowed" + ], + [ + [ + 194560, + 194560 + ], + "mapped", + [ + 20029 + ] + ], + [ + [ + 194561, + 194561 + ], + "mapped", + [ + 20024 + ] + ], + [ + [ + 194562, + 194562 + ], + "mapped", + [ + 20033 + ] + ], + [ + [ + 194563, + 194563 + ], + "mapped", + [ + 131362 + ] + ], + [ + [ + 194564, + 194564 + ], + "mapped", + [ + 20320 + ] + ], + [ + [ + 194565, + 194565 + ], + "mapped", + [ + 20398 + ] + ], + [ + [ + 194566, + 194566 + ], + "mapped", + [ + 20411 + ] + ], + [ + [ + 194567, + 194567 + ], + "mapped", + [ + 20482 + ] + ], + [ + [ + 194568, + 194568 + ], + "mapped", + [ + 20602 + ] + ], + [ + [ + 194569, + 194569 + ], + "mapped", + [ + 20633 + ] + ], + [ + [ + 194570, + 194570 + ], + "mapped", + [ + 20711 + ] + ], + [ + [ + 194571, + 194571 + ], + "mapped", + [ + 20687 + ] + ], + [ + [ + 194572, + 194572 + ], + "mapped", + [ + 13470 + ] + ], + [ + [ + 194573, + 194573 + ], + "mapped", + [ + 132666 + ] + ], + [ + [ + 194574, + 194574 + ], + "mapped", + [ + 20813 + ] + ], + [ + [ + 194575, + 194575 + ], + "mapped", + [ + 20820 + ] + ], + [ + [ + 194576, + 194576 + ], + "mapped", + [ + 20836 + ] + ], + [ + [ + 194577, + 194577 + ], + "mapped", + [ + 20855 + ] + ], + [ + [ + 194578, + 194578 + ], + "mapped", + [ + 132380 + ] + ], + [ + [ + 194579, + 194579 + ], + "mapped", + [ + 13497 + ] + ], + [ + [ + 194580, + 194580 + ], + "mapped", + [ + 20839 + ] + ], + [ + [ + 194581, + 194581 + ], + "mapped", + [ + 20877 + ] + ], + [ + [ + 194582, + 194582 + ], + "mapped", + [ + 132427 + ] + ], + [ + [ + 194583, + 194583 + ], + "mapped", + [ + 20887 + ] + ], + [ + [ + 194584, + 194584 + ], + "mapped", + [ + 20900 + ] + ], + [ + [ + 194585, + 194585 + ], + "mapped", + [ + 20172 + ] + ], + [ + [ + 194586, + 194586 + ], + "mapped", + [ + 20908 + ] + ], + [ + [ + 194587, + 194587 + ], + "mapped", + [ + 20917 + ] + ], + [ + [ + 194588, + 194588 + ], + "mapped", + [ + 168415 + ] + ], + [ + [ + 194589, + 194589 + ], + "mapped", + [ + 20981 + ] + ], + [ + [ + 194590, + 194590 + ], + "mapped", + [ + 20995 + ] + ], + [ + [ + 194591, + 194591 + ], + "mapped", + [ + 13535 + ] + ], + [ + [ + 194592, + 194592 + ], + "mapped", + [ + 21051 + ] + ], + [ + [ + 194593, + 194593 + ], + "mapped", + [ + 21062 + ] + ], + [ + [ + 194594, + 194594 + ], + "mapped", + [ + 21106 + ] + ], + [ + [ + 194595, + 194595 + ], + "mapped", + [ + 21111 + ] + ], + [ + [ + 194596, + 194596 + ], + "mapped", + [ + 13589 + ] + ], + [ + [ + 194597, + 194597 + ], + "mapped", + [ + 21191 + ] + ], + [ + [ + 194598, + 194598 + ], + "mapped", + [ + 21193 + ] + ], + [ + [ + 194599, + 194599 + ], + "mapped", + [ + 21220 + ] + ], + [ + [ + 194600, + 194600 + ], + "mapped", + [ + 21242 + ] + ], + [ + [ + 194601, + 194601 + ], + "mapped", + [ + 21253 + ] + ], + [ + [ + 194602, + 194602 + ], + "mapped", + [ + 21254 + ] + ], + [ + [ + 194603, + 194603 + ], + "mapped", + [ + 21271 + ] + ], + [ + [ + 194604, + 194604 + ], + "mapped", + [ + 21321 + ] + ], + [ + [ + 194605, + 194605 + ], + "mapped", + [ + 21329 + ] + ], + [ + [ + 194606, + 194606 + ], + "mapped", + [ + 21338 + ] + ], + [ + [ + 194607, + 194607 + ], + "mapped", + [ + 21363 + ] + ], + [ + [ + 194608, + 194608 + ], + "mapped", + [ + 21373 + ] + ], + [ + [ + 194609, + 194611 + ], + "mapped", + [ + 21375 + ] + ], + [ + [ + 194612, + 194612 + ], + "mapped", + [ + 133676 + ] + ], + [ + [ + 194613, + 194613 + ], + "mapped", + [ + 28784 + ] + ], + [ + [ + 194614, + 194614 + ], + "mapped", + [ + 21450 + ] + ], + [ + [ + 194615, + 194615 + ], + "mapped", + [ + 21471 + ] + ], + [ + [ + 194616, + 194616 + ], + "mapped", + [ + 133987 + ] + ], + [ + [ + 194617, + 194617 + ], + "mapped", + [ + 21483 + ] + ], + [ + [ + 194618, + 194618 + ], + "mapped", + [ + 21489 + ] + ], + [ + [ + 194619, + 194619 + ], + "mapped", + [ + 21510 + ] + ], + [ + [ + 194620, + 194620 + ], + "mapped", + [ + 21662 + ] + ], + [ + [ + 194621, + 194621 + ], + "mapped", + [ + 21560 + ] + ], + [ + [ + 194622, + 194622 + ], + "mapped", + [ + 21576 + ] + ], + [ + [ + 194623, + 194623 + ], + "mapped", + [ + 21608 + ] + ], + [ + [ + 194624, + 194624 + ], + "mapped", + [ + 21666 + ] + ], + [ + [ + 194625, + 194625 + ], + "mapped", + [ + 21750 + ] + ], + [ + [ + 194626, + 194626 + ], + "mapped", + [ + 21776 + ] + ], + [ + [ + 194627, + 194627 + ], + "mapped", + [ + 21843 + ] + ], + [ + [ + 194628, + 194628 + ], + "mapped", + [ + 21859 + ] + ], + [ + [ + 194629, + 194630 + ], + "mapped", + [ + 21892 + ] + ], + [ + [ + 194631, + 194631 + ], + "mapped", + [ + 21913 + ] + ], + [ + [ + 194632, + 194632 + ], + "mapped", + [ + 21931 + ] + ], + [ + [ + 194633, + 194633 + ], + "mapped", + [ + 21939 + ] + ], + [ + [ + 194634, + 194634 + ], + "mapped", + [ + 21954 + ] + ], + [ + [ + 194635, + 194635 + ], + "mapped", + [ + 22294 + ] + ], + [ + [ + 194636, + 194636 + ], + "mapped", + [ + 22022 + ] + ], + [ + [ + 194637, + 194637 + ], + "mapped", + [ + 22295 + ] + ], + [ + [ + 194638, + 194638 + ], + "mapped", + [ + 22097 + ] + ], + [ + [ + 194639, + 194639 + ], + "mapped", + [ + 22132 + ] + ], + [ + [ + 194640, + 194640 + ], + "mapped", + [ + 20999 + ] + ], + [ + [ + 194641, + 194641 + ], + "mapped", + [ + 22766 + ] + ], + [ + [ + 194642, + 194642 + ], + "mapped", + [ + 22478 + ] + ], + [ + [ + 194643, + 194643 + ], + "mapped", + [ + 22516 + ] + ], + [ + [ + 194644, + 194644 + ], + "mapped", + [ + 22541 + ] + ], + [ + [ + 194645, + 194645 + ], + "mapped", + [ + 22411 + ] + ], + [ + [ + 194646, + 194646 + ], + "mapped", + [ + 22578 + ] + ], + [ + [ + 194647, + 194647 + ], + "mapped", + [ + 22577 + ] + ], + [ + [ + 194648, + 194648 + ], + "mapped", + [ + 22700 + ] + ], + [ + [ + 194649, + 194649 + ], + "mapped", + [ + 136420 + ] + ], + [ + [ + 194650, + 194650 + ], + "mapped", + [ + 22770 + ] + ], + [ + [ + 194651, + 194651 + ], + "mapped", + [ + 22775 + ] + ], + [ + [ + 194652, + 194652 + ], + "mapped", + [ + 22790 + ] + ], + [ + [ + 194653, + 194653 + ], + "mapped", + [ + 22810 + ] + ], + [ + [ + 194654, + 194654 + ], + "mapped", + [ + 22818 + ] + ], + [ + [ + 194655, + 194655 + ], + "mapped", + [ + 22882 + ] + ], + [ + [ + 194656, + 194656 + ], + "mapped", + [ + 136872 + ] + ], + [ + [ + 194657, + 194657 + ], + "mapped", + [ + 136938 + ] + ], + [ + [ + 194658, + 194658 + ], + "mapped", + [ + 23020 + ] + ], + [ + [ + 194659, + 194659 + ], + "mapped", + [ + 23067 + ] + ], + [ + [ + 194660, + 194660 + ], + "mapped", + [ + 23079 + ] + ], + [ + [ + 194661, + 194661 + ], + "mapped", + [ + 23000 + ] + ], + [ + [ + 194662, + 194662 + ], + "mapped", + [ + 23142 + ] + ], + [ + [ + 194663, + 194663 + ], + "mapped", + [ + 14062 + ] + ], + [ + [ + 194664, + 194664 + ], + "disallowed" + ], + [ + [ + 194665, + 194665 + ], + "mapped", + [ + 23304 + ] + ], + [ + [ + 194666, + 194667 + ], + "mapped", + [ + 23358 + ] + ], + [ + [ + 194668, + 194668 + ], + "mapped", + [ + 137672 + ] + ], + [ + [ + 194669, + 194669 + ], + "mapped", + [ + 23491 + ] + ], + [ + [ + 194670, + 194670 + ], + "mapped", + [ + 23512 + ] + ], + [ + [ + 194671, + 194671 + ], + "mapped", + [ + 23527 + ] + ], + [ + [ + 194672, + 194672 + ], + "mapped", + [ + 23539 + ] + ], + [ + [ + 194673, + 194673 + ], + "mapped", + [ + 138008 + ] + ], + [ + [ + 194674, + 194674 + ], + "mapped", + [ + 23551 + ] + ], + [ + [ + 194675, + 194675 + ], + "mapped", + [ + 23558 + ] + ], + [ + [ + 194676, + 194676 + ], + "disallowed" + ], + [ + [ + 194677, + 194677 + ], + "mapped", + [ + 23586 + ] + ], + [ + [ + 194678, + 194678 + ], + "mapped", + [ + 14209 + ] + ], + [ + [ + 194679, + 194679 + ], + "mapped", + [ + 23648 + ] + ], + [ + [ + 194680, + 194680 + ], + "mapped", + [ + 23662 + ] + ], + [ + [ + 194681, + 194681 + ], + "mapped", + [ + 23744 + ] + ], + [ + [ + 194682, + 194682 + ], + "mapped", + [ + 23693 + ] + ], + [ + [ + 194683, + 194683 + ], + "mapped", + [ + 138724 + ] + ], + [ + [ + 194684, + 194684 + ], + "mapped", + [ + 23875 + ] + ], + [ + [ + 194685, + 194685 + ], + "mapped", + [ + 138726 + ] + ], + [ + [ + 194686, + 194686 + ], + "mapped", + [ + 23918 + ] + ], + [ + [ + 194687, + 194687 + ], + "mapped", + [ + 23915 + ] + ], + [ + [ + 194688, + 194688 + ], + "mapped", + [ + 23932 + ] + ], + [ + [ + 194689, + 194689 + ], + "mapped", + [ + 24033 + ] + ], + [ + [ + 194690, + 194690 + ], + "mapped", + [ + 24034 + ] + ], + [ + [ + 194691, + 194691 + ], + "mapped", + [ + 14383 + ] + ], + [ + [ + 194692, + 194692 + ], + "mapped", + [ + 24061 + ] + ], + [ + [ + 194693, + 194693 + ], + "mapped", + [ + 24104 + ] + ], + [ + [ + 194694, + 194694 + ], + "mapped", + [ + 24125 + ] + ], + [ + [ + 194695, + 194695 + ], + "mapped", + [ + 24169 + ] + ], + [ + [ + 194696, + 194696 + ], + "mapped", + [ + 14434 + ] + ], + [ + [ + 194697, + 194697 + ], + "mapped", + [ + 139651 + ] + ], + [ + [ + 194698, + 194698 + ], + "mapped", + [ + 14460 + ] + ], + [ + [ + 194699, + 194699 + ], + "mapped", + [ + 24240 + ] + ], + [ + [ + 194700, + 194700 + ], + "mapped", + [ + 24243 + ] + ], + [ + [ + 194701, + 194701 + ], + "mapped", + [ + 24246 + ] + ], + [ + [ + 194702, + 194702 + ], + "mapped", + [ + 24266 + ] + ], + [ + [ + 194703, + 194703 + ], + "mapped", + [ + 172946 + ] + ], + [ + [ + 194704, + 194704 + ], + "mapped", + [ + 24318 + ] + ], + [ + [ + 194705, + 194706 + ], + "mapped", + [ + 140081 + ] + ], + [ + [ + 194707, + 194707 + ], + "mapped", + [ + 33281 + ] + ], + [ + [ + 194708, + 194709 + ], + "mapped", + [ + 24354 + ] + ], + [ + [ + 194710, + 194710 + ], + "mapped", + [ + 14535 + ] + ], + [ + [ + 194711, + 194711 + ], + "mapped", + [ + 144056 + ] + ], + [ + [ + 194712, + 194712 + ], + "mapped", + [ + 156122 + ] + ], + [ + [ + 194713, + 194713 + ], + "mapped", + [ + 24418 + ] + ], + [ + [ + 194714, + 194714 + ], + "mapped", + [ + 24427 + ] + ], + [ + [ + 194715, + 194715 + ], + "mapped", + [ + 14563 + ] + ], + [ + [ + 194716, + 194716 + ], + "mapped", + [ + 24474 + ] + ], + [ + [ + 194717, + 194717 + ], + "mapped", + [ + 24525 + ] + ], + [ + [ + 194718, + 194718 + ], + "mapped", + [ + 24535 + ] + ], + [ + [ + 194719, + 194719 + ], + "mapped", + [ + 24569 + ] + ], + [ + [ + 194720, + 194720 + ], + "mapped", + [ + 24705 + ] + ], + [ + [ + 194721, + 194721 + ], + "mapped", + [ + 14650 + ] + ], + [ + [ + 194722, + 194722 + ], + "mapped", + [ + 14620 + ] + ], + [ + [ + 194723, + 194723 + ], + "mapped", + [ + 24724 + ] + ], + [ + [ + 194724, + 194724 + ], + "mapped", + [ + 141012 + ] + ], + [ + [ + 194725, + 194725 + ], + "mapped", + [ + 24775 + ] + ], + [ + [ + 194726, + 194726 + ], + "mapped", + [ + 24904 + ] + ], + [ + [ + 194727, + 194727 + ], + "mapped", + [ + 24908 + ] + ], + [ + [ + 194728, + 194728 + ], + "mapped", + [ + 24910 + ] + ], + [ + [ + 194729, + 194729 + ], + "mapped", + [ + 24908 + ] + ], + [ + [ + 194730, + 194730 + ], + "mapped", + [ + 24954 + ] + ], + [ + [ + 194731, + 194731 + ], + "mapped", + [ + 24974 + ] + ], + [ + [ + 194732, + 194732 + ], + "mapped", + [ + 25010 + ] + ], + [ + [ + 194733, + 194733 + ], + "mapped", + [ + 24996 + ] + ], + [ + [ + 194734, + 194734 + ], + "mapped", + [ + 25007 + ] + ], + [ + [ + 194735, + 194735 + ], + "mapped", + [ + 25054 + ] + ], + [ + [ + 194736, + 194736 + ], + "mapped", + [ + 25074 + ] + ], + [ + [ + 194737, + 194737 + ], + "mapped", + [ + 25078 + ] + ], + [ + [ + 194738, + 194738 + ], + "mapped", + [ + 25104 + ] + ], + [ + [ + 194739, + 194739 + ], + "mapped", + [ + 25115 + ] + ], + [ + [ + 194740, + 194740 + ], + "mapped", + [ + 25181 + ] + ], + [ + [ + 194741, + 194741 + ], + "mapped", + [ + 25265 + ] + ], + [ + [ + 194742, + 194742 + ], + "mapped", + [ + 25300 + ] + ], + [ + [ + 194743, + 194743 + ], + "mapped", + [ + 25424 + ] + ], + [ + [ + 194744, + 194744 + ], + "mapped", + [ + 142092 + ] + ], + [ + [ + 194745, + 194745 + ], + "mapped", + [ + 25405 + ] + ], + [ + [ + 194746, + 194746 + ], + "mapped", + [ + 25340 + ] + ], + [ + [ + 194747, + 194747 + ], + "mapped", + [ + 25448 + ] + ], + [ + [ + 194748, + 194748 + ], + "mapped", + [ + 25475 + ] + ], + [ + [ + 194749, + 194749 + ], + "mapped", + [ + 25572 + ] + ], + [ + [ + 194750, + 194750 + ], + "mapped", + [ + 142321 + ] + ], + [ + [ + 194751, + 194751 + ], + "mapped", + [ + 25634 + ] + ], + [ + [ + 194752, + 194752 + ], + "mapped", + [ + 25541 + ] + ], + [ + [ + 194753, + 194753 + ], + "mapped", + [ + 25513 + ] + ], + [ + [ + 194754, + 194754 + ], + "mapped", + [ + 14894 + ] + ], + [ + [ + 194755, + 194755 + ], + "mapped", + [ + 25705 + ] + ], + [ + [ + 194756, + 194756 + ], + "mapped", + [ + 25726 + ] + ], + [ + [ + 194757, + 194757 + ], + "mapped", + [ + 25757 + ] + ], + [ + [ + 194758, + 194758 + ], + "mapped", + [ + 25719 + ] + ], + [ + [ + 194759, + 194759 + ], + "mapped", + [ + 14956 + ] + ], + [ + [ + 194760, + 194760 + ], + "mapped", + [ + 25935 + ] + ], + [ + [ + 194761, + 194761 + ], + "mapped", + [ + 25964 + ] + ], + [ + [ + 194762, + 194762 + ], + "mapped", + [ + 143370 + ] + ], + [ + [ + 194763, + 194763 + ], + "mapped", + [ + 26083 + ] + ], + [ + [ + 194764, + 194764 + ], + "mapped", + [ + 26360 + ] + ], + [ + [ + 194765, + 194765 + ], + "mapped", + [ + 26185 + ] + ], + [ + [ + 194766, + 194766 + ], + "mapped", + [ + 15129 + ] + ], + [ + [ + 194767, + 194767 + ], + "mapped", + [ + 26257 + ] + ], + [ + [ + 194768, + 194768 + ], + "mapped", + [ + 15112 + ] + ], + [ + [ + 194769, + 194769 + ], + "mapped", + [ + 15076 + ] + ], + [ + [ + 194770, + 194770 + ], + "mapped", + [ + 20882 + ] + ], + [ + [ + 194771, + 194771 + ], + "mapped", + [ + 20885 + ] + ], + [ + [ + 194772, + 194772 + ], + "mapped", + [ + 26368 + ] + ], + [ + [ + 194773, + 194773 + ], + "mapped", + [ + 26268 + ] + ], + [ + [ + 194774, + 194774 + ], + "mapped", + [ + 32941 + ] + ], + [ + [ + 194775, + 194775 + ], + "mapped", + [ + 17369 + ] + ], + [ + [ + 194776, + 194776 + ], + "mapped", + [ + 26391 + ] + ], + [ + [ + 194777, + 194777 + ], + "mapped", + [ + 26395 + ] + ], + [ + [ + 194778, + 194778 + ], + "mapped", + [ + 26401 + ] + ], + [ + [ + 194779, + 194779 + ], + "mapped", + [ + 26462 + ] + ], + [ + [ + 194780, + 194780 + ], + "mapped", + [ + 26451 + ] + ], + [ + [ + 194781, + 194781 + ], + "mapped", + [ + 144323 + ] + ], + [ + [ + 194782, + 194782 + ], + "mapped", + [ + 15177 + ] + ], + [ + [ + 194783, + 194783 + ], + "mapped", + [ + 26618 + ] + ], + [ + [ + 194784, + 194784 + ], + "mapped", + [ + 26501 + ] + ], + [ + [ + 194785, + 194785 + ], + "mapped", + [ + 26706 + ] + ], + [ + [ + 194786, + 194786 + ], + "mapped", + [ + 26757 + ] + ], + [ + [ + 194787, + 194787 + ], + "mapped", + [ + 144493 + ] + ], + [ + [ + 194788, + 194788 + ], + "mapped", + [ + 26766 + ] + ], + [ + [ + 194789, + 194789 + ], + "mapped", + [ + 26655 + ] + ], + [ + [ + 194790, + 194790 + ], + "mapped", + [ + 26900 + ] + ], + [ + [ + 194791, + 194791 + ], + "mapped", + [ + 15261 + ] + ], + [ + [ + 194792, + 194792 + ], + "mapped", + [ + 26946 + ] + ], + [ + [ + 194793, + 194793 + ], + "mapped", + [ + 27043 + ] + ], + [ + [ + 194794, + 194794 + ], + "mapped", + [ + 27114 + ] + ], + [ + [ + 194795, + 194795 + ], + "mapped", + [ + 27304 + ] + ], + [ + [ + 194796, + 194796 + ], + "mapped", + [ + 145059 + ] + ], + [ + [ + 194797, + 194797 + ], + "mapped", + [ + 27355 + ] + ], + [ + [ + 194798, + 194798 + ], + "mapped", + [ + 15384 + ] + ], + [ + [ + 194799, + 194799 + ], + "mapped", + [ + 27425 + ] + ], + [ + [ + 194800, + 194800 + ], + "mapped", + [ + 145575 + ] + ], + [ + [ + 194801, + 194801 + ], + "mapped", + [ + 27476 + ] + ], + [ + [ + 194802, + 194802 + ], + "mapped", + [ + 15438 + ] + ], + [ + [ + 194803, + 194803 + ], + "mapped", + [ + 27506 + ] + ], + [ + [ + 194804, + 194804 + ], + "mapped", + [ + 27551 + ] + ], + [ + [ + 194805, + 194805 + ], + "mapped", + [ + 27578 + ] + ], + [ + [ + 194806, + 194806 + ], + "mapped", + [ + 27579 + ] + ], + [ + [ + 194807, + 194807 + ], + "mapped", + [ + 146061 + ] + ], + [ + [ + 194808, + 194808 + ], + "mapped", + [ + 138507 + ] + ], + [ + [ + 194809, + 194809 + ], + "mapped", + [ + 146170 + ] + ], + [ + [ + 194810, + 194810 + ], + "mapped", + [ + 27726 + ] + ], + [ + [ + 194811, + 194811 + ], + "mapped", + [ + 146620 + ] + ], + [ + [ + 194812, + 194812 + ], + "mapped", + [ + 27839 + ] + ], + [ + [ + 194813, + 194813 + ], + "mapped", + [ + 27853 + ] + ], + [ + [ + 194814, + 194814 + ], + "mapped", + [ + 27751 + ] + ], + [ + [ + 194815, + 194815 + ], + "mapped", + [ + 27926 + ] + ], + [ + [ + 194816, + 194816 + ], + "mapped", + [ + 27966 + ] + ], + [ + [ + 194817, + 194817 + ], + "mapped", + [ + 28023 + ] + ], + [ + [ + 194818, + 194818 + ], + "mapped", + [ + 27969 + ] + ], + [ + [ + 194819, + 194819 + ], + "mapped", + [ + 28009 + ] + ], + [ + [ + 194820, + 194820 + ], + "mapped", + [ + 28024 + ] + ], + [ + [ + 194821, + 194821 + ], + "mapped", + [ + 28037 + ] + ], + [ + [ + 194822, + 194822 + ], + "mapped", + [ + 146718 + ] + ], + [ + [ + 194823, + 194823 + ], + "mapped", + [ + 27956 + ] + ], + [ + [ + 194824, + 194824 + ], + "mapped", + [ + 28207 + ] + ], + [ + [ + 194825, + 194825 + ], + "mapped", + [ + 28270 + ] + ], + [ + [ + 194826, + 194826 + ], + "mapped", + [ + 15667 + ] + ], + [ + [ + 194827, + 194827 + ], + "mapped", + [ + 28363 + ] + ], + [ + [ + 194828, + 194828 + ], + "mapped", + [ + 28359 + ] + ], + [ + [ + 194829, + 194829 + ], + "mapped", + [ + 147153 + ] + ], + [ + [ + 194830, + 194830 + ], + "mapped", + [ + 28153 + ] + ], + [ + [ + 194831, + 194831 + ], + "mapped", + [ + 28526 + ] + ], + [ + [ + 194832, + 194832 + ], + "mapped", + [ + 147294 + ] + ], + [ + [ + 194833, + 194833 + ], + "mapped", + [ + 147342 + ] + ], + [ + [ + 194834, + 194834 + ], + "mapped", + [ + 28614 + ] + ], + [ + [ + 194835, + 194835 + ], + "mapped", + [ + 28729 + ] + ], + [ + [ + 194836, + 194836 + ], + "mapped", + [ + 28702 + ] + ], + [ + [ + 194837, + 194837 + ], + "mapped", + [ + 28699 + ] + ], + [ + [ + 194838, + 194838 + ], + "mapped", + [ + 15766 + ] + ], + [ + [ + 194839, + 194839 + ], + "mapped", + [ + 28746 + ] + ], + [ + [ + 194840, + 194840 + ], + "mapped", + [ + 28797 + ] + ], + [ + [ + 194841, + 194841 + ], + "mapped", + [ + 28791 + ] + ], + [ + [ + 194842, + 194842 + ], + "mapped", + [ + 28845 + ] + ], + [ + [ + 194843, + 194843 + ], + "mapped", + [ + 132389 + ] + ], + [ + [ + 194844, + 194844 + ], + "mapped", + [ + 28997 + ] + ], + [ + [ + 194845, + 194845 + ], + "mapped", + [ + 148067 + ] + ], + [ + [ + 194846, + 194846 + ], + "mapped", + [ + 29084 + ] + ], + [ + [ + 194847, + 194847 + ], + "disallowed" + ], + [ + [ + 194848, + 194848 + ], + "mapped", + [ + 29224 + ] + ], + [ + [ + 194849, + 194849 + ], + "mapped", + [ + 29237 + ] + ], + [ + [ + 194850, + 194850 + ], + "mapped", + [ + 29264 + ] + ], + [ + [ + 194851, + 194851 + ], + "mapped", + [ + 149000 + ] + ], + [ + [ + 194852, + 194852 + ], + "mapped", + [ + 29312 + ] + ], + [ + [ + 194853, + 194853 + ], + "mapped", + [ + 29333 + ] + ], + [ + [ + 194854, + 194854 + ], + "mapped", + [ + 149301 + ] + ], + [ + [ + 194855, + 194855 + ], + "mapped", + [ + 149524 + ] + ], + [ + [ + 194856, + 194856 + ], + "mapped", + [ + 29562 + ] + ], + [ + [ + 194857, + 194857 + ], + "mapped", + [ + 29579 + ] + ], + [ + [ + 194858, + 194858 + ], + "mapped", + [ + 16044 + ] + ], + [ + [ + 194859, + 194859 + ], + "mapped", + [ + 29605 + ] + ], + [ + [ + 194860, + 194861 + ], + "mapped", + [ + 16056 + ] + ], + [ + [ + 194862, + 194862 + ], + "mapped", + [ + 29767 + ] + ], + [ + [ + 194863, + 194863 + ], + "mapped", + [ + 29788 + ] + ], + [ + [ + 194864, + 194864 + ], + "mapped", + [ + 29809 + ] + ], + [ + [ + 194865, + 194865 + ], + "mapped", + [ + 29829 + ] + ], + [ + [ + 194866, + 194866 + ], + "mapped", + [ + 29898 + ] + ], + [ + [ + 194867, + 194867 + ], + "mapped", + [ + 16155 + ] + ], + [ + [ + 194868, + 194868 + ], + "mapped", + [ + 29988 + ] + ], + [ + [ + 194869, + 194869 + ], + "mapped", + [ + 150582 + ] + ], + [ + [ + 194870, + 194870 + ], + "mapped", + [ + 30014 + ] + ], + [ + [ + 194871, + 194871 + ], + "mapped", + [ + 150674 + ] + ], + [ + [ + 194872, + 194872 + ], + "mapped", + [ + 30064 + ] + ], + [ + [ + 194873, + 194873 + ], + "mapped", + [ + 139679 + ] + ], + [ + [ + 194874, + 194874 + ], + "mapped", + [ + 30224 + ] + ], + [ + [ + 194875, + 194875 + ], + "mapped", + [ + 151457 + ] + ], + [ + [ + 194876, + 194876 + ], + "mapped", + [ + 151480 + ] + ], + [ + [ + 194877, + 194877 + ], + "mapped", + [ + 151620 + ] + ], + [ + [ + 194878, + 194878 + ], + "mapped", + [ + 16380 + ] + ], + [ + [ + 194879, + 194879 + ], + "mapped", + [ + 16392 + ] + ], + [ + [ + 194880, + 194880 + ], + "mapped", + [ + 30452 + ] + ], + [ + [ + 194881, + 194881 + ], + "mapped", + [ + 151795 + ] + ], + [ + [ + 194882, + 194882 + ], + "mapped", + [ + 151794 + ] + ], + [ + [ + 194883, + 194883 + ], + "mapped", + [ + 151833 + ] + ], + [ + [ + 194884, + 194884 + ], + "mapped", + [ + 151859 + ] + ], + [ + [ + 194885, + 194885 + ], + "mapped", + [ + 30494 + ] + ], + [ + [ + 194886, + 194887 + ], + "mapped", + [ + 30495 + ] + ], + [ + [ + 194888, + 194888 + ], + "mapped", + [ + 30538 + ] + ], + [ + [ + 194889, + 194889 + ], + "mapped", + [ + 16441 + ] + ], + [ + [ + 194890, + 194890 + ], + "mapped", + [ + 30603 + ] + ], + [ + [ + 194891, + 194891 + ], + "mapped", + [ + 16454 + ] + ], + [ + [ + 194892, + 194892 + ], + "mapped", + [ + 16534 + ] + ], + [ + [ + 194893, + 194893 + ], + "mapped", + [ + 152605 + ] + ], + [ + [ + 194894, + 194894 + ], + "mapped", + [ + 30798 + ] + ], + [ + [ + 194895, + 194895 + ], + "mapped", + [ + 30860 + ] + ], + [ + [ + 194896, + 194896 + ], + "mapped", + [ + 30924 + ] + ], + [ + [ + 194897, + 194897 + ], + "mapped", + [ + 16611 + ] + ], + [ + [ + 194898, + 194898 + ], + "mapped", + [ + 153126 + ] + ], + [ + [ + 194899, + 194899 + ], + "mapped", + [ + 31062 + ] + ], + [ + [ + 194900, + 194900 + ], + "mapped", + [ + 153242 + ] + ], + [ + [ + 194901, + 194901 + ], + "mapped", + [ + 153285 + ] + ], + [ + [ + 194902, + 194902 + ], + "mapped", + [ + 31119 + ] + ], + [ + [ + 194903, + 194903 + ], + "mapped", + [ + 31211 + ] + ], + [ + [ + 194904, + 194904 + ], + "mapped", + [ + 16687 + ] + ], + [ + [ + 194905, + 194905 + ], + "mapped", + [ + 31296 + ] + ], + [ + [ + 194906, + 194906 + ], + "mapped", + [ + 31306 + ] + ], + [ + [ + 194907, + 194907 + ], + "mapped", + [ + 31311 + ] + ], + [ + [ + 194908, + 194908 + ], + "mapped", + [ + 153980 + ] + ], + [ + [ + 194909, + 194910 + ], + "mapped", + [ + 154279 + ] + ], + [ + [ + 194911, + 194911 + ], + "disallowed" + ], + [ + [ + 194912, + 194912 + ], + "mapped", + [ + 16898 + ] + ], + [ + [ + 194913, + 194913 + ], + "mapped", + [ + 154539 + ] + ], + [ + [ + 194914, + 194914 + ], + "mapped", + [ + 31686 + ] + ], + [ + [ + 194915, + 194915 + ], + "mapped", + [ + 31689 + ] + ], + [ + [ + 194916, + 194916 + ], + "mapped", + [ + 16935 + ] + ], + [ + [ + 194917, + 194917 + ], + "mapped", + [ + 154752 + ] + ], + [ + [ + 194918, + 194918 + ], + "mapped", + [ + 31954 + ] + ], + [ + [ + 194919, + 194919 + ], + "mapped", + [ + 17056 + ] + ], + [ + [ + 194920, + 194920 + ], + "mapped", + [ + 31976 + ] + ], + [ + [ + 194921, + 194921 + ], + "mapped", + [ + 31971 + ] + ], + [ + [ + 194922, + 194922 + ], + "mapped", + [ + 32000 + ] + ], + [ + [ + 194923, + 194923 + ], + "mapped", + [ + 155526 + ] + ], + [ + [ + 194924, + 194924 + ], + "mapped", + [ + 32099 + ] + ], + [ + [ + 194925, + 194925 + ], + "mapped", + [ + 17153 + ] + ], + [ + [ + 194926, + 194926 + ], + "mapped", + [ + 32199 + ] + ], + [ + [ + 194927, + 194927 + ], + "mapped", + [ + 32258 + ] + ], + [ + [ + 194928, + 194928 + ], + "mapped", + [ + 32325 + ] + ], + [ + [ + 194929, + 194929 + ], + "mapped", + [ + 17204 + ] + ], + [ + [ + 194930, + 194930 + ], + "mapped", + [ + 156200 + ] + ], + [ + [ + 194931, + 194931 + ], + "mapped", + [ + 156231 + ] + ], + [ + [ + 194932, + 194932 + ], + "mapped", + [ + 17241 + ] + ], + [ + [ + 194933, + 194933 + ], + "mapped", + [ + 156377 + ] + ], + [ + [ + 194934, + 194934 + ], + "mapped", + [ + 32634 + ] + ], + [ + [ + 194935, + 194935 + ], + "mapped", + [ + 156478 + ] + ], + [ + [ + 194936, + 194936 + ], + "mapped", + [ + 32661 + ] + ], + [ + [ + 194937, + 194937 + ], + "mapped", + [ + 32762 + ] + ], + [ + [ + 194938, + 194938 + ], + "mapped", + [ + 32773 + ] + ], + [ + [ + 194939, + 194939 + ], + "mapped", + [ + 156890 + ] + ], + [ + [ + 194940, + 194940 + ], + "mapped", + [ + 156963 + ] + ], + [ + [ + 194941, + 194941 + ], + "mapped", + [ + 32864 + ] + ], + [ + [ + 194942, + 194942 + ], + "mapped", + [ + 157096 + ] + ], + [ + [ + 194943, + 194943 + ], + "mapped", + [ + 32880 + ] + ], + [ + [ + 194944, + 194944 + ], + "mapped", + [ + 144223 + ] + ], + [ + [ + 194945, + 194945 + ], + "mapped", + [ + 17365 + ] + ], + [ + [ + 194946, + 194946 + ], + "mapped", + [ + 32946 + ] + ], + [ + [ + 194947, + 194947 + ], + "mapped", + [ + 33027 + ] + ], + [ + [ + 194948, + 194948 + ], + "mapped", + [ + 17419 + ] + ], + [ + [ + 194949, + 194949 + ], + "mapped", + [ + 33086 + ] + ], + [ + [ + 194950, + 194950 + ], + "mapped", + [ + 23221 + ] + ], + [ + [ + 194951, + 194951 + ], + "mapped", + [ + 157607 + ] + ], + [ + [ + 194952, + 194952 + ], + "mapped", + [ + 157621 + ] + ], + [ + [ + 194953, + 194953 + ], + "mapped", + [ + 144275 + ] + ], + [ + [ + 194954, + 194954 + ], + "mapped", + [ + 144284 + ] + ], + [ + [ + 194955, + 194955 + ], + "mapped", + [ + 33281 + ] + ], + [ + [ + 194956, + 194956 + ], + "mapped", + [ + 33284 + ] + ], + [ + [ + 194957, + 194957 + ], + "mapped", + [ + 36766 + ] + ], + [ + [ + 194958, + 194958 + ], + "mapped", + [ + 17515 + ] + ], + [ + [ + 194959, + 194959 + ], + "mapped", + [ + 33425 + ] + ], + [ + [ + 194960, + 194960 + ], + "mapped", + [ + 33419 + ] + ], + [ + [ + 194961, + 194961 + ], + "mapped", + [ + 33437 + ] + ], + [ + [ + 194962, + 194962 + ], + "mapped", + [ + 21171 + ] + ], + [ + [ + 194963, + 194963 + ], + "mapped", + [ + 33457 + ] + ], + [ + [ + 194964, + 194964 + ], + "mapped", + [ + 33459 + ] + ], + [ + [ + 194965, + 194965 + ], + "mapped", + [ + 33469 + ] + ], + [ + [ + 194966, + 194966 + ], + "mapped", + [ + 33510 + ] + ], + [ + [ + 194967, + 194967 + ], + "mapped", + [ + 158524 + ] + ], + [ + [ + 194968, + 194968 + ], + "mapped", + [ + 33509 + ] + ], + [ + [ + 194969, + 194969 + ], + "mapped", + [ + 33565 + ] + ], + [ + [ + 194970, + 194970 + ], + "mapped", + [ + 33635 + ] + ], + [ + [ + 194971, + 194971 + ], + "mapped", + [ + 33709 + ] + ], + [ + [ + 194972, + 194972 + ], + "mapped", + [ + 33571 + ] + ], + [ + [ + 194973, + 194973 + ], + "mapped", + [ + 33725 + ] + ], + [ + [ + 194974, + 194974 + ], + "mapped", + [ + 33767 + ] + ], + [ + [ + 194975, + 194975 + ], + "mapped", + [ + 33879 + ] + ], + [ + [ + 194976, + 194976 + ], + "mapped", + [ + 33619 + ] + ], + [ + [ + 194977, + 194977 + ], + "mapped", + [ + 33738 + ] + ], + [ + [ + 194978, + 194978 + ], + "mapped", + [ + 33740 + ] + ], + [ + [ + 194979, + 194979 + ], + "mapped", + [ + 33756 + ] + ], + [ + [ + 194980, + 194980 + ], + "mapped", + [ + 158774 + ] + ], + [ + [ + 194981, + 194981 + ], + "mapped", + [ + 159083 + ] + ], + [ + [ + 194982, + 194982 + ], + "mapped", + [ + 158933 + ] + ], + [ + [ + 194983, + 194983 + ], + "mapped", + [ + 17707 + ] + ], + [ + [ + 194984, + 194984 + ], + "mapped", + [ + 34033 + ] + ], + [ + [ + 194985, + 194985 + ], + "mapped", + [ + 34035 + ] + ], + [ + [ + 194986, + 194986 + ], + "mapped", + [ + 34070 + ] + ], + [ + [ + 194987, + 194987 + ], + "mapped", + [ + 160714 + ] + ], + [ + [ + 194988, + 194988 + ], + "mapped", + [ + 34148 + ] + ], + [ + [ + 194989, + 194989 + ], + "mapped", + [ + 159532 + ] + ], + [ + [ + 194990, + 194990 + ], + "mapped", + [ + 17757 + ] + ], + [ + [ + 194991, + 194991 + ], + "mapped", + [ + 17761 + ] + ], + [ + [ + 194992, + 194992 + ], + "mapped", + [ + 159665 + ] + ], + [ + [ + 194993, + 194993 + ], + "mapped", + [ + 159954 + ] + ], + [ + [ + 194994, + 194994 + ], + "mapped", + [ + 17771 + ] + ], + [ + [ + 194995, + 194995 + ], + "mapped", + [ + 34384 + ] + ], + [ + [ + 194996, + 194996 + ], + "mapped", + [ + 34396 + ] + ], + [ + [ + 194997, + 194997 + ], + "mapped", + [ + 34407 + ] + ], + [ + [ + 194998, + 194998 + ], + "mapped", + [ + 34409 + ] + ], + [ + [ + 194999, + 194999 + ], + "mapped", + [ + 34473 + ] + ], + [ + [ + 195000, + 195000 + ], + "mapped", + [ + 34440 + ] + ], + [ + [ + 195001, + 195001 + ], + "mapped", + [ + 34574 + ] + ], + [ + [ + 195002, + 195002 + ], + "mapped", + [ + 34530 + ] + ], + [ + [ + 195003, + 195003 + ], + "mapped", + [ + 34681 + ] + ], + [ + [ + 195004, + 195004 + ], + "mapped", + [ + 34600 + ] + ], + [ + [ + 195005, + 195005 + ], + "mapped", + [ + 34667 + ] + ], + [ + [ + 195006, + 195006 + ], + "mapped", + [ + 34694 + ] + ], + [ + [ + 195007, + 195007 + ], + "disallowed" + ], + [ + [ + 195008, + 195008 + ], + "mapped", + [ + 34785 + ] + ], + [ + [ + 195009, + 195009 + ], + "mapped", + [ + 34817 + ] + ], + [ + [ + 195010, + 195010 + ], + "mapped", + [ + 17913 + ] + ], + [ + [ + 195011, + 195011 + ], + "mapped", + [ + 34912 + ] + ], + [ + [ + 195012, + 195012 + ], + "mapped", + [ + 34915 + ] + ], + [ + [ + 195013, + 195013 + ], + "mapped", + [ + 161383 + ] + ], + [ + [ + 195014, + 195014 + ], + "mapped", + [ + 35031 + ] + ], + [ + [ + 195015, + 195015 + ], + "mapped", + [ + 35038 + ] + ], + [ + [ + 195016, + 195016 + ], + "mapped", + [ + 17973 + ] + ], + [ + [ + 195017, + 195017 + ], + "mapped", + [ + 35066 + ] + ], + [ + [ + 195018, + 195018 + ], + "mapped", + [ + 13499 + ] + ], + [ + [ + 195019, + 195019 + ], + "mapped", + [ + 161966 + ] + ], + [ + [ + 195020, + 195020 + ], + "mapped", + [ + 162150 + ] + ], + [ + [ + 195021, + 195021 + ], + "mapped", + [ + 18110 + ] + ], + [ + [ + 195022, + 195022 + ], + "mapped", + [ + 18119 + ] + ], + [ + [ + 195023, + 195023 + ], + "mapped", + [ + 35488 + ] + ], + [ + [ + 195024, + 195024 + ], + "mapped", + [ + 35565 + ] + ], + [ + [ + 195025, + 195025 + ], + "mapped", + [ + 35722 + ] + ], + [ + [ + 195026, + 195026 + ], + "mapped", + [ + 35925 + ] + ], + [ + [ + 195027, + 195027 + ], + "mapped", + [ + 162984 + ] + ], + [ + [ + 195028, + 195028 + ], + "mapped", + [ + 36011 + ] + ], + [ + [ + 195029, + 195029 + ], + "mapped", + [ + 36033 + ] + ], + [ + [ + 195030, + 195030 + ], + "mapped", + [ + 36123 + ] + ], + [ + [ + 195031, + 195031 + ], + "mapped", + [ + 36215 + ] + ], + [ + [ + 195032, + 195032 + ], + "mapped", + [ + 163631 + ] + ], + [ + [ + 195033, + 195033 + ], + "mapped", + [ + 133124 + ] + ], + [ + [ + 195034, + 195034 + ], + "mapped", + [ + 36299 + ] + ], + [ + [ + 195035, + 195035 + ], + "mapped", + [ + 36284 + ] + ], + [ + [ + 195036, + 195036 + ], + "mapped", + [ + 36336 + ] + ], + [ + [ + 195037, + 195037 + ], + "mapped", + [ + 133342 + ] + ], + [ + [ + 195038, + 195038 + ], + "mapped", + [ + 36564 + ] + ], + [ + [ + 195039, + 195039 + ], + "mapped", + [ + 36664 + ] + ], + [ + [ + 195040, + 195040 + ], + "mapped", + [ + 165330 + ] + ], + [ + [ + 195041, + 195041 + ], + "mapped", + [ + 165357 + ] + ], + [ + [ + 195042, + 195042 + ], + "mapped", + [ + 37012 + ] + ], + [ + [ + 195043, + 195043 + ], + "mapped", + [ + 37105 + ] + ], + [ + [ + 195044, + 195044 + ], + "mapped", + [ + 37137 + ] + ], + [ + [ + 195045, + 195045 + ], + "mapped", + [ + 165678 + ] + ], + [ + [ + 195046, + 195046 + ], + "mapped", + [ + 37147 + ] + ], + [ + [ + 195047, + 195047 + ], + "mapped", + [ + 37432 + ] + ], + [ + [ + 195048, + 195048 + ], + "mapped", + [ + 37591 + ] + ], + [ + [ + 195049, + 195049 + ], + "mapped", + [ + 37592 + ] + ], + [ + [ + 195050, + 195050 + ], + "mapped", + [ + 37500 + ] + ], + [ + [ + 195051, + 195051 + ], + "mapped", + [ + 37881 + ] + ], + [ + [ + 195052, + 195052 + ], + "mapped", + [ + 37909 + ] + ], + [ + [ + 195053, + 195053 + ], + "mapped", + [ + 166906 + ] + ], + [ + [ + 195054, + 195054 + ], + "mapped", + [ + 38283 + ] + ], + [ + [ + 195055, + 195055 + ], + "mapped", + [ + 18837 + ] + ], + [ + [ + 195056, + 195056 + ], + "mapped", + [ + 38327 + ] + ], + [ + [ + 195057, + 195057 + ], + "mapped", + [ + 167287 + ] + ], + [ + [ + 195058, + 195058 + ], + "mapped", + [ + 18918 + ] + ], + [ + [ + 195059, + 195059 + ], + "mapped", + [ + 38595 + ] + ], + [ + [ + 195060, + 195060 + ], + "mapped", + [ + 23986 + ] + ], + [ + [ + 195061, + 195061 + ], + "mapped", + [ + 38691 + ] + ], + [ + [ + 195062, + 195062 + ], + "mapped", + [ + 168261 + ] + ], + [ + [ + 195063, + 195063 + ], + "mapped", + [ + 168474 + ] + ], + [ + [ + 195064, + 195064 + ], + "mapped", + [ + 19054 + ] + ], + [ + [ + 195065, + 195065 + ], + "mapped", + [ + 19062 + ] + ], + [ + [ + 195066, + 195066 + ], + "mapped", + [ + 38880 + ] + ], + [ + [ + 195067, + 195067 + ], + "mapped", + [ + 168970 + ] + ], + [ + [ + 195068, + 195068 + ], + "mapped", + [ + 19122 + ] + ], + [ + [ + 195069, + 195069 + ], + "mapped", + [ + 169110 + ] + ], + [ + [ + 195070, + 195071 + ], + "mapped", + [ + 38923 + ] + ], + [ + [ + 195072, + 195072 + ], + "mapped", + [ + 38953 + ] + ], + [ + [ + 195073, + 195073 + ], + "mapped", + [ + 169398 + ] + ], + [ + [ + 195074, + 195074 + ], + "mapped", + [ + 39138 + ] + ], + [ + [ + 195075, + 195075 + ], + "mapped", + [ + 19251 + ] + ], + [ + [ + 195076, + 195076 + ], + "mapped", + [ + 39209 + ] + ], + [ + [ + 195077, + 195077 + ], + "mapped", + [ + 39335 + ] + ], + [ + [ + 195078, + 195078 + ], + "mapped", + [ + 39362 + ] + ], + [ + [ + 195079, + 195079 + ], + "mapped", + [ + 39422 + ] + ], + [ + [ + 195080, + 195080 + ], + "mapped", + [ + 19406 + ] + ], + [ + [ + 195081, + 195081 + ], + "mapped", + [ + 170800 + ] + ], + [ + [ + 195082, + 195082 + ], + "mapped", + [ + 39698 + ] + ], + [ + [ + 195083, + 195083 + ], + "mapped", + [ + 40000 + ] + ], + [ + [ + 195084, + 195084 + ], + "mapped", + [ + 40189 + ] + ], + [ + [ + 195085, + 195085 + ], + "mapped", + [ + 19662 + ] + ], + [ + [ + 195086, + 195086 + ], + "mapped", + [ + 19693 + ] + ], + [ + [ + 195087, + 195087 + ], + "mapped", + [ + 40295 + ] + ], + [ + [ + 195088, + 195088 + ], + "mapped", + [ + 172238 + ] + ], + [ + [ + 195089, + 195089 + ], + "mapped", + [ + 19704 + ] + ], + [ + [ + 195090, + 195090 + ], + "mapped", + [ + 172293 + ] + ], + [ + [ + 195091, + 195091 + ], + "mapped", + [ + 172558 + ] + ], + [ + [ + 195092, + 195092 + ], + "mapped", + [ + 172689 + ] + ], + [ + [ + 195093, + 195093 + ], + "mapped", + [ + 40635 + ] + ], + [ + [ + 195094, + 195094 + ], + "mapped", + [ + 19798 + ] + ], + [ + [ + 195095, + 195095 + ], + "mapped", + [ + 40697 + ] + ], + [ + [ + 195096, + 195096 + ], + "mapped", + [ + 40702 + ] + ], + [ + [ + 195097, + 195097 + ], + "mapped", + [ + 40709 + ] + ], + [ + [ + 195098, + 195098 + ], + "mapped", + [ + 40719 + ] + ], + [ + [ + 195099, + 195099 + ], + "mapped", + [ + 40726 + ] + ], + [ + [ + 195100, + 195100 + ], + "mapped", + [ + 40763 + ] + ], + [ + [ + 195101, + 195101 + ], + "mapped", + [ + 173568 + ] + ], + [ + [ + 195102, + 196605 + ], + "disallowed" + ], + [ + [ + 196606, + 196607 + ], + "disallowed" + ], + [ + [ + 196608, + 262141 + ], + "disallowed" + ], + [ + [ + 262142, + 262143 + ], + "disallowed" + ], + [ + [ + 262144, + 327677 + ], + "disallowed" + ], + [ + [ + 327678, + 327679 + ], + "disallowed" + ], + [ + [ + 327680, + 393213 + ], + "disallowed" + ], + [ + [ + 393214, + 393215 + ], + "disallowed" + ], + [ + [ + 393216, + 458749 + ], + "disallowed" + ], + [ + [ + 458750, + 458751 + ], + "disallowed" + ], + [ + [ + 458752, + 524285 + ], + "disallowed" + ], + [ + [ + 524286, + 524287 + ], + "disallowed" + ], + [ + [ + 524288, + 589821 + ], + "disallowed" + ], + [ + [ + 589822, + 589823 + ], + "disallowed" + ], + [ + [ + 589824, + 655357 + ], + "disallowed" + ], + [ + [ + 655358, + 655359 + ], + "disallowed" + ], + [ + [ + 655360, + 720893 + ], + "disallowed" + ], + [ + [ + 720894, + 720895 + ], + "disallowed" + ], + [ + [ + 720896, + 786429 + ], + "disallowed" + ], + [ + [ + 786430, + 786431 + ], + "disallowed" + ], + [ + [ + 786432, + 851965 + ], + "disallowed" + ], + [ + [ + 851966, + 851967 + ], + "disallowed" + ], + [ + [ + 851968, + 917501 + ], + "disallowed" + ], + [ + [ + 917502, + 917503 + ], + "disallowed" + ], + [ + [ + 917504, + 917504 + ], + "disallowed" + ], + [ + [ + 917505, + 917505 + ], + "disallowed" + ], + [ + [ + 917506, + 917535 + ], + "disallowed" + ], + [ + [ + 917536, + 917631 + ], + "disallowed" + ], + [ + [ + 917632, + 917759 + ], + "disallowed" + ], + [ + [ + 917760, + 917999 + ], + "ignored" + ], + [ + [ + 918000, + 983037 + ], + "disallowed" + ], + [ + [ + 983038, + 983039 + ], + "disallowed" + ], + [ + [ + 983040, + 1048573 + ], + "disallowed" + ], + [ + [ + 1048574, + 1048575 + ], + "disallowed" + ], + [ + [ + 1048576, + 1114109 + ], + "disallowed" + ], + [ + [ + 1114110, + 1114111 + ], + "disallowed" + ] +]; + +var punycode = require$$0__default$1["default"]; +var mappingTable = require$$1; + +var PROCESSING_OPTIONS = { + TRANSITIONAL: 0, + NONTRANSITIONAL: 1 +}; + +function normalize(str) { // fix bug in v8 + return str.split('\u0000').map(function (s) { return s.normalize('NFC'); }).join('\u0000'); +} + +function findStatus(val) { + var start = 0; + var end = mappingTable.length - 1; + + while (start <= end) { + var mid = Math.floor((start + end) / 2); + + var target = mappingTable[mid]; + if (target[0][0] <= val && target[0][1] >= val) { + return target; + } else if (target[0][0] > val) { + end = mid - 1; + } else { + start = mid + 1; + } + } + + return null; +} + +var regexAstralSymbols = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g; + +function countSymbols(string) { + return string + // replace every surrogate pair with a BMP symbol + .replace(regexAstralSymbols, '_') + // then get the length + .length; +} + +function mapChars(domain_name, useSTD3, processing_option) { + var hasError = false; + var processed = ""; + + var len = countSymbols(domain_name); + for (var i = 0; i < len; ++i) { + var codePoint = domain_name.codePointAt(i); + var status = findStatus(codePoint); + + switch (status[1]) { + case "disallowed": + hasError = true; + processed += String.fromCodePoint(codePoint); + break; + case "ignored": + break; + case "mapped": + processed += String.fromCodePoint.apply(String, status[2]); + break; + case "deviation": + if (processing_option === PROCESSING_OPTIONS.TRANSITIONAL) { + processed += String.fromCodePoint.apply(String, status[2]); + } else { + processed += String.fromCodePoint(codePoint); + } + break; + case "valid": + processed += String.fromCodePoint(codePoint); + break; + case "disallowed_STD3_mapped": + if (useSTD3) { + hasError = true; + processed += String.fromCodePoint(codePoint); + } else { + processed += String.fromCodePoint.apply(String, status[2]); + } + break; + case "disallowed_STD3_valid": + if (useSTD3) { + hasError = true; + } + + processed += String.fromCodePoint(codePoint); + break; + } + } + + return { + string: processed, + error: hasError + }; +} + +var combiningMarksRegex = /[\u0300-\u036F\u0483-\u0489\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u0610-\u061A\u064B-\u065F\u0670\u06D6-\u06DC\u06DF-\u06E4\u06E7\u06E8\u06EA-\u06ED\u0711\u0730-\u074A\u07A6-\u07B0\u07EB-\u07F3\u0816-\u0819\u081B-\u0823\u0825-\u0827\u0829-\u082D\u0859-\u085B\u08E4-\u0903\u093A-\u093C\u093E-\u094F\u0951-\u0957\u0962\u0963\u0981-\u0983\u09BC\u09BE-\u09C4\u09C7\u09C8\u09CB-\u09CD\u09D7\u09E2\u09E3\u0A01-\u0A03\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A70\u0A71\u0A75\u0A81-\u0A83\u0ABC\u0ABE-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AE2\u0AE3\u0B01-\u0B03\u0B3C\u0B3E-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B56\u0B57\u0B62\u0B63\u0B82\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD7\u0C00-\u0C03\u0C3E-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C62\u0C63\u0C81-\u0C83\u0CBC\u0CBE-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CE2\u0CE3\u0D01-\u0D03\u0D3E-\u0D44\u0D46-\u0D48\u0D4A-\u0D4D\u0D57\u0D62\u0D63\u0D82\u0D83\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DF2\u0DF3\u0E31\u0E34-\u0E3A\u0E47-\u0E4E\u0EB1\u0EB4-\u0EB9\u0EBB\u0EBC\u0EC8-\u0ECD\u0F18\u0F19\u0F35\u0F37\u0F39\u0F3E\u0F3F\u0F71-\u0F84\u0F86\u0F87\u0F8D-\u0F97\u0F99-\u0FBC\u0FC6\u102B-\u103E\u1056-\u1059\u105E-\u1060\u1062-\u1064\u1067-\u106D\u1071-\u1074\u1082-\u108D\u108F\u109A-\u109D\u135D-\u135F\u1712-\u1714\u1732-\u1734\u1752\u1753\u1772\u1773\u17B4-\u17D3\u17DD\u180B-\u180D\u18A9\u1920-\u192B\u1930-\u193B\u19B0-\u19C0\u19C8\u19C9\u1A17-\u1A1B\u1A55-\u1A5E\u1A60-\u1A7C\u1A7F\u1AB0-\u1ABE\u1B00-\u1B04\u1B34-\u1B44\u1B6B-\u1B73\u1B80-\u1B82\u1BA1-\u1BAD\u1BE6-\u1BF3\u1C24-\u1C37\u1CD0-\u1CD2\u1CD4-\u1CE8\u1CED\u1CF2-\u1CF4\u1CF8\u1CF9\u1DC0-\u1DF5\u1DFC-\u1DFF\u20D0-\u20F0\u2CEF-\u2CF1\u2D7F\u2DE0-\u2DFF\u302A-\u302F\u3099\u309A\uA66F-\uA672\uA674-\uA67D\uA69F\uA6F0\uA6F1\uA802\uA806\uA80B\uA823-\uA827\uA880\uA881\uA8B4-\uA8C4\uA8E0-\uA8F1\uA926-\uA92D\uA947-\uA953\uA980-\uA983\uA9B3-\uA9C0\uA9E5\uAA29-\uAA36\uAA43\uAA4C\uAA4D\uAA7B-\uAA7D\uAAB0\uAAB2-\uAAB4\uAAB7\uAAB8\uAABE\uAABF\uAAC1\uAAEB-\uAAEF\uAAF5\uAAF6\uABE3-\uABEA\uABEC\uABED\uFB1E\uFE00-\uFE0F\uFE20-\uFE2D]|\uD800[\uDDFD\uDEE0\uDF76-\uDF7A]|\uD802[\uDE01-\uDE03\uDE05\uDE06\uDE0C-\uDE0F\uDE38-\uDE3A\uDE3F\uDEE5\uDEE6]|\uD804[\uDC00-\uDC02\uDC38-\uDC46\uDC7F-\uDC82\uDCB0-\uDCBA\uDD00-\uDD02\uDD27-\uDD34\uDD73\uDD80-\uDD82\uDDB3-\uDDC0\uDE2C-\uDE37\uDEDF-\uDEEA\uDF01-\uDF03\uDF3C\uDF3E-\uDF44\uDF47\uDF48\uDF4B-\uDF4D\uDF57\uDF62\uDF63\uDF66-\uDF6C\uDF70-\uDF74]|\uD805[\uDCB0-\uDCC3\uDDAF-\uDDB5\uDDB8-\uDDC0\uDE30-\uDE40\uDEAB-\uDEB7]|\uD81A[\uDEF0-\uDEF4\uDF30-\uDF36]|\uD81B[\uDF51-\uDF7E\uDF8F-\uDF92]|\uD82F[\uDC9D\uDC9E]|\uD834[\uDD65-\uDD69\uDD6D-\uDD72\uDD7B-\uDD82\uDD85-\uDD8B\uDDAA-\uDDAD\uDE42-\uDE44]|\uD83A[\uDCD0-\uDCD6]|\uDB40[\uDD00-\uDDEF]/; + +function validateLabel(label, processing_option) { + if (label.substr(0, 4) === "xn--") { + label = punycode.toUnicode(label); + PROCESSING_OPTIONS.NONTRANSITIONAL; + } + + var error = false; + + if (normalize(label) !== label || + (label[3] === "-" && label[4] === "-") || + label[0] === "-" || label[label.length - 1] === "-" || + label.indexOf(".") !== -1 || + label.search(combiningMarksRegex) === 0) { + error = true; + } + + var len = countSymbols(label); + for (var i = 0; i < len; ++i) { + var status = findStatus(label.codePointAt(i)); + if ((processing === PROCESSING_OPTIONS.TRANSITIONAL && status[1] !== "valid") || + (processing === PROCESSING_OPTIONS.NONTRANSITIONAL && + status[1] !== "valid" && status[1] !== "deviation")) { + error = true; + break; + } + } + + return { + label: label, + error: error + }; +} + +function processing(domain_name, useSTD3, processing_option) { + var result = mapChars(domain_name, useSTD3, processing_option); + result.string = normalize(result.string); + + var labels = result.string.split("."); + for (var i = 0; i < labels.length; ++i) { + try { + var validation = validateLabel(labels[i]); + labels[i] = validation.label; + result.error = result.error || validation.error; + } catch(e) { + result.error = true; + } + } + + return { + string: labels.join("."), + error: result.error + }; +} + +tr46.toASCII = function(domain_name, useSTD3, processing_option, verifyDnsLength) { + var result = processing(domain_name, useSTD3, processing_option); + var labels = result.string.split("."); + labels = labels.map(function(l) { + try { + return punycode.toASCII(l); + } catch(e) { + result.error = true; + return l; + } + }); + + if (verifyDnsLength) { + var total = labels.slice(0, labels.length - 1).join(".").length; + if (total.length > 253 || total.length === 0) { + result.error = true; + } + + for (var i=0; i < labels.length; ++i) { + if (labels.length > 63 || labels.length === 0) { + result.error = true; + break; + } + } + } + + if (result.error) return null; + return labels.join("."); +}; + +tr46.toUnicode = function(domain_name, useSTD3) { + var result = processing(domain_name, useSTD3, PROCESSING_OPTIONS.NONTRANSITIONAL); + + return { + domain: result.string, + error: result.error + }; +}; + +tr46.PROCESSING_OPTIONS = PROCESSING_OPTIONS; + +(function (module) { +const punycode = require$$0__default$1["default"]; +const tr46$1 = tr46; + +const specialSchemes = { + ftp: 21, + file: null, + gopher: 70, + http: 80, + https: 443, + ws: 80, + wss: 443 +}; + +const failure = Symbol("failure"); + +function countSymbols(str) { + return punycode.ucs2.decode(str).length; +} + +function at(input, idx) { + const c = input[idx]; + return isNaN(c) ? undefined : String.fromCodePoint(c); +} + +function isASCIIDigit(c) { + return c >= 0x30 && c <= 0x39; +} + +function isASCIIAlpha(c) { + return (c >= 0x41 && c <= 0x5A) || (c >= 0x61 && c <= 0x7A); +} + +function isASCIIAlphanumeric(c) { + return isASCIIAlpha(c) || isASCIIDigit(c); +} + +function isASCIIHex(c) { + return isASCIIDigit(c) || (c >= 0x41 && c <= 0x46) || (c >= 0x61 && c <= 0x66); +} + +function isSingleDot(buffer) { + return buffer === "." || buffer.toLowerCase() === "%2e"; +} + +function isDoubleDot(buffer) { + buffer = buffer.toLowerCase(); + return buffer === ".." || buffer === "%2e." || buffer === ".%2e" || buffer === "%2e%2e"; +} + +function isWindowsDriveLetterCodePoints(cp1, cp2) { + return isASCIIAlpha(cp1) && (cp2 === 58 || cp2 === 124); +} + +function isWindowsDriveLetterString(string) { + return string.length === 2 && isASCIIAlpha(string.codePointAt(0)) && (string[1] === ":" || string[1] === "|"); +} + +function isNormalizedWindowsDriveLetterString(string) { + return string.length === 2 && isASCIIAlpha(string.codePointAt(0)) && string[1] === ":"; +} + +function containsForbiddenHostCodePoint(string) { + return string.search(/\u0000|\u0009|\u000A|\u000D|\u0020|#|%|\/|:|\?|@|\[|\\|\]/) !== -1; +} + +function containsForbiddenHostCodePointExcludingPercent(string) { + return string.search(/\u0000|\u0009|\u000A|\u000D|\u0020|#|\/|:|\?|@|\[|\\|\]/) !== -1; +} + +function isSpecialScheme(scheme) { + return specialSchemes[scheme] !== undefined; +} + +function isSpecial(url) { + return isSpecialScheme(url.scheme); +} + +function defaultPort(scheme) { + return specialSchemes[scheme]; +} + +function percentEncode(c) { + let hex = c.toString(16).toUpperCase(); + if (hex.length === 1) { + hex = "0" + hex; + } + + return "%" + hex; +} + +function utf8PercentEncode(c) { + const buf = new Buffer(c); + + let str = ""; + + for (let i = 0; i < buf.length; ++i) { + str += percentEncode(buf[i]); + } + + return str; +} + +function utf8PercentDecode(str) { + const input = new Buffer(str); + const output = []; + for (let i = 0; i < input.length; ++i) { + if (input[i] !== 37) { + output.push(input[i]); + } else if (input[i] === 37 && isASCIIHex(input[i + 1]) && isASCIIHex(input[i + 2])) { + output.push(parseInt(input.slice(i + 1, i + 3).toString(), 16)); + i += 2; + } else { + output.push(input[i]); + } + } + return new Buffer(output).toString(); +} + +function isC0ControlPercentEncode(c) { + return c <= 0x1F || c > 0x7E; +} + +const extraPathPercentEncodeSet = new Set([32, 34, 35, 60, 62, 63, 96, 123, 125]); +function isPathPercentEncode(c) { + return isC0ControlPercentEncode(c) || extraPathPercentEncodeSet.has(c); +} + +const extraUserinfoPercentEncodeSet = + new Set([47, 58, 59, 61, 64, 91, 92, 93, 94, 124]); +function isUserinfoPercentEncode(c) { + return isPathPercentEncode(c) || extraUserinfoPercentEncodeSet.has(c); +} + +function percentEncodeChar(c, encodeSetPredicate) { + const cStr = String.fromCodePoint(c); + + if (encodeSetPredicate(c)) { + return utf8PercentEncode(cStr); + } + + return cStr; +} + +function parseIPv4Number(input) { + let R = 10; + + if (input.length >= 2 && input.charAt(0) === "0" && input.charAt(1).toLowerCase() === "x") { + input = input.substring(2); + R = 16; + } else if (input.length >= 2 && input.charAt(0) === "0") { + input = input.substring(1); + R = 8; + } + + if (input === "") { + return 0; + } + + const regex = R === 10 ? /[^0-9]/ : (R === 16 ? /[^0-9A-Fa-f]/ : /[^0-7]/); + if (regex.test(input)) { + return failure; + } + + return parseInt(input, R); +} + +function parseIPv4(input) { + const parts = input.split("."); + if (parts[parts.length - 1] === "") { + if (parts.length > 1) { + parts.pop(); + } + } + + if (parts.length > 4) { + return input; + } + + const numbers = []; + for (const part of parts) { + if (part === "") { + return input; + } + const n = parseIPv4Number(part); + if (n === failure) { + return input; + } + + numbers.push(n); + } + + for (let i = 0; i < numbers.length - 1; ++i) { + if (numbers[i] > 255) { + return failure; + } + } + if (numbers[numbers.length - 1] >= Math.pow(256, 5 - numbers.length)) { + return failure; + } + + let ipv4 = numbers.pop(); + let counter = 0; + + for (const n of numbers) { + ipv4 += n * Math.pow(256, 3 - counter); + ++counter; + } + + return ipv4; +} + +function serializeIPv4(address) { + let output = ""; + let n = address; + + for (let i = 1; i <= 4; ++i) { + output = String(n % 256) + output; + if (i !== 4) { + output = "." + output; + } + n = Math.floor(n / 256); + } + + return output; +} + +function parseIPv6(input) { + const address = [0, 0, 0, 0, 0, 0, 0, 0]; + let pieceIndex = 0; + let compress = null; + let pointer = 0; + + input = punycode.ucs2.decode(input); + + if (input[pointer] === 58) { + if (input[pointer + 1] !== 58) { + return failure; + } + + pointer += 2; + ++pieceIndex; + compress = pieceIndex; + } + + while (pointer < input.length) { + if (pieceIndex === 8) { + return failure; + } + + if (input[pointer] === 58) { + if (compress !== null) { + return failure; + } + ++pointer; + ++pieceIndex; + compress = pieceIndex; + continue; + } + + let value = 0; + let length = 0; + + while (length < 4 && isASCIIHex(input[pointer])) { + value = value * 0x10 + parseInt(at(input, pointer), 16); + ++pointer; + ++length; + } + + if (input[pointer] === 46) { + if (length === 0) { + return failure; + } + + pointer -= length; + + if (pieceIndex > 6) { + return failure; + } + + let numbersSeen = 0; + + while (input[pointer] !== undefined) { + let ipv4Piece = null; + + if (numbersSeen > 0) { + if (input[pointer] === 46 && numbersSeen < 4) { + ++pointer; + } else { + return failure; + } + } + + if (!isASCIIDigit(input[pointer])) { + return failure; + } + + while (isASCIIDigit(input[pointer])) { + const number = parseInt(at(input, pointer)); + if (ipv4Piece === null) { + ipv4Piece = number; + } else if (ipv4Piece === 0) { + return failure; + } else { + ipv4Piece = ipv4Piece * 10 + number; + } + if (ipv4Piece > 255) { + return failure; + } + ++pointer; + } + + address[pieceIndex] = address[pieceIndex] * 0x100 + ipv4Piece; + + ++numbersSeen; + + if (numbersSeen === 2 || numbersSeen === 4) { + ++pieceIndex; + } + } + + if (numbersSeen !== 4) { + return failure; + } + + break; + } else if (input[pointer] === 58) { + ++pointer; + if (input[pointer] === undefined) { + return failure; + } + } else if (input[pointer] !== undefined) { + return failure; + } + + address[pieceIndex] = value; + ++pieceIndex; + } + + if (compress !== null) { + let swaps = pieceIndex - compress; + pieceIndex = 7; + while (pieceIndex !== 0 && swaps > 0) { + const temp = address[compress + swaps - 1]; + address[compress + swaps - 1] = address[pieceIndex]; + address[pieceIndex] = temp; + --pieceIndex; + --swaps; + } + } else if (compress === null && pieceIndex !== 8) { + return failure; + } + + return address; +} + +function serializeIPv6(address) { + let output = ""; + const seqResult = findLongestZeroSequence(address); + const compress = seqResult.idx; + let ignore0 = false; + + for (let pieceIndex = 0; pieceIndex <= 7; ++pieceIndex) { + if (ignore0 && address[pieceIndex] === 0) { + continue; + } else if (ignore0) { + ignore0 = false; + } + + if (compress === pieceIndex) { + const separator = pieceIndex === 0 ? "::" : ":"; + output += separator; + ignore0 = true; + continue; + } + + output += address[pieceIndex].toString(16); + + if (pieceIndex !== 7) { + output += ":"; + } + } + + return output; +} + +function parseHost(input, isSpecialArg) { + if (input[0] === "[") { + if (input[input.length - 1] !== "]") { + return failure; + } + + return parseIPv6(input.substring(1, input.length - 1)); + } + + if (!isSpecialArg) { + return parseOpaqueHost(input); + } + + const domain = utf8PercentDecode(input); + const asciiDomain = tr46$1.toASCII(domain, false, tr46$1.PROCESSING_OPTIONS.NONTRANSITIONAL, false); + if (asciiDomain === null) { + return failure; + } + + if (containsForbiddenHostCodePoint(asciiDomain)) { + return failure; + } + + const ipv4Host = parseIPv4(asciiDomain); + if (typeof ipv4Host === "number" || ipv4Host === failure) { + return ipv4Host; + } + + return asciiDomain; +} + +function parseOpaqueHost(input) { + if (containsForbiddenHostCodePointExcludingPercent(input)) { + return failure; + } + + let output = ""; + const decoded = punycode.ucs2.decode(input); + for (let i = 0; i < decoded.length; ++i) { + output += percentEncodeChar(decoded[i], isC0ControlPercentEncode); + } + return output; +} + +function findLongestZeroSequence(arr) { + let maxIdx = null; + let maxLen = 1; // only find elements > 1 + let currStart = null; + let currLen = 0; + + for (let i = 0; i < arr.length; ++i) { + if (arr[i] !== 0) { + if (currLen > maxLen) { + maxIdx = currStart; + maxLen = currLen; + } + + currStart = null; + currLen = 0; + } else { + if (currStart === null) { + currStart = i; + } + ++currLen; + } + } + + // if trailing zeros + if (currLen > maxLen) { + maxIdx = currStart; + maxLen = currLen; + } + + return { + idx: maxIdx, + len: maxLen + }; +} + +function serializeHost(host) { + if (typeof host === "number") { + return serializeIPv4(host); + } + + // IPv6 serializer + if (host instanceof Array) { + return "[" + serializeIPv6(host) + "]"; + } + + return host; +} + +function trimControlChars(url) { + return url.replace(/^[\u0000-\u001F\u0020]+|[\u0000-\u001F\u0020]+$/g, ""); +} + +function trimTabAndNewline(url) { + return url.replace(/\u0009|\u000A|\u000D/g, ""); +} + +function shortenPath(url) { + const path = url.path; + if (path.length === 0) { + return; + } + if (url.scheme === "file" && path.length === 1 && isNormalizedWindowsDriveLetter(path[0])) { + return; + } + + path.pop(); +} + +function includesCredentials(url) { + return url.username !== "" || url.password !== ""; +} + +function cannotHaveAUsernamePasswordPort(url) { + return url.host === null || url.host === "" || url.cannotBeABaseURL || url.scheme === "file"; +} + +function isNormalizedWindowsDriveLetter(string) { + return /^[A-Za-z]:$/.test(string); +} + +function URLStateMachine(input, base, encodingOverride, url, stateOverride) { + this.pointer = 0; + this.input = input; + this.base = base || null; + this.encodingOverride = encodingOverride || "utf-8"; + this.stateOverride = stateOverride; + this.url = url; + this.failure = false; + this.parseError = false; + + if (!this.url) { + this.url = { + scheme: "", + username: "", + password: "", + host: null, + port: null, + path: [], + query: null, + fragment: null, + + cannotBeABaseURL: false + }; + + const res = trimControlChars(this.input); + if (res !== this.input) { + this.parseError = true; + } + this.input = res; + } + + const res = trimTabAndNewline(this.input); + if (res !== this.input) { + this.parseError = true; + } + this.input = res; + + this.state = stateOverride || "scheme start"; + + this.buffer = ""; + this.atFlag = false; + this.arrFlag = false; + this.passwordTokenSeenFlag = false; + + this.input = punycode.ucs2.decode(this.input); + + for (; this.pointer <= this.input.length; ++this.pointer) { + const c = this.input[this.pointer]; + const cStr = isNaN(c) ? undefined : String.fromCodePoint(c); + + // exec state machine + const ret = this["parse " + this.state](c, cStr); + if (!ret) { + break; // terminate algorithm + } else if (ret === failure) { + this.failure = true; + break; + } + } +} + +URLStateMachine.prototype["parse scheme start"] = function parseSchemeStart(c, cStr) { + if (isASCIIAlpha(c)) { + this.buffer += cStr.toLowerCase(); + this.state = "scheme"; + } else if (!this.stateOverride) { + this.state = "no scheme"; + --this.pointer; + } else { + this.parseError = true; + return failure; + } + + return true; +}; + +URLStateMachine.prototype["parse scheme"] = function parseScheme(c, cStr) { + if (isASCIIAlphanumeric(c) || c === 43 || c === 45 || c === 46) { + this.buffer += cStr.toLowerCase(); + } else if (c === 58) { + if (this.stateOverride) { + if (isSpecial(this.url) && !isSpecialScheme(this.buffer)) { + return false; + } + + if (!isSpecial(this.url) && isSpecialScheme(this.buffer)) { + return false; + } + + if ((includesCredentials(this.url) || this.url.port !== null) && this.buffer === "file") { + return false; + } + + if (this.url.scheme === "file" && (this.url.host === "" || this.url.host === null)) { + return false; + } + } + this.url.scheme = this.buffer; + this.buffer = ""; + if (this.stateOverride) { + return false; + } + if (this.url.scheme === "file") { + if (this.input[this.pointer + 1] !== 47 || this.input[this.pointer + 2] !== 47) { + this.parseError = true; + } + this.state = "file"; + } else if (isSpecial(this.url) && this.base !== null && this.base.scheme === this.url.scheme) { + this.state = "special relative or authority"; + } else if (isSpecial(this.url)) { + this.state = "special authority slashes"; + } else if (this.input[this.pointer + 1] === 47) { + this.state = "path or authority"; + ++this.pointer; + } else { + this.url.cannotBeABaseURL = true; + this.url.path.push(""); + this.state = "cannot-be-a-base-URL path"; + } + } else if (!this.stateOverride) { + this.buffer = ""; + this.state = "no scheme"; + this.pointer = -1; + } else { + this.parseError = true; + return failure; + } + + return true; +}; + +URLStateMachine.prototype["parse no scheme"] = function parseNoScheme(c) { + if (this.base === null || (this.base.cannotBeABaseURL && c !== 35)) { + return failure; + } else if (this.base.cannotBeABaseURL && c === 35) { + this.url.scheme = this.base.scheme; + this.url.path = this.base.path.slice(); + this.url.query = this.base.query; + this.url.fragment = ""; + this.url.cannotBeABaseURL = true; + this.state = "fragment"; + } else if (this.base.scheme === "file") { + this.state = "file"; + --this.pointer; + } else { + this.state = "relative"; + --this.pointer; + } + + return true; +}; + +URLStateMachine.prototype["parse special relative or authority"] = function parseSpecialRelativeOrAuthority(c) { + if (c === 47 && this.input[this.pointer + 1] === 47) { + this.state = "special authority ignore slashes"; + ++this.pointer; + } else { + this.parseError = true; + this.state = "relative"; + --this.pointer; + } + + return true; +}; + +URLStateMachine.prototype["parse path or authority"] = function parsePathOrAuthority(c) { + if (c === 47) { + this.state = "authority"; + } else { + this.state = "path"; + --this.pointer; + } + + return true; +}; + +URLStateMachine.prototype["parse relative"] = function parseRelative(c) { + this.url.scheme = this.base.scheme; + if (isNaN(c)) { + this.url.username = this.base.username; + this.url.password = this.base.password; + this.url.host = this.base.host; + this.url.port = this.base.port; + this.url.path = this.base.path.slice(); + this.url.query = this.base.query; + } else if (c === 47) { + this.state = "relative slash"; + } else if (c === 63) { + this.url.username = this.base.username; + this.url.password = this.base.password; + this.url.host = this.base.host; + this.url.port = this.base.port; + this.url.path = this.base.path.slice(); + this.url.query = ""; + this.state = "query"; + } else if (c === 35) { + this.url.username = this.base.username; + this.url.password = this.base.password; + this.url.host = this.base.host; + this.url.port = this.base.port; + this.url.path = this.base.path.slice(); + this.url.query = this.base.query; + this.url.fragment = ""; + this.state = "fragment"; + } else if (isSpecial(this.url) && c === 92) { + this.parseError = true; + this.state = "relative slash"; + } else { + this.url.username = this.base.username; + this.url.password = this.base.password; + this.url.host = this.base.host; + this.url.port = this.base.port; + this.url.path = this.base.path.slice(0, this.base.path.length - 1); + + this.state = "path"; + --this.pointer; + } + + return true; +}; + +URLStateMachine.prototype["parse relative slash"] = function parseRelativeSlash(c) { + if (isSpecial(this.url) && (c === 47 || c === 92)) { + if (c === 92) { + this.parseError = true; + } + this.state = "special authority ignore slashes"; + } else if (c === 47) { + this.state = "authority"; + } else { + this.url.username = this.base.username; + this.url.password = this.base.password; + this.url.host = this.base.host; + this.url.port = this.base.port; + this.state = "path"; + --this.pointer; + } + + return true; +}; + +URLStateMachine.prototype["parse special authority slashes"] = function parseSpecialAuthoritySlashes(c) { + if (c === 47 && this.input[this.pointer + 1] === 47) { + this.state = "special authority ignore slashes"; + ++this.pointer; + } else { + this.parseError = true; + this.state = "special authority ignore slashes"; + --this.pointer; + } + + return true; +}; + +URLStateMachine.prototype["parse special authority ignore slashes"] = function parseSpecialAuthorityIgnoreSlashes(c) { + if (c !== 47 && c !== 92) { + this.state = "authority"; + --this.pointer; + } else { + this.parseError = true; + } + + return true; +}; + +URLStateMachine.prototype["parse authority"] = function parseAuthority(c, cStr) { + if (c === 64) { + this.parseError = true; + if (this.atFlag) { + this.buffer = "%40" + this.buffer; + } + this.atFlag = true; + + // careful, this is based on buffer and has its own pointer (this.pointer != pointer) and inner chars + const len = countSymbols(this.buffer); + for (let pointer = 0; pointer < len; ++pointer) { + const codePoint = this.buffer.codePointAt(pointer); + + if (codePoint === 58 && !this.passwordTokenSeenFlag) { + this.passwordTokenSeenFlag = true; + continue; + } + const encodedCodePoints = percentEncodeChar(codePoint, isUserinfoPercentEncode); + if (this.passwordTokenSeenFlag) { + this.url.password += encodedCodePoints; + } else { + this.url.username += encodedCodePoints; + } + } + this.buffer = ""; + } else if (isNaN(c) || c === 47 || c === 63 || c === 35 || + (isSpecial(this.url) && c === 92)) { + if (this.atFlag && this.buffer === "") { + this.parseError = true; + return failure; + } + this.pointer -= countSymbols(this.buffer) + 1; + this.buffer = ""; + this.state = "host"; + } else { + this.buffer += cStr; + } + + return true; +}; + +URLStateMachine.prototype["parse hostname"] = +URLStateMachine.prototype["parse host"] = function parseHostName(c, cStr) { + if (this.stateOverride && this.url.scheme === "file") { + --this.pointer; + this.state = "file host"; + } else if (c === 58 && !this.arrFlag) { + if (this.buffer === "") { + this.parseError = true; + return failure; + } + + const host = parseHost(this.buffer, isSpecial(this.url)); + if (host === failure) { + return failure; + } + + this.url.host = host; + this.buffer = ""; + this.state = "port"; + if (this.stateOverride === "hostname") { + return false; + } + } else if (isNaN(c) || c === 47 || c === 63 || c === 35 || + (isSpecial(this.url) && c === 92)) { + --this.pointer; + if (isSpecial(this.url) && this.buffer === "") { + this.parseError = true; + return failure; + } else if (this.stateOverride && this.buffer === "" && + (includesCredentials(this.url) || this.url.port !== null)) { + this.parseError = true; + return false; + } + + const host = parseHost(this.buffer, isSpecial(this.url)); + if (host === failure) { + return failure; + } + + this.url.host = host; + this.buffer = ""; + this.state = "path start"; + if (this.stateOverride) { + return false; + } + } else { + if (c === 91) { + this.arrFlag = true; + } else if (c === 93) { + this.arrFlag = false; + } + this.buffer += cStr; + } + + return true; +}; + +URLStateMachine.prototype["parse port"] = function parsePort(c, cStr) { + if (isASCIIDigit(c)) { + this.buffer += cStr; + } else if (isNaN(c) || c === 47 || c === 63 || c === 35 || + (isSpecial(this.url) && c === 92) || + this.stateOverride) { + if (this.buffer !== "") { + const port = parseInt(this.buffer); + if (port > Math.pow(2, 16) - 1) { + this.parseError = true; + return failure; + } + this.url.port = port === defaultPort(this.url.scheme) ? null : port; + this.buffer = ""; + } + if (this.stateOverride) { + return false; + } + this.state = "path start"; + --this.pointer; + } else { + this.parseError = true; + return failure; + } + + return true; +}; + +const fileOtherwiseCodePoints = new Set([47, 92, 63, 35]); + +URLStateMachine.prototype["parse file"] = function parseFile(c) { + this.url.scheme = "file"; + + if (c === 47 || c === 92) { + if (c === 92) { + this.parseError = true; + } + this.state = "file slash"; + } else if (this.base !== null && this.base.scheme === "file") { + if (isNaN(c)) { + this.url.host = this.base.host; + this.url.path = this.base.path.slice(); + this.url.query = this.base.query; + } else if (c === 63) { + this.url.host = this.base.host; + this.url.path = this.base.path.slice(); + this.url.query = ""; + this.state = "query"; + } else if (c === 35) { + this.url.host = this.base.host; + this.url.path = this.base.path.slice(); + this.url.query = this.base.query; + this.url.fragment = ""; + this.state = "fragment"; + } else { + if (this.input.length - this.pointer - 1 === 0 || // remaining consists of 0 code points + !isWindowsDriveLetterCodePoints(c, this.input[this.pointer + 1]) || + (this.input.length - this.pointer - 1 >= 2 && // remaining has at least 2 code points + !fileOtherwiseCodePoints.has(this.input[this.pointer + 2]))) { + this.url.host = this.base.host; + this.url.path = this.base.path.slice(); + shortenPath(this.url); + } else { + this.parseError = true; + } + + this.state = "path"; + --this.pointer; + } + } else { + this.state = "path"; + --this.pointer; + } + + return true; +}; + +URLStateMachine.prototype["parse file slash"] = function parseFileSlash(c) { + if (c === 47 || c === 92) { + if (c === 92) { + this.parseError = true; + } + this.state = "file host"; + } else { + if (this.base !== null && this.base.scheme === "file") { + if (isNormalizedWindowsDriveLetterString(this.base.path[0])) { + this.url.path.push(this.base.path[0]); + } else { + this.url.host = this.base.host; + } + } + this.state = "path"; + --this.pointer; + } + + return true; +}; + +URLStateMachine.prototype["parse file host"] = function parseFileHost(c, cStr) { + if (isNaN(c) || c === 47 || c === 92 || c === 63 || c === 35) { + --this.pointer; + if (!this.stateOverride && isWindowsDriveLetterString(this.buffer)) { + this.parseError = true; + this.state = "path"; + } else if (this.buffer === "") { + this.url.host = ""; + if (this.stateOverride) { + return false; + } + this.state = "path start"; + } else { + let host = parseHost(this.buffer, isSpecial(this.url)); + if (host === failure) { + return failure; + } + if (host === "localhost") { + host = ""; + } + this.url.host = host; + + if (this.stateOverride) { + return false; + } + + this.buffer = ""; + this.state = "path start"; + } + } else { + this.buffer += cStr; + } + + return true; +}; + +URLStateMachine.prototype["parse path start"] = function parsePathStart(c) { + if (isSpecial(this.url)) { + if (c === 92) { + this.parseError = true; + } + this.state = "path"; + + if (c !== 47 && c !== 92) { + --this.pointer; + } + } else if (!this.stateOverride && c === 63) { + this.url.query = ""; + this.state = "query"; + } else if (!this.stateOverride && c === 35) { + this.url.fragment = ""; + this.state = "fragment"; + } else if (c !== undefined) { + this.state = "path"; + if (c !== 47) { + --this.pointer; + } + } + + return true; +}; + +URLStateMachine.prototype["parse path"] = function parsePath(c) { + if (isNaN(c) || c === 47 || (isSpecial(this.url) && c === 92) || + (!this.stateOverride && (c === 63 || c === 35))) { + if (isSpecial(this.url) && c === 92) { + this.parseError = true; + } + + if (isDoubleDot(this.buffer)) { + shortenPath(this.url); + if (c !== 47 && !(isSpecial(this.url) && c === 92)) { + this.url.path.push(""); + } + } else if (isSingleDot(this.buffer) && c !== 47 && + !(isSpecial(this.url) && c === 92)) { + this.url.path.push(""); + } else if (!isSingleDot(this.buffer)) { + if (this.url.scheme === "file" && this.url.path.length === 0 && isWindowsDriveLetterString(this.buffer)) { + if (this.url.host !== "" && this.url.host !== null) { + this.parseError = true; + this.url.host = ""; + } + this.buffer = this.buffer[0] + ":"; + } + this.url.path.push(this.buffer); + } + this.buffer = ""; + if (this.url.scheme === "file" && (c === undefined || c === 63 || c === 35)) { + while (this.url.path.length > 1 && this.url.path[0] === "") { + this.parseError = true; + this.url.path.shift(); + } + } + if (c === 63) { + this.url.query = ""; + this.state = "query"; + } + if (c === 35) { + this.url.fragment = ""; + this.state = "fragment"; + } + } else { + // TODO: If c is not a URL code point and not "%", parse error. + + if (c === 37 && + (!isASCIIHex(this.input[this.pointer + 1]) || + !isASCIIHex(this.input[this.pointer + 2]))) { + this.parseError = true; + } + + this.buffer += percentEncodeChar(c, isPathPercentEncode); + } + + return true; +}; + +URLStateMachine.prototype["parse cannot-be-a-base-URL path"] = function parseCannotBeABaseURLPath(c) { + if (c === 63) { + this.url.query = ""; + this.state = "query"; + } else if (c === 35) { + this.url.fragment = ""; + this.state = "fragment"; + } else { + // TODO: Add: not a URL code point + if (!isNaN(c) && c !== 37) { + this.parseError = true; + } + + if (c === 37 && + (!isASCIIHex(this.input[this.pointer + 1]) || + !isASCIIHex(this.input[this.pointer + 2]))) { + this.parseError = true; + } + + if (!isNaN(c)) { + this.url.path[0] = this.url.path[0] + percentEncodeChar(c, isC0ControlPercentEncode); + } + } + + return true; +}; + +URLStateMachine.prototype["parse query"] = function parseQuery(c, cStr) { + if (isNaN(c) || (!this.stateOverride && c === 35)) { + if (!isSpecial(this.url) || this.url.scheme === "ws" || this.url.scheme === "wss") { + this.encodingOverride = "utf-8"; + } + + const buffer = new Buffer(this.buffer); // TODO: Use encoding override instead + for (let i = 0; i < buffer.length; ++i) { + if (buffer[i] < 0x21 || buffer[i] > 0x7E || buffer[i] === 0x22 || buffer[i] === 0x23 || + buffer[i] === 0x3C || buffer[i] === 0x3E) { + this.url.query += percentEncode(buffer[i]); + } else { + this.url.query += String.fromCodePoint(buffer[i]); + } + } + + this.buffer = ""; + if (c === 35) { + this.url.fragment = ""; + this.state = "fragment"; + } + } else { + // TODO: If c is not a URL code point and not "%", parse error. + if (c === 37 && + (!isASCIIHex(this.input[this.pointer + 1]) || + !isASCIIHex(this.input[this.pointer + 2]))) { + this.parseError = true; + } + + this.buffer += cStr; + } + + return true; +}; + +URLStateMachine.prototype["parse fragment"] = function parseFragment(c) { + if (isNaN(c)) ; else if (c === 0x0) { + this.parseError = true; + } else { + // TODO: If c is not a URL code point and not "%", parse error. + if (c === 37 && + (!isASCIIHex(this.input[this.pointer + 1]) || + !isASCIIHex(this.input[this.pointer + 2]))) { + this.parseError = true; + } + + this.url.fragment += percentEncodeChar(c, isC0ControlPercentEncode); + } + + return true; +}; + +function serializeURL(url, excludeFragment) { + let output = url.scheme + ":"; + if (url.host !== null) { + output += "//"; + + if (url.username !== "" || url.password !== "") { + output += url.username; + if (url.password !== "") { + output += ":" + url.password; + } + output += "@"; + } + + output += serializeHost(url.host); + + if (url.port !== null) { + output += ":" + url.port; + } + } else if (url.host === null && url.scheme === "file") { + output += "//"; + } + + if (url.cannotBeABaseURL) { + output += url.path[0]; + } else { + for (const string of url.path) { + output += "/" + string; + } + } + + if (url.query !== null) { + output += "?" + url.query; + } + + if (!excludeFragment && url.fragment !== null) { + output += "#" + url.fragment; + } + + return output; +} + +function serializeOrigin(tuple) { + let result = tuple.scheme + "://"; + result += serializeHost(tuple.host); + + if (tuple.port !== null) { + result += ":" + tuple.port; + } + + return result; +} + +module.exports.serializeURL = serializeURL; + +module.exports.serializeURLOrigin = function (url) { + // https://url.spec.whatwg.org/#concept-url-origin + switch (url.scheme) { + case "blob": + try { + return module.exports.serializeURLOrigin(module.exports.parseURL(url.path[0])); + } catch (e) { + // serializing an opaque origin returns "null" + return "null"; + } + case "ftp": + case "gopher": + case "http": + case "https": + case "ws": + case "wss": + return serializeOrigin({ + scheme: url.scheme, + host: url.host, + port: url.port + }); + case "file": + // spec says "exercise to the reader", chrome says "file://" + return "file://"; + default: + // serializing an opaque origin returns "null" + return "null"; + } +}; + +module.exports.basicURLParse = function (input, options) { + if (options === undefined) { + options = {}; + } + + const usm = new URLStateMachine(input, options.baseURL, options.encodingOverride, options.url, options.stateOverride); + if (usm.failure) { + return "failure"; + } + + return usm.url; +}; + +module.exports.setTheUsername = function (url, username) { + url.username = ""; + const decoded = punycode.ucs2.decode(username); + for (let i = 0; i < decoded.length; ++i) { + url.username += percentEncodeChar(decoded[i], isUserinfoPercentEncode); + } +}; + +module.exports.setThePassword = function (url, password) { + url.password = ""; + const decoded = punycode.ucs2.decode(password); + for (let i = 0; i < decoded.length; ++i) { + url.password += percentEncodeChar(decoded[i], isUserinfoPercentEncode); + } +}; + +module.exports.serializeHost = serializeHost; + +module.exports.cannotHaveAUsernamePasswordPort = cannotHaveAUsernamePasswordPort; + +module.exports.serializeInteger = function (integer) { + return String(integer); +}; + +module.exports.parseURL = function (input, options) { + if (options === undefined) { + options = {}; + } + + // We don't handle blobs, so this just delegates: + return module.exports.basicURLParse(input, { baseURL: options.baseURL, encodingOverride: options.encodingOverride }); +}; +}(urlStateMachine)); + +const usm = urlStateMachine.exports; + +URLImpl.implementation = class URLImpl { + constructor(constructorArgs) { + const url = constructorArgs[0]; + const base = constructorArgs[1]; + + let parsedBase = null; + if (base !== undefined) { + parsedBase = usm.basicURLParse(base); + if (parsedBase === "failure") { + throw new TypeError("Invalid base URL"); + } + } + + const parsedURL = usm.basicURLParse(url, { baseURL: parsedBase }); + if (parsedURL === "failure") { + throw new TypeError("Invalid URL"); + } + + this._url = parsedURL; + + // TODO: query stuff + } + + get href() { + return usm.serializeURL(this._url); + } + + set href(v) { + const parsedURL = usm.basicURLParse(v); + if (parsedURL === "failure") { + throw new TypeError("Invalid URL"); + } + + this._url = parsedURL; + } + + get origin() { + return usm.serializeURLOrigin(this._url); + } + + get protocol() { + return this._url.scheme + ":"; + } + + set protocol(v) { + usm.basicURLParse(v + ":", { url: this._url, stateOverride: "scheme start" }); + } + + get username() { + return this._url.username; + } + + set username(v) { + if (usm.cannotHaveAUsernamePasswordPort(this._url)) { + return; + } + + usm.setTheUsername(this._url, v); + } + + get password() { + return this._url.password; + } + + set password(v) { + if (usm.cannotHaveAUsernamePasswordPort(this._url)) { + return; + } + + usm.setThePassword(this._url, v); + } + + get host() { + const url = this._url; + + if (url.host === null) { + return ""; + } + + if (url.port === null) { + return usm.serializeHost(url.host); + } + + return usm.serializeHost(url.host) + ":" + usm.serializeInteger(url.port); + } + + set host(v) { + if (this._url.cannotBeABaseURL) { + return; + } + + usm.basicURLParse(v, { url: this._url, stateOverride: "host" }); + } + + get hostname() { + if (this._url.host === null) { + return ""; + } + + return usm.serializeHost(this._url.host); + } + + set hostname(v) { + if (this._url.cannotBeABaseURL) { + return; + } + + usm.basicURLParse(v, { url: this._url, stateOverride: "hostname" }); + } + + get port() { + if (this._url.port === null) { + return ""; + } + + return usm.serializeInteger(this._url.port); + } + + set port(v) { + if (usm.cannotHaveAUsernamePasswordPort(this._url)) { + return; + } + + if (v === "") { + this._url.port = null; + } else { + usm.basicURLParse(v, { url: this._url, stateOverride: "port" }); + } + } + + get pathname() { + if (this._url.cannotBeABaseURL) { + return this._url.path[0]; + } + + if (this._url.path.length === 0) { + return ""; + } + + return "/" + this._url.path.join("/"); + } + + set pathname(v) { + if (this._url.cannotBeABaseURL) { + return; + } + + this._url.path = []; + usm.basicURLParse(v, { url: this._url, stateOverride: "path start" }); + } + + get search() { + if (this._url.query === null || this._url.query === "") { + return ""; + } + + return "?" + this._url.query; + } + + set search(v) { + // TODO: query stuff + + const url = this._url; + + if (v === "") { + url.query = null; + return; + } + + const input = v[0] === "?" ? v.substring(1) : v; + url.query = ""; + usm.basicURLParse(input, { url, stateOverride: "query" }); + } + + get hash() { + if (this._url.fragment === null || this._url.fragment === "") { + return ""; + } + + return "#" + this._url.fragment; + } + + set hash(v) { + if (v === "") { + this._url.fragment = null; + return; + } + + const input = v[0] === "#" ? v.substring(1) : v; + this._url.fragment = ""; + usm.basicURLParse(input, { url: this._url, stateOverride: "fragment" }); + } + + toJSON() { + return this.href; + } +}; + +(function (module) { + +const conversions = lib; +const utils$1 = utils.exports; +const Impl = URLImpl; + +const impl = utils$1.implSymbol; + +function URL(url) { + if (!this || this[impl] || !(this instanceof URL)) { + throw new TypeError("Failed to construct 'URL': Please use the 'new' operator, this DOM object constructor cannot be called as a function."); + } + if (arguments.length < 1) { + throw new TypeError("Failed to construct 'URL': 1 argument required, but only " + arguments.length + " present."); + } + const args = []; + for (let i = 0; i < arguments.length && i < 2; ++i) { + args[i] = arguments[i]; + } + args[0] = conversions["USVString"](args[0]); + if (args[1] !== undefined) { + args[1] = conversions["USVString"](args[1]); + } + + module.exports.setup(this, args); +} + +URL.prototype.toJSON = function toJSON() { + if (!this || !module.exports.is(this)) { + throw new TypeError("Illegal invocation"); + } + const args = []; + for (let i = 0; i < arguments.length && i < 0; ++i) { + args[i] = arguments[i]; + } + return this[impl].toJSON.apply(this[impl], args); +}; +Object.defineProperty(URL.prototype, "href", { + get() { + return this[impl].href; + }, + set(V) { + V = conversions["USVString"](V); + this[impl].href = V; + }, + enumerable: true, + configurable: true +}); + +URL.prototype.toString = function () { + if (!this || !module.exports.is(this)) { + throw new TypeError("Illegal invocation"); + } + return this.href; +}; + +Object.defineProperty(URL.prototype, "origin", { + get() { + return this[impl].origin; + }, + enumerable: true, + configurable: true +}); + +Object.defineProperty(URL.prototype, "protocol", { + get() { + return this[impl].protocol; + }, + set(V) { + V = conversions["USVString"](V); + this[impl].protocol = V; + }, + enumerable: true, + configurable: true +}); + +Object.defineProperty(URL.prototype, "username", { + get() { + return this[impl].username; + }, + set(V) { + V = conversions["USVString"](V); + this[impl].username = V; + }, + enumerable: true, + configurable: true +}); + +Object.defineProperty(URL.prototype, "password", { + get() { + return this[impl].password; + }, + set(V) { + V = conversions["USVString"](V); + this[impl].password = V; + }, + enumerable: true, + configurable: true +}); + +Object.defineProperty(URL.prototype, "host", { + get() { + return this[impl].host; + }, + set(V) { + V = conversions["USVString"](V); + this[impl].host = V; + }, + enumerable: true, + configurable: true +}); + +Object.defineProperty(URL.prototype, "hostname", { + get() { + return this[impl].hostname; + }, + set(V) { + V = conversions["USVString"](V); + this[impl].hostname = V; + }, + enumerable: true, + configurable: true +}); + +Object.defineProperty(URL.prototype, "port", { + get() { + return this[impl].port; + }, + set(V) { + V = conversions["USVString"](V); + this[impl].port = V; + }, + enumerable: true, + configurable: true +}); + +Object.defineProperty(URL.prototype, "pathname", { + get() { + return this[impl].pathname; + }, + set(V) { + V = conversions["USVString"](V); + this[impl].pathname = V; + }, + enumerable: true, + configurable: true +}); + +Object.defineProperty(URL.prototype, "search", { + get() { + return this[impl].search; + }, + set(V) { + V = conversions["USVString"](V); + this[impl].search = V; + }, + enumerable: true, + configurable: true +}); + +Object.defineProperty(URL.prototype, "hash", { + get() { + return this[impl].hash; + }, + set(V) { + V = conversions["USVString"](V); + this[impl].hash = V; + }, + enumerable: true, + configurable: true +}); + + +module.exports = { + is(obj) { + return !!obj && obj[impl] instanceof Impl.implementation; + }, + create(constructorArgs, privateData) { + let obj = Object.create(URL.prototype); + this.setup(obj, constructorArgs, privateData); + return obj; + }, + setup(obj, constructorArgs, privateData) { + if (!privateData) privateData = {}; + privateData.wrapper = obj; + + obj[impl] = new Impl.implementation(constructorArgs, privateData); + obj[impl][utils$1.wrapperSymbol] = obj; + }, + interface: URL, + expose: { + Window: { URL: URL }, + Worker: { URL: URL } + } +}; +}(URL$2)); + +publicApi.URL = URL$2.exports.interface; +publicApi.serializeURL = urlStateMachine.exports.serializeURL; +publicApi.serializeURLOrigin = urlStateMachine.exports.serializeURLOrigin; +publicApi.basicURLParse = urlStateMachine.exports.basicURLParse; +publicApi.setTheUsername = urlStateMachine.exports.setTheUsername; +publicApi.setThePassword = urlStateMachine.exports.setThePassword; +publicApi.serializeHost = urlStateMachine.exports.serializeHost; +publicApi.serializeInteger = urlStateMachine.exports.serializeInteger; +publicApi.parseURL = urlStateMachine.exports.parseURL; + +// Based on https://github.com/tmpvar/jsdom/blob/aa85b2abf07766ff7bf5c1f6daafb3726f2f2db5/lib/jsdom/living/blob.js + +// fix for "Readable" isn't a named export issue +const Readable = Stream__default["default"].Readable; + +const BUFFER = Symbol('buffer'); +const TYPE = Symbol('type'); + +class Blob { + constructor() { + this[TYPE] = ''; + + const blobParts = arguments[0]; + const options = arguments[1]; + + const buffers = []; + let size = 0; + + if (blobParts) { + const a = blobParts; + const length = Number(a.length); + for (let i = 0; i < length; i++) { + const element = a[i]; + let buffer; + if (element instanceof Buffer) { + buffer = element; + } else if (ArrayBuffer.isView(element)) { + buffer = Buffer.from(element.buffer, element.byteOffset, element.byteLength); + } else if (element instanceof ArrayBuffer) { + buffer = Buffer.from(element); + } else if (element instanceof Blob) { + buffer = element[BUFFER]; + } else { + buffer = Buffer.from(typeof element === 'string' ? element : String(element)); + } + size += buffer.length; + buffers.push(buffer); + } + } + + this[BUFFER] = Buffer.concat(buffers); + + let type = options && options.type !== undefined && String(options.type).toLowerCase(); + if (type && !/[^\u0020-\u007E]/.test(type)) { + this[TYPE] = type; + } + } + get size() { + return this[BUFFER].length; + } + get type() { + return this[TYPE]; + } + text() { + return Promise.resolve(this[BUFFER].toString()); + } + arrayBuffer() { + const buf = this[BUFFER]; + const ab = buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength); + return Promise.resolve(ab); + } + stream() { + const readable = new Readable(); + readable._read = function () {}; + readable.push(this[BUFFER]); + readable.push(null); + return readable; + } + toString() { + return '[object Blob]'; + } + slice() { + const size = this.size; + + const start = arguments[0]; + const end = arguments[1]; + let relativeStart, relativeEnd; + if (start === undefined) { + relativeStart = 0; + } else if (start < 0) { + relativeStart = Math.max(size + start, 0); + } else { + relativeStart = Math.min(start, size); + } + if (end === undefined) { + relativeEnd = size; + } else if (end < 0) { + relativeEnd = Math.max(size + end, 0); + } else { + relativeEnd = Math.min(end, size); + } + const span = Math.max(relativeEnd - relativeStart, 0); + + const buffer = this[BUFFER]; + const slicedBuffer = buffer.slice(relativeStart, relativeStart + span); + const blob = new Blob([], { type: arguments[2] }); + blob[BUFFER] = slicedBuffer; + return blob; + } +} + +Object.defineProperties(Blob.prototype, { + size: { enumerable: true }, + type: { enumerable: true }, + slice: { enumerable: true } +}); + +Object.defineProperty(Blob.prototype, Symbol.toStringTag, { + value: 'Blob', + writable: false, + enumerable: false, + configurable: true +}); + +/** + * fetch-error.js + * + * FetchError interface for operational errors + */ + +/** + * Create FetchError instance + * + * @param String message Error message for human + * @param String type Error type for machine + * @param String systemError For Node.js system error + * @return FetchError + */ +function FetchError(message, type, systemError) { + Error.call(this, message); + + this.message = message; + this.type = type; + + // when err.type is `system`, err.code contains system error code + if (systemError) { + this.code = this.errno = systemError.code; + } + + // hide custom error implementation details from end-users + Error.captureStackTrace(this, this.constructor); +} + +FetchError.prototype = Object.create(Error.prototype); +FetchError.prototype.constructor = FetchError; +FetchError.prototype.name = 'FetchError'; + +let convert; +try { + convert = require('encoding').convert; +} catch (e) {} + +const INTERNALS = Symbol('Body internals'); + +// fix an issue where "PassThrough" isn't a named export for node <10 +const PassThrough = Stream__default["default"].PassThrough; + +/** + * Body mixin + * + * Ref: https://fetch.spec.whatwg.org/#body + * + * @param Stream body Readable stream + * @param Object opts Response options + * @return Void + */ +function Body(body) { + var _this = this; + + var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}, + _ref$size = _ref.size; + + let size = _ref$size === undefined ? 0 : _ref$size; + var _ref$timeout = _ref.timeout; + let timeout = _ref$timeout === undefined ? 0 : _ref$timeout; + + if (body == null) { + // body is undefined or null + body = null; + } else if (isURLSearchParams(body)) { + // body is a URLSearchParams + body = Buffer.from(body.toString()); + } else if (isBlob(body)) ; else if (Buffer.isBuffer(body)) ; else if (Object.prototype.toString.call(body) === '[object ArrayBuffer]') { + // body is ArrayBuffer + body = Buffer.from(body); + } else if (ArrayBuffer.isView(body)) { + // body is ArrayBufferView + body = Buffer.from(body.buffer, body.byteOffset, body.byteLength); + } else if (body instanceof Stream__default["default"]) ; else { + // none of the above + // coerce to string then buffer + body = Buffer.from(String(body)); + } + this[INTERNALS] = { + body, + disturbed: false, + error: null + }; + this.size = size; + this.timeout = timeout; + + if (body instanceof Stream__default["default"]) { + body.on('error', function (err) { + const error = err.name === 'AbortError' ? err : new FetchError(`Invalid response body while trying to fetch ${_this.url}: ${err.message}`, 'system', err); + _this[INTERNALS].error = error; + }); + } +} + +Body.prototype = { + get body() { + return this[INTERNALS].body; + }, + + get bodyUsed() { + return this[INTERNALS].disturbed; + }, + + /** + * Decode response as ArrayBuffer + * + * @return Promise + */ + arrayBuffer() { + return consumeBody.call(this).then(function (buf) { + return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength); + }); + }, + + /** + * Return raw response as Blob + * + * @return Promise + */ + blob() { + let ct = this.headers && this.headers.get('content-type') || ''; + return consumeBody.call(this).then(function (buf) { + return Object.assign( + // Prevent copying + new Blob([], { + type: ct.toLowerCase() + }), { + [BUFFER]: buf + }); + }); + }, + + /** + * Decode response as json + * + * @return Promise + */ + json() { + var _this2 = this; + + return consumeBody.call(this).then(function (buffer) { + try { + return JSON.parse(buffer.toString()); + } catch (err) { + return Body.Promise.reject(new FetchError(`invalid json response body at ${_this2.url} reason: ${err.message}`, 'invalid-json')); + } + }); + }, + + /** + * Decode response as text + * + * @return Promise + */ + text() { + return consumeBody.call(this).then(function (buffer) { + return buffer.toString(); + }); + }, + + /** + * Decode response as buffer (non-spec api) + * + * @return Promise + */ + buffer() { + return consumeBody.call(this); + }, + + /** + * Decode response as text, while automatically detecting the encoding and + * trying to decode to UTF-8 (non-spec api) + * + * @return Promise + */ + textConverted() { + var _this3 = this; + + return consumeBody.call(this).then(function (buffer) { + return convertBody(buffer, _this3.headers); + }); + } +}; + +// In browsers, all properties are enumerable. +Object.defineProperties(Body.prototype, { + body: { enumerable: true }, + bodyUsed: { enumerable: true }, + arrayBuffer: { enumerable: true }, + blob: { enumerable: true }, + json: { enumerable: true }, + text: { enumerable: true } +}); + +Body.mixIn = function (proto) { + for (const name of Object.getOwnPropertyNames(Body.prototype)) { + // istanbul ignore else: future proof + if (!(name in proto)) { + const desc = Object.getOwnPropertyDescriptor(Body.prototype, name); + Object.defineProperty(proto, name, desc); + } + } +}; + +/** + * Consume and convert an entire Body to a Buffer. + * + * Ref: https://fetch.spec.whatwg.org/#concept-body-consume-body + * + * @return Promise + */ +function consumeBody() { + var _this4 = this; + + if (this[INTERNALS].disturbed) { + return Body.Promise.reject(new TypeError(`body used already for: ${this.url}`)); + } + + this[INTERNALS].disturbed = true; + + if (this[INTERNALS].error) { + return Body.Promise.reject(this[INTERNALS].error); + } + + let body = this.body; + + // body is null + if (body === null) { + return Body.Promise.resolve(Buffer.alloc(0)); + } + + // body is blob + if (isBlob(body)) { + body = body.stream(); + } + + // body is buffer + if (Buffer.isBuffer(body)) { + return Body.Promise.resolve(body); + } + + // istanbul ignore if: should never happen + if (!(body instanceof Stream__default["default"])) { + return Body.Promise.resolve(Buffer.alloc(0)); + } + + // body is stream + // get ready to actually consume the body + let accum = []; + let accumBytes = 0; + let abort = false; + + return new Body.Promise(function (resolve, reject) { + let resTimeout; + + // allow timeout on slow response body + if (_this4.timeout) { + resTimeout = setTimeout(function () { + abort = true; + reject(new FetchError(`Response timeout while trying to fetch ${_this4.url} (over ${_this4.timeout}ms)`, 'body-timeout')); + }, _this4.timeout); + } + + // handle stream errors + body.on('error', function (err) { + if (err.name === 'AbortError') { + // if the request was aborted, reject with this Error + abort = true; + reject(err); + } else { + // other errors, such as incorrect content-encoding + reject(new FetchError(`Invalid response body while trying to fetch ${_this4.url}: ${err.message}`, 'system', err)); + } + }); + + body.on('data', function (chunk) { + if (abort || chunk === null) { + return; + } + + if (_this4.size && accumBytes + chunk.length > _this4.size) { + abort = true; + reject(new FetchError(`content size at ${_this4.url} over limit: ${_this4.size}`, 'max-size')); + return; + } + + accumBytes += chunk.length; + accum.push(chunk); + }); + + body.on('end', function () { + if (abort) { + return; + } + + clearTimeout(resTimeout); + + try { + resolve(Buffer.concat(accum, accumBytes)); + } catch (err) { + // handle streams that have accumulated too much data (issue #414) + reject(new FetchError(`Could not create Buffer from response body for ${_this4.url}: ${err.message}`, 'system', err)); + } + }); + }); +} + +/** + * Detect buffer encoding and convert to target encoding + * ref: http://www.w3.org/TR/2011/WD-html5-20110113/parsing.html#determining-the-character-encoding + * + * @param Buffer buffer Incoming buffer + * @param String encoding Target encoding + * @return String + */ +function convertBody(buffer, headers) { + if (typeof convert !== 'function') { + throw new Error('The package `encoding` must be installed to use the textConverted() function'); + } + + const ct = headers.get('content-type'); + let charset = 'utf-8'; + let res, str; + + // header + if (ct) { + res = /charset=([^;]*)/i.exec(ct); + } + + // no charset in content type, peek at response body for at most 1024 bytes + str = buffer.slice(0, 1024).toString(); + + // html5 + if (!res && str) { + res = / 0 && arguments[0] !== undefined ? arguments[0] : undefined; + + this[MAP] = Object.create(null); + + if (init instanceof Headers) { + const rawHeaders = init.raw(); + const headerNames = Object.keys(rawHeaders); + + for (const headerName of headerNames) { + for (const value of rawHeaders[headerName]) { + this.append(headerName, value); + } + } + + return; + } + + // We don't worry about converting prop to ByteString here as append() + // will handle it. + if (init == null) ; else if (typeof init === 'object') { + const method = init[Symbol.iterator]; + if (method != null) { + if (typeof method !== 'function') { + throw new TypeError('Header pairs must be iterable'); + } + + // sequence> + // Note: per spec we have to first exhaust the lists then process them + const pairs = []; + for (const pair of init) { + if (typeof pair !== 'object' || typeof pair[Symbol.iterator] !== 'function') { + throw new TypeError('Each header pair must be iterable'); + } + pairs.push(Array.from(pair)); + } + + for (const pair of pairs) { + if (pair.length !== 2) { + throw new TypeError('Each header pair must be a name/value tuple'); + } + this.append(pair[0], pair[1]); + } + } else { + // record + for (const key of Object.keys(init)) { + const value = init[key]; + this.append(key, value); + } + } + } else { + throw new TypeError('Provided initializer must be an object'); + } + } + + /** + * Return combined header value given name + * + * @param String name Header name + * @return Mixed + */ + get(name) { + name = `${name}`; + validateName(name); + const key = find(this[MAP], name); + if (key === undefined) { + return null; + } + + return this[MAP][key].join(', '); + } + + /** + * Iterate over all headers + * + * @param Function callback Executed for each item with parameters (value, name, thisArg) + * @param Boolean thisArg `this` context for callback function + * @return Void + */ + forEach(callback) { + let thisArg = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : undefined; + + let pairs = getHeaders(this); + let i = 0; + while (i < pairs.length) { + var _pairs$i = pairs[i]; + const name = _pairs$i[0], + value = _pairs$i[1]; + + callback.call(thisArg, value, name, this); + pairs = getHeaders(this); + i++; + } + } + + /** + * Overwrite header values given name + * + * @param String name Header name + * @param String value Header value + * @return Void + */ + set(name, value) { + name = `${name}`; + value = `${value}`; + validateName(name); + validateValue(value); + const key = find(this[MAP], name); + this[MAP][key !== undefined ? key : name] = [value]; + } + + /** + * Append a value onto existing header + * + * @param String name Header name + * @param String value Header value + * @return Void + */ + append(name, value) { + name = `${name}`; + value = `${value}`; + validateName(name); + validateValue(value); + const key = find(this[MAP], name); + if (key !== undefined) { + this[MAP][key].push(value); + } else { + this[MAP][name] = [value]; + } + } + + /** + * Check for header name existence + * + * @param String name Header name + * @return Boolean + */ + has(name) { + name = `${name}`; + validateName(name); + return find(this[MAP], name) !== undefined; + } + + /** + * Delete all header values given name + * + * @param String name Header name + * @return Void + */ + delete(name) { + name = `${name}`; + validateName(name); + const key = find(this[MAP], name); + if (key !== undefined) { + delete this[MAP][key]; + } + } + + /** + * Return raw headers (non-spec api) + * + * @return Object + */ + raw() { + return this[MAP]; + } + + /** + * Get an iterator on keys. + * + * @return Iterator + */ + keys() { + return createHeadersIterator(this, 'key'); + } + + /** + * Get an iterator on values. + * + * @return Iterator + */ + values() { + return createHeadersIterator(this, 'value'); + } + + /** + * Get an iterator on entries. + * + * This is the default iterator of the Headers object. + * + * @return Iterator + */ + [Symbol.iterator]() { + return createHeadersIterator(this, 'key+value'); + } +} +Headers.prototype.entries = Headers.prototype[Symbol.iterator]; + +Object.defineProperty(Headers.prototype, Symbol.toStringTag, { + value: 'Headers', + writable: false, + enumerable: false, + configurable: true +}); + +Object.defineProperties(Headers.prototype, { + get: { enumerable: true }, + forEach: { enumerable: true }, + set: { enumerable: true }, + append: { enumerable: true }, + has: { enumerable: true }, + delete: { enumerable: true }, + keys: { enumerable: true }, + values: { enumerable: true }, + entries: { enumerable: true } +}); + +function getHeaders(headers) { + let kind = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'key+value'; + + const keys = Object.keys(headers[MAP]).sort(); + return keys.map(kind === 'key' ? function (k) { + return k.toLowerCase(); + } : kind === 'value' ? function (k) { + return headers[MAP][k].join(', '); + } : function (k) { + return [k.toLowerCase(), headers[MAP][k].join(', ')]; + }); +} + +const INTERNAL = Symbol('internal'); + +function createHeadersIterator(target, kind) { + const iterator = Object.create(HeadersIteratorPrototype); + iterator[INTERNAL] = { + target, + kind, + index: 0 + }; + return iterator; +} + +const HeadersIteratorPrototype = Object.setPrototypeOf({ + next() { + // istanbul ignore if + if (!this || Object.getPrototypeOf(this) !== HeadersIteratorPrototype) { + throw new TypeError('Value of `this` is not a HeadersIterator'); + } + + var _INTERNAL = this[INTERNAL]; + const target = _INTERNAL.target, + kind = _INTERNAL.kind, + index = _INTERNAL.index; + + const values = getHeaders(target, kind); + const len = values.length; + if (index >= len) { + return { + value: undefined, + done: true + }; + } + + this[INTERNAL].index = index + 1; + + return { + value: values[index], + done: false + }; + } +}, Object.getPrototypeOf(Object.getPrototypeOf([][Symbol.iterator]()))); + +Object.defineProperty(HeadersIteratorPrototype, Symbol.toStringTag, { + value: 'HeadersIterator', + writable: false, + enumerable: false, + configurable: true +}); + +/** + * Export the Headers object in a form that Node.js can consume. + * + * @param Headers headers + * @return Object + */ +function exportNodeCompatibleHeaders(headers) { + const obj = Object.assign({ __proto__: null }, headers[MAP]); + + // http.request() only supports string as Host header. This hack makes + // specifying custom Host header possible. + const hostHeaderKey = find(headers[MAP], 'Host'); + if (hostHeaderKey !== undefined) { + obj[hostHeaderKey] = obj[hostHeaderKey][0]; + } + + return obj; +} + +/** + * Create a Headers object from an object of headers, ignoring those that do + * not conform to HTTP grammar productions. + * + * @param Object obj Object of headers + * @return Headers + */ +function createHeadersLenient(obj) { + const headers = new Headers(); + for (const name of Object.keys(obj)) { + if (invalidTokenRegex.test(name)) { + continue; + } + if (Array.isArray(obj[name])) { + for (const val of obj[name]) { + if (invalidHeaderCharRegex.test(val)) { + continue; + } + if (headers[MAP][name] === undefined) { + headers[MAP][name] = [val]; + } else { + headers[MAP][name].push(val); + } + } + } else if (!invalidHeaderCharRegex.test(obj[name])) { + headers[MAP][name] = [obj[name]]; + } + } + return headers; +} + +const INTERNALS$1 = Symbol('Response internals'); + +// fix an issue where "STATUS_CODES" aren't a named export for node <10 +const STATUS_CODES = http__default["default"].STATUS_CODES; + +/** + * Response class + * + * @param Stream body Readable stream + * @param Object opts Response options + * @return Void + */ +class Response { + constructor() { + let body = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null; + let opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + + Body.call(this, body, opts); + + const status = opts.status || 200; + const headers = new Headers(opts.headers); + + if (body != null && !headers.has('Content-Type')) { + const contentType = extractContentType(body); + if (contentType) { + headers.append('Content-Type', contentType); + } + } + + this[INTERNALS$1] = { + url: opts.url, + status, + statusText: opts.statusText || STATUS_CODES[status], + headers, + counter: opts.counter + }; + } + + get url() { + return this[INTERNALS$1].url || ''; + } + + get status() { + return this[INTERNALS$1].status; + } + + /** + * Convenience property representing if the request ended normally + */ + get ok() { + return this[INTERNALS$1].status >= 200 && this[INTERNALS$1].status < 300; + } + + get redirected() { + return this[INTERNALS$1].counter > 0; + } + + get statusText() { + return this[INTERNALS$1].statusText; + } + + get headers() { + return this[INTERNALS$1].headers; + } + + /** + * Clone this response + * + * @return Response + */ + clone() { + return new Response(clone(this), { + url: this.url, + status: this.status, + statusText: this.statusText, + headers: this.headers, + ok: this.ok, + redirected: this.redirected + }); + } +} + +Body.mixIn(Response.prototype); + +Object.defineProperties(Response.prototype, { + url: { enumerable: true }, + status: { enumerable: true }, + ok: { enumerable: true }, + redirected: { enumerable: true }, + statusText: { enumerable: true }, + headers: { enumerable: true }, + clone: { enumerable: true } +}); + +Object.defineProperty(Response.prototype, Symbol.toStringTag, { + value: 'Response', + writable: false, + enumerable: false, + configurable: true +}); + +const INTERNALS$2 = Symbol('Request internals'); +const URL = Url__default["default"].URL || publicApi.URL; + +// fix an issue where "format", "parse" aren't a named export for node <10 +const parse_url = Url__default["default"].parse; +const format_url = Url__default["default"].format; + +/** + * Wrapper around `new URL` to handle arbitrary URLs + * + * @param {string} urlStr + * @return {void} + */ +function parseURL(urlStr) { + /* + Check whether the URL is absolute or not + Scheme: https://tools.ietf.org/html/rfc3986#section-3.1 + Absolute URL: https://tools.ietf.org/html/rfc3986#section-4.3 + */ + if (/^[a-zA-Z][a-zA-Z\d+\-.]*:/.exec(urlStr)) { + urlStr = new URL(urlStr).toString(); + } + + // Fallback to old implementation for arbitrary URLs + return parse_url(urlStr); +} + +const streamDestructionSupported = 'destroy' in Stream__default["default"].Readable.prototype; + +/** + * Check if a value is an instance of Request. + * + * @param Mixed input + * @return Boolean + */ +function isRequest(input) { + return typeof input === 'object' && typeof input[INTERNALS$2] === 'object'; +} + +function isAbortSignal(signal) { + const proto = signal && typeof signal === 'object' && Object.getPrototypeOf(signal); + return !!(proto && proto.constructor.name === 'AbortSignal'); +} + +/** + * Request class + * + * @param Mixed input Url or Request instance + * @param Object init Custom options + * @return Void + */ +class Request { + constructor(input) { + let init = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + + let parsedURL; + + // normalize input + if (!isRequest(input)) { + if (input && input.href) { + // in order to support Node.js' Url objects; though WHATWG's URL objects + // will fall into this branch also (since their `toString()` will return + // `href` property anyway) + parsedURL = parseURL(input.href); + } else { + // coerce input to a string before attempting to parse + parsedURL = parseURL(`${input}`); + } + input = {}; + } else { + parsedURL = parseURL(input.url); + } + + let method = init.method || input.method || 'GET'; + method = method.toUpperCase(); + + if ((init.body != null || isRequest(input) && input.body !== null) && (method === 'GET' || method === 'HEAD')) { + throw new TypeError('Request with GET/HEAD method cannot have body'); + } + + let inputBody = init.body != null ? init.body : isRequest(input) && input.body !== null ? clone(input) : null; + + Body.call(this, inputBody, { + timeout: init.timeout || input.timeout || 0, + size: init.size || input.size || 0 + }); + + const headers = new Headers(init.headers || input.headers || {}); + + if (inputBody != null && !headers.has('Content-Type')) { + const contentType = extractContentType(inputBody); + if (contentType) { + headers.append('Content-Type', contentType); + } + } + + let signal = isRequest(input) ? input.signal : null; + if ('signal' in init) signal = init.signal; + + if (signal != null && !isAbortSignal(signal)) { + throw new TypeError('Expected signal to be an instanceof AbortSignal'); + } + + this[INTERNALS$2] = { + method, + redirect: init.redirect || input.redirect || 'follow', + headers, + parsedURL, + signal + }; + + // node-fetch-only options + this.follow = init.follow !== undefined ? init.follow : input.follow !== undefined ? input.follow : 20; + this.compress = init.compress !== undefined ? init.compress : input.compress !== undefined ? input.compress : true; + this.counter = init.counter || input.counter || 0; + this.agent = init.agent || input.agent; + } + + get method() { + return this[INTERNALS$2].method; + } + + get url() { + return format_url(this[INTERNALS$2].parsedURL); + } + + get headers() { + return this[INTERNALS$2].headers; + } + + get redirect() { + return this[INTERNALS$2].redirect; + } + + get signal() { + return this[INTERNALS$2].signal; + } + + /** + * Clone this request + * + * @return Request + */ + clone() { + return new Request(this); + } +} + +Body.mixIn(Request.prototype); + +Object.defineProperty(Request.prototype, Symbol.toStringTag, { + value: 'Request', + writable: false, + enumerable: false, + configurable: true +}); + +Object.defineProperties(Request.prototype, { + method: { enumerable: true }, + url: { enumerable: true }, + headers: { enumerable: true }, + redirect: { enumerable: true }, + clone: { enumerable: true }, + signal: { enumerable: true } +}); + +/** + * Convert a Request to Node.js http request options. + * + * @param Request A Request instance + * @return Object The options object to be passed to http.request + */ +function getNodeRequestOptions(request) { + const parsedURL = request[INTERNALS$2].parsedURL; + const headers = new Headers(request[INTERNALS$2].headers); + + // fetch step 1.3 + if (!headers.has('Accept')) { + headers.set('Accept', '*/*'); + } + + // Basic fetch + if (!parsedURL.protocol || !parsedURL.hostname) { + throw new TypeError('Only absolute URLs are supported'); + } + + if (!/^https?:$/.test(parsedURL.protocol)) { + throw new TypeError('Only HTTP(S) protocols are supported'); + } + + if (request.signal && request.body instanceof Stream__default["default"].Readable && !streamDestructionSupported) { + throw new Error('Cancellation of streamed requests with AbortSignal is not supported in node < 8'); + } + + // HTTP-network-or-cache fetch steps 2.4-2.7 + let contentLengthValue = null; + if (request.body == null && /^(POST|PUT)$/i.test(request.method)) { + contentLengthValue = '0'; + } + if (request.body != null) { + const totalBytes = getTotalBytes(request); + if (typeof totalBytes === 'number') { + contentLengthValue = String(totalBytes); + } + } + if (contentLengthValue) { + headers.set('Content-Length', contentLengthValue); + } + + // HTTP-network-or-cache fetch step 2.11 + if (!headers.has('User-Agent')) { + headers.set('User-Agent', 'node-fetch/1.0 (+https://github.com/bitinn/node-fetch)'); + } + + // HTTP-network-or-cache fetch step 2.15 + if (request.compress && !headers.has('Accept-Encoding')) { + headers.set('Accept-Encoding', 'gzip,deflate'); + } + + let agent = request.agent; + if (typeof agent === 'function') { + agent = agent(parsedURL); + } + + // HTTP-network fetch step 4.2 + // chunked encoding is handled by Node.js + + return Object.assign({}, parsedURL, { + method: request.method, + headers: exportNodeCompatibleHeaders(headers), + agent + }); +} + +/** + * abort-error.js + * + * AbortError interface for cancelled requests + */ + +/** + * Create AbortError instance + * + * @param String message Error message for human + * @return AbortError + */ +function AbortError(message) { + Error.call(this, message); + + this.type = 'aborted'; + this.message = message; + + // hide custom error implementation details from end-users + Error.captureStackTrace(this, this.constructor); +} + +AbortError.prototype = Object.create(Error.prototype); +AbortError.prototype.constructor = AbortError; +AbortError.prototype.name = 'AbortError'; + +const URL$1 = Url__default["default"].URL || publicApi.URL; + +// fix an issue where "PassThrough", "resolve" aren't a named export for node <10 +const PassThrough$1 = Stream__default["default"].PassThrough; + +const isDomainOrSubdomain = function isDomainOrSubdomain(destination, original) { + const orig = new URL$1(original).hostname; + const dest = new URL$1(destination).hostname; + + return orig === dest || orig[orig.length - dest.length - 1] === '.' && orig.endsWith(dest); +}; + +/** + * isSameProtocol reports whether the two provided URLs use the same protocol. + * + * Both domains must already be in canonical form. + * @param {string|URL} original + * @param {string|URL} destination + */ +const isSameProtocol = function isSameProtocol(destination, original) { + const orig = new URL$1(original).protocol; + const dest = new URL$1(destination).protocol; + + return orig === dest; +}; + +/** + * Fetch function + * + * @param Mixed url Absolute url or Request instance + * @param Object opts Fetch options + * @return Promise + */ +function fetch(url, opts) { + + // allow custom promise + if (!fetch.Promise) { + throw new Error('native promise missing, set fetch.Promise to your favorite alternative'); + } + + Body.Promise = fetch.Promise; + + // wrap http.request into fetch + return new fetch.Promise(function (resolve, reject) { + // build request object + const request = new Request(url, opts); + const options = getNodeRequestOptions(request); + + const send = (options.protocol === 'https:' ? https__default["default"] : http__default["default"]).request; + const signal = request.signal; + + let response = null; + + const abort = function abort() { + let error = new AbortError('The user aborted a request.'); + reject(error); + if (request.body && request.body instanceof Stream__default["default"].Readable) { + destroyStream(request.body, error); + } + if (!response || !response.body) return; + response.body.emit('error', error); + }; + + if (signal && signal.aborted) { + abort(); + return; + } + + const abortAndFinalize = function abortAndFinalize() { + abort(); + finalize(); + }; + + // send request + const req = send(options); + let reqTimeout; + + if (signal) { + signal.addEventListener('abort', abortAndFinalize); + } + + function finalize() { + req.abort(); + if (signal) signal.removeEventListener('abort', abortAndFinalize); + clearTimeout(reqTimeout); + } + + if (request.timeout) { + req.once('socket', function (socket) { + reqTimeout = setTimeout(function () { + reject(new FetchError(`network timeout at: ${request.url}`, 'request-timeout')); + finalize(); + }, request.timeout); + }); + } + + req.on('error', function (err) { + reject(new FetchError(`request to ${request.url} failed, reason: ${err.message}`, 'system', err)); + + if (response && response.body) { + destroyStream(response.body, err); + } + + finalize(); + }); + + fixResponseChunkedTransferBadEnding(req, function (err) { + if (signal && signal.aborted) { + return; + } + + if (response && response.body) { + destroyStream(response.body, err); + } + }); + + /* c8 ignore next 18 */ + if (parseInt(process.version.substring(1)) < 14) { + // Before Node.js 14, pipeline() does not fully support async iterators and does not always + // properly handle when the socket close/end events are out of order. + req.on('socket', function (s) { + s.addListener('close', function (hadError) { + // if a data listener is still present we didn't end cleanly + const hasDataListener = s.listenerCount('data') > 0; + + // if end happened before close but the socket didn't emit an error, do it now + if (response && hasDataListener && !hadError && !(signal && signal.aborted)) { + const err = new Error('Premature close'); + err.code = 'ERR_STREAM_PREMATURE_CLOSE'; + response.body.emit('error', err); + } + }); + }); + } + + req.on('response', function (res) { + clearTimeout(reqTimeout); + + const headers = createHeadersLenient(res.headers); + + // HTTP fetch step 5 + if (fetch.isRedirect(res.statusCode)) { + // HTTP fetch step 5.2 + const location = headers.get('Location'); + + // HTTP fetch step 5.3 + let locationURL = null; + try { + locationURL = location === null ? null : new URL$1(location, request.url).toString(); + } catch (err) { + // error here can only be invalid URL in Location: header + // do not throw when options.redirect == manual + // let the user extract the errorneous redirect URL + if (request.redirect !== 'manual') { + reject(new FetchError(`uri requested responds with an invalid redirect URL: ${location}`, 'invalid-redirect')); + finalize(); + return; + } + } + + // HTTP fetch step 5.5 + switch (request.redirect) { + case 'error': + reject(new FetchError(`uri requested responds with a redirect, redirect mode is set to error: ${request.url}`, 'no-redirect')); + finalize(); + return; + case 'manual': + // node-fetch-specific step: make manual redirect a bit easier to use by setting the Location header value to the resolved URL. + if (locationURL !== null) { + // handle corrupted header + try { + headers.set('Location', locationURL); + } catch (err) { + // istanbul ignore next: nodejs server prevent invalid response headers, we can't test this through normal request + reject(err); + } + } + break; + case 'follow': + // HTTP-redirect fetch step 2 + if (locationURL === null) { + break; + } + + // HTTP-redirect fetch step 5 + if (request.counter >= request.follow) { + reject(new FetchError(`maximum redirect reached at: ${request.url}`, 'max-redirect')); + finalize(); + return; + } + + // HTTP-redirect fetch step 6 (counter increment) + // Create a new Request object. + const requestOpts = { + headers: new Headers(request.headers), + follow: request.follow, + counter: request.counter + 1, + agent: request.agent, + compress: request.compress, + method: request.method, + body: request.body, + signal: request.signal, + timeout: request.timeout, + size: request.size + }; + + if (!isDomainOrSubdomain(request.url, locationURL) || !isSameProtocol(request.url, locationURL)) { + for (const name of ['authorization', 'www-authenticate', 'cookie', 'cookie2']) { + requestOpts.headers.delete(name); + } + } + + // HTTP-redirect fetch step 9 + if (res.statusCode !== 303 && request.body && getTotalBytes(request) === null) { + reject(new FetchError('Cannot follow redirect with body being a readable stream', 'unsupported-redirect')); + finalize(); + return; + } + + // HTTP-redirect fetch step 11 + if (res.statusCode === 303 || (res.statusCode === 301 || res.statusCode === 302) && request.method === 'POST') { + requestOpts.method = 'GET'; + requestOpts.body = undefined; + requestOpts.headers.delete('content-length'); + } + + // HTTP-redirect fetch step 15 + resolve(fetch(new Request(locationURL, requestOpts))); + finalize(); + return; + } + } + + // prepare response + res.once('end', function () { + if (signal) signal.removeEventListener('abort', abortAndFinalize); + }); + let body = res.pipe(new PassThrough$1()); + + const response_options = { + url: request.url, + status: res.statusCode, + statusText: res.statusMessage, + headers: headers, + size: request.size, + timeout: request.timeout, + counter: request.counter + }; + + // HTTP-network fetch step 12.1.1.3 + const codings = headers.get('Content-Encoding'); + + // HTTP-network fetch step 12.1.1.4: handle content codings + + // in following scenarios we ignore compression support + // 1. compression support is disabled + // 2. HEAD request + // 3. no Content-Encoding header + // 4. no content response (204) + // 5. content not modified response (304) + if (!request.compress || request.method === 'HEAD' || codings === null || res.statusCode === 204 || res.statusCode === 304) { + response = new Response(body, response_options); + resolve(response); + return; + } + + // For Node v6+ + // Be less strict when decoding compressed responses, since sometimes + // servers send slightly invalid responses that are still accepted + // by common browsers. + // Always using Z_SYNC_FLUSH is what cURL does. + const zlibOptions = { + flush: zlib__default["default"].Z_SYNC_FLUSH, + finishFlush: zlib__default["default"].Z_SYNC_FLUSH + }; + + // for gzip + if (codings == 'gzip' || codings == 'x-gzip') { + body = body.pipe(zlib__default["default"].createGunzip(zlibOptions)); + response = new Response(body, response_options); + resolve(response); + return; + } + + // for deflate + if (codings == 'deflate' || codings == 'x-deflate') { + // handle the infamous raw deflate response from old servers + // a hack for old IIS and Apache servers + const raw = res.pipe(new PassThrough$1()); + raw.once('data', function (chunk) { + // see http://stackoverflow.com/questions/37519828 + if ((chunk[0] & 0x0F) === 0x08) { + body = body.pipe(zlib__default["default"].createInflate()); + } else { + body = body.pipe(zlib__default["default"].createInflateRaw()); + } + response = new Response(body, response_options); + resolve(response); + }); + raw.on('end', function () { + // some old IIS servers return zero-length OK deflate responses, so 'data' is never emitted. + if (!response) { + response = new Response(body, response_options); + resolve(response); + } + }); + return; + } + + // for br + if (codings == 'br' && typeof zlib__default["default"].createBrotliDecompress === 'function') { + body = body.pipe(zlib__default["default"].createBrotliDecompress()); + response = new Response(body, response_options); + resolve(response); + return; + } + + // otherwise, use response as-is + response = new Response(body, response_options); + resolve(response); + }); + + writeToStream(req, request); + }); +} +function fixResponseChunkedTransferBadEnding(request, errorCallback) { + let socket; + + request.on('socket', function (s) { + socket = s; + }); + + request.on('response', function (response) { + const headers = response.headers; + + if (headers['transfer-encoding'] === 'chunked' && !headers['content-length']) { + response.once('close', function (hadError) { + // tests for socket presence, as in some situations the + // the 'socket' event is not triggered for the request + // (happens in deno), avoids `TypeError` + // if a data listener is still present we didn't end cleanly + const hasDataListener = socket && socket.listenerCount('data') > 0; + + if (hasDataListener && !hadError) { + const err = new Error('Premature close'); + err.code = 'ERR_STREAM_PREMATURE_CLOSE'; + errorCallback(err); + } + }); + } + }); +} + +function destroyStream(stream, err) { + if (stream.destroy) { + stream.destroy(err); + } else { + // node < 8 + stream.emit('error', err); + stream.end(); + } +} + +/** + * Redirect code matching + * + * @param Number code Status code + * @return Boolean + */ +fetch.isRedirect = function (code) { + return code === 301 || code === 302 || code === 303 || code === 307 || code === 308; +}; + +// expose Promise +fetch.Promise = global.Promise; + +/** + * Helpers. + */ + +var s = 1000; +var m = s * 60; +var h = m * 60; +var d = h * 24; +var w = d * 7; +var y = d * 365.25; + +/** + * Parse or format the given `val`. + * + * Options: + * + * - `long` verbose formatting [false] + * + * @param {String|Number} val + * @param {Object} [options] + * @throws {Error} throw an error if val is not a non-empty string or a number + * @return {String|Number} + * @api public + */ + +var ms = function (val, options) { + options = options || {}; + var type = typeof val; + if (type === 'string' && val.length > 0) { + return parse(val); + } else if (type === 'number' && isFinite(val)) { + return options.long ? fmtLong(val) : fmtShort(val); + } + throw new Error( + 'val is not a non-empty string or a valid number. val=' + + JSON.stringify(val) + ); +}; + +/** + * Parse the given `str` and return milliseconds. + * + * @param {String} str + * @return {Number} + * @api private + */ + +function parse(str) { + str = String(str); + if (str.length > 100) { + return; + } + var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec( + str + ); + if (!match) { + return; + } + var n = parseFloat(match[1]); + var type = (match[2] || 'ms').toLowerCase(); + switch (type) { + case 'years': + case 'year': + case 'yrs': + case 'yr': + case 'y': + return n * y; + case 'weeks': + case 'week': + case 'w': + return n * w; + case 'days': + case 'day': + case 'd': + return n * d; + case 'hours': + case 'hour': + case 'hrs': + case 'hr': + case 'h': + return n * h; + case 'minutes': + case 'minute': + case 'mins': + case 'min': + case 'm': + return n * m; + case 'seconds': + case 'second': + case 'secs': + case 'sec': + case 's': + return n * s; + case 'milliseconds': + case 'millisecond': + case 'msecs': + case 'msec': + case 'ms': + return n; + default: + return undefined; + } +} + +/** + * Short format for `ms`. + * + * @param {Number} ms + * @return {String} + * @api private + */ + +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'; +} + +/** + * Long format for `ms`. + * + * @param {Number} ms + * @return {String} + * @api private + */ + +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'; +} + +/** + * Pluralization helper. + */ + +function plural(ms, msAbs, n, name) { + var isPlural = msAbs >= n * 1.5; + return Math.round(ms / n) + ' ' + name + (isPlural ? 's' : ''); +} + +async function _asyncOptionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = await fn(value); } else if (op === 'call' || op === 'optionalCall') { value = await fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } +// CHECK_VERSION is a hardcoded version of the current data structure. +// If something is breaking, this needs to be manually adapted. +const CHECK_VERSION = 4; + +// run main +main() + .then(() => process.exit(0)) + .catch((err) => { + console.error(err); + process.exit(1); + }); + +async function main() { + const state = JSON.parse(process.argv[2]); + await Promise.race([check(state), timeout(state.timeout)]); +} + +async function check(state) { + // make the cache file if we haven't already + const config = await Config.new(state); + // get the signature + const signature = await getSignature(); + + const clientEventID = state.client_event_id || v4(); + + // format the URL + const urlObj = Url__default["default"].parse(state.endpoint, true); + const basepath = (urlObj.pathname || '').replace(/\/$/, ''); + urlObj.pathname = `${basepath}/v1/check/${state.product}`; + urlObj.query = { + checkpoint_version: CHECK_VERSION.toString(), + local_timestamp: state.local_timestamp, + information: state.information, + schema_providers: state.schema_providers, + schema_preview_features: state.schema_preview_features, + schema_generators_providers: state.schema_generators_providers, + command: state.command, + client_event_id: clientEventID, + signature, + project_hash: state.project_hash, + cli_path_hash: state.cli_path_hash, + arch: state.arch, + os: state.os, + node_version: state.node_version, + version: state.version, + ci: typeof state.ci !== 'undefined' ? String(state.ci) : undefined, + ci_name: state.ci_name || '', + cli_install_type: state.cli_install_type, + previous_client_event_id: await _asyncOptionalChain([(await config.get('output')), 'optionalAccess', async _ => _.client_event_id]), + check_if_update_available: String(state.check_if_update_available), + }; + + // When env.CHECKPOINT_DEBUG_STDOUT !== undefined, + // print what would be sent to the telemetry server without actually sending it + if (process.env.CHECKPOINT_DEBUG_STDOUT !== undefined) { + process.stdout.write('[checkpoint-client] debug\n'); + process.stdout.write(JSON.stringify(urlObj, null, ' ')); + return + } + + // send the request + const response = await fetch(Url__default["default"].format(urlObj), { + method: 'get', + timeout: state.timeout, + headers: { + Accept: 'application/json', + 'User-Agent': 'prisma/js-checkpoint', + }, + }); + if (!response.ok) { + throw new Error(`checkpoint response error: ${response.status} ${response.statusText}`) + } + // read the response body + const output = await response.json(); + + // create or update the configuration + // Only do so if there's a need to check if an update is available + // That is to say, if the cache is stale or doesn't exist + if (state.check_if_update_available) { + await config.set({ + last_reminder: 0, + cached_at: Date.now(), + version: state.version, + cli_path: state.cli_path, + output, + }); + } + + // write to process.stdout + process.stdout.write(JSON.stringify(output, null, ' ')); +} + +// this should take a maximum of 5 seconds +async function timeout(millis) { + await sleep(millis); + throw new Error(`checkpoint-client: process timed out after ${ms(millis)}`) +} + +// sleep helper method +function sleep(ms) { + return new Promise((resolve) => { + // we want to unreference this timeout to ensure + // that it doesn't hold up the process from exiting + setTimeout(resolve, ms).unref(); + }) +} diff --git a/backend/node_modules/prisma/build/prisma_schema_build_bg.wasm b/backend/node_modules/prisma/build/prisma_schema_build_bg.wasm new file mode 100644 index 0000000000000000000000000000000000000000..e4eb321c92adab50cbb02cb63d1c750e0ff90240 --- /dev/null +++ b/backend/node_modules/prisma/build/prisma_schema_build_bg.wasm @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:bca8b35bd5ebe0164323d5f761a7a5075fa6ad00e1dfc7906e9da5d4c13c0287 +size 2966822 diff --git a/backend/node_modules/prisma/build/public/assets/alert.60ea9f84.svg b/backend/node_modules/prisma/build/public/assets/alert.60ea9f84.svg new file mode 100644 index 0000000000000000000000000000000000000000..3c522497c687430db948ec8c35b4cfc69fbfed12 --- /dev/null +++ b/backend/node_modules/prisma/build/public/assets/alert.60ea9f84.svg @@ -0,0 +1,5 @@ + + + + + diff --git a/backend/node_modules/prisma/build/public/assets/array.1a36c222.svg b/backend/node_modules/prisma/build/public/assets/array.1a36c222.svg new file mode 100644 index 0000000000000000000000000000000000000000..79e97b3ea71f10b49fee4fed462c1f253acccabb --- /dev/null +++ b/backend/node_modules/prisma/build/public/assets/array.1a36c222.svg @@ -0,0 +1,4 @@ + + + diff --git a/backend/node_modules/prisma/build/public/assets/boolean.9188b434.svg b/backend/node_modules/prisma/build/public/assets/boolean.9188b434.svg new file mode 100644 index 0000000000000000000000000000000000000000..786dee492ea84ff8b60f09b98a9401af969a1de9 --- /dev/null +++ b/backend/node_modules/prisma/build/public/assets/boolean.9188b434.svg @@ -0,0 +1,4 @@ + + + diff --git a/backend/node_modules/prisma/build/public/assets/chevron-down.24f76e3c.svg b/backend/node_modules/prisma/build/public/assets/chevron-down.24f76e3c.svg new file mode 100644 index 0000000000000000000000000000000000000000..18f9335724e156eee00a4887458f55b01bff3772 --- /dev/null +++ b/backend/node_modules/prisma/build/public/assets/chevron-down.24f76e3c.svg @@ -0,0 +1,3 @@ + + + diff --git a/backend/node_modules/prisma/build/public/assets/cross.c2610cf5.svg b/backend/node_modules/prisma/build/public/assets/cross.c2610cf5.svg new file mode 100644 index 0000000000000000000000000000000000000000..d3d9478dca0610f7a316f9c10f45dc9bdca3d23a --- /dev/null +++ b/backend/node_modules/prisma/build/public/assets/cross.c2610cf5.svg @@ -0,0 +1,11 @@ + + + \ No newline at end of file diff --git a/backend/node_modules/prisma/build/public/assets/datetime.a3bf710a.svg b/backend/node_modules/prisma/build/public/assets/datetime.a3bf710a.svg new file mode 100644 index 0000000000000000000000000000000000000000..97a9f0f82a263c3acef2385086cd7de909d84dbe --- /dev/null +++ b/backend/node_modules/prisma/build/public/assets/datetime.a3bf710a.svg @@ -0,0 +1,4 @@ + + + \ No newline at end of file diff --git a/backend/node_modules/prisma/build/public/assets/download.8d34b65a.svg b/backend/node_modules/prisma/build/public/assets/download.8d34b65a.svg new file mode 100644 index 0000000000000000000000000000000000000000..50ca3f676f9ce5cd747d9e373f47eb6398c86501 --- /dev/null +++ b/backend/node_modules/prisma/build/public/assets/download.8d34b65a.svg @@ -0,0 +1,4 @@ + + + + diff --git a/backend/node_modules/prisma/build/public/assets/ellipsis.a8c5a34a.svg b/backend/node_modules/prisma/build/public/assets/ellipsis.a8c5a34a.svg new file mode 100644 index 0000000000000000000000000000000000000000..dc27e11124a5c6054f1c1ba19361bc7f8e99ac4f --- /dev/null +++ b/backend/node_modules/prisma/build/public/assets/ellipsis.a8c5a34a.svg @@ -0,0 +1,10 @@ + + + + + + + \ No newline at end of file diff --git a/backend/node_modules/prisma/build/public/assets/enum.7ec0b64c.svg b/backend/node_modules/prisma/build/public/assets/enum.7ec0b64c.svg new file mode 100644 index 0000000000000000000000000000000000000000..a77c3a6bafcd4993dc95643f15402cd61f3f5cee --- /dev/null +++ b/backend/node_modules/prisma/build/public/assets/enum.7ec0b64c.svg @@ -0,0 +1,6 @@ + + + + + diff --git a/backend/node_modules/prisma/build/public/assets/folder.d77b8eaf.svg b/backend/node_modules/prisma/build/public/assets/folder.d77b8eaf.svg new file mode 100644 index 0000000000000000000000000000000000000000..f8025d4fc3fd302b2023d1a6738d3379abf82f2a --- /dev/null +++ b/backend/node_modules/prisma/build/public/assets/folder.d77b8eaf.svg @@ -0,0 +1,6 @@ + + + \ No newline at end of file diff --git a/backend/node_modules/prisma/build/public/assets/hamburger.5fdadeac.svg b/backend/node_modules/prisma/build/public/assets/hamburger.5fdadeac.svg new file mode 100644 index 0000000000000000000000000000000000000000..513e80fb55a0c42972750113d01977fbcc9c6fa5 --- /dev/null +++ b/backend/node_modules/prisma/build/public/assets/hamburger.5fdadeac.svg @@ -0,0 +1,4 @@ + + + + \ No newline at end of file diff --git a/backend/node_modules/prisma/build/public/assets/index.js b/backend/node_modules/prisma/build/public/assets/index.js new file mode 100644 index 0000000000000000000000000000000000000000..6d77f866719f6a790a741b3b22c316f9fc084665 --- /dev/null +++ b/backend/node_modules/prisma/build/public/assets/index.js @@ -0,0 +1 @@ +var e=Object.defineProperty,t=Object.defineProperties,s=Object.getOwnPropertyDescriptors,i=Object.getOwnPropertySymbols,a=Object.prototype.hasOwnProperty,n=Object.prototype.propertyIsEnumerable,r=(t,s,i)=>s in t?e(t,s,{enumerable:!0,configurable:!0,writable:!0,value:i}):t[s]=i,l=(e,t)=>{for(var s in t||(t={}))a.call(t,s)&&r(e,s,t[s]);if(i)for(var s of i(t))n.call(t,s)&&r(e,s,t[s]);return e},o=(e,i)=>t(e,s(i)),d=(e,t)=>{var s={};for(var r in e)a.call(e,r)&&t.indexOf(r)<0&&(s[r]=e[r]);if(null!=e&&i)for(var r of i(e))t.indexOf(r)<0&&n.call(e,r)&&(s[r]=e[r]);return s};import{m as c,l as h,o as p,a as u,u as m,b as g,d as v,c as f,v as y,t as I,e as C,w,r as b,f as E,g as _,h as x,i as S,R as N,j as L,k as R,n as O,p as M,q as k,s as D,A,x as T,F as P,y as V}from"./vendor.js";var j=Object.defineProperty,F=Object.getOwnPropertyDescriptor,B=(e,t,s,i)=>{for(var a,n=i>1?void 0:i?F(t,s):t,r=e.length-1;r>=0;r--)(a=e[r])&&(n=(i?a(t,s,n):a(n))||n);return i&&n&&j(t,s,n),n};class H{constructor(){this.transport={type:"http",url:`${window.location.origin}/api`},this.updates=!1,this.readonly=!1,c(this)}async update(e){h.exports.has(e,"transport")&&(this.transport=e.transport),h.exports.has(e,"updates")&&(this.updates=e.updates),h.exports.has(e,"readonly")&&(this.readonly=e.readonly)}}B([p],H.prototype,"transport",2),B([p],H.prototype,"updates",2),B([p],H.prototype,"readonly",2),B([u],H.prototype,"update",1);var q=new H;class Z{constructor(e){this.path=e.path,this.code=e.code,this.type=e.type,this.message=e.message,this.stack=e.stack,this.context=e.context||null,this.nativeError=e.nativeError}}const U=({path:e,message:t,code:s,type:i,stack:a,context:n,nativeError:r})=>{const l=new Z({path:e,message:t,code:s,type:i,stack:a,context:n||null,nativeError:r});return console.error(`[${e}] ${t}`,n),console.error(r),l},z=(e,t,s)=>{const i=a=>a===e.length?s&&s():t(e[a],(()=>i(a+1)));return i(0)};const $=[(e,t,s)=>(e.createObjectStore("projects",{keyPath:"id"}),e.createObjectStore("openTabs",{keyPath:"id"}),e.createObjectStore("sessions",{keyPath:"id"}),e.createObjectStore("scripts",{keyPath:"id"}),s()),(e,t,s)=>(e.createObjectStore("models",{keyPath:"id"}),e.createObjectStore("fields",{keyPath:"id"}),e.createObjectStore("enums",{keyPath:"id"}),s()),(e,t,s)=>{const i=t.objectStore("sessions"),a=t.objectStore("scripts"),n=i.getAll();n.onsuccess=()=>{const e=a.getAll();e.onsuccess=()=>{const t=n.result,r=e.result;z(t,((e,t)=>{const s=r.find((t=>t.id===e.scriptId));s?i.put(o(l({},e),{lastSavedHash:s.lastSavedHash||""})).onsuccess=t:e.lastSavedHash=""}),(()=>{z(r,((e,t)=>{delete e.lastSavedHash,a.put(e).onsuccess=t}),(()=>s()))}))}}},(e,t,s)=>{e.createObjectStore("tabs",{keyPath:"id"});const i=t.objectStore("openTabs"),a=t.objectStore("tabs"),n=i.getAll();n.onsuccess=()=>{const t=n.result;z(t,((e,t)=>{if(!e.sessionId)return t();e.preview=!1,a.put(e).onsuccess=t}),(()=>(e.deleteObjectStore("openTabs"),s())))}},(e,t,s)=>{const i=t.objectStore("tabs"),a=t.objectStore("projects"),n=i.getAll();n.onsuccess=()=>{const e=a.getAll();e.onsuccess=()=>{const t=n.result,i=e.result;z(i,((e,s)=>{e.tabOrder=t.filter((t=>t.projectId===e.id)).map((e=>e.id)),a.put(e).onsuccess=s}),(()=>s()))}}},(e,t,s)=>{const i=["tabs","sessions","scripts","models","fields","enums"],a={};z(i,((e,s)=>{const i=t.objectStore(e).getAll();i.onsuccess=()=>{a[e]=i.result,s()}}),(()=>{z(i,((s,i)=>{e.deleteObjectStore(s),e.createObjectStore(s,{keyPath:["id","projectId"]});const n=a[s];z(n,((e,i)=>{t.objectStore(s).put(e).onsuccess=i}),(()=>i()))}),(()=>(e.createObjectStore("actions",{keyPath:["id","projectId"]}),s())))}))},(e,t,s)=>{const i=t.objectStore("projects"),a=i.getAll();a.onsuccess=()=>{const e=a.result;z(e,((e,t)=>{e.theme="light",i.put(e).onsuccess=t}),(()=>s()))}},(e,t,s)=>{const i=t.objectStore("sessions"),a=t.objectStore("scripts"),n=i.getAll();n.onsuccess=()=>{const e=n.result;z(e,((e,t)=>{e.type=e.scriptId?"script":"fallback",i.put(e).onsuccess=t}),(()=>{const e=a.getAll();e.onsuccess=()=>{const t=e.result;z(t,((e,t)=>{e.generated=!1,a.put(e).onsuccess=t}),(()=>s()))}}))}},(e,t,s)=>{const i=t.objectStore("scripts"),a=i.getAll();a.onsuccess=()=>{const e=a.result;z(e,((e,t)=>{e.frozen=e.generated,delete e.generated,i.put(e).onsuccess=t}),(()=>s()))}},(e,t,s)=>(e.deleteObjectStore("models"),e.deleteObjectStore("fields"),e.deleteObjectStore("enums"),s()),(e,t,s)=>{const i=t.objectStore("projects");i.createIndex("createdAt","createdAt"),i.createIndex("updatedAt","updatedAt");const a=t.objectStore("actions");a.createIndex("createdAt","createdAt"),a.createIndex("updatedAt","updatedAt");const n=t.objectStore("scripts");n.createIndex("createdAt","createdAt"),n.createIndex("updatedAt","updatedAt");const r=t.objectStore("sessions");r.createIndex("createdAt","createdAt"),r.createIndex("updatedAt","updatedAt");const l=t.objectStore("tabs");l.createIndex("createdAt","createdAt"),l.createIndex("updatedAt","updatedAt");const o=i.getAll();return o.onsuccess=()=>{const e=o.result;z(e,((e,t)=>{delete e.tabOrder,e.createdAt=(new Date).toISOString(),e.updatedAt=(new Date).toISOString(),i.put(e).onsuccess=t}),(()=>{z([a,n,r,l],((e,t)=>{const s=e.getAll();s.onsuccess=()=>{const i=s.result;z(i,((t,s)=>{t.createdAt=(new Date).toISOString(),t.updatedAt=(new Date).toISOString(),e.put(t).onsuccess=s}),(()=>t()))}}),(()=>s()))}))},s()},(e,t,s)=>{const i=t.objectStore("projects");i.deleteIndex("createdAt"),i.createIndex("createdAt",["id","createdAt"]),i.deleteIndex("updatedAt"),i.createIndex("updatedAt",["id","updatedAt"]);const a=t.objectStore("actions");a.deleteIndex("createdAt"),a.createIndex("createdAt",["id","projectId","createdAt"]),a.deleteIndex("updatedAt"),a.createIndex("updatedAt",["id","projectId","updatedAt"]);const n=t.objectStore("scripts");n.deleteIndex("createdAt"),n.createIndex("createdAt",["id","projectId","createdAt"]),n.deleteIndex("updatedAt"),n.createIndex("updatedAt",["id","projectId","updatedAt"]);const r=t.objectStore("sessions");r.deleteIndex("createdAt"),r.createIndex("createdAt",["id","projectId","createdAt"]),r.deleteIndex("updatedAt"),r.createIndex("updatedAt",["id","projectId","updatedAt"]);const l=t.objectStore("tabs");return l.deleteIndex("createdAt"),l.createIndex("createdAt",["id","projectId","createdAt"]),l.deleteIndex("updatedAt"),l.createIndex("updatedAt",["id","projectId","updatedAt"]),s()},(e,t,s)=>{const i=t.objectStore("scripts"),a=i.getAll();a.onsuccess=()=>{const e=a.result;z(e,((e,t)=>{e.where=e.where.map((e=>(e.fieldIds=[e.fieldId],delete e.fieldId,e))),i.put(e).onsuccess=t}),(()=>s()))}}],J=(e,t,s,i)=>{console.log("------Starting IndexedDB migration------");const a=m(i);z($.slice(t),((t,s)=>t(e,a,s)),(()=>console.log("------IndexedDB migration complete------")))};class W{constructor(e,t){this.cursor=()=>this.db.transaction(this.storeName).store.openCursor(),this.transaction=e=>this.db.transaction(this.storeName,e),this.getAll=async({projectId:e}={})=>{const t=await this.db.getAllFromIndex(this.storeName,"createdAt");return e?t.filter((t=>t.projectId===e)):t},this.create=async e=>{try{await this.db.put(this.storeName,o(l({},e),{createdAt:(new Date).toISOString(),updatedAt:(new Date).toISOString()}))}catch(t){console.log("Error during PersistenceItem.create",t,this.storeName)}},this.update=async(e,t)=>{try{const t=await this.db.get(this.storeName,e);await this.db.put(this.storeName,o(l({},t),{updatedAt:(new Date).toISOString()}))}catch(s){console.log("Error during PersistenceItem.update",s,this.storeName)}},this.delete=async e=>{try{await this.db.delete(this.storeName,e)}catch(t){console.log("Error during PersistenceItem.delete",t,this.storeName)}},this.clear=async()=>{try{await this.db.clear(this.storeName)}catch(e){console.log("Error during PersistenceItem.clear",e,this.storeName)}},this.storeName=e,this.db=t}}var K=new class{constructor(){this.databaseName="Prisma Studio",this.indexedDBVersion=13,this.databaseInstance=null,this.projectId="",this.ready=!1,this.init=async({projectId:e})=>{try{this.projectId=e,this.databaseInstance=await g(this.databaseName,this.indexedDBVersion,{upgrade:J}),this.projects=new W("projects",this.databaseInstance),this.tabs=new W("tabs",this.databaseInstance),this.sessions=new W("sessions",this.databaseInstance),this.scripts=new W("scripts",this.databaseInstance),this.actions=new W("actions",this.databaseInstance),this.ready=!0}catch(t){throw U({path:"PersistenceStore.init",message:"Unable to init PersistenceStore",nativeError:t})}},this.save=(e,t)=>new Promise((async(s,i)=>{if(!this.ready)throw U({path:"PersistenceStore.save",message:"PersistenceStore is not ready to receive `save` operations yet",context:{tableName:e,value:t}});try{switch(e){case"sessions":await this.sessions.create(t);break;case"scripts":await this.scripts.create(t);break;case"tabs":await this.tabs.create(t);break;case"projects":await this.projects.create(t);break;case"actions":await this.actions.create(t)}s()}catch(a){i(a)}})),this.load=async e=>new Promise((async(t,s)=>{if(!this.ready)throw U({path:"PersistenceStore.load",message:"PersistenceStore is not ready to receive `load` operations yet",context:{tableName:e}});try{switch(e){case"projects":return t(await this.projects.getAll());default:return t(await this[e].getAll({projectId:this.projectId}))}}catch(i){return s(i)}})),this.remove=async(e,t)=>new Promise((async(s,i)=>{if(!this.ready)throw U({path:"PersistenceStore.remove",message:"PersistenceStore is not ready to receive `remove` operations yet",context:{tableName:e,id:t}});try{switch(e){case"projects":return await this[e].delete(t),s();default:return await this[e].delete([t,this.projectId]),s()}}catch(a){return i(a)}})),this.clear=async e=>new Promise((async(t,s)=>{if(!this.ready)throw U({path:"PersistenceStore.clear",message:"PersistenceStore is not ready to receive `clear` operations yet",context:{tableName:e}});try{return await this[e].clear(),t()}catch(i){return s(i)}})),this.clearAll=async()=>{var e;null==(e=this.databaseInstance)||e.close(),await v(this.databaseName)}}},G=Object.defineProperty,Q=Object.getOwnPropertyDescriptor,Y=(e,t,s,i)=>{for(var a,n=i>1?void 0:i?Q(t,s):t,r=e.length-1;r>=0;r--)(a=e[r])&&(n=(i?a(t,s,n):a(n))||n);return i&&n&&G(t,s,n),n};class X{constructor(e,{idbTableName:t}={}){this.idbTableName=null,this.members={},this.type=e,this.idbTableName=null!=t?t:null,c(this)}get values(){return this.members}get size(){return Object.keys(this.members).length}async restore(){if(this.idbTableName){(await K.load(this.idbTableName)).forEach((e=>{e?this.add(e,{skipPersist:!0}):console.warn("Attempt to restore a null member from IndexedDB, ignoring",{member:e,idbTableName:this.idbTableName})}))}return Promise.resolve()}get(e){return e&&this.members[e]||null}add(e,{skipPersist:t=!1}={}){let s;if(e.id||(e.id=y()),this.members[e.id])s=this.members[e.id],s.update(e,{skipPersist:t});else{s=new(0,this.type)(e),s.idbTableName=this.idbTableName,this.members[e.id]=s,!t&&this.idbTableName&&K.save(this.idbTableName,s.serialize())}return s}remove(e){const t=this.members[e];return t&&delete this.members[e],this.idbTableName&&K.remove(this.idbTableName,e),t}clear(){this.members={},this.idbTableName&&K.clear(this.idbTableName)}toJS(){return I(this)}}Y([p],X.prototype,"idbTableName",2),Y([p],X.prototype,"members",2),Y([f],X.prototype,"values",1),Y([f],X.prototype,"size",1),Y([u],X.prototype,"restore",1),Y([u],X.prototype,"add",1),Y([u],X.prototype,"remove",1),Y([u],X.prototype,"clear",1),Y([u],X.prototype,"toJS",1);var ee=Object.defineProperty,te=Object.getOwnPropertyDescriptor,se=(e,t,s,i)=>{for(var a,n=i>1?void 0:i?te(t,s):t,r=e.length-1;r>=0;r--)(a=e[r])&&(n=(i?a(t,s,n):a(n))||n);return i&&n&&ee(t,s,n),n};class ie{constructor(e){this.forceUpdate=async()=>{await K.save(this.idbTableName,this.serialize())},this.id=e.id,this.idbTableName=null,c(this)}update(e,{skipPersist:t=!1}={}){if(!t&&this.idbTableName){const t=this.serialize(),s=Object.keys(t),i=Object.keys(e);new Set([...s,...i]).size!==s.length+i.length&&this.forceUpdate()}}serialize(){}}se([p],ie.prototype,"id",2),se([p],ie.prototype,"idbTableName",2),se([u],ie.prototype,"update",1),se([u],ie.prototype,"forceUpdate",2);const ae=(e,t)=>`${e}.${t}`;var ne=Object.defineProperty,re=Object.getOwnPropertyDescriptor,le=(e,t,s,i)=>{for(var a,n=i>1?void 0:i?re(t,s):t,r=e.length-1;r>=0;r--)(a=e[r])&&(n=(i?a(t,s,n):a(n))||n);return i&&n&&ne(t,s,n),n};class oe extends ie{constructor(e){super(e),this.id=e.id,this.name=e.name,this.values=e.values,c(this)}update(e,t={}){h.exports.has(e,"name")&&(this.name=e.name),h.exports.has(e,"values")&&(this.values=e.values),super.update(e,t)}}le([C],oe.prototype,"id",2),le([p],oe.prototype,"name",2),le([p],oe.prototype,"values",2),le([C],oe.prototype,"update",1);var de=Object.defineProperty,ce=Object.getOwnPropertyDescriptor;class he extends X{constructor(){super(oe),this.getByName=e=>this.get(e),c(this)}add(e,t={}){return super.add(l({id:e.name},e),t)}}((e,t,s,i)=>{for(var a,n=i>1?void 0:i?ce(t,s):t,r=e.length-1;r>=0;r--)(a=e[r])&&(n=(i?a(t,s,n):a(n))||n);i&&n&&de(t,s,n)})([C],he.prototype,"add",1);var pe=new he,ue=Object.defineProperty,me=Object.getOwnPropertyDescriptor,ge=(e,t,s,i)=>{for(var a,n=i>1?void 0:i?me(t,s):t,r=e.length-1;r>=0;r--)(a=e[r])&&(n=(i?a(t,s,n):a(n))||n);return i&&n&&ue(t,s,n),n};class ve extends ie{constructor(e){if(super(e),this.id=e.id,this.modelId=e.modelId,this.name=e.name,this.type=e.type,this.kind=e.kind,"Json"===this.type&&"string"==typeof e.default)try{this.default=JSON.parse(e.default)}catch(t){this.default=e.default}else if("BigInt"===this.type&&"string"==typeof e.default)try{this.default=BigInt(e.default)}catch(t){this.default=e.default}else this.default=e.default;this.isId=e.isId,this.isUnique=e.isUnique,this.isRequired=e.isRequired,this.isList=e.isList,this.isReadOnly=e.isReadOnly,this.isUpdatedAt=e.isUpdatedAt,this.relationName=e.relationName,this.relationFromFieldNames=e.relationFromFieldNames,this.relationToFieldNames=e.relationToFieldNames,c(this)}get model(){return ds.get(this.modelId)}get isScalar(){return"scalar"===this.kind&&!this.isEnum}get isString(){return"String"===this.type}get isInt(){return"Int"===this.type}get isBigInt(){return"BigInt"===this.type}get isFloat(){return"Float"===this.type}get isDecimal(){return"Decimal"===this.type}get isBoolean(){return"Boolean"===this.type}get isDateTime(){return"DateTime"===this.type}get isJson(){return"Json"===this.type}get isBytes(){return"Bytes"===this.type}get isEnum(){return!!this.typeAsEnum}get isRelation(){return"object"===this.kind}get isScalarListRelation(){return this.isScalar&&this.isList&&this.isPartOfRelation||!1}get isScalarListTwoWayMNRelation(){var e;if(this.isScalarListRelation){const t=(null==(e=this.model)?void 0:e.name)||null;if(!t)return!1;const s=this.relationItIsPartOf;if(!s)return!1;const i=ds.getByName(s.type);if(!i)return!1;const a=i.fields.find((e=>e.type===t));if(!a)return!1;const n=a.relationFromFieldNames[0],r=i.getFieldByName(n);if(!r)return!1;if(r.isScalarListRelation)return!0}return!1}get isPartOfRelation(){return null!==this.relationItIsPartOf}get relationItIsPartOf(){return this.model&&this.model.fields.find((e=>e.isRelation&&e.relationFromFieldNames.includes(this.name)))||null}get isSortable(){return this.isScalar&&!this.isList||this.isEnum&&!this.isList}get isFunctionDefault(){return"string"!=typeof this.default&&"number"!=typeof this.default&&"boolean"!=typeof this.default&&"bigint"!=typeof this.default&&!h.exports.isArray(this.default)}get defaultAsString(){return this.isList?"[]":this.default?"string"==typeof this.default||"number"==typeof this.default||"boolean"==typeof this.default?`${this.default}`:"bigint"==typeof this.default||h.exports.isArray(this.default)?this.default.toString():h.exports.isObject(this.default)?`${this.default.name}()`:"":""}get placeholder(){return this.isList?"[]":this.isString?"Value":this.isInt||this.isFloat||this.isBigInt||this.isDecimal?"1337":this.isBoolean?"false":this.isDateTime?(new Date).toISOString():this.isJson?"{}":this.isEnum?this.typeAsEnum.values[0]:this.isRelation?"ID":"Value"}get typeAsModel(){return this.isRelation?ds.getByName(this.type):null}get typeAsEnum(){return pe.getByName(this.type)}get typeAsLabel(){let e=this.type;const t=this.typeAsModel;return t&&(e=t.name),this.isList?e+="[]":this.isRequired||(e+="?"),e}get lowestValidValue(){if(this.isList)return[];if(!this.isRequired)return null;if(this.isString)return"";if(this.isInt||this.isFloat||this.isDecimal)return 0;if(this.isBigInt)return BigInt(0);if(this.isBoolean)return!1;if(this.isDateTime)return new Date(0).toISOString();if(this.isJson)return{};if(this.isEnum){if(!this.typeAsEnum)throw U({path:"Field.lowestValidValue",message:"Invalid type of field: enum",context:{fieldId:this.id,type:this.type}});return this.typeAsEnum.values[0]}return null}get getRelationIDFieldName(){if(!this.isRelation)return null;const e=ds.getByName(this.type);return e&&e.idField?e.idField.name:null}update(e,t={}){h.exports.has(e,"default")&&(this.default=e.default),h.exports.has(e,"isId")&&(this.isId=e.isId),h.exports.has(e,"isUnique")&&(this.isUnique=e.isUnique),h.exports.has(e,"isRequired")&&(this.isRequired=e.isRequired),h.exports.has(e,"isList")&&(this.isList=e.isList),h.exports.has(e,"isReadOnly")&&(this.isReadOnly=e.isReadOnly),h.exports.has(e,"isUpdatedAt")&&(this.isUpdatedAt=e.isUpdatedAt),super.update(e,t)}}ge([C],ve.prototype,"id",2),ge([p],ve.prototype,"modelId",2),ge([p],ve.prototype,"name",2),ge([p],ve.prototype,"type",2),ge([p],ve.prototype,"kind",2),ge([p],ve.prototype,"default",2),ge([p],ve.prototype,"isId",2),ge([p],ve.prototype,"isUnique",2),ge([p],ve.prototype,"isRequired",2),ge([p],ve.prototype,"isList",2),ge([p],ve.prototype,"isReadOnly",2),ge([p],ve.prototype,"isUpdatedAt",2),ge([p],ve.prototype,"relationName",2),ge([p],ve.prototype,"relationFromFieldNames",2),ge([p],ve.prototype,"relationToFieldNames",2),ge([f],ve.prototype,"model",1),ge([f],ve.prototype,"isScalar",1),ge([f],ve.prototype,"isString",1),ge([f],ve.prototype,"isInt",1),ge([f],ve.prototype,"isBigInt",1),ge([f],ve.prototype,"isFloat",1),ge([f],ve.prototype,"isDecimal",1),ge([f],ve.prototype,"isBoolean",1),ge([f],ve.prototype,"isDateTime",1),ge([f],ve.prototype,"isJson",1),ge([f],ve.prototype,"isBytes",1),ge([f],ve.prototype,"isEnum",1),ge([f],ve.prototype,"isRelation",1),ge([f],ve.prototype,"isScalarListRelation",1),ge([f],ve.prototype,"isScalarListTwoWayMNRelation",1),ge([f],ve.prototype,"isPartOfRelation",1),ge([f],ve.prototype,"relationItIsPartOf",1),ge([f],ve.prototype,"isSortable",1),ge([f],ve.prototype,"isFunctionDefault",1),ge([f],ve.prototype,"defaultAsString",1),ge([f],ve.prototype,"placeholder",1),ge([f],ve.prototype,"typeAsModel",1),ge([f],ve.prototype,"typeAsEnum",1),ge([f],ve.prototype,"typeAsLabel",1),ge([f],ve.prototype,"lowestValidValue",1),ge([f],ve.prototype,"getRelationIDFieldName",1),ge([C],ve.prototype,"update",1);var fe=new class extends X{constructor(){super(ve)}getByName(e,t){return this.get(ae(t,e))}},ye=Object.defineProperty,Ie=Object.getOwnPropertyDescriptor,Ce=(e,t,s,i)=>{for(var a,n=i>1?void 0:i?Ie(t,s):t,r=e.length-1;r>=0;r--)(a=e[r])&&(n=(i?a(t,s,n):a(n))||n);return i&&n&&ye(t,s,n),n};const we=class{constructor(){this.previousError={type:null},this.updateError=(e={})=>{h.exports.has(e,"visible")&&(this.error.visible=e.visible)},this.updateActions=(e={})=>{h.exports.has(e,"visible")&&(this.actions.visible=e.visible)},this.setPreviousError=e=>{this.previousError=e,localStorage.setItem(we.previousErrorLocalStorageKey,JSON.stringify(e))},this.error={visible:!1};const e=localStorage.getItem(we.previousErrorLocalStorageKey);e&&(this.previousError=JSON.parse(e)),this.actions={visible:!1},c(this)}};let be=we;be.previousErrorLocalStorageKey="previousError",Ce([p],be.prototype,"error",2),Ce([p],be.prototype,"actions",2),Ce([p],be.prototype,"previousError",2),Ce([u],be.prototype,"updateError",2),Ce([u],be.prototype,"updateActions",2),Ce([u],be.prototype,"setPreviousError",2);var Ee=new be;const _e=(e,t)=>{if(null==t)throw U({path:"getRecordId",message:"Invalid recordValue",context:{modelId:e,recordValue:t}});const s=ds.get(e);if(!s)throw U({path:"getRecordId",message:"Invalid modelId",context:{modelId:e}});let i=`${e}::`;return i+=s.uniqueIdentifier.fields.map((e=>null===t[e.name]?"null":void 0===t[e.name]?"undefined":t[e.name])).join(","),i};var xe=Object.defineProperty,Se=Object.getOwnPropertyDescriptor,Ne=(e,t,s,i)=>{for(var a,n=i>1?void 0:i?Se(t,s):t,r=e.length-1;r>=0;r--)(a=e[r])&&(n=(i?a(t,s,n):a(n))||n);return i&&n&&xe(t,s,n),n};class Le{constructor(e){this.update=e=>{h.exports.has(e,"selectedRecordIds")&&(this.selectedRecordIds=e.selectedRecordIds)},this.sessionId=e.sessionId,this.selectedRecordIds=[],c(this)}get session(){return $e.get(this.sessionId)}get maxRows(){var e,t;return(null==(t=null==(e=this.session)?void 0:e.script)?void 0:t.recordIds.length)||0}get maxColumns(){var e,t;return(null==(t=null==(e=this.session)?void 0:e.script)?void 0:t.fieldIds.length)||0}get selectedRecords(){return this.selectedRecordIds.map((e=>dt.get(e)))}}Ne([p],Le.prototype,"sessionId",2),Ne([p],Le.prototype,"selectedRecordIds",2),Ne([f],Le.prototype,"session",1),Ne([f],Le.prototype,"maxRows",1),Ne([f],Le.prototype,"maxColumns",1),Ne([f],Le.prototype,"selectedRecords",1),Ne([u],Le.prototype,"update",2);const Re=(e,t)=>{const s=e.split("::"),i=Number(s[0].slice(1,-1));if(isNaN(i))throw U({path:"parseTreePath",message:"Invalid tree path: Failed to parse segment as index",context:{path:e,recordIdx:i}});const a=dt.get(t[i]);if(!a)throw U({path:"parseTreePath",message:"Invalid tree path: Invalid record index",context:{path:e,recordIdx:i}});return s.slice(1).reduce((({model:t,field:s,index:i,record:a,value:n,arraySliceIndices:r},l)=>{var o,d,c,h,p,u;if(l.startsWith("[")&&l.endsWith("]"))if(s=null,i=Number(l.slice(1,-1)),isNaN(i)){const e=l.slice(1,-1).split("-");r=[Number(e[0]),Number(e[1])],i=null,a=null,n=n.slice(r[0],r[1]+1)}else if(t){const c=_e(t.id,n[i]);if(!c)throw U({path:"parseTreePath",message:"Invalid tree path: Failed to parse tree path segment as array",context:{path:e,fieldName:l,recordId:c,accumulator:{model:t,field:s,index:i,record:a,value:n,arraySliceIndices:r}}});n=null!=(d=null==(a=null!=(o=dt.get(c))?o:null)?void 0:a.value)?d:null}else a=null,n=null!=(c=n[i])?c:null;else{if(!t)throw U({path:"parseTreePath",message:"Invalid tree path: Failed to parse tree path segment as field name",context:{path:e,fieldName:l,accumulator:{model:t,field:s,index:i,record:a,value:n,arraySliceIndices:r}}});if(!(s=t.getFieldByName(l)))throw U({path:"parseTreePath",message:"Invalid field name",context:{path:e,fieldName:l,accumulator:{model:t,field:s,index:i,record:a,value:n,arraySliceIndices:r}}});if(t=null!=(h=s.typeAsModel)?h:null,i=null,a=null,n=n[l],r=null,!s.isScalar&&!s.isEnum&&!Array.isArray(n)&&null!=n){const o=t&&_e(t.id,n);if(!o)throw U({path:"parseTreePath",message:"Invalid tree path: Failed to parse tree path segment as relation",context:{path:e,fieldName:l,recordId:o,accumulator:{model:t,field:s,index:i,record:a,value:n,arraySliceIndices:r}}});n=null!=(u=null==(a=null!=(p=dt.get(o))?p:null)?void 0:a.value)?u:null}}return{model:t,field:s,index:i,record:a,value:n,arraySliceIndices:r}}),{model:a.model,field:null,index:null,record:a,value:a.value,arraySliceIndices:null})};var Oe=Object.defineProperty,Me=Object.getOwnPropertyDescriptor,ke=(e,t,s,i)=>{for(var a,n=i>1?void 0:i?Me(t,s):t,r=e.length-1;r>=0;r--)(a=e[r])&&(n=(i?a(t,s,n):a(n))||n);return i&&n&&Oe(t,s,n),n};class De{constructor(e){this.selectionOrder=[],this.isExpanded=e=>this.expandedPaths.includes(e),this.select=e=>{this.activePath=e},this.move=(e,t)=>{0===this.selectionOrder.length&&this.setSelectionOrder();const s=this.selectionOrder.findIndex((e=>e===this.activePath));let i;switch(t){case"up":i=this.selectionOrder[s-e];break;case"down":i=this.selectionOrder[s+e]}this.activePath=i||"[0]"},this.expand=()=>{var e,t;if(this.isExpanded(this.activePath))return;if(!(null==(e=this.session)?void 0:e.script))throw U({path:"SessionSelectionTree.expand",message:"Unable to resolve recordIds",context:{sessionId:this.sessionId,scriptId:null==(t=this.session)?void 0:t.scriptId}});const{record:s,value:i,field:a}=Re(this.activePath,this.session.script.recordIds);null!=i&&((null==a?void 0:a.isList)||!(null==a?void 0:a.isScalar)&&!(null==a?void 0:a.isEnum))&&0!==(null==i?void 0:i.length)&&(this.expandedPaths.push(this.activePath),this.setSelectionOrder(),s&&s.fetchRelations())},this.collapse=()=>{this.expandedPaths=this.expandedPaths.filter((e=>!e.startsWith(this.activePath))),this.setSelectionOrder()},this.update=e=>{h.exports.has(e,"isEditing")&&(this.isEditing=e.isEditing)},this.reset=()=>{this.isEditing=!1},this.sessionId=e.sessionId,this.isEditing=e.isEditing,this.activePath="",this.expandedPaths=[],c(this)}get session(){return $e.get(this.sessionId)}jumpToParent(){const e=this.activePath.split("::").slice(0,-1).join("::");""!=e&&(this.activePath=e)}setSelectionOrder(){var e,t;if(!(null==(e=this.session)?void 0:e.script))throw U({path:"SessionSelectionTree.setSelectionOrder",message:"Unable to resolve recordIds",context:{sessionId:this.sessionId,scriptId:null==(t=this.session)?void 0:t.scriptId}});const{recordIds:s}=this.session.script;let i=s.map(((e,t)=>`[${t}]`));this.expandedPaths.forEach((e=>{const{value:t,model:a}=Re(e,s),n=i.findIndex((t=>t===e)),r=[];if(r.push(i[n]),Array.isArray(t))if(t.length<=100)r.push(...Array.from({length:t.length}).map(((t,s)=>`${e}::[${s}]`)));else{const s=Math.floor(t.length/100);r.push(...Array.from({length:s}).map(((t,s)=>`${e}::[${100*s}-${100*(s+1)-1}]`))),t.length%100!=0&&r.push(`${e}::[${100*s}-${100*s+t.length%100-1}]`)}else null!==t&&a&&r.push(...a.fields.map((t=>`${e}::${t.name}`)));i=[...i.slice(0,n),...r,...i.slice(n+1)]})),this.selectionOrder=i}}ke([p],De.prototype,"sessionId",2),ke([p],De.prototype,"isEditing",2),ke([p],De.prototype,"activePath",2),ke([p],De.prototype,"expandedPaths",2),ke([p],De.prototype,"selectionOrder",2),ke([f],De.prototype,"session",1),ke([u],De.prototype,"select",2),ke([u],De.prototype,"move",2),ke([u],De.prototype,"expand",2),ke([u],De.prototype,"collapse",2),ke([u],De.prototype,"jumpToParent",1),ke([u],De.prototype,"setSelectionOrder",1),ke([u],De.prototype,"update",2),ke([u],De.prototype,"reset",2);var Ae=Object.defineProperty,Te=Object.getOwnPropertyDescriptor,Pe=(e,t,s,i)=>{for(var a,n=i>1?void 0:i?Te(t,s):t,r=e.length-1;r>=0;r--)(a=e[r])&&(n=(i?a(t,s,n):a(n))||n);return i&&n&&Ae(t,s,n),n};class Ve{constructor(e){this.table=new Le(e.table),this.tree=new De(e.tree),c(this)}}Pe([p],Ve.prototype,"table",2),Pe([p],Ve.prototype,"tree",2);var je=Object.defineProperty,Fe=Object.getOwnPropertyDescriptor,Be=(e,t,s,i)=>{for(var a,n=i>1?void 0:i?Fe(t,s):t,r=e.length-1;r>=0;r--)(a=e[r])&&(n=(i?a(t,s,n):a(n))||n);return i&&n&&je(t,s,n),n};class He extends ie{constructor(e){var t,s;super(e),this.createUncommittedRecord=()=>{if(!this.isScript)return;const e=Os.add({type:"create",recordId:null,sessionId:this.id,value:{modelId:this.script.modelId}});Os.add({type:"update",recordId:e.recordId,sessionId:this.id,value:this.script.model.fields.reduce(((e,t)=>(t.isId?e[t.name]=void 0:void 0!==t.default?t.isFunctionDefault?e[t.name]=void 0:e[t.name]=t.default:t.isUpdatedAt?e[t.name]=(new Date).toISOString():!t.isScalar&&!t.isEnum||t.isPartOfRelation?t.isRelation&&t.isList?e[t.name]=t.lowestValidValue:e[t.name]=void 0:e[t.name]=t.lowestValidValue,e)),{})})},this.update=(e,t={})=>{h.exports.has(e,"lastSavedHash")&&(this.lastSavedHash=e.lastSavedHash),super.update(e,t)},this.serialize=()=>({projectId:es.activeProjectId,id:this.id,type:this.type,lastSavedHash:this.lastSavedHash,scriptId:this.scriptId}),this.id=e.id,this.type=e.type,this.scriptId=null!=(t=e.scriptId)?t:null,this.lastSavedHash=null!=(s=e.lastSavedHash)?s:this.hash,c(this),this.selection=new Ve({table:{sessionId:this.id,selectedRecordIds:[]},tree:{sessionId:this.id,isEditing:!1}})}get script(){if(!this.isScript)throw U({path:"Session.script",message:"Invalid `get` call to script: Session is not a `script` type",context:{type:this.type,scriptId:this.scriptId}});const e=Mt.get(this.scriptId);if(!e)throw U({path:"Session.script",message:"Invalid scriptId in session",context:{type:this.type,scriptId:this.scriptId}});return e}get name(){return this.isScript?this.script.model.name:"Session Name"}get isScript(){return"script"===this.type}get isModelList(){return"model-list"===this.type}get isDirty(){return this.isScript?!this.script.frozen&&(null===this.script.name||(!!Object.values(Os.values).filter((e=>e.sessionId===this.id))||null!==this.script.name&&this.lastSavedHash!==this.hash)):this.lastSavedHash!==this.hash}get hash(){return this.isScript?this.script.hash:""}forceSave(){this.isDirty&&this.update({lastSavedHash:this.hash})}discardChanges(){if(this.isScript)try{const{code:e,modelId:t,where:s,fieldIds:i,sortFieldId:a,sortOrder:n}=JSON.parse(this.lastSavedHash);this.script.update({code:e,modelId:t,where:s,fieldIds:i,sort:{fieldId:a,order:n}})}catch(e){console.log("Could not restore session",e)}}}Be([C],He.prototype,"id",2),Be([p],He.prototype,"scriptId",2),Be([p],He.prototype,"lastSavedHash",2),Be([f],He.prototype,"script",1),Be([f],He.prototype,"name",1),Be([f],He.prototype,"isScript",1),Be([f],He.prototype,"isModelList",1),Be([f],He.prototype,"isDirty",1),Be([f],He.prototype,"hash",1),Be([u],He.prototype,"createUncommittedRecord",2),Be([u],He.prototype,"forceSave",1),Be([u],He.prototype,"discardChanges",1),Be([C],He.prototype,"update",2);var qe=Object.defineProperty,Ze=Object.getOwnPropertyDescriptor,Ue=(e,t,s,i)=>{for(var a,n=i>1?void 0:i?Ze(t,s):t,r=e.length-1;r>=0;r--)(a=e[r])&&(n=(i?a(t,s,n):a(n))||n);return i&&n&&qe(t,s,n),n};class ze extends X{constructor(){super(He,{idbTableName:"sessions"}),this.findOrCreate=({scriptId:e})=>Object.values(this.values).find((t=>t.scriptId===e))||this.add({type:"script",scriptId:e,lastSavedHash:null}),this.remove=e=>{const t=super.remove(e);return Object.values(Os.values).forEach((t=>{t.sessionId===e&&Os.remove(t.id)})),t},c(this)}}Ue([u],ze.prototype,"findOrCreate",2),Ue([C],ze.prototype,"remove",2);var $e=new ze;const Je=(e,t)=>e.isList?Array.isArray(t)?t.every((t=>e.isEnum?!We(e,t):e.isRelation?!Ke(e,t):!Ge(e,t)))?void 0:"Every value in this list must be valid":"Value must be a list":e.isEnum?We(e,t):e.isRelation?Ke(e,t):Ge(e,t),We=(e,t)=>{if(!e.isRequired&&h.exports.isNil(t))return;if(void 0===t&&void 0!==e.default)return;const s=e.typeAsEnum;return s&&s.values.includes(t)?void 0:"Value must be an Enum variant"},Ke=(e,t)=>{if(!e.isRequired&&h.exports.isNil(t))return;if(e.isRequired&&!t)return"Required fields must not be `null`";return e.typeAsModel?void 0:`Value must be a ${e.type} identifier`},Ge=(e,t)=>{if((void 0!==t||void 0===e.default)&&(e.isList||e.isRequired||!h.exports.isNil(t)))return e.isRequired&&h.exports.isNil(t)?"Required fields must not be `null`":e.isString&&"string"!=typeof t?"Value must be a String":!e.isInt||"number"==typeof t&&!isNaN(t)&&Number.isInteger(t)?e.isFloat&&("number"!=typeof t||isNaN(t))?"Value must be a Float":e.isBigInt&&"bigint"!=typeof t?"Value must be a valid BigInt":e.isBoolean&&"boolean"!=typeof t?"Value must be a Boolean":e.isDateTime&&isNaN(new Date(String(t)))?"Value must be a valid DateTime":e.isJson&&"object"!=typeof t?"Value must be a valid Json":void 0:"Value must be an Integer"};var Qe=Object.defineProperty,Ye=Object.getOwnPropertyDescriptor,Xe=(e,t,s,i)=>{for(var a,n=i>1?void 0:i?Ye(t,s):t,r=e.length-1;r>=0;r--)(a=e[r])&&(n=(i?a(t,s,n):a(n))||n);return i&&n&&Qe(t,s,n),n};class et extends ie{constructor(e){if(super(e),this.serialize=()=>({projectId:es.activeProjectId,id:this.id,type:this.type,recordId:this.recordId,sessionId:this.sessionId,value:I(this.value)}),this.id=e.id,this.sessionId=e.sessionId,this.type=e.type,this.value=e.value,c(this),"create"===this.type){const t=`tmp--${this.id}`,s=e.value.modelId;dt.add({id:t,modelId:s,value:{}}),this.recordId=t}else this.recordId=e.recordId}get record(){return this.recordId?dt.get(this.recordId):null}get session(){return $e.get(this.sessionId)}get isValid(){return(e=>{const t=Os.get(e);if(!t)throw U({path:"isActionValid",message:"Invalid action",context:{actionId:e}});const s=dt.get(t.recordId);if(!s)return!1;const i=s.model;if(!i)return!1;const a=Object.keys(t.value);switch(t.type){case"create":return!!ds.get(t.value.modelId);case"delete":return!!dt.get(t.recordId);case"update":return a.every((e=>{const s=i.getFieldByName(e),a=t.value[e];return!!s&&!Je(s,a)}));default:return!1}})(this.id)}update(e,t={}){h.exports.has(e,"recordId")&&(this.recordId=e.recordId),h.exports.has(e,"sessionId")&&(this.sessionId=e.sessionId),h.exports.has(e,"value")&&(this.value=e.value),super.update(e,t)}}Xe([C],et.prototype,"id",2),Xe([p],et.prototype,"recordId",2),Xe([p],et.prototype,"sessionId",2),Xe([p],et.prototype,"type",2),Xe([p],et.prototype,"value",2),Xe([f],et.prototype,"record",1),Xe([f],et.prototype,"session",1),Xe([f],et.prototype,"isValid",1),Xe([C],et.prototype,"update",1);const tt=async e=>{var t,s;console.log("Running query: ",e);let{error:i,data:a}=await window.transport.request({channel:"prisma",action:"clientRequest",payload:{data:l({schemaHash:es.activeProject.schemaHash},e)}});if(i)throw U({path:"runQuery",code:i.code,type:i.type,stack:i.stack,message:`Error in Prisma Client request: \n\n${i.message}`,context:{code:e,error:i}});if(!a)throw U({path:"runQuery",message:`Malformed response from Prisma Client: \n\n${a}`,context:{code:e}});const n=ds.get(e.modelName);if(!n)throw U({path:"runQuery",message:"Unrecognized Model",context:{code:e,response:a}});const r=Object.entries((null==(t=e.args)?void 0:t.select)||(null==(s=e.args)?void 0:s.include)||{}).filter((([e,t])=>!!t)).map((([e])=>{var t;return null==(t=fe.getByName(n.id,e))?void 0:t.id})).filter((e=>!!e));if(!a)return Promise.resolve({modelId:n.id,fieldIds:r,recordIds:[]});Array.isArray(a)||(a=[a]);const o=a.map((e=>dt.add({modelId:n.id,value:e}).id));return{modelId:n.id,fieldIds:r,recordIds:o}};var st=Object.defineProperty,it=Object.getOwnPropertyDescriptor,at=(e,t,s,i)=>{for(var a,n=i>1?void 0:i?it(t,s):t,r=e.length-1;r>=0;r--)(a=e[r])&&(n=(i?a(t,s,n):a(n))||n);return i&&n&&st(t,s,n),n};class nt extends ie{constructor(e){super(e),this.fetchRelations=async()=>{try{if(!this.isCommitted)return;await tt((e=>{const t=dt.get(e);if(!t)throw U({path:"getFindOneQuery",message:"Invalid recordId",context:{recordId:e}});const s=t.model,i=s.uniqueIdentifier,a=i.name,n=i.fields.reduce(((e,s)=>(e[s.name]=t.value[s.name],e)),{});let r;return r=1===i.fields.length?n:{[`${a}`]:n},{modelName:s.name,operation:"findUnique",args:{where:r,select:s.fields.reduce(((e,t)=>(e[t.name]=!0,e)),{})}}})(this.id))}catch(e){ys.update({type:"client",description:"Unable to fetch record",dump:e.message}),Ee.updateError({visible:!0})}},this.id=e.id,this.valueInDB=e.value||{},this.modelId=e.modelId,c(this)}get model(){let e=ds.get(this.modelId);if(!e)throw U({path:"Record.model",message:"Invalid modelId",context:{modelId:this.modelId}});return e}get value(){const e=Os.actions.filter((e=>e.recordId===this.id&&"update"===e.type));if(0==e.length)return this.valueInDB;const t=e[0];return this.model.fields.reduce(((e,s)=>void 0===t.value[s.name]?(e[s.name]=this.valueInDB[s.name],e):(e[s.name]=t.value[s.name],e)),{})}get isCommitted(){return!this.id.startsWith("tmp-")}get dirtyFieldNames(){if(!this.isCommitted)return this.model.fields.map((e=>e.name));const e=Os.actions.filter((e=>{var t;return e.sessionId===(null==(t=Bt.activeTab)?void 0:t.sessionId)&&e.recordId===this.id})).reduce(((e,t)=>(Object.keys(t.value).forEach((t=>{e.add(t)})),e)),new Set);return Array.from(e)}get invalidFields(){return Object.keys(this.value).map((e=>{const t=this.model.getFieldByName(e);if(!t)return;const s=Je(t,this.value[e]);return s?{field:t,reason:s}:void 0})).filter((e=>!!e))}update(e,t={}){h.exports.has(e,"value")&&(this.valueInDB=l(l({},this.valueInDB),e.value)),super.update(e,t)}}at([C],nt.prototype,"id",2),at([p],nt.prototype,"modelId",2),at([p],nt.prototype,"valueInDB",2),at([f],nt.prototype,"model",1),at([f],nt.prototype,"value",1),at([f],nt.prototype,"isCommitted",1),at([f],nt.prototype,"dirtyFieldNames",1),at([f],nt.prototype,"invalidFields",1),at([C],nt.prototype,"update",1),at([u],nt.prototype,"fetchRelations",2);var rt=Object.defineProperty,lt=Object.getOwnPropertyDescriptor;class ot extends X{constructor(){super(nt),c(this)}add(e,t={}){var s;const i=null!=(s=e.id)?s:_e(e.modelId,e.value);if(!i)throw U({path:"RecordStore.add",message:"Unable to determine ID for record to create",context:{record:e}});const a=super.add(l({id:i},e));return Object.keys(e.value).forEach((s=>{var i;const n=a.model.getFieldByName(s);if(!n)throw U({path:"RecordStore.add",message:"Invalid field name",context:{fieldName:s,recordValue:e.value}});if(!n.isRelation)return;const r=null==(i=n.typeAsModel)?void 0:i.id;if(!r)throw U({path:"RecordStore.add",message:"Unable to create related records",context:{fieldId:n.id,type:n.type}});if(n.isList)e.value[s].map((e=>{const s=_e(r,e);!this.get(s)&&e&&this.add({modelId:r,value:e},t)}));else if(null!==e.value[s]){const i=_e(r,e.value[s]);!this.get(i)&&e.value[s]&&this.add({modelId:r,value:e.value[s]},t)}})),a}}((e,t,s,i)=>{for(var a,n=i>1?void 0:i?lt(t,s):t,r=e.length-1;r>=0;r--)(a=e[r])&&(n=(i?a(t,s,n):a(n))||n);i&&n&&rt(t,s,n)})([C],ot.prototype,"add",1);var dt=new ot;const ct=e=>Array.from(new Set(e)),ht=({modelId:e,where:t,fieldIds:s,sort:i,pagination:a})=>{const n=ds.get(e);if(!n)throw U({path:"getFindManyQuery",message:"Invalid modelId",context:{modelId:e}});const r={};if(t&&(null==t?void 0:t.size)>0&&(r.where={AND:Object.values(t.values).reduce(((e,t)=>{var s,i,a,n,r,l,o,d,c;if(!t.enabled||!t.isValid)return e;if(!h.exports.first(t.fields)||!h.exports.last(t.fields))return e;"in"===t.operation||"notIn"===t.operation?t.value=JSON.parse(t.value||"[]"):!(null==(s=h.exports.last(t.fields))?void 0:s.isInt)&&!(null==(i=h.exports.last(t.fields))?void 0:i.isFloat)||(null==(a=h.exports.last(t.fields))?void 0:a.isList)?(null==(n=h.exports.last(t.fields))?void 0:n.isBoolean)&&!(null==(r=h.exports.last(t.fields))?void 0:r.isList)?t.value=Boolean("false"!==t.value&&t.value):(null==(l=h.exports.last(t.fields))?void 0:l.isDateTime)&&!(null==(o=h.exports.last(t.fields))?void 0:o.isList)?t.value=new Date(t.value).toISOString():(null==(d=h.exports.last(t.fields))?void 0:d.isBigInt)&&!(null==(c=h.exports.last(t.fields))?void 0:c.isList)&&(t.value=BigInt(t.value)):t.value=Number(t.value);let p={[`${t.operation}`]:t.value};return"isNull"===t.operation?p={equals:null}:"isNotNull"===t.operation&&(p={not:{equals:null}}),h.exports.last(t.fields).isList&&(p={some:p}),t.fields.length>1&&(p={[`${h.exports.last(t.fields).name}`]:p}),h.exports.first(t.fields).isList&&(p={some:p}),e.push({[h.exports.first(t.fields).name]:p}),e}),[])}),(null==i?void 0:i.fieldId)&&(null==i?void 0:i.order)){const e=fe.get(i.fieldId);if(!e)throw U({path:"getFindManyQuery",message:"Invalid sort fieldId",context:{sort:i}});r.orderBy=[{[`${e.name}`]:i.order}]}void 0!==(null==a?void 0:a.take)&&null!==a.take&&(r.take=Number(a.take)),void 0!==(null==a?void 0:a.skip)&&null!==a.skip&&(r.skip=Number(a.skip)),s=s?ct([].concat(n.uniqueIdentifier.fields.map((e=>e.id)),s)):n.fieldIds;const l=((e,t)=>t.slice().sort(((t,s)=>e.fieldIds.findIndex((e=>e===t))-e.fieldIds.findIndex((e=>e===s)))))(n,s).map((e=>fe.get(e)));return r.select=l.reduce(((e,t)=>{if(!t)return e;if(t.isList&&t.isRelation){const s=t.getRelationIDFieldName;e[t.name]=!s||{select:{[s]:!0}}}else e[t.name]=!0;return e}),{}),{modelName:n.name,operation:"findMany",args:r}};var pt=Object.defineProperty,ut=Object.getOwnPropertyDescriptor,mt=(e,t,s,i)=>{for(var a,n=i>1?void 0:i?ut(t,s):t,r=e.length-1;r>=0;r--)(a=e[r])&&(n=(i?a(t,s,n):a(n))||n);return i&&n&&pt(t,s,n),n};class gt{constructor(e){this.take=e.take,this.skip=e.skip,c(this)}update(e={}){h.exports.has(e,"take")&&(this.take=e.take),h.exports.has(e,"skip")&&(this.skip=e.skip)}reset(){this.update({take:100,skip:0})}}mt([p],gt.prototype,"take",2),mt([p],gt.prototype,"skip",2),mt([u],gt.prototype,"update",1),mt([u],gt.prototype,"reset",1);var vt=Object.defineProperty,ft=Object.getOwnPropertyDescriptor,yt=(e,t,s,i)=>{for(var a,n=i>1?void 0:i?ft(t,s):t,r=e.length-1;r>=0;r--)(a=e[r])&&(n=(i?a(t,s,n):a(n))||n);return i&&n&&vt(t,s,n),n};class It{constructor(e){this.fieldId=e.fieldId,this.order=e.order,c(this)}get field(){return fe.get(this.fieldId)}update(e={}){h.exports.has(e,"fieldId")&&(this.fieldId=e.fieldId),h.exports.has(e,"order")&&(this.order=e.order)}reset(){this.update({fieldId:null,order:"asc"})}}yt([p],It.prototype,"fieldId",2),yt([p],It.prototype,"order",2),yt([f],It.prototype,"field",1),yt([u],It.prototype,"update",1),yt([u],It.prototype,"reset",1);const Ct=(e,t)=>{if(!e.isScalar)return!1;if(e.isString)return"string"==typeof t;if(e.isInt||e.isFloat||e.isDecimal)return""!==t&&!isNaN(Number(t));if(e.isBigInt)try{return""!==t&&!!BigInt(t)}catch(s){return!1}if(e.isBoolean)return"true"===t||"false"===t;if(e.isDateTime)return!isNaN(new Date(t));if(e.isJson)try{return!!JSON.parse(t)}catch(s){return!1}return!!e.isBytes&&"string"==typeof t},wt=(e,t)=>!!e.isEnum&&e.typeAsEnum.values.includes(t);var bt=Object.defineProperty,Et=Object.getOwnPropertyDescriptor,_t=(e,t,s,i)=>{for(var a,n=i>1?void 0:i?Et(t,s):t,r=e.length-1;r>=0;r--)(a=e[r])&&(n=(i?a(t,s,n):a(n))||n);return i&&n&&bt(t,s,n),n};class xt extends ie{constructor(e){super(e),this.update=(e,t)=>{h.exports.has(e,"fieldIds")&&(this.fieldIds=e.fieldIds),h.exports.has(e,"operation")&&(this.operation=e.operation),h.exports.has(e,"value")&&(this.value=e.value),h.exports.has(e,"enabled")&&(this.enabled=e.enabled),this.script.update({where:[]}),super.update(e,t)},this.serialize=()=>({id:String(this.id),fieldIds:[...this.fieldIds],operation:String(this.operation),value:this.value,scriptId:String(this.scriptId),enabled:this.enabled}),this.id=e.id,this.fieldIds=e.fieldIds,this.operation=e.operation||this.supportedOperations[0],this.value=e.value,this.scriptId=e.scriptId,this.enabled=e.enabled||!0,c(this)}get fields(){return this.fieldIds.map((e=>{const t=fe.get(e);if(!t)throw U({path:"ScriptWhereItem.fields",message:"Invalid fieldId",context:{fieldId:e}});return t}))}get script(){const e=Mt.get(this.scriptId);if(!e)throw U({path:"ScriptWhereItem.script",message:"Invalid scriptId",context:{scriptId:this.scriptId}});return e}get supportedOperations(){const e=h.exports.last(this.fields);if(!e)return[];let t;if(e.isRequired&&e.isString)t="StringFilter";else if(!e.isRequired&&e.isString)t="StringNullableFilter";else if(e.isRequired&&e.isInt)t="IntFilter";else if(!e.isRequired&&e.isInt)t="IntNullableFilter";else if(e.isRequired&&e.isFloat)t="FloatFilter";else if(!e.isRequired&&e.isFloat)t="FloatNullableFilter";else if(e.isRequired&&e.isBigInt)t="BigIntFilter";else if(!e.isRequired&&e.isBigInt)t="BigIntNullableFilter";else if(e.isRequired&&e.isDecimal)t="DecimalFilter";else if(!e.isRequired&&e.isDecimal)t="DecimalNullableFilter";else if(e.isRequired&&e.isBoolean)t="BoolFilter";else if(!e.isRequired&&e.isBoolean)t="BoolNullableFilter";else if(e.isRequired&&e.isDateTime)t="DateTimeFilter";else if(!e.isRequired&&e.isDateTime)t="DateTimeNullableFilter";else if(e.isRequired&&e.isJson)t="JsonFilter";else if(!e.isRequired&&e.isJson)t="JsonNullableFilter";else if(e.isRequired&&e.isBytes)t="BytesFilter";else if(!e.isRequired&&e.isBytes)t="BytesNullableFilter";else if(e.isRequired&&e.isEnum)t=`Enum${e.type}Filter`;else if(!e.isRequired&&e.isEnum)t=`Enum${e.type}NullableFilter`;else{if(!e.isRelation)throw U({path:"ScriptWhere.supportedOperations",message:"Unsupported field for `where` filter",context:{fields:this.fields.map((e=>null==e?void 0:e.serialize()))}});t=`${e.type}WhereInput`}const s=Ms.inputObjectTypes.get(t);if(!s)throw U({path:"ScriptWhere.supportedOperations",message:"Could not find appropriate InputType for this field type. This should never happen.",context:{inputTypeName:t,fields:this.fields.map((e=>null==e?void 0:e.serialize()))}});const i=s.fields.map((e=>e.name)).filter((e=>"mode"!==e));return e.isRequired||e.isRelation?i:i.concat(["isNull","isNotNull"])}get isValid(){return(e=>{var t,s,i,a,n,r;if(!e.enabled)return!0;if(!h.exports.last(e.fields))return!1;if(!e.operation)return!1;if(!(null==(t=h.exports.last(e.fields))?void 0:t.isScalar)&&!(null==(s=h.exports.last(e.fields))?void 0:s.isEnum))return!1;if(e.fields.length>1&&!(null==(i=h.exports.first(e.fields))?void 0:i.isRelation))return!1;if(["isNull","isNotNull"].includes(e.operation)&&(void 0===e.value||null===e.value))return!0;if((null==(a=h.exports.last(e.fields))?void 0:a.isRequired)&&(void 0===e.value||null===e.value))return!1;if(void 0===e.value||null===e.value)return!1;if(["in","notIn"].includes(e.operation))try{const t=JSON.parse(e.value);return Array.isArray(t)&&t.every((t=>{var s,i;return(null==(s=h.exports.last(e.fields))?void 0:s.isScalar)?Ct(h.exports.last(e.fields),t):!!(null==(i=h.exports.last(e.fields))?void 0:i.isEnum)&&wt(h.exports.last(e.fields),t)}))}catch(l){return!1}return!!e.supportedOperations.includes(e.operation)&&((null==(n=h.exports.last(e.fields))?void 0:n.isScalar)?Ct(h.exports.last(e.fields),e.value):!(null==(r=h.exports.last(e.fields))?void 0:r.isEnum)||wt(h.exports.last(e.fields),e.value))})(this)}getFilterableFieldsAtIndex(e){if(e>=this.fieldIds.length)throw U({path:"ScriptWhere.getFilterableFieldsAtIndex",message:"Index is out of range",context:{fieldIds:this.fieldIds,index:e}});if(0===e)return this.script.model.fields.filter((e=>e.isScalar&&!e.isList||e.isEnum&&!e.isList||e.isRelation));if(1===e){return fe.get(this.fieldIds[e-1]).typeAsModel.fields.filter((e=>e.isScalar&&!e.isList||e.isEnum&&!e.isList))}return[]}}_t([C],xt.prototype,"id",2),_t([p],xt.prototype,"fieldIds",2),_t([p],xt.prototype,"operation",2),_t([p],xt.prototype,"value",2),_t([p],xt.prototype,"scriptId",2),_t([p],xt.prototype,"enabled",2),_t([f],xt.prototype,"fields",1),_t([f],xt.prototype,"script",1),_t([f],xt.prototype,"supportedOperations",1),_t([f],xt.prototype,"isValid",1),_t([C],xt.prototype,"update",2);class St extends X{constructor({modelId:e,scriptId:t}){super(xt),this.serialize=()=>Object.values(this.values).map((e=>e.serialize())),this.modelId=e,this.scriptId=t,c(this)}get model(){let e=ds.get(this.modelId);if(!e)throw U({path:"ScriptWhere.model",message:"Invalid modelId",context:{modelId:this.modelId}});return e}get script(){return Mt.get(this.scriptId)}add(e,t){var s;const i=super.add(o(l({},e),{scriptId:this.scriptId}),t);return null==(s=this.script)||s.update({where:[]},t),i}}_t([p],St.prototype,"modelId",2),_t([p],St.prototype,"scriptId",2),_t([f],St.prototype,"model",1),_t([f],St.prototype,"script",1),_t([C],St.prototype,"add",1);var Nt=Object.defineProperty,Lt=Object.getOwnPropertyDescriptor,Rt=(e,t,s,i)=>{for(var a,n=i>1?void 0:i?Lt(t,s):t,r=e.length-1;r>=0;r--)(a=e[r])&&(n=(i?a(t,s,n):a(n))||n);return i&&n&&Nt(t,s,n),n};class Ot extends ie{constructor(e){var t,s,i,a,n,r,l,o;super(e),this.run=async()=>{if(!this.model)throw U({path:"Script.run",message:"Invalid modelId",context:{modelId:this.modelId}});this.update({running:!0}),Ee.updateError({visible:!1});const e=this.frozen||"visual"===this.inputMode?ht({modelId:this.modelId,where:this.where,sort:this.sort,pagination:this.pagination}):this.code;try{const[,{recordIds:t,modelId:s,fieldIds:i}]=await Promise.all([this.model.runCountQuery(),tt(e)]);this.update({recordIds:t}),"visual"===this.inputMode&&this.update({code:e}),"code"===this.inputMode&&this.update({modelId:s,fieldIds:i}),Ee.previousError.type&&Ee.setPreviousError({type:null})}catch(t){"PrismaClientSchemaDriftedError"===t.type?ys.update({type:"schemaDrift",description:"Your source Prisma Schema has changed. Please reload Studio to continue. Your changes will be saved.",dump:""}):ys.update({type:"client",description:"Unable to run script",dump:`Message: ${t.message}\n \nQuery:\n${JSON.stringify({modelName:e.modelName,operation:e.operation,args:e.args},null,2)}\n `}),Ee.updateError({visible:!0})}finally{this.update({running:!1})}},this.loadMore=async()=>{if(this.__recordIds.length>=(this.model.count||0)||"code"===this.inputMode)return[];this.update({running:!0});const e=ht({modelId:this.modelId,where:this.where,sort:this.sort,pagination:{take:100,skip:this.pagination.skip+this.__recordIds.length}});try{const{recordIds:t}=await tt(e),s=ct([...this.__recordIds,...t]);return this.update({running:!1,recordIds:s,pagination:{take:s.length}}),t.map((e=>dt.get(e))).filter((e=>!!e))}catch(t){throw this.update({running:!1}),console.log(t.type),"PrismaClientSchemaDriftedError"===t.type?ys.update({type:"schemaDrift",description:"Your source Prisma Schema has changed. Please reload Studio to continue. Your changes will be saved.",dump:""}):ys.update({type:"client",description:"Unable to fetch paginated records",dump:`Message: ${t.message}\n \nStack: ${t.stack}\n \nQuery:\n${JSON.stringify(e,null,2)}\n `}),Ee.updateError({visible:!0}),U({path:"Script.loadMore",message:"Unable to fetch next page of records",context:{take:this.pagination.take,skip:this.pagination.skip,lastFetchedRecordId:h.exports.last(this.__recordIds)},nativeError:t})}},this.update=(e,t={})=>{h.exports.has(e,"name")&&(this.name=e.name),h.exports.has(e,"frozen")&&(this.frozen=e.frozen),h.exports.has(e,"modelId")&&(this.modelId=e.modelId),h.exports.has(e,"fieldIds")&&(this.fieldIds=e.fieldIds),h.exports.has(e,"inputMode")&&(this.inputMode=e.inputMode),h.exports.has(e,"viewMode")&&(this.viewMode=e.viewMode),h.exports.has(e,"sort")&&this.sort.update(e.sort),h.exports.has(e,"pagination")&&this.pagination.update(e.pagination),h.exports.has(e,"code")&&(this.code="string"==typeof e.code?JSON.parse(e.code):e.code),h.exports.has(e,"recordIds")&&(this.__recordIds=e.recordIds.filter((e=>{var t;return(null==(t=dt.get(e))?void 0:t.modelId)===this.modelId}))),h.exports.has(e,"running")&&(this.running=e.running),super.update(e,t)},this.serialize=()=>({projectId:es.activeProjectId,id:this.id,frozen:this.frozen,name:this.name,inputMode:this.inputMode,code:JSON.stringify(this.code),modelId:this.modelId,where:this.where.serialize(),fieldIds:this.fieldIds.map((e=>String(e))),sortFieldId:this.sort.fieldId,sortOrder:this.sort.order,viewMode:this.viewMode}),this.id=e.id,this.frozen=e.frozen,this.name=e.name,this.modelId=e.modelId,this.fieldIds=e.fieldIds||[],this.inputMode="visual",this.where=new St({modelId:e.modelId,scriptId:this.id}),(e.where||[]).forEach((e=>this.where.add(e))),this.sort=new It({fieldId:null!=(s=null==(t=e.sort)?void 0:t.fieldId)?s:null,order:null!=(a=null==(i=e.sort)?void 0:i.order)?a:"asc"}),this.pagination=new gt({take:null!=(r=null==(n=e.pagination)?void 0:n.take)?r:100,skip:null!=(o=null==(l=e.pagination)?void 0:l.skip)?o:0}),this.viewMode="table",this.code=("string"==typeof e.code?JSON.parse(e.code):e.code)||ht({modelId:this.modelId,where:this.where,sort:this.sort,pagination:this.pagination}),this.__recordIds=[],this.running=!1,c(this)}get hash(){return(({code:e,modelId:t,where:s,fieldIds:i})=>JSON.stringify({code:e,modelId:t,where:s.serialize(),fieldIds:i}))({code:this.code,modelId:this.modelId,where:this.where,fieldIds:this.fieldIds})}get model(){let e=ds.get(this.modelId);if(!e)throw U({path:"Script.model",message:"Invalid modelId",context:{modelId:this.modelId}});return e}get fields(){return this.fieldIds.map((e=>{const t=fe.get(e);if(!t)throw U({path:"Script.fields",message:"Invalid fieldId",context:{fieldId:e}});return t}))}get recordIds(){const e=Os.actions.filter((e=>{var t,s;return"create"===e.type&&e.sessionId===(null==(t=Bt.activeTab)?void 0:t.sessionId)&&(null==(s=e.record)?void 0:s.modelId)===this.modelId})).map((e=>e.recordId)).filter((e=>!!e)),t=Os.actions.filter((e=>{var t;return"delete"===e.type&&e.sessionId===(null==(t=Bt.activeTab)?void 0:t.sessionId)})).map((e=>e.recordId));return[...e,...this.__recordIds.filter((e=>!t.includes(e)))]}get records(){return this.recordIds.map((e=>dt.get(e))).filter((e=>!!e))}get uncommittedRecords(){return Os.actions.filter((e=>{var t;return"create"===e.type&&(null==(t=e.record)?void 0:t.modelId)===this.modelId})).map((e=>e.record)).filter((e=>!!e))}reset(){this.update({recordIds:[],inputMode:"visual",viewMode:"table",running:!1}),this.sort.reset(),this.pagination.reset()}}Rt([C],Ot.prototype,"id",2),Rt([p],Ot.prototype,"frozen",2),Rt([p],Ot.prototype,"name",2),Rt([p],Ot.prototype,"modelId",2),Rt([p],Ot.prototype,"fieldIds",2),Rt([p],Ot.prototype,"inputMode",2),Rt([p],Ot.prototype,"where",2),Rt([p],Ot.prototype,"sort",2),Rt([p],Ot.prototype,"pagination",2),Rt([p],Ot.prototype,"viewMode",2),Rt([p],Ot.prototype,"code",2),Rt([p],Ot.prototype,"running",2),Rt([p],Ot.prototype,"__recordIds",2),Rt([f],Ot.prototype,"hash",1),Rt([f],Ot.prototype,"model",1),Rt([f],Ot.prototype,"fields",1),Rt([f],Ot.prototype,"recordIds",1),Rt([f],Ot.prototype,"records",1),Rt([f],Ot.prototype,"uncommittedRecords",1),Rt([u],Ot.prototype,"run",2),Rt([u],Ot.prototype,"loadMore",2),Rt([C],Ot.prototype,"update",2),Rt([u],Ot.prototype,"reset",1);var Mt=new class extends X{constructor(){super(Ot,{idbTableName:"scripts"})}},kt=Object.defineProperty,Dt=Object.getOwnPropertyDescriptor,At=(e,t,s,i)=>{for(var a,n=i>1?void 0:i?Dt(t,s):t,r=e.length-1;r>=0;r--)(a=e[r])&&(n=(i?a(t,s,n):a(n))||n);return i&&n&&kt(t,s,n),n};class Tt extends ie{constructor(e){super(e),this.save=()=>{this.session&&(this.session.forceSave(),this.session.isScript&&!this.session.script.name&&this.session.script.update({name:`Copy of ${this.session.script.model.name}`}))},this.discardChanges=()=>{this.session&&this.session.discardChanges()},this.load=({modelId:e,scriptId:t,sessionId:s})=>{if(!s&&!t&&!e)throw U({path:"Tab.load",message:"Invaid params",context:{modelId:e,scriptId:t,sessionId:s}});if(e){const s=ds.get(e);if(!s)throw U({path:"Tab.load",message:"Invalid modelId",context:{modelId:e}});t=Mt.add({frozen:!0,name:null,modelId:e,fieldIds:s.fieldIds}).id}t&&(s=$e.add({type:"script",scriptId:t,lastSavedHash:null}).id),s&&this.update({sessionId:s}),Os.actions.length>0?Ee.updateActions({visible:!0}):Ee.updateActions({visible:!1})},this.update=(e,t={})=>(h.exports.has(e,"sessionId")&&(this.sessionId=e.sessionId),h.exports.has(e,"preview")&&(this.preview=e.preview),super.update(e,t)),this.serialize=()=>({projectId:es.activeProjectId,id:this.id,sessionId:this.sessionId,preview:this.preview}),this.id=e.id,this.sessionId=e.sessionId,this.preview=e.preview||!1,this.isFiltersOpen=!1,c(this),this.preview&&(this.disposer=w((()=>{var e;return!!(null==(e=this.session)?void 0:e.isDirty)}),(()=>{this.update({preview:!1})})))}get title(){var e;return(null==(e=this.session)?void 0:e.isScript)?this.session.script.name||this.session.script.model&&this.session.script.model.name:"+"}get session(){return $e.get(this.sessionId)}get isDirty(){if(!this.session)return!1;if(!this.session.isScript)return!1;const e=this.session.script,t=Object.values(Os.values).filter((e=>e.sessionId===this.sessionId));return e.fieldIds.length!==e.model.fieldIds.length||0!==e.pagination.skip||t.length>0}get hasFilters(){if(!this.session)return!1;if(!this.session.isScript)return!1;return this.session.script.where.size>0}clean(){this.disposer&&this.disposer()}toggleFilterPanel(){this.isFiltersOpen=!this.isFiltersOpen}}At([C],Tt.prototype,"id",2),At([p],Tt.prototype,"sessionId",2),At([p],Tt.prototype,"preview",2),At([p],Tt.prototype,"isFiltersOpen",2),At([f],Tt.prototype,"title",1),At([f],Tt.prototype,"session",1),At([f],Tt.prototype,"isDirty",1),At([f],Tt.prototype,"hasFilters",1),At([u],Tt.prototype,"save",2),At([u],Tt.prototype,"discardChanges",2),At([u],Tt.prototype,"load",2),At([C],Tt.prototype,"update",2),At([u],Tt.prototype,"clean",1),At([u],Tt.prototype,"toggleFilterPanel",1);var Pt=Object.defineProperty,Vt=Object.getOwnPropertyDescriptor,jt=(e,t,s,i)=>{for(var a,n=i>1?void 0:i?Vt(t,s):t,r=e.length-1;r>=0;r--)(a=e[r])&&(n=(i?a(t,s,n):a(n))||n);return i&&n&&Pt(t,s,n),n};class Ft extends X{constructor(){super(Tt,{idbTableName:"tabs"}),this.hydrate=({activeTabId:e})=>{let t=this.get(e);t&&t.session?(Object.values(this.values).forEach((e=>{if(e.session){if(e.session.isScript){if(!ds.get(e.session.script.modelId))return void this.remove(e.id)}}else this.remove(e.id)})),t=this.get(e),t&&t.session?this.switch({id:e}):this.switch({id:"model-list-tab"})):this.switch({id:"model-list-tab"})},this.remove=e=>{var t,s;if(!this.get(e))return this.get("model-list-tab");const i=this.openTabs.findIndex((e=>e.id===this.activeTabId)),a=this.openTabs.findIndex((t=>t.id===e)),n=super.remove(e);if(Object.values(Os.values).filter((e=>e.sessionId===n.sessionId)).forEach((e=>Os.remove(e.id))),i===a){let e=a-1;-1===e&&(e=a),this.switch({id:null!=(s=null==(t=this.openTabs[e])?void 0:t.id)?s:"model-list-tab"})}return n},this.clearAllTabs=()=>{const e=Object.values(this.values).filter((e=>"model-list-tab"!==e.id)).map((e=>e.id));this.switch({id:"model-list-tab"}),e.forEach((e=>{const t=this.get(e);(null==t?void 0:t.session)&&(Object.values(Os.values).filter((e=>e.sessionId===t.sessionId)).forEach((e=>Os.remove(e.id))),super.remove(e))}))},this.activeTabId="model-list-tab",c(this),$e.add({id:"model-list-session",type:"model-list",scriptId:null,lastSavedHash:null},{skipPersist:!0}),super.add({id:"model-list-tab",sessionId:"model-list-session",preview:!1},{skipPersist:!0})}get activeTab(){return this.get(this.activeTabId)}get openTabs(){return Object.values(this.values).reverse().filter((e=>!!e&&!!e.session&&!e.session.isModelList))}get regularTabCount(){return this.openTabs.length}get nonModelListTabs(){return this.openTabs.filter((e=>{var t;return!(null==(t=e.session)?void 0:t.isModelList)}))}get previewTab(){return Object.values(this.values).find((e=>e.preview))||null}add(e,t={}){var s=e,{modelId:i,scriptId:a,sessionId:n}=s,r=d(s,["modelId","scriptId","sessionId"]);let c;if(!n&&!a&&!i)throw U({path:"TabStore.add",message:"Invaid params",context:{modelId:i,scriptId:a,sessionId:n}});if(i){const e=ds.get(i);if(!e)throw U({path:"TabStore.add",message:"Invalid modelId",context:{modelId:i}});a=Mt.add({frozen:!0,name:null,modelId:i,fieldIds:e.fieldIds}).id}return a&&(n=$e.add({type:"script",scriptId:a,lastSavedHash:null}).id),n&&(c=super.add(o(l({},r),{sessionId:n}),t)),c}switch({id:e,index:t,direction:s}){if(!e&&void 0===t&&void 0===s)throw U({path:"TabStore.switch",message:"Invalid params",context:{id:e,index:t,direction:s}});let i;if(e?i=this.get(e):void 0!==t&&(i=this.openTabs[t]),s){const e=this.openTabs.findIndex((e=>e.id===this.activeTabId));-1!==e&&("right"===s?(i=this.openTabs[e+1],e===this.openTabs.length-1&&(i=this.openTabs[0])):"left"===s&&(i=this.openTabs[e-1]))}i||(i=this.get("model-list-tab")),this.activeTabId=i.id,Os.actions.length>0?Ee.updateActions({visible:!0}):Ee.updateActions({visible:!1})}}jt([p],Ft.prototype,"activeTabId",2),jt([f],Ft.prototype,"activeTab",1),jt([f],Ft.prototype,"openTabs",1),jt([f],Ft.prototype,"regularTabCount",1),jt([f],Ft.prototype,"nonModelListTabs",1),jt([f],Ft.prototype,"previewTab",1),jt([u],Ft.prototype,"hydrate",2),jt([C],Ft.prototype,"add",1),jt([u],Ft.prototype,"switch",1),jt([C],Ft.prototype,"remove",2),jt([u],Ft.prototype,"clearAllTabs",2);var Bt=new Ft,Ht=Object.defineProperty,qt=Object.getOwnPropertyDescriptor,Zt=(e,t,s,i)=>{for(var a,n=i>1?void 0:i?qt(t,s):t,r=e.length-1;r>=0;r--)(a=e[r])&&(n=(i?a(t,s,n):a(n))||n);return i&&n&&Ht(t,s,n),n};class Ut{constructor(){const e=window.matchMedia("(prefers-color-scheme: dark)"),t=new URLSearchParams(window.location.search).get("theme"),s=localStorage.getItem("theme");this.theme=t||(s||(e.matches?"dark":"light")),c(this),window.matchMedia("(prefers-color-scheme: dark)").addEventListener("change",(e=>this.apply(e.matches?"dark":"light")))}apply(e){this.theme=e;const t=window.matchMedia("(prefers-color-scheme: dark)");t.matches&&"light"===this.theme||!t.matches&&"dark"===this.theme?localStorage.setItem("theme",this.theme):localStorage.removeItem("theme")}hydrate(e){this.apply(e)}}Zt([p],Ut.prototype,"theme",2),Zt([u],Ut.prototype,"apply",1),Zt([u],Ut.prototype,"hydrate",1);var zt=new Ut,$t=Object.defineProperty,Jt=Object.getOwnPropertyDescriptor,Wt=(e,t,s,i)=>{for(var a,n=i>1?void 0:i?Jt(t,s):t,r=e.length-1;r>=0;r--)(a=e[r])&&(n=(i?a(t,s,n):a(n))||n);return i&&n&&$t(t,s,n),n};class Kt extends ie{constructor(e){super(e),this.update=(e,t)=>{h.exports.has(e,"name")&&(this.name=e.name),h.exports.has(e,"schemaPath")&&(this.schemaPath=e.schemaPath),h.exports.has(e,"schemaHash")&&(this.schemaHash=e.schemaHash),h.exports.has(e,"recentModelIds")&&(this.recentModelIds=e.recentModelIds),super.update(e,t)},this.id=e.id,this.name=e.name,this.schemaPath=e.schemaPath,this.schemaHash=e.schemaHash,this.recentModelIds=e.recentModelIds||[],c(this),b((()=>[Bt.activeTabId,zt.theme]),(()=>{Ws.ready&&K.save("projects",this.serialize())}),{fireImmediately:!0})}get recentModels(){return this.recentModelIds.map((e=>ds.get(e))).filter((e=>!!e))}addRecentModel(e){this.recentModelIds.includes(e)&&(this.recentModelIds=this.recentModelIds.filter((t=>t!==e))),5===this.recentModelIds.length&&this.recentModelIds.pop(),this.recentModelIds.unshift(e)}serialize(){return{id:this.id,activeTabId:String(Bt.activeTabId),recentModelIds:this.recentModelIds.map((e=>String(e)))}}}Wt([C],Kt.prototype,"id",2),Wt([p],Kt.prototype,"name",2),Wt([p],Kt.prototype,"schemaPath",2),Wt([p],Kt.prototype,"schemaHash",2),Wt([p],Kt.prototype,"recentModelIds",2),Wt([f],Kt.prototype,"recentModels",1),Wt([u],Kt.prototype,"addRecentModel",1),Wt([C],Kt.prototype,"update",2);var Gt=Object.defineProperty,Qt=Object.getOwnPropertyDescriptor,Yt=(e,t,s,i)=>{for(var a,n=i>1?void 0:i?Qt(t,s):t,r=e.length-1;r>=0;r--)(a=e[r])&&(n=(i?a(t,s,n):a(n))||n);return i&&n&&Gt(t,s,n),n};class Xt extends X{constructor(){super(Kt,{idbTableName:"projects"}),this.activeProjectId=null,c(this)}get activeProject(){const e=this.activeProjectId;return e?this.get(e):null}switch(e){this.activeProjectId=e}}Yt([p],Xt.prototype,"activeProjectId",2),Yt([f],Xt.prototype,"activeProject",1),Yt([u],Xt.prototype,"switch",1);var es=new Xt;const ts=({modelId:e})=>{const t=ds.get(e);if(!t)throw U({path:"getCountQuery",message:"Invalid modelId",context:{modelId:e}});return{modelName:t.name,operation:"count"}};var ss=Object.defineProperty,is=Object.getOwnPropertyDescriptor,as=(e,t,s,i)=>{for(var a,n=i>1?void 0:i?is(t,s):t,r=e.length-1;r>=0;r--)(a=e[r])&&(n=(i?a(t,s,n):a(n))||n);return i&&n&&ss(t,s,n),n};class ns extends ie{constructor(e){super(e),this.getFieldByName=e=>fe.getByName(e,this.id),this.runCountQuery=async()=>{try{const{error:e,data:t}=await window.transport.request({channel:"prisma",action:"clientRequest",payload:{data:l({schemaHash:es.activeProject.schemaHash},ts({modelId:this.id}))}});if(e||!t)throw e;if(Array.isArray(t))throw new Error(`Malformed response for \`count\` query: ${JSON.stringify(t,null,2)} `);const s=parseInt(t);this.update({count:s})}catch(e){console.log("Count request failed for model:",this.name,e),this.update({count:0})}},this.id=e.id,this.dbName=e.dbName,this.name=e.name,this.plural=e.plural,this.count=void 0,this.fieldIds=e.fieldIds||[],this.compoundId=e.compoundId,this.compoundUnique=e.compoundUnique,c(this)}get fields(){return this.fieldIds.map((e=>{const t=fe.get(e);if(!t)throw U({path:"Model.field",message:"Invalid fieldId",context:{fieldId:e}});return t}))}get uniqueIdentifier(){var e,t;if(this.idField)return{name:this.idField.name,fields:[this.idField]};if(this.compoundId.fieldIds.length>0){const t=this.compoundId.fieldIds.map((e=>{const t=fe.get(e);if(!t)throw U({path:"Model.uniqueIdentifier",message:"Invalid fieldId in compoundId.fieldIds",context:{fieldId:e}});return t}));return{name:null!=(e=this.compoundId.name)?e:t.map((e=>e.name)).join("_"),fields:t}}if(this.compoundUnique.fieldIds.length>0){const e=this.compoundUnique.fieldIds.map((e=>{const t=fe.get(e);if(!t)throw U({path:"Model.uniqueIdentifier",message:"Invalid fieldId in compoundUnique.fieldIds",context:{fieldId:e}});return t}));return{name:null!=(t=this.compoundUnique.name)?t:e.map((e=>e.name)).join("_"),fields:e}}const s=this.uniqueFields&&this.uniqueFields[0];if(s)return{name:s.name,fields:[s]};throw U({path:"ModelStore.uniqueIdentifiers",message:"Unable to resolve unique identifiers for model",context:{modelId:this.id}})}get idField(){return this.fields.find((e=>e.isId))||null}get hasScalarListRelation(){return this.fields.some((e=>e.isScalarListRelation))||!1}get hasScalarListTwoWayMNRelation(){return this.fields.some((e=>e.isScalarListTwoWayMNRelation))||!1}get uniqueFields(){return this.fields.filter((e=>e.isUnique))}update(e,t={}){h.exports.has(e,"name")&&(this.name=e.name),h.exports.has(e,"plural")&&(this.plural=e.plural),h.exports.has(e,"count")&&(this.count=e.count),h.exports.has(e,"fieldIds")&&(this.fieldIds=e.fieldIds),h.exports.has(e,"compoundId")&&(this.compoundId=e.compoundId),h.exports.has(e,"compoundUnique")&&(this.compoundUnique=e.compoundUnique),super.update(e,t)}}as([C],ns.prototype,"id",2),as([p],ns.prototype,"dbName",2),as([p],ns.prototype,"name",2),as([p],ns.prototype,"plural",2),as([p],ns.prototype,"count",2),as([p],ns.prototype,"fieldIds",2),as([p],ns.prototype,"compoundId",2),as([p],ns.prototype,"compoundUnique",2),as([f],ns.prototype,"fields",1),as([f],ns.prototype,"uniqueIdentifier",1),as([f],ns.prototype,"idField",1),as([f],ns.prototype,"hasScalarListRelation",1),as([f],ns.prototype,"hasScalarListTwoWayMNRelation",1),as([f],ns.prototype,"uniqueFields",1),as([u],ns.prototype,"runCountQuery",2),as([C],ns.prototype,"update",1);var rs=Object.defineProperty,ls=Object.getOwnPropertyDescriptor;class os extends X{constructor(){super(ns),c(this)}add(e,t={}){const s=e.name;return super.add(o(l({},e),{id:s}),t)}getByName(e){return this.get(e)}}((e,t,s,i)=>{for(var a,n=i>1?void 0:i?ls(t,s):t,r=e.length-1;r>=0;r--)(a=e[r])&&(n=(i?a(t,s,n):a(n))||n);i&&n&&rs(t,s,n)})([C],os.prototype,"add",1);var ds=new os,cs=Object.defineProperty,hs=Object.getOwnPropertyDescriptor;class ps{constructor(){c(this)}send(e){window.transport.request({channel:"telemetry",action:"send",payload:{data:{command:e.command,commandDetails:JSON.stringify(e.commandDetails),commandContext:JSON.stringify({model_count:ds.size})}}})}}((e,t,s,i)=>{for(var a,n=i>1?void 0:i?hs(t,s):t,r=e.length-1;r>=0;r--)(a=e[r])&&(n=(i?a(t,s,n):a(n))||n);i&&n&&cs(t,s,n)})([u],ps.prototype,"send",1);var us=new ps,ms=Object.defineProperty,gs=Object.getOwnPropertyDescriptor,vs=(e,t,s,i)=>{for(var a,n=i>1?void 0:i?gs(t,s):t,r=e.length-1;r>=0;r--)(a=e[r])&&(n=(i?a(t,s,n):a(n))||n);return i&&n&&ms(t,s,n),n};class fs{constructor(){this.type="fatal",this.description=null,this.dump=null,c(this)}update(e){this.type=e.type,this.description=e.description,this.dump=e.dump,us.send({command:"error_throw",commandDetails:{type:this.type,description:this.description}})}}vs([p],fs.prototype,"type",2),vs([p],fs.prototype,"description",2),vs([p],fs.prototype,"dump",2),vs([u],fs.prototype,"update",1);var ys=new fs;const Is=e=>{const t=[];return e.filter((e=>"delete"===e.type)).forEach((s=>{if(!s.record)throw U({path:"prismaQueriesFromActions._delete",message:"Unrecognized Record in Action",context:{action:s.serialize()}});const i=s.record.model,a={where:Es(s)};t.push({modelName:i.name,operation:"delete",args:a}),e=e.filter((e=>s.id!==e.id&&s.recordId!==e.recordId))})),{actions:e,requests:t}},Cs=e=>{const t=[];return e.filter((e=>"create"===e.type)).forEach((s=>{if(!s.record)throw U({path:"prismaQueriesFromActions._create",message:"Unrecognized Record in Action",context:{action:s.serialize()}});const i=s.record.model,a={data:{},select:bs(s)},n=e.find((e=>"update"===e.type&&e.sessionId===s.sessionId&&e.recordId===s.recordId));n&&(a.data=xs(n),a.select=l(l({},a.select),bs(n))),t.push({modelName:i.name,operation:"create",args:a}),e=e.filter((e=>e.id!==(null==n?void 0:n.id)&&s.id!==e.id))})),{actions:e,requests:t}},ws=e=>{const t=[];return e.filter((e=>"update"===e.type)).forEach((s=>{if(!s.record)throw U({path:"prismaQueriesFromActions._update",message:"Unrecognized Record in Action",context:{action:s.serialize()}});const i=s.record.model,a={where:Es(s),data:_s(s),select:bs(s)};t.push({modelName:i.name,operation:"update",args:a}),e=e.filter((e=>s.id!==e.id))})),{actions:e,requests:t}},bs=e=>{if(!e.record)throw U({path:"prismaQueriesFromActions._getRequestSelectArgument",message:"Unrecognized Record in Action",context:{action:e.serialize()}});const t=e.record.model.uniqueIdentifier.fields.reduce(((e,t)=>(e[t.name]=!0,e)),{});return"create"===e.type||"delete"===e.type?t:Object.keys(e.value).reduce(((e,t)=>(e[t]=!0,e)),t)},Es=e=>{if(!e.record)throw U({path:"prismaQueriesFromActions._getRequestWhereArgument",message:"Unrecognized Record in Action",context:{action:e.serialize()}});const t=e.record.model.uniqueIdentifier,s=t.name,i=t.fields.reduce(((t,s)=>(t[s.name]=e.record.valueInDB[s.name],t)),{});return 1===t.fields.length?i:{[s]:i}},_s=e=>{if(!e.record)throw U({path:"prismaQueriesFromActions._getUpdateRequestDataArgument",message:"Unrecognized Record in Action",context:{action:e.serialize()}});const t=e.record.model;return Object.keys(e.value).reduce(((s,i)=>{const a=t.getFieldByName(i),n=e.value[i];if(!a)throw U({path:"prismaQueriesFromActions._getUpdateRequestDataArgument",message:"Malformed field in action",context:{action:e.serialize()}});if(a.isReadOnly)return s;if(void 0===n)return s;if(a.isScalar&&a.isList||a.isEnum&&a.isList)s[i]={set:n};else if(a.isScalar||a.isEnum)s[i]=n;else if(a.isList&&a.isRelation){if(!a.typeAsModel)throw U({path:"prismaQueriesFromActions._getUpdateRequestDataArgument",message:"Invalid field type",context:{field:a.serialize()}});const t=(e.record.valueInDB[i]||[]).map((e=>_e(a.typeAsModel.id,e))),r=n.map((e=>_e(a.typeAsModel.id,e))),l=h.exports.difference(r,t),o=h.exports.difference(t,r);s[i]={},h.exports.isEmpty(l)||(s[i].connect=l.map(((e,t)=>{const s=dt.get(e)||dt.add({id:e,modelId:a.typeAsModel.id,value:n[t]}),i=s.model.uniqueIdentifier,r=i.name,l=i.fields.reduce(((e,t)=>(e[t.name]=s.valueInDB[t.name],e)),{});return 1===i.fields.length?l:{[r]:l}}))),h.exports.isEmpty(o)||(s[i].disconnect=o.map(((t,s)=>{const i=dt.get(t);if(!i)throw U({path:"prismaQueriesFromActions._getUpdateRequestDataArgument",message:"Attempting to disconnect a non-existent record",context:{action:e.serialize(),index:s}});const a=i.model.uniqueIdentifier,n=a.name,r=a.fields.reduce(((e,t)=>(e[t.name]=i.valueInDB[t.name],e)),{});return 1===a.fields.length?r:{[n]:r}})))}else if(a.isRelation)if(null===n)s[i]={disconnect:!0};else{if(!a.typeAsModel)throw U({path:"prismaQueriesFromActions._getUpdateRequestDataArgument",message:"Invalid field type",context:{field:a.serialize()}});const e=_e(a.typeAsModel.id,n),t=dt.get(e)||dt.add({id:e,modelId:a.typeAsModel.id,value:n}),r=t.model.uniqueIdentifier,l=r.name,o=r.fields.reduce(((e,s)=>(e[s.name]=t.valueInDB[s.name],e)),{});1===r.fields.length?s[i]={connect:o}:s[i]={connect:{[l]:o}}}return s}),{})},xs=e=>{const t=_s(e);return Object.keys(t).forEach((s=>{if(!e.record)throw U({path:"prismaQueriesFromActions._getCreateRequestDataArgument",message:"Unrecognized Record in Action",context:{action:e.serialize()}});const i=e.record.model.getFieldByName(s);if(!i)throw U({path:"prismaQueriesFromActions._getUpdateRequestDataArgument",message:"Malformed field in action",context:{action:e.serialize()}});i.isRelation&&!i.isList&&t[s].disconnect&&delete t[s],i.isRelation&&i.isList&&t[s].disconnect&&delete t[s].disconnect})),t};var Ss=Object.defineProperty,Ns=Object.getOwnPropertyDescriptor,Ls=(e,t,s,i)=>{for(var a,n=i>1?void 0:i?Ns(t,s):t,r=e.length-1;r>=0;r--)(a=e[r])&&(n=(i?a(t,s,n):a(n))||n);return i&&n&&Ss(t,s,n),n};class Rs extends X{constructor(){super(et,{idbTableName:"actions"}),this.committing=!1,this.add=(e,t={})=>{var s;const i=super.add(e,t);return this.consolidate(),this.actions.length>0&&(null==(s=Bt.activeTab)||s.update({preview:!1}),Ee.updateActions({visible:!0})),i},this.remove=e=>{const t=super.remove(e);return 0===this.actions.length&&Ee.updateActions({visible:!1}),t},this.commit=async()=>{var e,t;if(this.invalidActions.length>0)return console.error("Commit failed: Some actions are invalid",this.invalidActions),ys.update({type:"fatal",description:"Failed to commit changes because some actions are invalid",dump:`Invalid actions: \n${JSON.stringify(this.invalidActions,null,2)}`}),void Ee.updateError({visible:!0});if(!(null==(t=null==(e=Bt.activeTab)?void 0:e.session)?void 0:t.isScript))return;const s=this.actions;let i=[];try{i=(e=>{const t=e.map((e=>Os.get(e))),s=[Is,Cs,ws].reduce(((e,t)=>{const s=t(e.actions);return e.actions=s.actions,e.requests.push(...s.requests),e}),{actions:t,requests:[]});return s.actions.length>0&&console.warn("All actions were not processed. Pending actions: ",JSON.stringify(I(s.actions),null,2)),s.requests})(s.map((e=>e.id))),console.log("Committing actions: ",i)}catch(a){throw console.error("Commit failed: Unable to generate Prisma Client requests",a),ys.update({type:"fatal",description:"An unexpected error occurred while saving your changes",dump:`Message: ${a instanceof Error?a.message:"No error message"}\n`}),Ee.updateError({visible:!0}),a}E((()=>this.committing=!0));try{const{error:e}=await window.transport.request({channel:"prisma",action:"clientRequest",payload:{data:{schemaHash:es.activeProject.schemaHash,operation:"$transaction",queries:i}}});if(e)throw e;this.actions.filter((e=>"create"===e.type)).forEach((e=>{var t;return null==(t=e.record)?void 0:t.model.update({count:(e.record.model.count||0)+1})})),this.actions.filter((e=>"delete"===e.type)).forEach((e=>{var t;return null==(t=e.record)?void 0:t.model.update({count:(e.record.model.count||0)-1})})),this.discard(),Bt.activeTab.session.isScript&&await Bt.activeTab.session.script.run(),E((()=>this.committing=!1))}catch(a){E((()=>this.committing=!1));const e=Bt.activeTab.session.script.model;if("PrismaClientSchemaDriftedError"===a.type)ys.update({type:"schemaDrift",description:"Your source Prisma Schema has changed. Please reload Studio to continue. Your changes will be saved.",dump:""});else if("PrismaClientRustPanicError"===a.type||"PrismaClientUnknownRequestError"===a.type)ys.update({type:"fatal",description:`An unexpected error occurred while saving your changes to the \`${e.name}\` table`,dump:`Message: ${a.message}\n\nQuery: \n${JSON.stringify(i[0],null,2)}\n`});else{const e=`Type: ${a.type}\nMessage: ${a.message}\n\nCode: ${a.code}\n\nQuery:\n${i[0]}\n`;ys.update({type:"client",description:`Failed to commit changes: ${a.message}`,dump:e})}throw Ee.updateError({visible:!0}),a}},this.discard=()=>{const e=[...this.actions];for(let t=0;t{const e=Object.values(this.values).map((e=>e.id)),t=new Set,s=(i,a)=>{const n=this.get(i);if(!n)return;const r=e.findIndex(((e,t)=>{if(t<=a)return!1;const s=this.get(e);return!!s&&(s.sessionId===n.sessionId&&s.recordId===n.recordId&&s.type===n.type)}));if(-1===r)return;const o=this.get(e[r]);return o?(n.update({value:l(l({},n.value),o.value)}),t.add(e[r]),e.splice(r,1),s(i,a)):void 0};e.forEach(s);e.forEach((s=>{const i=this.get(s);i&&"delete"===i.type&&e.forEach((e=>{var a;const n=this.get(e);n&&(n&&"delete"!==n.type&&n.recordId===i.recordId&&t.add(e),(null==(a=n.record)?void 0:a.isCommitted)||t.add(s))}))})),t.forEach((e=>this.remove(e)))},c(this)}get actions(){return Object.values(this.values).filter((e=>{var t;return e.sessionId===(null==(t=Bt.activeTab)?void 0:t.sessionId)}))}get invalidActions(){return this.actions.filter((e=>!e.isValid))}}Ls([p],Rs.prototype,"committing",2),Ls([f],Rs.prototype,"actions",1),Ls([f],Rs.prototype,"invalidActions",1),Ls([C],Rs.prototype,"add",2),Ls([C],Rs.prototype,"remove",2),Ls([u],Rs.prototype,"commit",2),Ls([u],Rs.prototype,"discard",2),Ls([u],Rs.prototype,"consolidate",2);var Os=new Rs;var Ms=new class{constructor(){this.inputObjectTypes=new Map}hydrate(e){(e.schema.inputObjectTypes.prisma||[]).forEach((e=>this.inputObjectTypes.set(e.name,e)));const{models:t,enums:s,types:i}=e.datamodel;t.forEach((t=>{var s,a,n,r,l,o,d;const c=ds.add({dbName:t.dbName,name:t.name,plural:(null==(s=e.mappings.modelOperations.find((e=>e.model===t.name)))?void 0:s.plural)||t.name,fieldIds:[],compoundId:{name:null,fieldIds:[]},compoundUnique:{name:null,fieldIds:[]}});let h=[];t.fields.forEach((e=>{if("unsupported"===e.kind)return;"object"===e.kind&&i.some((t=>t.name===e.type))&&(e.type="Json",e.kind="scalar");let t=fe.add({id:ae(c.id,e.name),modelId:c.id,name:e.name,type:e.type,kind:e.kind,default:e.default,isId:e.isId,isUnique:e.isUnique,isRequired:e.isRequired,isList:e.isList,isReadOnly:e.isReadOnly,isUpdatedAt:e.isUpdatedAt,relationName:e.relationName||"",relationFromFieldNames:e.relationFromFields||[],relationToFieldNames:e.relationToFields||[]});h.push(t.id)}));const p={name:null!=(n=null==(a=t.primaryKey)?void 0:a.name)?n:null,fieldIds:((null==(r=t.primaryKey)?void 0:r.fields)||[]).map((e=>ae(c.id,e)))},u={name:null!=(o=null==(l=t.uniqueIndexes[0])?void 0:l.name)?o:null,fieldIds:(null==(d=t.uniqueIndexes[0])?void 0:d.fields.map((e=>ae(t.name,e))))||[]};c.update({fieldIds:h,compoundId:p,compoundUnique:u})})),s.forEach((e=>{pe.add({name:e.name,values:e.values.map((e=>e.name))})}))}removeUnusedModels(e){const{models:t}=e.datamodel;h.exports.difference(Object.values(ds.values).map((e=>e.id)),t.map((e=>e.name))).forEach((e=>{Object.values(Os.values).forEach((t=>{var s;(null==(s=t.session)?void 0:s.isScript)&&t.session.script.modelId===e&&Os.remove(t.id)})),Object.values(Bt.values).forEach((t=>{var s;(null==(s=t.session)?void 0:s.isScript)&&t.session.script.modelId===e&&Bt.remove(t.id)})),Object.values($e.values).forEach((t=>{(null==t?void 0:t.isScript)&&t.script.modelId===e&&$e.remove(t.id)})),ds.remove(e)}))}removeUnusedFields(e){const{models:t}=e.datamodel;h.exports.difference(Object.values(fe.values).map((e=>e.id)),h.exports.flatten(t.map((e=>e.fields.map((t=>ae(e.name,t.name))))))).forEach((e=>fe.remove(e)))}removeUnusedEnums(e){const{enums:t}=e.datamodel;h.exports.difference(Object.values(pe.values).map((e=>e.id)),t.map((e=>e.name))).forEach((e=>pe.remove(e)))}};function ks(e,t,s,i){Object.defineProperty(e,t,{get:s,set:i,enumerable:!0,configurable:!0})}var Ds={};ks(Ds,"serializeRPCMessage",(()=>As)),ks(Ds,"deserializeRPCMessage",(()=>Ts));function As(e){return JSON.stringify(e,((e,t)=>"bigint"==typeof t?"PrismaBigInt::"+t:"Buffer"===(null==t?void 0:t.type)&&Array.isArray(null==t?void 0:t.data)?"PrismaBytes::"+_.Buffer.from(t.data).toString("base64"):t))}function Ts(e){return JSON.parse(e,((e,t)=>"string"==typeof t&&t.startsWith("PrismaBigInt::")?BigInt(t.substr("PrismaBigInt::".length)):"string"==typeof t&&t.startsWith("PrismaBytes::")?t.substr("PrismaBytes::".length):t))}class Ps{constructor(e){this.requestIdCounter=0,this.baseUrl=e}request(e){const t=new URL(this.baseUrl);return t.search=window.location.search,new Promise(((s,i)=>{const a=this.requestIdCounter;fetch(t.toString(),{method:"POST",headers:{"Content-Type":"text/plain"},body:As({requestId:a,channel:e.channel,action:e.action,payload:e.payload})}).then((async e=>{if(200===e.status){const t=Ts(await e.text());return s(t.payload)}return console.error("Non-200 Status Code in HTTPTransport.send. Body:",e.body),i({message:`Error in HTTP Request (Status: ${e.status})`,stack:JSON.stringify(e.body,null,2)})})).catch((e=>(console.error("Unable to communicate with backend: ",e),i({message:"Unable to communicate with Prisma Client. Is Studio still running? You may need to restart it using `npx prisma studio`",stack:e})))),this.requestIdCounter++}))}}const Vs=async()=>{const e=Object.values(ds.values),{error:t,data:s}=await window.transport.request({channel:"prisma",action:"clientRequest",payload:{data:{schemaHash:es.activeProject.schemaHash,operation:"$transaction",queries:e.map((e=>ts({modelId:e.id})))}}});if(t)throw U({path:"getAllCounts",message:"Unable to process `count` query",context:{error:t}});if(!Array.isArray(s))throw U({path:"getAllCounts",message:"Malformed response for `count` query:\n\n",context:{error:t}});s.forEach(((t,s)=>{e[s].update({count:t})}))},js=e=>(e=>{if("object"==typeof(t=e)&&null!==t&&"message"in t&&"string"==typeof t.message)return e;var t;try{return new Error(JSON.stringify(e))}catch{return new Error(String(e))}})(e).message;var Fs=Object.defineProperty,Bs=Object.getOwnPropertyDescriptor,Hs=(e,t,s,i)=>{for(var a,n=i>1?void 0:i?Bs(t,s):t,r=e.length-1;r>=0;r--)(a=e[r])&&(n=(i?a(t,s,n):a(n))||n);return i&&n&&Fs(t,s,n),n};class qs{constructor(){this.hasCheckedForUpdates=!1,this.latestVersion="0.511.0",this.changelog="",this.isDownloading=!1,this.isUpdateReady=!1,this.isInstalling=!1,this.check=async()=>{if(!q.updates)return;E((()=>{this.hasCheckedForUpdates=!1,this.isDownloading=!1,this.isUpdateReady=!1,this.isInstalling=!1}));const{error:e,data:t}=await window.transport.request({channel:"update",action:"check",payload:{data:null}});if(e)return void console.error("Update check failed",e);const{available:s,version:i,changelog:a}=t;E(s?()=>{this.hasCheckedForUpdates=!0,this.latestVersion=i,this.changelog=a}:()=>{this.hasCheckedForUpdates=!0,this.latestVersion="0.511.0"})},this.download=async()=>q.updates?this.isDownloading?Promise.reject("Another download is in progress"):(E((()=>{this.isDownloading=!0,this.isUpdateReady=!1,this.isInstalling=!1})),await window.transport.request({channel:"update",action:"download",payload:{data:null}}),void E((()=>{this.isDownloading=!1,this.isUpdateReady=!0}))):Promise.resolve(),this.cancelDownload=async()=>{if(q.updates){if(!this.isDownloading)return Promise.resolve();await window.transport.request({channel:"update",action:"downloadCancel",payload:{data:null}}),E((()=>{this.isDownloading=!1,this.isUpdateReady=!1}))}},this.install=async()=>{q.updates&&(E((()=>{this.isDownloading=!1,this.isUpdateReady=!0,this.isInstalling=!0})),await window.transport.request({channel:"update",action:"install",payload:{data:null}}),E((()=>{this.isUpdateReady=!1,this.isInstalling=!1})))},c(this)}get isUpToDate(){return"0.511.0"===this.latestVersion}}Hs([p],qs.prototype,"hasCheckedForUpdates",2),Hs([p],qs.prototype,"latestVersion",2),Hs([p],qs.prototype,"changelog",2),Hs([p],qs.prototype,"isDownloading",2),Hs([p],qs.prototype,"isUpdateReady",2),Hs([p],qs.prototype,"isInstalling",2),Hs([f],qs.prototype,"isUpToDate",1),Hs([u],qs.prototype,"check",2),Hs([u],qs.prototype,"download",2),Hs([u],qs.prototype,"cancelDownload",2);var Zs=new qs;var Us=Object.defineProperty,zs=Object.getOwnPropertyDescriptor,$s=(e,t,s,i)=>{for(var a,n=i>1?void 0:i?zs(t,s):t,r=e.length-1;r>=0;r--)(a=e[r])&&(n=(i?a(t,s,n):a(n))||n);return i&&n&&Us(t,s,n),n};class Js{constructor(){this.ready=!1,c(this),x({enforceActions:"observed"}),console.log("Studio version","0.511.0")}async initTransport(e){if(e)window.transport=e;else{if("http"!==q.transport.type)return console.error("Unrecognized transport, aborting"),Promise.reject();window.transport=new Ps(q.transport.url)}window.toJS=I,window.stores={ActionStore:Os,BootstrapStore:Ws,ConfigStore:q,DMMFStore:Ms,EnumStore:pe,ErrorStore:ys,FieldStore:fe,LayoutStore:Ee,ModelStore:ds,PersistenceStore:K,ProjectStore:es,RecordStore:dt,ScriptStore:Mt,SessionStore:$e,TabStore:Bt,TelemetryStore:us,ThemeStore:zt,UpdateStore:Zs}}async init(){console.time("Bootstrap Duration"),this.update({ready:!1}),this.disposeProjectReaction&&this.disposeProjectReaction();try{const{error:e,data:t}=await window.transport.request({channel:"prisma",action:"getDMMF",payload:{data:null}});if(e||!t)throw new Error(`Error starting Prisma Client: ${JSON.stringify(e,null,2)}`);const{dmmf:s,schemaHash:i}=t,{error:a,data:n}=await window.transport.request({channel:"project",action:"get",payload:{data:null}});if(a||!n)throw new Error(`Error fetching project: ${a}`);const{name:r,schemaPath:l}=n,o=(e=>((e.endsWith("/")||e.endsWith("\\"))&&(e=e.slice(0,-1)),(e.startsWith("/")||e.startsWith("\\"))&&(e=e.slice(1)),e.replace(RegExp(/\/|\\/,"gi"),"-")))(l);es.add({id:o,name:r,schemaPath:l,schemaHash:i,recentModelIds:[]},{skipPersist:!0}),es.switch(o),await K.init({projectId:o}),Ms.hydrate(s);for(let c of[es,fe,ds,pe,Mt,dt,$e,Os,Bt])await c.restore();Ms.removeUnusedModels(s),Ms.removeUnusedFields(s),Ms.removeUnusedEnums(s),window.requestIdleCallback?window.requestIdleCallback(Vs):await Vs();Object.values(Mt.values).filter((e=>e.frozen&&ds.get(e.modelId))).forEach((e=>{E((()=>{e.update({fieldIds:e.model.fieldIds})}))}));const d=(await K.load("projects")).find((e=>e.id===o));d&&Bt.hydrate({activeTabId:d.activeTabId}),await es.activeProject.forceUpdate(),this.update({ready:!0}),console.timeEnd("Bootstrap Duration")}catch(e){console.error(e);const t=(e=>{const t=/Error code: (P\d{4})/g.exec(e);return(null==t?void 0:t[1])?t[1]:""})(js(e));throw this.update({ready:!0}),0!==t.length?ys.update({type:"client",description:`There was an error parsing your schema file with Prisma. Review documentation on error ${t} to learn more.`,dump:`${e.message}\n${e.stack}`}):ys.update({type:"fatal",description:"Unable to load project",dump:`${e.message}\n${e.stack}`}),Ee.updateError({visible:!0}),U({path:"BootstrapStore.init",message:"Studio bootstrap failed",context:{message:e.message,stack:e.stack},nativeError:e})}window.requestIdleCallback?window.requestIdleCallback(this.cleanupIndexedDB):this.cleanupIndexedDB()}update(e={}){h.exports.has(e,"ready")&&(this.ready=e.ready)}cleanupIndexedDB(){const e=Object.values(Bt.openTabs).map((e=>e.sessionId));Object.values($e.values).filter((t=>!e.includes(t.id))).forEach((e=>$e.remove(e.id)));const t=Object.values($e.values).map((e=>e.scriptId));Object.values(Mt.values).filter((e=>!t.includes(e.id)&&null===e.name)).forEach((e=>Mt.remove(e.id)))}}$s([p],Js.prototype,"ready",2),$s([u],Js.prototype,"initTransport",1),$s([u],Js.prototype,"init",1),$s([u],Js.prototype,"update",1);var Ws=new Js;var Ks="_container_18uec_1",Gs="_wide_18uec_32",Qs="_ghost_18uec_35",Ys="_blue_18uec_49",Xs="_green_18uec_62",ei="_red_18uec_75",ti="_disabled_18uec_85";var si=S((e=>{var t=e,{dataTestId:s,innerRef:i,className:a,children:n,ghost:r=!1,wide:o=!1,blue:c=!1,green:h=!1,red:p=!1,disabled:u,onClick:m}=t,g=d(t,["dataTestId","innerRef","className","children","ghost","wide","blue","green","red","disabled","onClick"]);return N.createElement("button",l({"data-testid":null!=s?s:"button",ref:i,className:L(Ks,{[Gs]:o,[Qs]:r,[Ys]:c,[Xs]:h,[ei]:p,[ti]:u},a),disabled:u,onClick:e=>{u||m&&(e.stopPropagation(),e.preventDefault(),m(e))}},g),n)}));function ii(e){return R.exports.createElement("svg",Object.assign({viewBox:"0 0 24 24",xmlns:"http://www.w3.org/2000/svg"},e),R.exports.createElement("path",{d:"M7.875 16.9722L12 21.25M12 21.25L16.125 16.9722M12 21.25V11.625",fill:"none",stroke:"currentColor",strokeWidth:2,strokeLinecap:"round",strokeLinejoin:"round"}),R.exports.createElement("path",{d:"M20.8773 17.125C21.7462 16.5127 22.3978 15.6389 22.7375 14.6303C23.0773 13.6217 23.0874 12.5309 22.7666 11.5162C22.4458 10.5014 21.8107 9.6155 20.9534 8.987C20.0961 8.3585 19.0612 8.02011 17.999 8.02095H16.7398C16.4392 6.84701 15.8767 5.7567 15.0948 4.8321C14.3129 3.90751 13.3319 3.17272 12.2256 2.68306C11.1193 2.1934 9.91659 1.96162 8.70798 2.00518C7.49937 2.04873 6.31637 2.36649 5.24803 2.93452C4.1797 3.50255 3.25387 4.30606 2.54025 5.28455C1.82663 6.26304 1.34382 7.39102 1.12815 8.58356C0.912487 9.77611 0.969594 11.0021 1.29517 12.1694C1.62075 13.3366 2.20632 14.4146 3.00779 15.3222",fill:"none",stroke:"currentColor",strokeWidth:2,strokeLinecap:"round",strokeLinejoin:"round"}))}function ai(e){return R.exports.createElement("svg",Object.assign({viewBox:"0 0 88 43",fill:"none",xmlns:"http://www.w3.org/2000/svg"},e),R.exports.createElement("path",{d:"M9.632 40.256C7.92533 40.256 6.432 39.9893 5.152 39.456C3.872 38.9013 2.88 38.1227 2.176 37.12C1.49333 36.096 1.152 34.912 1.152 33.568V32.864C1.152 32.7573 1.184 32.672 1.248 32.608C1.33333 32.5227 1.42933 32.48 1.536 32.48H5.184C5.29067 32.48 5.376 32.5227 5.44 32.608C5.52533 32.672 5.568 32.7573 5.568 32.864V33.344C5.568 34.1973 5.96267 34.9227 6.752 35.52C7.54133 36.096 8.608 36.384 9.952 36.384C11.0827 36.384 11.9253 36.1493 12.48 35.68C13.0347 35.1893 13.312 34.592 13.312 33.888C13.312 33.376 13.1413 32.9493 12.8 32.608C12.4587 32.2453 11.9893 31.936 11.392 31.68C10.816 31.4027 9.888 31.0293 8.608 30.56C7.17867 30.0693 5.96267 29.568 4.96 29.056C3.97867 28.544 3.14667 27.8507 2.464 26.976C1.80267 26.08 1.472 24.9813 1.472 23.68C1.472 22.4 1.80267 21.28 2.464 20.32C3.12533 19.36 4.04267 18.624 5.216 18.112C6.38933 17.6 7.744 17.344 9.28 17.344C10.9013 17.344 12.3413 17.632 13.6 18.208C14.88 18.784 15.872 19.5947 16.576 20.64C17.3013 21.664 17.664 22.8587 17.664 24.224V24.704C17.664 24.8107 17.6213 24.9067 17.536 24.992C17.472 25.056 17.3867 25.088 17.28 25.088H13.6C13.4933 25.088 13.3973 25.056 13.312 24.992C13.248 24.9067 13.216 24.8107 13.216 24.704V24.448C13.216 23.552 12.8427 22.7947 12.096 22.176C11.3707 21.536 10.368 21.216 9.088 21.216C8.08533 21.216 7.296 21.4293 6.72 21.856C6.16533 22.2827 5.888 22.8693 5.888 23.616C5.888 24.1493 6.048 24.5973 6.368 24.96C6.70933 25.3227 7.2 25.6533 7.84 25.952C8.50133 26.2293 9.51467 26.6133 10.88 27.104C12.3947 27.6587 13.5787 28.1493 14.432 28.576C15.3067 29.0027 16.0853 29.6427 16.768 30.496C17.472 31.328 17.824 32.416 17.824 33.76C17.824 35.7653 17.088 37.3547 15.616 38.528C14.144 39.68 12.1493 40.256 9.632 40.256ZM29.1753 26.784C29.1753 26.8907 29.1326 26.9867 29.0473 27.072C28.9833 27.136 28.8979 27.168 28.7913 27.168H25.7193C25.6126 27.168 25.5593 27.2213 25.5593 27.328V34.112C25.5593 34.816 25.6979 35.3387 25.9753 35.68C26.2739 36.0213 26.7433 36.192 27.3833 36.192H28.4393C28.5459 36.192 28.6313 36.2347 28.6953 36.32C28.7806 36.384 28.8233 36.4693 28.8233 36.576V39.616C28.8233 39.8507 28.6953 39.9893 28.4393 40.032C27.5433 40.0747 26.9033 40.096 26.5193 40.096C24.7486 40.096 23.4259 39.808 22.5513 39.232C21.6766 38.6347 21.2286 37.5253 21.2073 35.904V27.328C21.2073 27.2213 21.1539 27.168 21.0473 27.168H19.2233C19.1166 27.168 19.0206 27.136 18.9353 27.072C18.8713 26.9867 18.8393 26.8907 18.8393 26.784V23.936C18.8393 23.8293 18.8713 23.744 18.9353 23.68C19.0206 23.5947 19.1166 23.552 19.2233 23.552H21.0473C21.1539 23.552 21.2073 23.4987 21.2073 23.392V19.584C21.2073 19.4773 21.2393 19.392 21.3033 19.328C21.3886 19.2427 21.4846 19.2 21.5913 19.2H25.1753C25.2819 19.2 25.3673 19.2427 25.4313 19.328C25.5166 19.392 25.5593 19.4773 25.5593 19.584V23.392C25.5593 23.4987 25.6126 23.552 25.7193 23.552H28.7913C28.8979 23.552 28.9833 23.5947 29.0473 23.68C29.1326 23.744 29.1753 23.8293 29.1753 23.936V26.784ZM40.5315 23.936C40.5315 23.8293 40.5635 23.744 40.6275 23.68C40.7128 23.5947 40.8088 23.552 40.9155 23.552H44.6595C44.7662 23.552 44.8515 23.5947 44.9155 23.68C45.0008 23.744 45.0435 23.8293 45.0435 23.936V39.616C45.0435 39.7227 45.0008 39.8187 44.9155 39.904C44.8515 39.968 44.7662 40 44.6595 40H40.9155C40.8088 40 40.7128 39.968 40.6275 39.904C40.5635 39.8187 40.5315 39.7227 40.5315 39.616V38.528C40.5315 38.464 40.5102 38.432 40.4675 38.432C40.4248 38.4107 40.3822 38.432 40.3395 38.496C39.4862 39.648 38.1635 40.224 36.3715 40.224C34.7502 40.224 33.4168 39.7333 32.3715 38.752C31.3262 37.7707 30.8035 36.3947 30.8035 34.624V23.936C30.8035 23.8293 30.8355 23.744 30.8995 23.68C30.9848 23.5947 31.0808 23.552 31.1875 23.552H34.8995C35.0062 23.552 35.0915 23.5947 35.1555 23.68C35.2408 23.744 35.2835 23.8293 35.2835 23.936V33.504C35.2835 34.3573 35.5075 35.0507 35.9555 35.584C36.4248 36.1173 37.0648 36.384 37.8755 36.384C38.6008 36.384 39.1982 36.1707 39.6675 35.744C40.1368 35.296 40.4248 34.72 40.5315 34.016V23.936ZM57.617 17.984C57.617 17.8773 57.649 17.792 57.713 17.728C57.7983 17.6427 57.8943 17.6 58.001 17.6H61.745C61.8517 17.6 61.937 17.6427 62.001 17.728C62.0863 17.792 62.129 17.8773 62.129 17.984V39.616C62.129 39.7227 62.0863 39.8187 62.001 39.904C61.937 39.968 61.8517 40 61.745 40H58.001C57.8943 40 57.7983 39.968 57.713 39.904C57.649 39.8187 57.617 39.7227 57.617 39.616V38.56C57.617 38.496 57.5957 38.464 57.553 38.464C57.5103 38.4427 57.4677 38.4533 57.425 38.496C56.529 39.6693 55.3023 40.256 53.745 40.256C52.2517 40.256 50.961 39.84 49.873 39.008C48.8063 38.176 48.0383 37.0347 47.569 35.584C47.2063 34.4747 47.025 33.184 47.025 31.712C47.025 30.1973 47.217 28.8747 47.601 27.744C48.0917 26.3787 48.8597 25.3013 49.905 24.512C50.9717 23.7013 52.2837 23.296 53.841 23.296C55.377 23.296 56.5717 23.8293 57.425 24.896C57.4677 24.96 57.5103 24.9813 57.553 24.96C57.5957 24.9387 57.617 24.896 57.617 24.832V17.984ZM56.945 35.008C57.3717 34.2187 57.585 33.1413 57.585 31.776C57.585 30.3467 57.3503 29.2267 56.881 28.416C56.3903 27.584 55.6757 27.168 54.737 27.168C53.7343 27.168 52.977 27.584 52.465 28.416C51.9317 29.248 51.665 30.3787 51.665 31.808C51.665 33.088 51.889 34.1547 52.337 35.008C52.8703 35.9253 53.6597 36.384 54.705 36.384C55.665 36.384 56.4117 35.9253 56.945 35.008ZM67.006 21.696C66.2807 21.696 65.6727 21.4613 65.182 20.992C64.7127 20.5013 64.478 19.8933 64.478 19.168C64.478 18.4213 64.7127 17.8133 65.182 17.344C65.6513 16.8747 66.2593 16.64 67.006 16.64C67.7527 16.64 68.3607 16.8747 68.83 17.344C69.2993 17.8133 69.534 18.4213 69.534 19.168C69.534 19.8933 69.2887 20.5013 68.798 20.992C68.3287 21.4613 67.7313 21.696 67.006 21.696ZM65.086 40C64.9793 40 64.8833 39.968 64.798 39.904C64.734 39.8187 64.702 39.7227 64.702 39.616V23.904C64.702 23.7973 64.734 23.712 64.798 23.648C64.8833 23.5627 64.9793 23.52 65.086 23.52H68.83C68.9367 23.52 69.022 23.5627 69.086 23.648C69.1713 23.712 69.214 23.7973 69.214 23.904V39.616C69.214 39.7227 69.1713 39.8187 69.086 39.904C69.022 39.968 68.9367 40 68.83 40H65.086ZM79.0342 40.256C77.2422 40.256 75.7062 39.7867 74.4262 38.848C73.1462 37.9093 72.2716 36.6293 71.8022 35.008C71.5036 34.0053 71.3542 32.9173 71.3542 31.744C71.3542 30.4853 71.5036 29.3547 71.8022 28.352C72.2929 26.7733 73.1782 25.536 74.4582 24.64C75.7382 23.744 77.2742 23.296 79.0662 23.296C80.8156 23.296 82.3089 23.744 83.5462 24.64C84.7836 25.5147 85.6582 26.7413 86.1702 28.32C86.5116 29.3867 86.6822 30.5067 86.6822 31.68C86.6822 32.832 86.5329 33.9093 86.2342 34.912C85.7649 36.576 84.8902 37.888 83.6102 38.848C82.3516 39.7867 80.8262 40.256 79.0342 40.256ZM79.0342 36.384C79.7382 36.384 80.3356 36.1707 80.8262 35.744C81.3169 35.3173 81.6689 34.7307 81.8822 33.984C82.0529 33.3013 82.1382 32.5547 82.1382 31.744C82.1382 30.848 82.0529 30.0907 81.8822 29.472C81.6476 28.7467 81.2849 28.1813 80.7942 27.776C80.3036 27.3707 79.7062 27.168 79.0022 27.168C78.2769 27.168 77.6689 27.3707 77.1782 27.776C76.7089 28.1813 76.3676 28.7467 76.1542 29.472C75.9836 29.984 75.8982 30.7413 75.8982 31.744C75.8982 32.704 75.9729 33.4507 76.1222 33.984C76.3356 34.7307 76.6876 35.3173 77.1782 35.744C77.6902 36.1707 78.3089 36.384 79.0342 36.384Z",fill:"#2D3748"}),R.exports.createElement("path",{d:"M5.9 3.186C6.516 3.186 7.05733 3.312 7.524 3.564C7.99067 3.816 8.35 4.17533 8.602 4.642C8.86333 5.09933 8.994 5.62667 8.994 6.224C8.994 6.812 8.85867 7.33 8.588 7.778C8.32667 8.226 7.95333 8.576 7.468 8.828C6.992 9.07067 6.44133 9.192 5.816 9.192H3.828C3.78133 9.192 3.758 9.21533 3.758 9.262V12.832C3.758 12.8787 3.73933 12.9207 3.702 12.958C3.674 12.986 3.63667 13 3.59 13H1.952C1.90533 13 1.86333 12.986 1.826 12.958C1.798 12.9207 1.784 12.8787 1.784 12.832V3.354C1.784 3.30733 1.798 3.27 1.826 3.242C1.86333 3.20467 1.90533 3.186 1.952 3.186H5.9ZM5.606 7.61C6.03533 7.61 6.38067 7.48867 6.642 7.246C6.90333 6.994 7.034 6.66733 7.034 6.266C7.034 5.85533 6.90333 5.524 6.642 5.272C6.38067 5.02 6.03533 4.894 5.606 4.894H3.828C3.78133 4.894 3.758 4.91733 3.758 4.964V7.54C3.758 7.58667 3.78133 7.61 3.828 7.61H5.606ZM16.0035 13C15.9102 13 15.8448 12.958 15.8075 12.874L14.0575 8.996C14.0388 8.95867 14.0108 8.94 13.9735 8.94H12.6715C12.6248 8.94 12.6015 8.96333 12.6015 9.01V12.832C12.6015 12.8787 12.5828 12.9207 12.5455 12.958C12.5175 12.986 12.4802 13 12.4335 13H10.7955C10.7488 13 10.7068 12.986 10.6695 12.958C10.6415 12.9207 10.6275 12.8787 10.6275 12.832V3.368C10.6275 3.32133 10.6415 3.284 10.6695 3.256C10.7068 3.21867 10.7488 3.2 10.7955 3.2H14.7995C15.3968 3.2 15.9195 3.32133 16.3675 3.564C16.8248 3.80667 17.1748 4.152 17.4175 4.6C17.6695 5.048 17.7955 5.566 17.7955 6.154C17.7955 6.78867 17.6368 7.33467 17.3195 7.792C17.0022 8.24 16.5588 8.55733 15.9895 8.744C15.9428 8.76267 15.9288 8.79533 15.9475 8.842L17.8515 12.804C17.8702 12.8413 17.8795 12.8693 17.8795 12.888C17.8795 12.9627 17.8282 13 17.7255 13H16.0035ZM12.6715 4.894C12.6248 4.894 12.6015 4.91733 12.6015 4.964V7.358C12.6015 7.40467 12.6248 7.428 12.6715 7.428H14.5055C14.8975 7.428 15.2148 7.31133 15.4575 7.078C15.7095 6.84467 15.8355 6.54133 15.8355 6.168C15.8355 5.79467 15.7095 5.49133 15.4575 5.258C15.2148 5.01533 14.8975 4.894 14.5055 4.894H12.6715ZM19.8151 13C19.7685 13 19.7265 12.986 19.6891 12.958C19.6611 12.9207 19.6471 12.8787 19.6471 12.832V3.368C19.6471 3.32133 19.6611 3.284 19.6891 3.256C19.7265 3.21867 19.7685 3.2 19.8151 3.2H21.4531C21.4998 3.2 21.5371 3.21867 21.5651 3.256C21.6025 3.284 21.6211 3.32133 21.6211 3.368V12.832C21.6211 12.8787 21.6025 12.9207 21.5651 12.958C21.5371 12.986 21.4998 13 21.4531 13H19.8151ZM27.1049 13.112C26.3582 13.112 25.7049 12.9953 25.1449 12.762C24.5849 12.5193 24.1509 12.1787 23.8429 11.74C23.5442 11.292 23.3949 10.774 23.3949 10.186V9.878C23.3949 9.83133 23.4089 9.794 23.4369 9.766C23.4742 9.72867 23.5162 9.71 23.5629 9.71H25.1589C25.2055 9.71 25.2429 9.72867 25.2709 9.766C25.3082 9.794 25.3269 9.83133 25.3269 9.878V10.088C25.3269 10.4613 25.4995 10.7787 25.8449 11.04C26.1902 11.292 26.6569 11.418 27.2449 11.418C27.7395 11.418 28.1082 11.3153 28.3509 11.11C28.5935 10.8953 28.7149 10.634 28.7149 10.326C28.7149 10.102 28.6402 9.91533 28.4909 9.766C28.3415 9.60733 28.1362 9.472 27.8749 9.36C27.6229 9.23867 27.2169 9.07533 26.6569 8.87C26.0315 8.65533 25.4995 8.436 25.0609 8.212C24.6315 7.988 24.2675 7.68467 23.9689 7.302C23.6795 6.91 23.5349 6.42933 23.5349 5.86C23.5349 5.3 23.6795 4.81 23.9689 4.39C24.2582 3.97 24.6595 3.648 25.1729 3.424C25.6862 3.2 26.2789 3.088 26.9509 3.088C27.6602 3.088 28.2902 3.214 28.8409 3.466C29.4009 3.718 29.8349 4.07267 30.1429 4.53C30.4602 4.978 30.6189 5.50067 30.6189 6.098V6.308C30.6189 6.35467 30.6002 6.39667 30.5629 6.434C30.5349 6.462 30.4975 6.476 30.4509 6.476H28.8409C28.7942 6.476 28.7522 6.462 28.7149 6.434C28.6869 6.39667 28.6729 6.35467 28.6729 6.308V6.196C28.6729 5.804 28.5095 5.47267 28.1829 5.202C27.8655 4.922 27.4269 4.782 26.8669 4.782C26.4282 4.782 26.0829 4.87533 25.8309 5.062C25.5882 5.24867 25.4669 5.50533 25.4669 5.832C25.4669 6.06533 25.5369 6.26133 25.6769 6.42C25.8262 6.57867 26.0409 6.72333 26.3209 6.854C26.6102 6.97533 27.0535 7.14333 27.6509 7.358C28.3135 7.60067 28.8315 7.81533 29.2049 8.002C29.5875 8.18867 29.9282 8.46867 30.2269 8.842C30.5349 9.206 30.6889 9.682 30.6889 10.27C30.6889 11.1473 30.3669 11.8427 29.7229 12.356C29.0789 12.86 28.2062 13.112 27.1049 13.112ZM38.791 3.312C38.8377 3.23733 38.903 3.2 38.987 3.2H40.625C40.6717 3.2 40.709 3.21867 40.737 3.256C40.7744 3.284 40.793 3.32133 40.793 3.368V12.832C40.793 12.8787 40.7744 12.9207 40.737 12.958C40.709 12.986 40.6717 13 40.625 13H38.987C38.9404 13 38.8984 12.986 38.861 12.958C38.833 12.9207 38.819 12.8787 38.819 12.832V6.658C38.819 6.62067 38.8097 6.602 38.791 6.602C38.7724 6.602 38.7537 6.616 38.735 6.644L37.251 8.968C37.2044 9.04267 37.139 9.08 37.055 9.08H36.229C36.145 9.08 36.0797 9.04267 36.033 8.968L34.549 6.644C34.5304 6.616 34.5117 6.60667 34.493 6.616C34.4744 6.616 34.465 6.63467 34.465 6.672V12.832C34.465 12.8787 34.4464 12.9207 34.409 12.958C34.381 12.986 34.3437 13 34.297 13H32.659C32.6124 13 32.5704 12.986 32.533 12.958C32.505 12.9207 32.491 12.8787 32.491 12.832V3.368C32.491 3.32133 32.505 3.284 32.533 3.256C32.5704 3.21867 32.6124 3.2 32.659 3.2H34.297C34.381 3.2 34.4464 3.23733 34.493 3.312L36.593 6.574C36.621 6.63 36.649 6.63 36.677 6.574L38.791 3.312ZM49.1488 13C49.0555 13 48.9948 12.9533 48.9668 12.86L48.5468 11.488C48.5282 11.4507 48.5048 11.432 48.4768 11.432H45.0328C45.0048 11.432 44.9815 11.4507 44.9628 11.488L44.5568 12.86C44.5288 12.9533 44.4682 13 44.3748 13H42.5968C42.5408 13 42.4988 12.986 42.4708 12.958C42.4428 12.9207 42.4382 12.8693 42.4568 12.804L45.4808 3.34C45.5088 3.24667 45.5695 3.2 45.6628 3.2H47.8608C47.9542 3.2 48.0148 3.24667 48.0428 3.34L51.0668 12.804C51.0762 12.8227 51.0808 12.846 51.0808 12.874C51.0808 12.958 51.0295 13 50.9268 13H49.1488ZM45.4668 9.822C45.4575 9.878 45.4762 9.906 45.5228 9.906H47.9868C48.0428 9.906 48.0615 9.878 48.0428 9.822L46.7828 5.664C46.7735 5.62667 46.7595 5.61267 46.7408 5.622C46.7222 5.622 46.7082 5.636 46.6988 5.664L45.4668 9.822Z",fill:"#718096"}))}var ni="_container_vmd0x_1";var ri=S((e=>{var t=e,{className:s,children:i,onClick:a}=t,n=d(t,["className","children","onClick"]);return N.createElement(si,l({className:L(ni,s),onClick:a},n),i)}));class li extends N.PureComponent{componentDidMount(){var e;const{target:t,keys:s,preventDefault:i,stopPropagation:a,onMatch:n}=this.props,r=null!=(e=null==t?void 0:t.current)?e:document;this.instance=O(r),this.instance.bind(s,((e,t)=>{i&&e.preventDefault(),a&&e.stopImmediatePropagation(),n(e,t)}),"keydown")}componentWillUnmount(){this.instance.unbind(this.props.keys,"keydown")}render(){return N.createElement(N.Fragment,null)}}li.defaultProps={preventDefault:!0,stopPropagation:!0};var oi={container:"_container_1lyn8_1",input:"_input_1lyn8_6",file:"_file_1lyn8_16"};class di extends N.PureComponent{constructor(){super(...arguments),this.input=N.createRef(),this.handleChange=e=>{const{disabled:t,onChange:s}=this.props;t||s(e.currentTarget.value)},this.handleBlur=()=>{const{disabled:e,onBlur:t}=this.props;e||t()}}componentDidMount(){var e;const t=null!=(e=this.props.innerRef)?e:this.input;t.current&&this.props.focusOnMount&&t.current.focus()}render(){const e=this.props,{className:t,innerRef:s,style:i,type:a,tabIndex:n,value:r,placeholder:o,disabled:c,focusOnMount:h,onChange:p,onBlur:u,onConfirm:m,onCancel:g}=e,v=d(e,["className","innerRef","style","type","tabIndex","value","placeholder","disabled","focusOnMount","onChange","onBlur","onConfirm","onCancel"]),f=null!=s?s:this.input;return N.createElement("div",l({className:L(oi.container,t),style:i},v),N.createElement("input",{ref:f,lang:"en",tabIndex:n,className:L(oi.input,{[oi.disabled]:c}),type:a,placeholder:o,disabled:c,value:null===r?"":r,onChange:this.handleChange,onBlur:this.handleBlur}),m&&N.createElement(li,{keys:"enter",target:f,onMatch:m}),g&&N.createElement(li,{keys:"esc",target:f,onMatch:g}))}}function ci(e){return R.exports.createElement("svg",Object.assign({width:24,height:24,viewBox:"0 0 24 24",xmlns:"http://www.w3.org/2000/svg"},e),R.exports.createElement("path",{d:"M8.70711 7.29289C8.31658 6.90237 7.68342 6.90237 7.29289 7.29289C6.90237 7.68342 6.90237 8.31658 7.29289 8.70711L8.70711 7.29289ZM15.7782 17.1924C16.1687 17.5829 16.8019 17.5829 17.1924 17.1924C17.5829 16.8019 17.5829 16.1687 17.1924 15.7782L15.7782 17.1924ZM7.29289 15.7782C6.90237 16.1687 6.90237 16.8019 7.29289 17.1924C7.68342 17.5829 8.31658 17.5829 8.70711 17.1924L7.29289 15.7782ZM17.1924 8.70711C17.5829 8.31658 17.5829 7.68342 17.1924 7.29289C16.8019 6.90237 16.1687 6.90237 15.7782 7.29289L17.1924 8.70711ZM7.29289 8.70711L15.7782 17.1924L17.1924 15.7782L8.70711 7.29289L7.29289 8.70711ZM8.70711 17.1924L17.1924 8.70711L15.7782 7.29289L7.29289 15.7782L8.70711 17.1924Z",fill:"currentColor"}))}function hi(e){return R.exports.createElement("svg",Object.assign({viewBox:"0 0 24 24",xmlns:"http://www.w3.org/2000/svg"},e),R.exports.createElement("path",{d:"m23.968743,20.378119c0,0.634822 -0.252181,1.243672 -0.701129,1.69262c-0.448948,0.448948 -1.057797,0.701129 -1.69262,0.701129l-19.149988,0c-0.634858,0 -1.24372,-0.252181 -1.692632,-0.701129c-0.448924,-0.448948 -0.701117,-1.057797 -0.701117,-1.69262l0,-16.75624c0,-0.634858 0.252193,-1.24372 0.701117,-1.692632c0.448912,-0.448924 1.057774,-0.701117 1.692632,-0.701117l5.984371,0l2.393749,3.590623l10.771868,0c0.634822,0 1.243672,0.252193 1.69262,0.701117c0.448948,0.448912 0.701129,1.057774 0.701129,1.692632l0,13.165617z"}))}function pi(e){return R.exports.createElement("svg",Object.assign({viewBox:"0 0 24 24",xmlns:"http://www.w3.org/2000/svg"},e),R.exports.createElement("path",{fill:"none",d:"m10.7143,14.96883c2.6036,0 4.7143,-2.1106 4.7143,-4.7143c0,-2.60358 -2.1107,-4.71424 -4.7143,-4.71424c-2.60364,0 -4.7143,2.11066 -4.7143,4.71424c0,2.6037 2.11066,4.7143 4.7143,4.7143z"}),R.exports.createElement("path",{fill:"none",d:"m18,17.54023l-3.4286,-3.4285",strokeLinecap:"round"}))}di.defaultProps={value:"",disabled:!1,focusOnMount:!1,onChange:()=>{},onBlur:()=>{}};var ui="_header_zfcta_1",mi="_search_zfcta_15",gi="_list_zfcta_25",vi="_project_zfcta_32",fi="_projectRemoveButton_zfcta_44",yi="_projectMeta_zfcta_54",Ii="_projectName_zfcta_59",Ci="_projectDir_zfcta_63";class wi extends N.PureComponent{constructor(e){super(e),this.state={projects:[],searchText:""},this.handleSearch=e=>{this.setState({searchText:e})}}async componentDidMount(){const{error:e,data:t}=await window.transport.request({channel:"project",action:"getAll",payload:{data:null}});if(e)return U({path:"ProjectList.componentDidMount",message:"Failed to fetch all projects",context:{error:e}});this.setState({projects:t||[]})}handleOpen(e){window.transport.request({channel:"project",action:"open",payload:{data:{schemaPath:e}}})}handleRemove(e){this.setState((t=>({projects:t.projects.filter((t=>t.schemaPath!==e))}))),window.transport.request({channel:"project",action:"delete",payload:{data:{schemaPath:e}}})}guessProjectName(e){return e.name?e.name:e.schemaPath.endsWith("/prisma/schema.prisma")?h.exports.capitalize(e.schemaPath.split("/").slice(-3,-2)[0]):e.schemaPath.endsWith("\\prisma\\schema.prisma")?h.exports.capitalize(e.schemaPath.split("\\").slice(-3,-2)[0]):e.schemaPath.endsWith("/schema.prisma")?h.exports.capitalize(e.schemaPath.split("/").slice(-2,-1)[0]):e.schemaPath.endsWith("\\schema.prisma")?h.exports.capitalize(e.schemaPath.split("\\").slice(-2,-1)[0]):"Untitled Project"}render(){const{projects:e,searchText:t}=this.state,s=e.filter((e=>{var s,i;return(null==(s=e.name)?void 0:s.toLowerCase().includes(null==t?void 0:t.toLowerCase()))||(null==(i=e.schemaPath)?void 0:i.toLowerCase().includes(null==t?void 0:t.toLowerCase()))}));return N.createElement(N.Fragment,null,N.createElement("div",{className:ui},N.createElement(pi,null),N.createElement(di,{type:"text",className:mi,value:t,placeholder:"Search",onChange:this.handleSearch})),N.createElement("div",{className:gi},s.map((e=>N.createElement("div",{key:e.schemaPath,className:vi,onClick:()=>this.handleOpen(e.schemaPath)},N.createElement(hi,null),N.createElement("div",{className:yi},N.createElement("span",{className:Ii},this.guessProjectName(e)),N.createElement("span",{className:Ci},e.schemaPath)),N.createElement(ri,{className:fi,onClick:()=>this.handleRemove(e.schemaPath)},N.createElement(ci,null)))))))}}var bi={container:"_container_1qwck_1",left:"_left_1qwck_8",right:"_right_1qwck_9",logotype:"_logotype_1qwck_19",logo:"_logo_1qwck_19",fadeIn:"_fadeIn_1qwck_1",type:"_type_1qwck_33",updateContainer:"_updateContainer_1qwck_42",downloadIcon:"_downloadIcon_1qwck_51",alertIcon:"_alertIcon_1qwck_57",updateText:"_updateText_1qwck_63",readMoreLink:"_readMoreLink_1qwck_69",links:"_links_1qwck_75",link:"_link_1qwck_75",slideInRight:"_slideInRight_1qwck_1",footer:"_footer_1qwck_101"};class Ei extends N.Component{constructor(){super(...arguments),this.handleOpen=async()=>{const{error:e,data:t}=await window.transport.request({channel:"window",action:"pickPrismaSchema",payload:{data:null}});e||await window.transport.request({channel:"project",action:"open",payload:{data:{schemaPath:t.path}}})},this.handleInstallUpdate=async()=>{await Zs.download(),await Zs.install()},this.handleCancelDownload=async()=>{await Zs.cancelDownload()}}async componentDidMount(){await Zs.check()}render(){return N.createElement("div",{className:L(bi.container,{"theme--light":"light"===zt.theme,"theme--dark":"dark"===zt.theme})},N.createElement("div",{className:bi.container},N.createElement("div",{className:bi.left},N.createElement("div",{className:bi.logotype},N.createElement("img",{src:"./icon-1024.png",className:bi.logo}),N.createElement(ai,{className:bi.type})),Zs.hasCheckedForUpdates&&!Zs.isUpToDate&&N.createElement("div",{className:bi.updateContainer},N.createElement(ii,{className:bi.downloadIcon}),!Zs.isDownloading&&!Zs.isInstalling&&N.createElement(N.Fragment,null,N.createElement("span",{className:bi.updateText},"New version available"),N.createElement(si,{green:!0,onClick:this.handleInstallUpdate},"Update")),Zs.isDownloading&&N.createElement(N.Fragment,null,N.createElement("span",{className:bi.updateText},"Downloading .."),N.createElement(si,{red:!0,onClick:this.handleCancelDownload},"Cancel")),Zs.isInstalling&&N.createElement(N.Fragment,null,N.createElement("span",{className:bi.updateText},"Installing .."),N.createElement(si,{red:!0,onClick:this.handleCancelDownload},"Cancel"))),N.createElement("div",{className:bi.links},N.createElement("a",{className:bi.link},"0.511.0"),"|",N.createElement("a",{className:bi.link,href:"https://github.com/prisma/studio/releases",target:"_blank",rel:"noreferrer noopener"},"Changelog"))),N.createElement("div",{className:bi.right},N.createElement(wi,null),N.createElement("div",{className:bi.footer},N.createElement(si,{className:bi.button,onClick:this.handleOpen},"Select Schema")))))}}var _i=S(Ei);function xi(e){return R.exports.createElement("svg",Object.assign({viewBox:"0 0 24 24",xmlns:"http://www.w3.org/2000/svg"},e),R.exports.createElement("rect",{fillRule:"evenodd",clipRule:"evenodd",y:10,width:24,height:4,rx:2}))}function Si(e){return R.exports.createElement("svg",Object.assign({viewBox:"0 0 24 24",xmlns:"http://www.w3.org/2000/svg"},e),R.exports.createElement("path",{fillRule:"evenodd",clipRule:"evenodd",d:"M23.3327 2.54004C24.1705 3.30678 24.227 4.60642 23.4591 5.44287L9.78844 20.3338C9.3987 20.7583 8.8484 21 8.27163 21C7.69485 21 7.14456 20.7583 6.75481 20.3338L0.540861 13.5652C-0.227044 12.7287 -0.170453 11.4291 0.667261 10.6624C1.50497 9.89561 2.80659 9.95212 3.57449 10.7886L8.27163 15.9049L20.4255 2.66625C21.1934 1.82981 22.495 1.7733 23.3327 2.54004Z"}))}var Ni="_container_me63q_1",Li="_checkbox_me63q_8",Ri="_checked_me63q_22";var Oi=S((({className:e,checked:t=!1,indeterminate:s=!1,onChange:i})=>N.createElement("div",{"data-testid":"checkbox","data-test-selected":t,className:L(Ni,e),onClick:()=>i&&i(!t)},N.createElement("div",{className:L(Li,{[Ri]:t})},t&&(s?N.createElement(xi,null):N.createElement(Si,null))))));var Mi="_mask_2ab49_1";var ki=S((({className:e,onClick:t})=>N.createElement("div",{"data-testid":"mask",className:L(Mi,e),onClick:t})));var Di="_container_7tz9e_1",Ai="_transparent_7tz9e_11";class Ti extends N.PureComponent{constructor(){super(...arguments),this.state={top:0,bottom:0,left:0,right:0,minWidth:void 0,maxWidth:void 0,minHeight:void 0,maxHeight:void 0}}componentDidMount(){this.setPosition(this.props)}componentWillReceiveProps(e){this.setPosition(e)}setPosition({target:e,targetOffsetX:t,targetOffsetY:s,align:i="left"}){if(!(null==e?void 0:e.current))return;const a=e.current.getBoundingClientRect(),n=document.querySelector("[data-sidebar-container]");if(n){const e=n.getBoundingClientRect();"right"===i?this.setState({top:a.top-e.top+s,right:e.right-a.right+t,left:void 0}):this.setState({top:a.top-e.top+s,left:a.left-e.left+t,right:void 0})}else"right"===i?this.setState({top:a.top+s,right:window.innerWidth-a.right+t,left:void 0}):this.setState({top:a.top+s,left:a.left+t,right:void 0})}hasFixedParent(e){let t=e.parentElement;for(;t;){if("fixed"===window.getComputedStyle(t).position)return!0;t=t.parentElement}return!1}render(){const e=this.props,{className:t,maskClassName:s,domElementId:i,target:a,targetOffsetX:n,targetOffsetY:r,darken:o,children:c,align:h,onClickOutside:p}=e,u=d(e,["className","maskClassName","domElementId","target","targetOffsetX","targetOffsetY","darken","children","align","onClickOutside"]);return N.createElement(N.Fragment,null,M.createPortal(N.createElement(N.Fragment,null,N.createElement(ki,{className:L({[Ai]:!o},s),onClick:p}),N.createElement("div",l({"data-testid":"modal","data-align":h,className:L(Di,t),style:a&&this.state},u),c)),document.getElementById(i)))}}Ti.defaultProps={domElementId:"modal-root",targetOffsetX:0,targetOffsetY:20,darken:!1};var Pi=S(Ti);var Vi="_container_58c43_1";var ji=S((({className:e,target:t,targetOffsetX:s,targetOffsetY:i,darken:a,align:n,children:r,onClickOutside:l})=>N.createElement(Pi,{className:L(Vi,e),target:t,targetOffsetX:s,targetOffsetY:i,darken:a,onClickOutside:l,align:n},r)));var Fi="_container_bc1do_1",Bi="_pill_bc1do_8",Hi="_label_bc1do_26",qi="_open_bc1do_33",Zi="_exists_bc1do_43";var Ui="_tooltip_1bhvr_1",zi="_search_1bhvr_7",$i="_checkbox_1bhvr_30",Ji="_name_1bhvr_39",Wi="_type_1bhvr_50";class Ki extends N.PureComponent{constructor(){super(...arguments),this.button=N.createRef(),this.state={isOpen:!1,searchValue:""},this.handleToggle=()=>{this.setState((e=>({isOpen:!e.isOpen})))},this.handleSelect=async e=>{var t,s;null==(t=Bt.activeTab)||t.update({preview:!1});const i=null==(s=Bt.activeTab)?void 0:s.session.script;E((()=>{let t;t=i.fieldIds.includes(e)?i.fieldIds.filter((t=>t!==e)):i.fieldIds.concat(e),i.update({frozen:!1,fieldIds:t})}))},this.handleSearch=e=>{this.setState({searchValue:e})},this.handleSelectAll=async()=>{var e,t;null==(e=Bt.activeTab)||e.update({preview:!1});const s=null==(t=Bt.activeTab)?void 0:t.session.script;E((()=>{const e=s.fieldIds.length>0?[]:s.model.fieldIds;s.update({frozen:!1,fieldIds:e})}))}}render(){const{isOpen:e,searchValue:t}=this.state,{model:s,fieldIds:i}=Bt.activeTab.session.script,a=s.fields.filter((e=>e.name.toLowerCase().includes(t.toLowerCase()))),n=s.fieldIds.filter((e=>i.includes(e)));return N.createElement("div",{className:Fi},N.createElement("div",{"data-testid":"field-filter",ref:this.button,className:L(Bi,{[qi]:e,[Zi]:n.length0,indeterminate:n.lengththis.handleSelectAll()}),N.createElement(di,{type:"text",className:zi,placeholder:"Search",value:t,onChange:this.handleSearch}),a.map((e=>{const t=n.includes(e.id);return N.createElement(N.Fragment,{key:e.id},N.createElement(Oi,{className:$i,checked:t,onChange:()=>this.handleSelect(e.id)}),N.createElement("div",{"data-testid":"filter-option",className:Ji,onClick:()=>this.handleSelect(e.id)},e.name),N.createElement("div",{className:Wi,onClick:()=>this.handleSelect(e.id)},e.typeAsLabel))})))))}}var Gi=S(Ki);var Qi={tooltip:"_tooltip_13qj3_1",tooltipBody:"_tooltipBody_13qj3_4",text:"_text_13qj3_8",separator:"_separator_13qj3_15",input:"_input_13qj3_19"};class Yi extends N.PureComponent{constructor(){super(...arguments),this.button=N.createRef(),this.tooltipBody=N.createRef(),this.runScriptDebounced=h.exports.debounce((()=>{var e;(null==(e=Bt.activeTab)?void 0:e.session.script).run()}),300,{leading:!1,trailing:!0}),this.state={isOpen:!1},this.handleToggle=()=>{this.setState((e=>({isOpen:!e.isOpen})))},this.handleChangeTake=e=>{var t,s;null==(t=Bt.activeTab)||t.update({preview:!1});(null==(s=Bt.activeTab)?void 0:s.session.script).update({frozen:!1,pagination:{take:Number(e)}}),this.runScriptDebounced(),us.send({command:"pagination_change",commandDetails:{take_change:!0,skip_change:!1}})},this.handleChangeSkip=e=>{var t,s;null==(t=Bt.activeTab)||t.update({preview:!1});const i=Number(e);if(isNaN(i)||i<0)return;(null==(s=Bt.activeTab)?void 0:s.session.script).update({frozen:!1,pagination:{skip:i}}),this.runScriptDebounced(),us.send({command:"pagination_change",commandDetails:{take_change:!1,skip_change:!0}})}}render(){var e;const{isOpen:t}=this.state,{recordIds:s,model:i,pagination:a}=Bt.activeTab.session.script;return N.createElement("div",{className:Fi},N.createElement("div",{"data-testid":"page-filter",ref:this.button,className:L(Bi,{[qi]:t}),onClick:this.handleToggle},N.createElement("span",{className:Hi}," Showing "),N.createElement("span",null,N.createElement("span",{className:Qi.noPadding,"data-testid":"pagination__take"},s.length)," of ",N.createElement("span",{className:Qi.noPadding,"data-testid":"pagination__total"},null!=(e=i.count)?e:"?"))),t&&N.createElement(ji,{className:Qi.tooltip,target:this.button,onClickOutside:this.handleToggle,targetOffsetX:0,targetOffsetY:25},N.createElement("div",{className:Qi.tooltipBody,ref:this.tooltipBody},N.createElement("span",{className:Qi.text},"Take"),N.createElement(di,{"data-testid":"pagination__take-input",type:"number",tabIndex:0,focusOnMount:!0,className:Qi.input,value:String(a.take),onChange:this.handleChangeTake}),N.createElement("div",{className:Qi.separator}),N.createElement("span",{className:Qi.text},"Skip"),N.createElement(di,{"data-testid":"pagination__skip-input",type:"number",tabIndex:0,focusOnMount:!0,className:Qi.input,value:String(a.skip),onChange:this.handleChangeSkip}))),t&&N.createElement(li,{keys:"esc",target:this.tooltipBody,onMatch:()=>this.handleToggle()}))}}var Xi=S(Yi);class ea extends N.PureComponent{constructor(){super(...arguments),this.button=N.createRef(),this.handleAddWhere=()=>{var e,t;null==(e=Bt.activeTab)||e.update({preview:!1});const s=null==(t=Bt.activeTab)?void 0:t.session.script;s.update({frozen:!1});const i=s.where.add({fieldIds:[s.model.uniqueIdentifier.fields[0].id],value:null});s.pagination.reset(),us.send({command:"filter_change",commandDetails:{total_filters_count:s.where.size,field_types:i.fields.map((e=>e.type)),operation:i.operation}})}}render(){const{where:e}=Bt.activeTab.session.script;return N.createElement("div",{className:Fi},N.createElement("div",{"data-testid":"where-filter",ref:this.button,className:L(Bi,{[Zi]:e.size>0}),onClick:()=>Bt.activeTab.toggleFilterPanel()}," ",N.createElement("span",{className:L(Hi)},"Filters"),N.createElement("span",null,e.size||"None"," ")))}}var ta=S(ea);var sa={container:"_container_1n6lm_1",separator:"_separator_1n6lm_6",action:"_action_1n6lm_13",discardBtn:"_discardBtn_1n6lm_16"};class ia extends N.PureComponent{constructor(){super(...arguments),this.handleDiscard=()=>{const{onSuccess:e}=this.props;Os.discard(),null==e||e(),us.send({command:"action_discard",commandDetails:{pending_action_count:Os.actions.length}})},this.handleCommit=async()=>{const{onSuccess:e,onFailure:t}=this.props;try{console.log("Actions before commit:",Os.actions),await Os.commit(),null==e||e()}catch(s){console.error("Commit failed:",s),null==t||t()}us.send({command:"action_commit",commandDetails:{pending_action_count:Os.actions.length}})}}render(){const e=Os.actions.filter((e=>"create"!==e.type||!Os.actions.find((t=>t.recordId===e.recordId)))).length,t=Os.invalidActions.length;return 0===e?null:N.createElement(N.Fragment,null,N.createElement("div",{className:sa.separator}),N.createElement("div",{"data-testid":"pending-actions",className:L(sa.container,this.props.className)},N.createElement(si,{"data-testid":"commit-actions",green:!0,className:L(sa.action,sa.confirmBtn),disabled:t>0||Os.committing,onClick:this.handleCommit},Os.committing?"Saving Changes":`Save ${e} change${e>1?"s":""}`),N.createElement(si,{"data-testid":"discard-actions",ghost:!0,disabled:Os.committing,className:L(sa.action,sa.discardBtn),onClick:this.handleDiscard},"Discard changes"),N.createElement(li,{keys:"mod+s",onMatch:()=>Os.commit()})))}}var aa=S(ia);function na(e){return R.exports.createElement("svg",Object.assign({viewBox:"0 0 24 24",xmlns:"http://www.w3.org/2000/svg"},e),R.exports.createElement("path",{fillRule:"evenodd",clipRule:"evenodd",d:"M14 1.71429C14 0.767512 13.1046 0 12 0C10.8954 0 10 0.767512 10 1.71429V10L1.71429 10C0.767512 10 0 10.8954 0 12C0 13.1046 0.767512 14 1.71429 14L10 14V22.2857C10 23.2325 10.8954 24 12 24C13.1046 24 14 23.2325 14 22.2857V14L22.2857 14C23.2325 14 24 13.1046 24 12C24 10.8954 23.2325 10 22.2857 10L14 10V1.71429Z"}))}var ra="_filters_1cwxq_1",la="_cell_1cwxq_29",oa="_fields_1cwxq_35",da="_field_1cwxq_35",ca="_dropdown_1cwxq_43",ha="_operation_1cwxq_49",pa="_value_1cwxq_50",ua="_deleteButton_1cwxq_106",ma="_addButton_1cwxq_129",ga="_removeButton_1cwxq_178",va="_infoBox_1cwxq_189",fa="_container_1cwxq_193",ya="_containerHidden_1cwxq_201",Ia="_containerWithoutFilters_1cwxq_205",Ca="_filterControlsRow_1cwxq_210",wa="_filterControlsRowWithoutFilters_1cwxq_214",ba="_invalid_1cwxq_218",Ea="_relationType_1cwxq_222";function _a(e){return R.exports.createElement("svg",Object.assign({viewBox:"0 0 24 24",xmlns:"http://www.w3.org/2000/svg"},e),R.exports.createElement("g",null,R.exports.createElement("circle",{cx:6,cy:12,r:2}),R.exports.createElement("circle",{cx:12,cy:12,r:2}),R.exports.createElement("circle",{cx:18,cy:12,r:2})))}var xa="_container_1u411_1",Sa="_button_1u411_7",Na="_open_1u411_18",La="_textButton_1u411_27",Ra="_caret_1u411_46",Oa="_select_1u411_56";var Ma="_container_32t9m_1",ka="_mask_32t9m_25",Da="_item_32t9m_29",Aa="_highlighted_32t9m_37";class Ta extends N.PureComponent{constructor(e){super(e),this.menuRef=N.createRef(),this.itemRefs=[],this.handleHighlightNext=()=>{const{items:e}=this.props;this.setState((t=>t.highlightIndex===e.length-1?{highlightIndex:0}:{highlightIndex:t.highlightIndex+1}),(()=>{var e,t;null==(e=this.itemRefs[this.state.highlightIndex].current)||e.scrollIntoView(!1),null==(t=this.itemRefs[this.state.highlightIndex].current)||t.scrollIntoView({block:"nearest"})}))},this.handleHighlightPrevious=()=>{const{items:e}=this.props;this.setState((t=>0===t.highlightIndex||-1===t.highlightIndex?{highlightIndex:e.length-1}:{highlightIndex:t.highlightIndex-1}),(()=>{var e,t;null==(e=this.itemRefs[this.state.highlightIndex].current)||e.scrollIntoView(!1),null==(t=this.itemRefs[this.state.highlightIndex].current)||t.scrollIntoView({block:"nearest"})}))},this.handleSelect=()=>{const{highlightIndex:e}=this.state,{items:t,onSelect:s}=this.props;e<0||e>=t.length||s(t[e])},this.handleCancel=e=>{e.preventDefault()},this.state={highlightIndex:-1},this.itemRefs=e.items.map((()=>N.createRef()))}componentDidMount(){var e,t;(null==(e=this.props.target.current)?void 0:e.getBoundingClientRect())&&(null==(t=this.menuRef.current)||t.focus())}render(){const{highlightIndex:e}=this.state,{target:t,items:s,onSelect:i,onBlur:a}=this.props;return N.createElement(Pi,{className:Ma,maskClassName:ka,domElementId:"dropdown-root",target:t,targetOffsetY:0,darken:!1,onClickOutside:a},N.createElement(N.Fragment,null,N.createElement("div",{ref:this.menuRef,className:Ma,tabIndex:1},s.map(((t,s)=>N.createElement("div",{ref:this.itemRefs[s],key:t.id,"data-testid":"dropdown-menu__item",className:L(Da,{[Aa]:e===s}),onClick:()=>i(t)},t.label)))),N.createElement(li,{keys:"up",target:this.menuRef,onMatch:this.handleHighlightPrevious}),N.createElement(li,{keys:"down",target:this.menuRef,onMatch:this.handleHighlightNext}),N.createElement(li,{keys:"esc",target:this.menuRef,onMatch:()=>null==a?void 0:a()}),N.createElement(li,{keys:"enter",target:this.menuRef,onMatch:this.handleSelect})))}}var Pa=S(Ta);class Va extends N.PureComponent{constructor(){super(...arguments),this.button=N.createRef(),this.state={isOpen:!1},this.handleToggle=()=>{this.state.isOpen?this.handleClose():this.handleOpen()},this.handleSelect=e=>{const{onSelect:t}=this.props;t&&t(e),setTimeout((()=>this.handleToggle()),0)},this.handleOpen=()=>{setTimeout((()=>this.setState({isOpen:!0})),0)},this.handleClose=()=>{setTimeout((()=>this.setState({isOpen:!1})),0)}}render(){const e=this.props,{className:t,type:s,nativeSelect:i,items:a,selectedItem:n,onSelect:r,innerRef:o,buttonClassName:c}=e,h=d(e,["className","type","nativeSelect","items","selectedItem","onSelect","innerRef","buttonClassName"]),{isOpen:p}=this.state;return N.createElement("div",{className:L(xa,t)},N.createElement("div",l({ref:this.button,className:L(Sa,{[Na]:p},c),onClick:this.handleToggle},h),"button"===s&&N.createElement(_a,null),"text"===s&&N.createElement("div",{"data-testid":"dropdown__item--selected",className:La,title:null==n?void 0:n.label},N.createElement("span",null,(null==n?void 0:n.label)||""),N.createElement("div",{className:Ra}))),i&&N.createElement("select",{ref:o,className:Oa,value:null==n?void 0:n.id,onChange:e=>this.handleSelect(a.find((t=>t.id===e.currentTarget.value)))},a.map((e=>N.createElement("option",{key:e.id,value:e.id},e.label)))),p&&!i&&N.createElement(Pa,{target:this.button,items:a,onSelect:this.handleSelect,onBlur:this.handleClose}))}}var ja=S(Va);class Fa extends N.PureComponent{constructor(){super(...arguments),this.runScriptDebounced=h.exports.debounce((()=>{var e;(null==(e=Bt.activeTab)?void 0:e.session.script).run()}),500,{leading:!1,trailing:!0}),this.handleChangeField=({id:e},t)=>{var s,i,a,n;const{whereId:r}=this.props;null==(s=Bt.activeTab)||s.update({preview:!1});const l=null==(i=Bt.activeTab)?void 0:i.session.script,o=l.where.get(r);if(o){if(l.update({frozen:!1}),0===t){const t=fe.get(e);if(null==t?void 0:t.isRelation){const t=null==(n=null==(a=fe.get(e))?void 0:a.typeAsModel)?void 0:n.uniqueIdentifier.fields[0].id;o.update({fieldIds:[e,t]})}else o.update({fieldIds:[e]})}else{const s=[...o.fieldIds];s[t]=e,o.update({fieldIds:s})}o.supportedOperations.includes(o.operation)||this.handleChangeOperation({id:o.supportedOperations[0]}),["in","notIn"].includes(o.operation)&&this.handleChangeValue("[]"),this.runScriptDebounced(),us.send({command:"filter_change",commandDetails:{total_filters_count:l.where.size,field_types:o.fields.map((e=>e.type)),operation:o.operation}})}},this.handleChangeOperation=({id:e})=>{var t,s;const{whereId:i}=this.props;null==(t=Bt.activeTab)||t.update({preview:!1});const a=null==(s=Bt.activeTab)?void 0:s.session.script,n=a.where.get(i);n&&(a.update({frozen:!1}),n.update({operation:e}),["in","notIn"].includes(n.operation)&&this.handleChangeValue("[]"),["isNull","isNotNull"].includes(n.operation)&&this.handleChangeValue(""),this.runScriptDebounced(),us.send({command:"filter_change",commandDetails:{total_filters_count:a.where.size,field_types:n.fields.map((e=>e.type)),operation:n.operation}}))},this.handleChangeValue=e=>{var t,s;const{whereId:i}=this.props;null==(t=Bt.activeTab)||t.update({preview:!1});const a=null==(s=Bt.activeTab)?void 0:s.session.script;a.update({frozen:!1});const n=a.where.get(i);n&&(n.update({value:e}),this.runScriptDebounced())},this.handleDelete=()=>{var e,t;const{whereId:s}=this.props;null==(e=Bt.activeTab)||e.update({preview:!1});const i=null==(t=Bt.activeTab)?void 0:t.session.script;Object.values(i.where.values).length,i.where.remove(s),this.runScriptDebounced()}}render(){const{whereId:e,rowIndex:t}=this.props,s=Bt.activeTab.session.script.where.get(e);return s?N.createElement(N.Fragment,null,N.createElement("div",{className:L(oa,la)},N.createElement("div",{className:da},N.createElement("div",{className:Ea},0===t?"where":"and"))),N.createElement("div",{className:L(oa,la)},s.fields.slice(0,2).map(((e,t)=>N.createElement("div",{className:da,key:t},N.createElement(ja,{"data-testid":"where-filter__row__field"+(t>0?"_relation_scalars":""),"data-test-invalid":!s.isValid,buttonClassName:ca,type:"text",items:s.getFilterableFieldsAtIndex(t).map((e=>({id:e.id,label:e.name}))),selectedItem:{id:e.id,label:e.name},onSelect:e=>this.handleChangeField(e,t)}))))),N.createElement("div",{className:L(ha,la)},N.createElement(ja,{"data-testid":"where-filter__row__operation",buttonClassName:ca,type:"text",items:s.supportedOperations.map((e=>({id:e,label:e}))),selectedItem:{id:s.operation,label:s.operation},onSelect:this.handleChangeOperation})),N.createElement("div",{className:L(pa,la)},N.createElement("input",{className:L({[ba]:!s.isValid}),"data-testid":"where-filter__row__value",type:"text",disabled:"isNull"===s.operation||"isNotNull"===s.operation,placeholder:"enter value...",value:null===s.value?"":s.value,onChange:e=>this.handleChangeValue(e.currentTarget.value)})),N.createElement("div",{className:L(ua,la)},N.createElement(ri,{"data-testid":"where-filter__row__delete-btn",onClick:this.handleDelete},N.createElement(na,null)))):null}}var Ba=S(Fa);class Ha extends N.PureComponent{constructor(){super(...arguments),this.handleAddWhere=()=>{var e,t;null==(e=Bt.activeTab)||e.update({preview:!1});const s=null==(t=Bt.activeTab)?void 0:t.session.script;s.update({frozen:!1});const i=s.where.add({fieldIds:[s.model.uniqueIdentifier.fields[0].id],value:null});s.pagination.reset(),us.send({command:"filter_change",commandDetails:{total_filters_count:s.where.size,field_types:i.fields.map((e=>e.type)),operation:i.operation}})},this.handleResetFilters=()=>{var e,t;null==(e=Bt.activeTab)||e.update({preview:!1});const s=null==(t=Bt.activeTab)?void 0:t.session.script;s.where.clear(),s.run()}}render(){const{where:e}=Bt.activeTab.session.script,t=Object.values(e.values).length>0;return N.createElement("div",{className:L(fa,{[Ia]:0===Object.values(e.values).length},{[ya]:!Bt.activeTab.isFiltersOpen})},t?N.createElement("div",{className:ra},Object.values(e.values).map(((e,t)=>N.createElement(Ba,{rowIndex:t,key:e.id,whereId:e.id})))):N.createElement("div",{className:va},"ℹ️ Use filters to narrow your search results. Multiple filters show results at their intersection (AND)."),N.createElement("div",{className:t?Ca:wa},N.createElement(si,{"data-testid":"create-where-filter-btn",className:ma,blue:!0,onClick:this.handleAddWhere},N.createElement(N.Fragment,null,N.createElement(na,null),"Add a new filter")),t&&N.createElement(N.Fragment,null,N.createElement(si,{className:ga,onClick:this.handleResetFilters},"Clear all"))))}}var qa=S(Ha);var Za={toggleButton:"_toggleButton_hwrx9_1",themeToggle:"_themeToggle_hwrx9_2",maximizeButton:"_maximizeButton_hwrx9_3",studioContainer:"_studioContainer_hwrx9_32",studioOverlay:"_studioOverlay_hwrx9_38",rightOpen:"_rightOpen_hwrx9_50",sidebarContainer:"_sidebarContainer_hwrx9_58",open:"_open_hwrx9_66",sidebar:"_sidebar_hwrx9_58",right:"_right_hwrx9_50",content:"_content_hwrx9_109"};var Ua={form:"_form_xd1d4_1",field:"_field_xd1d4_7",label:"_label_xd1d4_16",input:"_input_xd1d4_22",json:"_json_xd1d4_41",checkboxInput:"_checkboxInput_xd1d4_49",switch:"_switch_xd1d4_68",relationWrapper:"_relationWrapper_xd1d4_92",relationHeader:"_relationHeader_xd1d4_98",relationGrid:"_relationGrid_xd1d4_102",relationItemRowHeader:"_relationItemRowHeader_xd1d4_106",relationItemRow:"_relationItemRow_xd1d4_106",column:"_column_xd1d4_118",checkboxColumn:"_checkboxColumn_xd1d4_119",column_id:"_column_id_xd1d4_141",cell:"_cell_xd1d4_147",relationList:"_relationList_xd1d4_152",relationItems:"_relationItems_xd1d4_161",relationTableHeader:"_relationTableHeader_xd1d4_176"};var za="_val_1jd4a_10",$a="_input_1jd4a_16";const Ja=({value:e,onChange:t,className:s,label:i})=>{const a=e=>e?e.slice(0,16):"",[n,r]=R.exports.useState(a(e));R.exports.useEffect((()=>{r(a(e))}),[e]);return N.createElement("div",{className:L($a,s)},i&&N.createElement("label",null,i," ",N.createElement("small",{className:za},e)),t&&N.createElement("input",{type:"datetime-local",value:n,onChange:e=>{const s=e.target.value;var i;r(s),null==t||t((i=s)?new Date(i).toISOString():"")},className:L(Ua.input,Ua.datetime)}))},Wa=({checked:e,onChange:t})=>{const[s,i]=R.exports.useState(e);return N.createElement(N.Fragment,null,N.createElement("label",{className:Ua.checkboxInput},N.createElement("input",{type:"checkbox",checked:s,onChange:e=>{i(e.target.checked),t(e.target.checked)}}),N.createElement("span",{className:Ua.switch},N.createElement("span",null))))},Ka=({record:e,fieldName:t,currentValue:s,onToggle:i,relationOptions:a})=>{var n;const[r,l]=N.useState((()=>(s||[]).some((t=>t.id===e.valueInDB.id))));N.useEffect((()=>{const t=(s||[]).some((t=>t.id===e.valueInDB.id));l(t)}),[s,e.valueInDB.id]);const o=a=>{const n=a.target.checked;l(n);const r=Array.isArray(s)?s:[];let o;o=n?r.some((t=>t.id===e.valueInDB.id))?r:[...r,{id:e.valueInDB.id}]:r.filter((t=>t.id!==e.valueInDB.id)),i(t,o,e.valueInDB.id,n)},d=e=>e?N.createElement("label",{className:Ua.relationItemRow},N.createElement("div",{className:Ua.checkboxColumn},N.createElement("div",{className:Ua.cell},N.createElement("input",{type:"checkbox",checked:r,onChange:o,className:Ua.relationCheckbox}))),Object.entries(e).map((([e,t],s)=>N.createElement("span",{key:s,className:`${Ua.column} ${Ua[`column_${e}`]}`},N.createElement("div",{className:Ua.cell},String(t)))))):"Loading...";return e.valueInDB.id===(null==(n=a[0])?void 0:n.valueInDB.id)?N.createElement(N.Fragment,null,N.createElement("li",{className:Ua.relationTableHeader},(c=e.valueInDB)?N.createElement("div",{className:Ua.relationItemRowHeader},N.createElement("div",{className:Ua.checkboxColumn},N.createElement("div",{className:Ua.cell})),Object.entries(c).map((([e],t)=>N.createElement("span",{key:t,className:`${Ua.column} ${Ua[`column_${e}`]}`},N.createElement("div",{className:Ua.cell},e))))):null),N.createElement("li",{className:Ua.relationItem},d(e.valueInDB))):N.createElement("li",{className:Ua.relationItem},d(e.valueInDB));var c},Ga=({data:e,onUpdate:t})=>{const s=(s,i)=>{E((()=>{var a;console.log("Updating field:",s,"with value:",i);const n=o(l({},e.value),{[s]:i});console.log("Full updated value:",n),null==t||t(n);const r=null==(a=Bt.activeTab)?void 0:a.sessionId;r&&Os.add({type:"update",recordId:e.id,sessionId:r,value:{[s]:i}})}))},[i,a]=N.useState({}),[n,r]=N.useState({});N.useEffect((()=>{const t={};Object.entries(e.value).forEach((([s,i])=>{var a;const n=null==(a=e.model)?void 0:a.getFieldByName(s);(null==n?void 0:n.isRelation)&&n.isList&&(t[s]=Array.isArray(i)?i:[])})),r(t)}),[e]);const d=(e,t,i,a)=>{const d=n[e]||[];let c;c=a?d.some((e=>e.id===i))?d:[...d,{id:i}]:d.filter((e=>e.id!==i)),r((t=>o(l({},t),{[e]:c}))),s(e,c)},c=(e,t,r)=>{var c,h,p;const[u,m]=N.useState(t||""),g=t=>{m(t.target.value),s(e,t.target.value)};if(r.isString)return N.createElement("input",{type:"text",value:u,onChange:g,className:L(Ua.input,Ua.string),autoComplete:"off",autoCorrect:"off",autoCapitalize:"off",spellCheck:"false","data-form-type":"other",name:"no-remember",translate:"no"});if(r.isInt||r.isFloat||r.isDecimal){const[i,a]=N.useState(t||""),n=t=>{const i=t.target.value;a(i);const n=r.isInt?parseInt(i,10):parseFloat(i);s(e,n)};return N.createElement("input",{type:"number",value:i,onChange:n,className:L(Ua.input,Ua.number),autoComplete:"off",autoCorrect:"off",autoCapitalize:"off",spellCheck:"false","data-form-type":"other",name:"no-remember",translate:"no"})}if(r.isEnum)return N.createElement("select",{value:t||"",onChange:t=>s(e,t.target.value),className:L(Ua.input,Ua.enum),autoComplete:"off",autoCorrect:"off",autoCapitalize:"off",spellCheck:"false","data-form-type":"other",name:"no-remember",translate:"no"},N.createElement("option",{value:""},"Select ",e),null==(c=r.typeAsEnum)?void 0:c.values.map((e=>N.createElement("option",{key:e,value:e},e))));if(r.isBoolean)return N.createElement(N.Fragment,null,N.createElement(Wa,{checked:t||!1,onChange:t=>s(e,t)}));if(r.isDateTime)return N.createElement(Ja,{value:t,onChange:t=>s(e,t)});if(r.isRelation){N.useEffect((()=>{(async e=>{if(e.typeAsModel)try{console.log("Loading relations for field:",{fieldName:e.name,fieldType:e.type,modelId:e.typeAsModel.id});const t=Mt.add({name:null,frozen:!0,modelId:e.typeAsModel.id,fieldIds:e.typeAsModel.fieldIds},{skipPersist:!0});await t.run(),a((s=>o(l({},s),{[e.name]:t.records})))}catch(t){console.error("Failed to load relation options:",t),a((t=>o(l({},t),{[e.name]:[]})))}})(r)}),[r]);const s=i[r.name]||[],c=n[e]||t||[];return N.createElement("div",{className:Ua.relationWrapper},r.isList?N.createElement("div",{className:Ua.relationList},N.createElement("div",{className:Ua.relationHeader},r.name," (",c.length," items)"),N.createElement("ul",{className:Ua.relationItems},s.map((t=>N.createElement(Ka,{key:t.valueInDB.id,record:t,fieldName:e,currentValue:c,onToggle:d,relationOptions:s}))))):N.createElement("div",{className:Ua.relationSingle},N.createElement("div",{className:Ua.relationHeader},r.name),t?N.createElement("div",{className:Ua.relationItem},(null==(p=null==(h=r.typeAsModel)?void 0:h.fields[0])?void 0:p.name)?t[r.typeAsModel.fields[0].name]:t.id):N.createElement("div",{className:Ua.relationEmpty},"No relation set")))}return N.createElement("div",{className:Ua.readOnly},JSON.stringify(t))};return N.createElement("div",{className:Ua.form},Object.entries(e.value).map((([t,s])=>{var i;const a=null==(i=e.model)?void 0:i.getFieldByName(t);return a?N.createElement("div",{key:t,className:Ua.field},!a.isList&&N.createElement("label",{className:Ua.label},t),c(t,s,a)):(console.warn(`Field not found for fieldName: ${t}`),null)})))};function Qa(e){return R.exports.createElement("svg",Object.assign({xmlns:"http://www.w3.org/2000/svg",viewBox:"0 0 24 24",fill:"none",stroke:"currentColor",strokeWidth:2,strokeLinecap:"round",strokeLinejoin:"round"},e),R.exports.createElement("path",{d:"M8 3H5a2 2 0 0 0-2 2v3"}),R.exports.createElement("path",{d:"M21 8V5a2 2 0 0 0-2-2h-3"}),R.exports.createElement("path",{d:"M3 16v3a2 2 0 0 0 2 2h3"}),R.exports.createElement("path",{d:"M16 21h3a2 2 0 0 0 2-2v-3"}))}function Ya(e){return R.exports.createElement("svg",Object.assign({xmlns:"http://www.w3.org/2000/svg",width:24,height:24,viewBox:"0 0 24 24",fill:"none",stroke:"currentColor",strokeWidth:2,strokeLinecap:"round",strokeLinejoin:"round"},e),R.exports.createElement("path",{d:"M8 3v3a2 2 0 0 1-2 2H3"}),R.exports.createElement("path",{d:"M21 8h-3a2 2 0 0 1-2-2V3"}),R.exports.createElement("path",{d:"M3 16h3a2 2 0 0 1 2 2v3"}),R.exports.createElement("path",{d:"M16 21v-3a2 2 0 0 1 2-2h3"}))}function Xa(e){return R.exports.createElement("svg",Object.assign({xmlns:"http://www.w3.org/2000/svg",width:24,height:24,viewBox:"0 0 24 24",fill:"none",stroke:"currentColor",strokeWidth:2,strokeLinecap:"round",strokeLinejoin:"round"},e),R.exports.createElement("path",{d:"M12 3a6 6 0 0 0 9 9 9 9 0 1 1-9-9Z"}))}function en(e){return R.exports.createElement("svg",Object.assign({xmlns:"http://www.w3.org/2000/svg",viewBox:"0 0 24 24",fill:"none",stroke:"currentColor",strokeWidth:2,strokeLinecap:"round",strokeLinejoin:"round"},e),R.exports.createElement("rect",{width:18,height:18,x:3,y:3,rx:2}),R.exports.createElement("path",{d:"M9 3v18"}))}function tn(e){return R.exports.createElement("svg",Object.assign({xmlns:"http://www.w3.org/2000/svg",width:24,height:24,viewBox:"0 0 24 24",fill:"none",stroke:"currentColor",strokeWidth:2,strokeLinecap:"round",strokeLinejoin:"round"},e),R.exports.createElement("circle",{cx:12,cy:12,r:4}),R.exports.createElement("path",{d:"M12 2v2"}),R.exports.createElement("path",{d:"M12 20v2"}),R.exports.createElement("path",{d:"m4.93 4.93 1.41 1.41"}),R.exports.createElement("path",{d:"m17.66 17.66 1.41 1.41"}),R.exports.createElement("path",{d:"M2 12h2"}),R.exports.createElement("path",{d:"M20 12h2"}),R.exports.createElement("path",{d:"m6.34 17.66-1.41 1.41"}),R.exports.createElement("path",{d:"m19.07 4.93-1.41 1.41"}))}const sn=R.exports.createContext(void 0),an=({children:e})=>{const[t,s]=R.exports.useState(!1),[i,a]=R.exports.useState(!1),[n,r]=R.exports.useState(!1),[l,o]=R.exports.useState(null);return N.createElement(sn.Provider,{value:{isOpen:t,setIsOpen:s,isRightOpen:i,setIsRightOpen:a,toggle:()=>s((e=>!e)),toggleRight:()=>a((e=>!e)),maximize:()=>r((e=>!e)),isMaximized:n,sidebarData:l,setSidebarData:o}},N.createElement("div",{className:L(Za.sidebarContainer,{[Za.open]:t},{[Za.rightOpen]:i},{[Za.maximized]:n}),"data-sidebar-container":!0,"data-state":t?"open":"closed","data-right-state":i?"open":"closed","data-maximized":n},e))},nn=()=>{const e=R.exports.useContext(sn);if(!e)throw new Error("useSidebar must be used within a SidebarProvider");return e},rn=()=>{const{maximize:e,isMaximized:t}=nn();return N.createElement("button",{onClick:()=>{E((()=>{t&&zt.apply("light"),e()}))},className:Za.maximizeButton},t?N.createElement(Ya,null):N.createElement(Qa,null))},ln=()=>{const{isMaximized:e}=nn(),[t,s]=N.useState(zt.theme);N.useEffect((()=>{E((()=>{e||zt.apply("light")}));const t=D(zt,"theme",(e=>{E((()=>{s(e.newValue)}))}));return()=>t()}),[e]);return N.createElement("button",{onClick:()=>{E((()=>{e&&zt.apply("light"===t?"dark":"light")}))},className:Za.themeToggle},"light"===t?N.createElement(Xa,null):N.createElement(tn,null))},on=()=>{const{toggle:e}=nn();return N.createElement("button",{onClick:e,className:Za.toggleButton},N.createElement(en,null))},dn=({children:e})=>{const{isOpen:t}=nn();return N.createElement("div",{className:L(Za.sidebar,{[Za.open]:t}),"data-state":t?"open":"closed"},N.createElement("div",{className:Za.content},e))},cn=({children:e})=>{const{isRightOpen:t,sidebarData:s,setIsRightOpen:i,setSidebarData:a}=nn(),n=N.useRef(null);return N.useEffect((()=>{s&&k(s.data)?console.log("sidebarData.data is observable"):console.warn("sidebarData.data is not observable")}),[s]),N.useEffect((()=>{E((()=>{!t&&a&&a(null)}))}),[t,a]),N.useEffect((()=>{if(!(null==s?void 0:s.data))return;const e=D(s.data,(e=>{"update"===e.type&&"value"===e.name&&E((()=>{null==a||a({data:s.data,onUpdate:s.onUpdate})}))}));return()=>e()}),[s,a]),N.useEffect((()=>{const e=e=>{n.current&&!n.current.contains(e.target)&&t&&E((()=>{i(!1)}))};return document.addEventListener("mousedown",e),()=>{document.removeEventListener("mousedown",e)}}),[t,i]),N.createElement("div",{ref:n,className:L(Za.sidebar,{[Za.right]:!0,[Za.open]:t}),"data-state":t?"open":"closed"},N.createElement("div",{className:Za.content},s&&N.createElement(Ga,{data:s.data,onUpdate:s.onUpdate}),e))},hn=({children:e})=>{const{isRightOpen:t,isOpen:s}=nn();return N.createElement("div",{className:L(Za.studioContainer,{[Za.rightOpen]:t,[Za.leftOpen]:s})},e,N.createElement("div",{className:L(Za.studioOverlay,{[Za.rightOpen]:t,[Za.leftOpen]:s})}))};var pn="_button_iu38q_1";function un({data:e,onUpdate:t}){const{toggleRight:s,setSidebarData:i,isRightOpen:a}=nn();return N.createElement("button",{"data-testid":"trigger-button",className:pn,onClick:()=>{console.log("Triggered with data:",e),a?(s(),setTimeout((()=>{null==i||i({data:e,onUpdate:t}),s()}),0)):(null==i||i({data:e,onUpdate:t}),s())}},N.createElement(en,null))}var mn="_container_u5odf_1",gn="_firstCommittedRow_u5odf_7",vn="_tableCell_u5odf_11",fn="_dirty_u5odf_11",yn="_invalid_u5odf_15",In="_empty_u5odf_19";var Cn="_input_1ebqz_1";class wn extends N.PureComponent{constructor(e){super(e),this.input=N.createRef(),this.getValue=()=>this.state.value,this.focus=()=>{var e;null==(e=this.input.current)||e.focus()},this.handleChange=e=>{const t=e.currentTarget.value;if(""!==t)try{const e=BigInt(t);this.setState({value:e})}catch(s){}else this.setState({value:null})};const{initialValue:t}=e,s=null==t?null:BigInt(t);this.state={value:s}}render(){const{value:e}=this.state;return N.createElement("input",{"data-testid":"input--bigint",ref:this.input,className:Cn,type:"string",value:null==e?"":e.toString(),placeholder:"null",onChange:this.handleChange})}}var bn=S(wn);var En="_container_1f6qf_1";class _n extends N.PureComponent{constructor(){super(...arguments),this.handleDragStart=e=>{e.dataTransfer.effectAllowed="move",e.dataTransfer.setData("text/html",e.target.parentNode),e.dataTransfer.setDragImage(e.target.parentNode,20,20),this.props.onDragStart(e)},this.handleDragEnd=e=>{this.props.onDragEnd(e)}}render(){const e=this.props,{className:t,children:s}=e,i=d(e,["className","children"]);return N.createElement("div",o(l({draggable:!0,className:L(En,t)},i),{onDragStart:e=>this.handleDragStart(e),onDragEnd:e=>this.handleDragEnd(e)}),s)}}var xn=S(_n);function Sn(e){return R.exports.createElement("svg",Object.assign({viewBox:"0 0 24 24",xmlns:"http://www.w3.org/2000/svg"},e),R.exports.createElement("path",{opacity:.5,fillRule:"evenodd",clipRule:"evenodd",d:"M24 10H0V6H24V10Z",fill:"currentColor"}),R.exports.createElement("path",{opacity:.5,fillRule:"evenodd",clipRule:"evenodd",d:"M24 18H0V14H24V18Z",fill:"currentColor"}))}var Nn="_container_i5u05_1",Ln="_input_i5u05_7",Rn="_itemContainer_i5u05_27",On="_itemScrollContainer_i5u05_45",Mn="_item_i5u05_27",kn="_invalid_i5u05_53",Dn="_dragButton_i5u05_63",An="_closeButton_i5u05_77",Tn="_addScalarListItemBtn_i5u05_101",Pn="_separator_i5u05_109",Vn="_draggedOver_i5u05_113";class jn extends N.PureComponent{constructor(e){super(e),this.items=[],this.draggedItem=null,this.getValue=()=>this.state.value,this.focus=()=>{var e;const{value:t}=this.state;t&&(null==(e=this.items[Math.max(t.length,0)].current)||e.focus())},this.handleChange=e=>{try{const t=JSON.parse(e.currentTarget.value);Array.isArray(t)&&this.setState({value:t.map((e=>BigInt(e)))})}catch(t){}},this.handleChangeItem=(e,t)=>{const{value:s}=this.state;try{let i=BigInt(t.currentTarget.value);if(!Array.isArray(s))throw U({path:"BigIntListInput.handleChangeItem",message:"Invalid value",context:{value:s,idx:e,changedItem:i}});const a=[...s];return a.splice(e,1,i),this.setState({value:a})}catch(i){}},this.handleChangeNewItem=e=>{try{let t=BigInt(e.currentTarget.value);this.setState({newItem:t})}catch(t){}},this.handleAddNewItem=()=>{const{value:e,newItem:t}=this.state;if(!Array.isArray(e))throw U({path:"BigIntListInput.handleAddItem",message:"Invalid value",context:{value:e,newItem:t}});this.items.push(N.createRef()),this.setState({value:[...e,t||BigInt(0)],newItem:null},(()=>{var e,t;null==(e=this.items[this.items.length-1].current)||e.focus(),null==(t=this.items[this.items.length-2].current)||t.scrollIntoView(!1)}))},this.handleEnterKeydown=e=>{const{value:t}=this.state;if(!Array.isArray(t))throw U({path:"BigIntListInput.handleEnterKeydown",message:"Invalid value",context:{value:t,idx:e}});let s=[...t];s.splice(e+1,0,null),this.items.push(N.createRef()),this.setState({value:s,newItem:null},(()=>{var t,s,i;null==(t=this.items[e+1].current)||t.focus(),null==(s=this.items[e+1].current)||s.scrollIntoView(!1),null==(i=this.items[e+1].current)||i.scrollIntoView({block:"nearest"})}))},this.handleRemoveItem=e=>{var t,s,i,a;const{value:n}=this.state;if(!Array.isArray(n))throw U({path:"BigIntListInput.handleRemoveClick",message:"Invalid Value",context:{value:n,idx:e}});this.items.splice(e,1);const r=[...n];r.splice(e,1),null==(s=null==(t=this.items[e-1])?void 0:t.current)||s.focus(),null==(a=null==(i=this.items[e-1])?void 0:i.current)||a.scrollIntoView(),setTimeout((()=>this.setState({value:r})),0)},this.handleTabKeydown=(e,t)=>{var s;const{value:i}=this.state;if(!Array.isArray(i))throw U({path:"BigIntListInput.handleTabKeydown",message:"Invalid value",context:{value:i,idx:e}});e===i.length||(t.preventDefault(),t.stopPropagation(),null==(s=this.items[e+1].current)||s.focus())},this.handleShiftTabKeydown=(e,t)=>{var s;0===e||(t.preventDefault(),t.stopPropagation(),null==(s=this.items[e-1].current)||s.focus())},this.handleFinishEditing=()=>{this.props.stopEditing()},this.handleDragStart=e=>{this.draggedItem=this.items[e]},this.handleDragOver=(e,t)=>{t.preventDefault(),this.setState({draggedOverIdx:e})},this.handleDragEnd=e=>{var t,s;if(!this.draggedItem)return;const{value:i=[]}=this.state;if(!Array.isArray(i))throw U({path:"BigIntListInput.HandleDragEnd",message:"Invalid value",context:{value:i,idx:e}});const a=[...i];let n=BigInt(null!=(s=null==(t=this.draggedItem.current)?void 0:t.value)?s:0);this.items.splice(e,1),a.splice(e,1),this.state.draggedOverIdx>e?(this.items.splice(this.state.draggedOverIdx-1,0,this.draggedItem),a.splice(this.state.draggedOverIdx-1,0,n)):(this.items.splice(this.state.draggedOverIdx,0,this.draggedItem),a.splice(this.state.draggedOverIdx,0,n)),this.draggedItem=null,this.setState({value:a,draggedOverIdx:-1})};const{initialValue:t}=e;if(!Array.isArray(t))throw U({path:"BigIntListInput.constructor",message:"Invalid initialValue",context:{initialValue:t}});this.state={value:t.map((e=>BigInt(e))),newItem:null,draggedOverIdx:-1},this.items=Array.from({length:Math.max(t.length,1)}).map((()=>N.createRef())),this.items.push(N.createRef())}render(){const{value:e}=this.state;if(!Array.isArray(e))throw U({path:"BigIntListInput.render",message:"Invalid value",context:{value:e}});return N.createElement(N.Fragment,null,N.createElement("div",{"data-testid":"input--bigint-list",className:Nn},N.createElement("input",{type:"text",className:Ln,value:e.map((e=>(null==e?void 0:e.toString())||"null")),onChange:this.handleChange}),N.createElement("ul",{className:L(Rn,"ag-theme-dark")},N.createElement("div",{className:On},N.createElement("div",{className:L(Pn,{[Vn]:0===this.state.draggedOverIdx})}),e.map(((e,t)=>N.createElement(N.Fragment,{key:t},N.createElement(Fn,{innerRef:this.items[t],value:null===e?"":e.toString(),invalid:null===e||Number.isNaN(e),onChange:this.handleChangeItem.bind(this,t),onRemove:this.handleRemoveItem.bind(this,t),onEnter:this.handleEnterKeydown.bind(this,t),onTab:this.handleTabKeydown.bind(this,t),onShiftTab:this.handleShiftTabKeydown.bind(this,t),onModEnter:this.handleFinishEditing.bind(this),onDragStart:this.handleDragStart.bind(this,t),onDragEnd:this.handleDragEnd.bind(this,t),onDragOver:this.handleDragOver.bind(this,t)}),N.createElement("div",{className:L(Pn,{[Vn]:this.state.draggedOverIdx===t+1})}))))),N.createElement(Fn,{innerRef:this.items[e.length],value:null===this.state.newItem?"":this.state.newItem.toString(),invalid:!1,onChange:this.handleChangeNewItem,onAdd:this.handleAddNewItem,onEnter:this.handleAddNewItem,onShiftTab:this.handleShiftTabKeydown.bind(this,e.length),onDragOver:this.handleDragOver.bind(this,e.length)}))))}}class Fn extends N.Component{render(){return N.createElement("li",{"data-testid":"input--bigint-list-item",className:L(Mn,{[kn]:this.props.invalid}),onDragOver:this.props.onDragOver},this.props.onDragStart&&this.props.onDragEnd&&N.createElement(xn,{className:Dn,onDragStart:this.props.onDragStart,onDragEnd:this.props.onDragEnd},N.createElement(Sn,null)),N.createElement("input",{ref:this.props.innerRef,className:Ln,type:"text",value:this.props.value,tabIndex:this.props.tabIndex,onChange:this.props.onChange}),this.props.onAdd&&N.createElement(si,{"data-testid":"input--bigint-list-item__add-btn",onClick:this.props.onAdd,className:Tn},"Add"),this.props.onRemove&&N.createElement(si,{"data-testid":"input--bigint-list-item__remove-btn",onClick:e=>{var t,s;return null==(s=(t=this.props).onRemove)?void 0:s.call(t,e)},className:An},N.createElement(na,null)),this.props.onEnter&&N.createElement(li,{keys:"enter",target:this.props.innerRef,onMatch:this.props.onEnter}),this.props.onTab&&N.createElement(li,{keys:["tab"],preventDefault:!1,stopPropagation:!1,target:this.props.innerRef,onMatch:this.props.onTab}),this.props.onShiftTab&&N.createElement(li,{keys:["shift+tab"],preventDefault:!1,stopPropagation:!1,target:this.props.innerRef,onMatch:this.props.onShiftTab}),this.props.onModEnter&&N.createElement(li,{keys:["mod+enter"],preventDefault:!1,stopPropagation:!1,target:this.props.innerRef,onMatch:this.props.onModEnter}))}}var Bn=S(jn);var Hn="_container_z3tbz_1",qn="_input_z3tbz_7",Zn="_dropdown_z3tbz_19",Un="_match_z3tbz_37",zn="_highlight_z3tbz_45";class $n extends N.Component{constructor(e){super(e),this.input=N.createRef(),this.focus=()=>{var e;null==(e=this.input.current)||e.focus()},this.handleChange=e=>{const{suggestions:t,onChange:s}=this.props,i=e.currentTarget.value,a=t.findIndex((e=>e.toUpperCase().startsWith(i.toUpperCase())));this.setState({phrase:i,highlightIdx:a}),s(t[a]||t[0])},this.handleSuggestionClick=e=>{const{suggestions:t,onChange:s,onSubmit:i}=this.props,a=t[e];s(a),null==i||i(a)},this.handleSubmit=()=>{const{highlightIdx:e}=this.state,{suggestions:t,onChange:s,onSubmit:i}=this.props,a=t[e]||t[0];s(a),null==i||i(a)},this.state={phrase:String(e.value),highlightIdx:0}}render(){const{phrase:e,highlightIdx:t}=this.state,{className:s,style:i,suggestions:a,dataTestId:n}=this.props;return N.createElement("div",{"data-testid":n,className:L(Hn,s),style:i},N.createElement("input",{ref:this.input,type:"text",className:qn,value:e,onChange:this.handleChange}),N.createElement("ul",{className:Zn},a.map(((e,s)=>N.createElement("li",{key:e,"data-testid":"suggestion",className:L(Un,{[zn]:t===s}),onClick:()=>this.handleSuggestionClick(s)},e)))),N.createElement(li,{target:this.input,keys:"up",onMatch:()=>this.setState({highlightIdx:Math.max(t-1,0)})}),N.createElement(li,{target:this.input,keys:"down",onMatch:()=>this.setState((e=>({highlightIdx:Math.min(e.highlightIdx+1,a.length-1)})))}),N.createElement(li,{target:this.input,preventDefault:!1,stopPropagation:!1,keys:"enter",onMatch:this.handleSubmit}))}}var Jn=S($n);var Wn="_input_j8mok_1";class Kn extends N.PureComponent{constructor(e){super(e),this.input=N.createRef(),this.getValue=()=>this.state.value,this.focus=()=>{var e;null==(e=this.input.current)||e.focus()},this.handleChange=e=>{this.setState({value:"true"===e})},this.handleSubmit=e=>{this.setState({value:"true"===e},(()=>{this.props.stopEditing()}))},this.state={value:!!e.initialValue}}render(){const{value:e}=this.state;return N.createElement(Jn,{ref:this.input,dataTestId:"input--boolean",className:Wn,value:null==e?"":String(e),suggestions:["true","false"],onChange:this.handleChange,onSubmit:this.handleSubmit})}}var Gn=S(Kn);var Qn="_itemContainer_1k9ef_1",Yn="_itemDropdown_1k9ef_5";class Xn extends N.PureComponent{constructor(e){var t;super(e),this.items=[],this.draggedItem=null,this.getValue=()=>this.state.value,this.focus=()=>{var e;const{value:t}=this.state;t&&(null==(e=this.items[Math.max(t.length-1,0)].current)||e.focus())},this.handleChangeItem=(e,t)=>{const{value:s}=this.state;if(!Array.isArray(s))throw U({path:"BooleanListInput.handleChangeItem",message:"Invalid value",context:{value:s,changedItem:e}});const i=[...s];return i.splice(t,1,"true"===e.id),this.setState({value:i})},this.handleChangeNewItem=e=>{this.setState({newItem:e},(()=>setTimeout((()=>this.handleAddNewItem()),0)))},this.handleAddNewItem=()=>{const{value:e,newItem:t}=this.state;if(t){if(!Array.isArray(e))throw U({path:"BooleanListInput.handleAddNewItem",message:"Invalid value",context:{value:e,newItem:t}});this.items.push(N.createRef()),this.setState({value:[...e,"true"===t.id],newItem:null},(()=>{var e,t,s;null==(t=null==(e=this.items[this.items.length-2])?void 0:e.current)||t.focus(),null==(s=this.items[this.items.length-2].current)||s.scrollIntoView(!1)}))}},this.handleRemoveItem=e=>{const{value:t}=this.state;if(!Array.isArray(t))throw U({path:"BooleanListInput.handleRemoveClick",message:"Invalid Value",context:{value:t,idx:e}});this.items.splice(e,1);const s=[...t];s.splice(e,1),setTimeout((()=>this.setState({value:s})),0)},this.handleDragStart=e=>{this.draggedItem=this.items[e]},this.handleDragOver=(e,t)=>{t.preventDefault(),this.setState({draggedOverIdx:e})},this.handleDragEnd=e=>{var t,s;if(!this.draggedItem)return;const i=null!=(t=this.state.value)?t:[];if(!Array.isArray(i))throw U({path:"BooleanListInput.HandleDragEnd",message:"Invalid value",context:{value:i,idx:e}});const a=String(null==(s=this.draggedItem.current)?void 0:s.value),n=[...i];this.items.splice(e,1),n.splice(e,1),this.state.draggedOverIdx>e?(this.items.splice(this.state.draggedOverIdx-1,0,this.draggedItem),n.splice(this.state.draggedOverIdx-1,0,"true"===a)):(this.items.splice(this.state.draggedOverIdx,0,this.draggedItem),n.splice(this.state.draggedOverIdx,0,"true"===a)),this.draggedItem=null,this.setState({value:n,draggedOverIdx:-1})};const{initialValue:s}=e;if(!Array.isArray(s))throw U({path:"BooleanListInput.constructor",message:"Invalid initialValue",context:{initialValue:s}});this.state={value:s,newItem:null,draggedOverIdx:-1},this.items=Array.from({length:Math.max(null!=(t=null==s?void 0:s.length)?t:0,1)}).map((()=>N.createRef())),this.items.push(N.createRef())}render(){const{value:e}=this.state;if(!Array.isArray(e))throw U({path:"BooleanListInput.render",message:"Invalid value",context:{value:e}});return N.createElement(N.Fragment,null,N.createElement("div",{"data-testid":"input--boolean-list",className:Nn},N.createElement("input",{type:"text",className:Ln,value:JSON.stringify(e),readOnly:!0}),N.createElement("ul",{className:L(Rn,Qn,"ag-theme-dark")},N.createElement("div",{className:On},N.createElement("div",{className:L(Pn,{[Vn]:0===this.state.draggedOverIdx})}),e.map(((e,t)=>N.createElement(N.Fragment,{key:t},N.createElement(er,{innerRef:this.items[t],suggestions:[{id:"true",label:"true"},{id:"false",label:"false"}],value:{id:String(e),label:String(e)},invalid:!0!==e&&!1!==e,onChange:e=>this.handleChangeItem(e,t),onRemove:this.handleRemoveItem.bind(this,t),onDragStart:this.handleDragStart.bind(this,t),onDragEnd:this.handleDragEnd.bind(this,t),onDragOver:this.handleDragOver.bind(this,t)}),N.createElement("div",{className:L(Pn,{[Vn]:this.state.draggedOverIdx===t+1})}))))),N.createElement(er,{key:e.length,innerRef:this.items[e.length],suggestions:[{id:"",label:""},{id:"true",label:"true"},{id:"false",label:"false"}],value:{id:"",label:""},invalid:!1,onChange:e=>this.handleChangeNewItem(e),onAdd:this.handleAddNewItem,onDragOver:this.handleDragOver.bind(this,e.length)}))))}}class er extends N.Component{render(){return N.createElement("li",{"data-testid":"input--boolean-list-item",className:L(Mn,{[kn]:this.props.invalid}),onDragOver:this.props.onDragOver||void 0},this.props.onDragStart&&this.props.onDragEnd&&N.createElement(xn,{className:Dn,onDragStart:this.props.onDragStart,onDragEnd:this.props.onDragEnd},N.createElement(Sn,null)),N.createElement(ja,{innerRef:this.props.innerRef,"data-testid":"input",className:Yn,type:"text",nativeSelect:!0,items:this.props.suggestions,selectedItem:this.props.value,onSelect:e=>this.props.onChange(e)}),this.props.onAdd&&N.createElement(si,{"data-testid":"input--boolean-list-item__add-btn",onClick:this.props.onAdd,className:Tn},"Add"),this.props.onRemove&&N.createElement(si,{"data-testid":"input--boolean-list-item__remove-btn",onClick:e=>{var t,s;return null==(s=(t=this.props).onRemove)?void 0:s.call(t,e)},className:An},N.createElement(na,null)))}}var tr=S(Xn);class sr extends N.PureComponent{constructor(e){super(e),this.input=N.createRef(),this.getValue=()=>this.state.value?_.Buffer.from(this.state.value,"base64"):null,this.focus=()=>{var e;null==(e=this.input.current)||e.focus()},this.handleChange=e=>{const{field:t}=this.props,s=e.currentTarget.value;t.isRequired||""!==s?this.setState({value:s}):this.setState({value:null})};const{initialValue:t}=e,s=null==t?null:(e.initialValue instanceof Uint8Array?_.Buffer.from(e.initialValue):e.initialValue||_.Buffer.from("")).toString("base64");this.state={value:s}}render(){const{value:e}=this.state;return N.createElement("input",{"data-testid":"input--bytes",ref:this.input,className:Cn,type:"text",value:null==e?"":e,placeholder:"null",onChange:this.handleChange})}}var ir=S(sr);class ar extends N.PureComponent{constructor(e){super(e),this.items=[],this.draggedItem=null,this.getValue=()=>{var e;return null==(e=this.state.value)?void 0:e.map((e=>_.Buffer.from(e||"","base64")))},this.focus=()=>{var e;const{value:t}=this.state;t&&(null==(e=this.items[Math.max(t.length,0)].current)||e.focus())},this.handleChange=e=>{try{const t=JSON.parse(e.currentTarget.value);Array.isArray(t)&&this.setState({value:t})}catch(t){}},this.handleChangeItem=(e,t)=>{const{value:s}=this.state,i=t.currentTarget.value;if(!Array.isArray(s))throw U({path:"BytesListInput.handleChangeItem",message:"Invalid value",context:{value:s,idx:e,changedItem:i}});const a=[...s];return a.splice(e,1,i),this.setState({value:a})},this.handleChangeNewItem=e=>{const t=e.currentTarget.value;this.setState({newItem:t})},this.handleAddNewItem=()=>{const{value:e,newItem:t}=this.state;if(!Array.isArray(e))throw U({path:"BytesListInput.handleAddItem",message:"Invalid value",context:{value:e,newItem:t}});this.items.push(N.createRef()),this.setState({value:[...e,t],newItem:null},(()=>{var e,t;null==(e=this.items[this.items.length-1].current)||e.focus(),null==(t=this.items[this.items.length-2].current)||t.scrollIntoView(!1)}))},this.handleEnterKeydown=e=>{const{value:t}=this.state;if(!Array.isArray(t))throw U({path:"BytesListInput.handleEnterKeydown",message:"Invalid value",context:{value:t,idx:e}});let s=[...t];s.splice(e+1,0,""),this.items.push(N.createRef()),this.setState({value:s,newItem:null},(()=>{var t,s,i;null==(t=this.items[e+1].current)||t.focus(),null==(s=this.items[e+1].current)||s.scrollIntoView(!1),null==(i=this.items[e+1].current)||i.scrollIntoView({block:"nearest"})}))},this.handleRemoveItem=(e,t)=>{var s,i,a,n;const{value:r}=this.state;if(t.preventDefault(),t.stopPropagation(),!Array.isArray(r))throw U({path:"BytesListInput.handleRemoveClick",message:"Invalid Value",context:{value:r,idx:e}});const l=[...r];l.splice(e,1),this.items.splice(e,1),null==(i=null==(s=this.items[e-1])?void 0:s.current)||i.focus(),null==(n=null==(a=this.items[e-1])?void 0:a.current)||n.scrollIntoView(),setTimeout((()=>this.setState({value:l})),0)},this.handleTabKeydown=(e,t)=>{var s;const{value:i}=this.state;if(!Array.isArray(i))throw U({path:"BytesListInput.handleTabKeydown",message:"Invalid value",context:{value:i,idx:e}});e===i.length||(t.preventDefault(),t.stopPropagation(),null==(s=this.items[e+1].current)||s.focus())},this.handleShiftTabKeydown=(e,t)=>{var s;0===e||(t.preventDefault(),t.stopPropagation(),null==(s=this.items[e-1].current)||s.focus())},this.handleFinishEditing=()=>{this.props.stopEditing()},this.handleDragStart=e=>{this.draggedItem=this.items[e]},this.handleDragOver=(e,t)=>{t.preventDefault(),this.setState({draggedOverIdx:e})},this.handleDragEnd=e=>{var t;if(!this.draggedItem)return;const{value:s=[]}=this.state;if(!Array.isArray(s))throw U({path:"BytesListInput.HandleDragEnd",message:"Invalid value",context:{value:s,idx:e}});const i=[...s],a=(null==(t=this.draggedItem.current)?void 0:t.value)||"";this.items.splice(e,1),i.splice(e,1),this.state.draggedOverIdx>e?(this.items.splice(this.state.draggedOverIdx-1,0,this.draggedItem),i.splice(this.state.draggedOverIdx-1,0,a)):(this.items.splice(this.state.draggedOverIdx,0,this.draggedItem),i.splice(this.state.draggedOverIdx,0,a)),this.draggedItem=null,this.setState({value:i,draggedOverIdx:-1})};const{initialValue:t}=e;if(!Array.isArray(t))throw U({path:"BytesListInput.constructor",message:"Invalid initialValue",context:{initialValue:t}});this.state={value:t.map((e=>(e instanceof Uint8Array?_.Buffer.from(e):e).toString("base64"))),newItem:null,draggedOverIdx:-1},this.items=Array.from({length:Math.max(t.length,1)}).map((()=>N.createRef())),this.items.push(N.createRef())}render(){const{value:e}=this.state;if(!Array.isArray(e))throw U({path:"BytesListInput.render",message:"Invalid value",context:{value:e}});return N.createElement(N.Fragment,null,N.createElement("div",{"data-testid":"input--bytes-list",className:Nn},N.createElement("input",{type:"text",className:Ln,value:e.join(", "),onChange:this.handleChange}),N.createElement("ul",{className:L(Rn,"ag-theme-dark")},N.createElement("div",{className:On},N.createElement("div",{className:L(Pn,{[Vn]:0===this.state.draggedOverIdx})}),e.map(((e,t)=>N.createElement(N.Fragment,{key:t},N.createElement(nr,{innerRef:this.items[t],value:null===e?"":e,onChange:this.handleChangeItem.bind(this,t),onRemove:this.handleRemoveItem.bind(this,t),onEnter:this.handleEnterKeydown.bind(this,t),onTab:this.handleTabKeydown.bind(this,t),onShiftTab:this.handleShiftTabKeydown.bind(this,t),onModEnter:this.handleFinishEditing.bind(this),onDragStart:this.handleDragStart.bind(this,t),onDragEnd:this.handleDragEnd.bind(this,t),onDragOver:this.handleDragOver.bind(this,t)}),N.createElement("div",{className:L(Pn,{[Vn]:this.state.draggedOverIdx===t+1})}))))),N.createElement(nr,{innerRef:this.items[e.length],value:this.state.newItem||"",onChange:this.handleChangeNewItem,onAdd:this.handleAddNewItem,onEnter:this.handleAddNewItem,onShiftTab:this.handleShiftTabKeydown.bind(this,e.length),onDragOver:this.handleDragOver.bind(this,e.length)}))))}}class nr extends N.Component{render(){return N.createElement("li",{"data-testid":"input--bytes-list-item",className:Mn,onDragOver:this.props.onDragOver},this.props.onDragStart&&this.props.onDragEnd&&N.createElement(xn,{className:Dn,onDragStart:this.props.onDragStart,onDragEnd:this.props.onDragEnd},N.createElement(Sn,null)),N.createElement("input",{ref:this.props.innerRef,className:Ln,type:"text",value:this.props.value,tabIndex:this.props.tabIndex,onChange:this.props.onChange}),this.props.onAdd&&N.createElement(si,{"data-testid":"input--bytes-list-item__add-btn",onClick:this.props.onAdd,className:Tn},"Add"),this.props.onRemove&&N.createElement(si,{"data-testid":"input--bytes-list-item__remove-btn",onClick:this.props.onRemove,className:An},N.createElement(na,null)),this.props.onEnter&&N.createElement(li,{keys:"enter",target:this.props.innerRef,onMatch:this.props.onEnter}),this.props.onTab&&N.createElement(li,{keys:["tab"],preventDefault:!1,stopPropagation:!1,target:this.props.innerRef,onMatch:this.props.onTab}),this.props.onShiftTab&&N.createElement(li,{keys:["shift+tab"],preventDefault:!1,stopPropagation:!1,target:this.props.innerRef,onMatch:this.props.onShiftTab}),this.props.onModEnter&&N.createElement(li,{keys:["mod+enter"],preventDefault:!1,stopPropagation:!1,target:this.props.innerRef,onMatch:this.props.onModEnter}))}}var rr=S(ar);class lr extends N.PureComponent{constructor(e){super(e),this.input=N.createRef(),this.getValue=()=>{const{value:e}=this.state;if(!e)return e;try{return new Date(e).toISOString()}catch(t){return e}},this.focus=()=>{var e;null==(e=this.input.current)||e.focus()},this.handleChange=e=>{const{field:t}=this.props,s=e.currentTarget.value;t.isRequired||""!==s?this.setState({value:s}):this.setState({value:null})};const{initialValue:t}=e,s=null==t?null:t;this.state={value:s}}render(){const{value:e}=this.state;return N.createElement("input",{"data-testid":"input--datetime",ref:this.input,className:Cn,type:"text",value:null==e?"":String(e),placeholder:"null",onChange:this.handleChange})}}var or=S(lr);class dr extends N.PureComponent{constructor(e){var t;super(e),this.input=N.createRef(),this.getValue=()=>this.state.value,this.focus=()=>{var e;null==(e=this.input.current)||e.focus()},this.handleChange=e=>{this.setState({value:e})},this.handleSubmit=e=>{this.setState({value:e},(()=>{this.props.stopEditing()}))},this.state={value:null!=(t=e.initialValue)?t:null}}render(){const{value:e}=this.state,{field:t}=this.props;return N.createElement(Jn,{ref:this.input,dataTestId:"input--enum",className:Wn,value:null==e?"":String(e),suggestions:t.typeAsEnum.values,onChange:this.handleChange,onSubmit:this.handleSubmit})}}var cr=S(dr);class hr extends N.PureComponent{constructor(e){super(e),this.items=[],this.draggedItem=null,this.getValue=()=>this.state.value,this.focus=()=>{var e;const{value:t}=this.state;t&&(null==(e=this.items[Math.max(t.length-1,0)].current)||e.focus())},this.handleChangeItem=(e,t)=>{const{value:s}=this.state,i=String(e.id);if(!Array.isArray(s))throw U({path:"EnumListInput.handleChangeItem",message:"Invalid value",context:{value:s,changedItem:i}});const a=[...s];return a.splice(t,1,i),this.setState({value:a})},this.handleChangeNewItem=e=>{this.setState({newItem:e},(()=>setTimeout((()=>this.handleAddNewItem()),0)))},this.handleAddNewItem=()=>{const{value:e,newItem:t}=this.state;if(t){if(!Array.isArray(e))throw U({path:"EnumListInput.handleAddNewItem",message:"Invalid value",context:{value:e,newItem:t}});this.items.push(N.createRef()),this.setState({value:[...e,String(t.id)],newItem:null},(()=>{var e,t,s;null==(t=null==(e=this.items[this.items.length-2])?void 0:e.current)||t.focus(),null==(s=this.items[this.items.length-2].current)||s.scrollIntoView(!1)}))}},this.handleRemoveItem=e=>{var t,s,i,a;const{value:n}=this.state;if(!Array.isArray(n))throw U({path:"EnumListInput.handleRemoveClick",message:"Invalid Value",context:{value:n,idx:e}});this.items.splice(e,1);const r=[...n];r.splice(e,1),null==(s=null==(t=this.items[e-1])?void 0:t.current)||s.focus(),null==(a=null==(i=this.items[e-1])?void 0:i.current)||a.scrollIntoView(),setTimeout((()=>this.setState({value:r})),0)},this.handleDragStart=e=>{this.draggedItem=this.items[e]},this.handleDragOver=(e,t)=>{t.preventDefault(),this.setState({draggedOverIdx:e})},this.handleDragEnd=e=>{var t;if(!this.draggedItem)return;const{value:s=[]}=this.state;if(!Array.isArray(s))throw U({path:"EnumListInput.HandleDragEnd",message:"Invalid value",context:{value:s,idx:e}});const i=String(null==(t=this.draggedItem.current)?void 0:t.value),a=[...s];this.items.splice(e,1),a.splice(e,1),this.state.draggedOverIdx>e?(this.items.splice(this.state.draggedOverIdx-1,0,this.draggedItem),a.splice(this.state.draggedOverIdx-1,0,i)):(this.items.splice(this.state.draggedOverIdx,0,this.draggedItem),a.splice(this.state.draggedOverIdx,0,i)),this.draggedItem=null,this.setState({value:a,draggedOverIdx:-1})};const{initialValue:t}=e;if(!Array.isArray(t))throw U({path:"EnumListInput.constructor",message:"Invalid initialValue",context:{initialValue:t}});this.state={value:t,newItem:null,draggedOverIdx:-1},this.items=Array.from({length:Math.max(t.length,1)}).map((()=>N.createRef())),this.items.push(N.createRef())}render(){const{value:e}=this.state,{field:t}=this.props;if(!Array.isArray(e))throw U({path:"EnumListInput.render",message:"Invalid value",context:{value:e}});return N.createElement(N.Fragment,null,N.createElement("div",{"data-testid":"input--enum-list",className:Nn},N.createElement("input",{type:"text",className:Ln,value:JSON.stringify(e),readOnly:!0}),N.createElement("ul",{className:L(Rn,Qn,"ag-theme-dark")},N.createElement("div",{className:On},N.createElement("div",{className:L(Pn,{[Vn]:0===this.state.draggedOverIdx})}),e.map(((e,s)=>N.createElement(N.Fragment,{key:s},N.createElement(pr,{innerRef:this.items[s],suggestions:t.typeAsEnum.values.map((e=>({id:e,label:e}))),value:{id:String(e),label:String(e)},onChange:e=>this.handleChangeItem(e,s),onRemove:this.handleRemoveItem.bind(this,s),onDragStart:this.handleDragStart.bind(this,s),onDragEnd:this.handleDragEnd.bind(this,s),onDragOver:this.handleDragOver.bind(this,s)}),N.createElement("div",{className:L(Pn,{[Vn]:this.state.draggedOverIdx===s+1})}))))),N.createElement(pr,{key:e.length,innerRef:this.items[e.length],suggestions:[{id:"",label:""},...t.typeAsEnum.values.map((e=>({id:e,label:e})))],value:{id:"",label:""},onChange:e=>this.handleChangeNewItem(e),onAdd:this.handleAddNewItem.bind(this),onDragOver:this.handleDragOver.bind(this,e.length)}))))}}class pr extends N.Component{render(){return N.createElement("li",{className:Mn,onDragOver:this.props.onDragOver||void 0},this.props.onDragStart&&this.props.onDragEnd&&N.createElement(xn,{className:Dn,onDragStart:this.props.onDragStart,onDragEnd:this.props.onDragEnd},N.createElement(Sn,null)),N.createElement(ja,{innerRef:this.props.innerRef,"data-testid":"input",className:Yn,type:"text",nativeSelect:!0,items:this.props.suggestions,selectedItem:this.props.value,onSelect:e=>this.props.onChange(e)}),this.props.onAdd&&N.createElement(si,{"data-testid":"input--enum-list__add-btn",onClick:this.props.onAdd,className:Tn},"Add"),this.props.onRemove&&N.createElement(si,{"data-testid":"input--enum-list__remove-btn",onClick:e=>{var t,s;return null==(s=(t=this.props).onRemove)?void 0:s.call(t,e)},className:An},N.createElement(na,null)))}}var ur=S(hr);var mr="_input_c6cnd_1";class gr extends N.PureComponent{constructor(e){var t;super(e),this.input=N.createRef(),this.getValue=()=>this.state.value,this.focus=()=>{var e;null==(e=this.input.current)||e.focus()},this.handleChange=(e=!1)=>{var t;const{api:s,field:i}=this.props,a=(null==(t=this.input.current)?void 0:t.value)||"";if(!i.isRequired&&""===a)return this.setState({value:null});try{const t=JSON.parse(a);if(i.isList&&!Array.isArray(t))throw new Error;return this.setState({value:t},(()=>e&&(null==s?void 0:s.stopEditing())))}catch(n){return this.setState({value:a},(()=>e&&(null==s?void 0:s.stopEditing())))}},this.state={value:null!=(t=e.initialValue)?t:null}}render(){const{value:e}=this.state;return N.createElement(N.Fragment,null,N.createElement("textarea",{"data-testid":"input--json",ref:this.input,className:mr,value:"string"==typeof e?e:JSON.stringify(e),onChange:e=>this.handleChange()}))}}var vr=S(gr);class fr extends N.PureComponent{constructor(e){super(e),this.items=[],this.draggedItem=null,this.getValue=()=>this.state.value,this.focus=()=>{var e;const{value:t}=this.state;t&&(null==(e=this.items[Math.max(t.length,0)].current)||e.focus())},this.handleChange=e=>{try{const t=JSON.parse(e.currentTarget.value);Array.isArray(t)&&this.setState({value:t.map((e=>String(e)))})}catch(t){}},this.handleChangeItem=(e,t)=>{var s;const{value:i}=this.state;if(!Array.isArray(i))throw U({path:"JsonListInput.handleChangeItem",message:"Invalid value",context:{value:i,idx:e}});let a=null!=(s=t.currentTarget.value)?s:"";try{a=JSON.parse(a)}catch(r){}const n=[...i];return n.splice(e,1,a),this.setState({value:n})},this.handleChangeNewItem=e=>{var t;let s=null!=(t=e.currentTarget.value)?t:"";try{s=JSON.parse(s)}catch(i){}this.setState({newItem:s})},this.handleAddNewItem=()=>{const{value:e,newItem:t}=this.state;if(!Array.isArray(e))throw U({path:"JsonListInput.handleAddItem",message:"Invalid value",context:{value:e,newItem:t}});this.items.push(N.createRef()),this.setState({value:[...e,t||""],newItem:null},(()=>{var e,t;null==(e=this.items[this.items.length-1].current)||e.focus(),null==(t=this.items[this.items.length-2].current)||t.scrollIntoView(!1)}))},this.handleEnterKeydown=e=>{const{value:t}=this.state;if(!Array.isArray(t))throw U({path:"JsonListInput.handleEnterKeydown",message:"Invalid value",context:{value:t,idx:e}});let s=[...t];s.splice(e+1,0,""),this.items.push(N.createRef()),this.setState({value:s,newItem:null},(()=>{var t,s,i;null==(t=this.items[e+1].current)||t.focus(),null==(s=this.items[e+1].current)||s.scrollIntoView(!1),null==(i=this.items[e+1].current)||i.scrollIntoView({block:"nearest"})}))},this.handleRemoveItem=e=>{var t,s,i,a;const{value:n}=this.state;if(!Array.isArray(n))throw U({path:"JsonListInput.handleRemoveClick",message:"Invalid Value",context:{value:n,idx:e}});const r=[...n];r.splice(e,1),this.items.splice(e,1),null==(s=null==(t=this.items[e-1])?void 0:t.current)||s.focus(),null==(a=null==(i=this.items[e-1])?void 0:i.current)||a.scrollIntoView(),setTimeout((()=>this.setState({value:r})),0)},this.handleTabKeydown=(e,t)=>{var s;const{value:i}=this.state;if(!Array.isArray(i))throw U({path:"JsonListInput.handleTabKeydown",message:"Invalid value",context:{value:i,idx:e}});e===i.length||(t.preventDefault(),t.stopPropagation(),null==(s=this.items[e+1].current)||s.focus())},this.handleShiftTabKeydown=(e,t)=>{var s;0===e||(t.preventDefault(),t.stopPropagation(),null==(s=this.items[e-1].current)||s.focus())},this.handleFinishEditing=()=>{this.props.stopEditing()},this.handleDragStart=e=>{this.draggedItem=this.items[e]},this.handleDragOver=(e,t)=>{t.preventDefault(),this.setState({draggedOverIdx:e})},this.handleDragEnd=e=>{var t,s;if(!this.draggedItem)return;const{value:i=[]}=this.state;if(!Array.isArray(i))throw U({path:"JsonListInput.HandleDragEnd",message:"Invalid value",context:{value:i,idx:e}});let a=null!=(s=null==(t=this.draggedItem.current)?void 0:t.value)?s:"";const n=[...i];try{a=JSON.parse(a)}catch(r){}this.items.splice(e,1),n.splice(e,1),this.state.draggedOverIdx>e?(this.items.splice(this.state.draggedOverIdx-1,0,this.draggedItem),n.splice(this.state.draggedOverIdx-1,0,a)):(this.items.splice(this.state.draggedOverIdx,0,this.draggedItem),n.splice(this.state.draggedOverIdx,0,a)),this.draggedItem=null,this.setState({value:n,draggedOverIdx:-1})};const{initialValue:t}=e;if(!Array.isArray(t))throw U({path:"JsonListInput.constructor",message:"Invalid initialValue",context:{initialValue:t}});this.state={value:t,newItem:null,draggedOverIdx:-1},this.items=Array.from({length:Math.max(t.length,1)}).map((()=>N.createRef())),this.items.push(N.createRef())}render(){const{value:e,newItem:t}=this.state;if(!Array.isArray(e))throw U({path:"JsonListInput.render",message:"Invalid value",context:{value:e}});return N.createElement(N.Fragment,null,N.createElement("div",{"data-testid":"input--json-list",className:Nn},N.createElement("input",{type:"text",className:Ln,value:JSON.stringify(e),onChange:this.handleChange}),N.createElement("ul",{className:L(Rn,"ag-theme-dark")},N.createElement("div",{className:On},N.createElement("div",{className:L(Pn,{[Vn]:0===this.state.draggedOverIdx})}),e.map(((e,t)=>N.createElement(N.Fragment,{key:t},N.createElement(yr,{innerRef:this.items[t],value:e,invalid:"string"==typeof e,onChange:this.handleChangeItem.bind(this,t),onRemove:this.handleRemoveItem.bind(this,t),onEnter:this.handleEnterKeydown.bind(this,t),onTab:this.handleTabKeydown.bind(this,t),onShiftTab:this.handleShiftTabKeydown.bind(this,t),onModEnter:this.handleFinishEditing.bind(this),onDragStart:this.handleDragStart.bind(this,t),onDragEnd:this.handleDragEnd.bind(this,t),onDragOver:this.handleDragOver.bind(this,t)}),N.createElement("div",{className:L(Pn,{[Vn]:this.state.draggedOverIdx===t+1})}))))),N.createElement(yr,{innerRef:this.items[e.length],value:t,invalid:!1,onChange:this.handleChangeNewItem,onAdd:this.handleAddNewItem,onEnter:this.handleAddNewItem,onShiftTab:this.handleShiftTabKeydown.bind(this,e.length),onDragOver:this.handleDragOver.bind(this,e.length)}))))}}class yr extends N.Component{render(){return N.createElement("li",{className:L(Mn,{[kn]:this.props.invalid}),onDragOver:this.props.onDragOver},this.props.onDragStart&&this.props.onDragEnd&&N.createElement(xn,{className:Dn,onDragStart:this.props.onDragStart,onDragEnd:this.props.onDragEnd},N.createElement(Sn,null)),N.createElement("input",{ref:this.props.innerRef,className:Ln,type:"text",value:null===this.props.value?"":"string"==typeof this.props.value?this.props.value:JSON.stringify(this.props.value),tabIndex:this.props.tabIndex,onChange:this.props.onChange}),this.props.onAdd&&N.createElement(si,{"data-testid":"input--json-list__add-btn",onClick:this.props.onAdd,className:Tn},"Add"),this.props.onRemove&&N.createElement(si,{"data-testid":"input--json-list__remove-btn",onClick:e=>{var t,s;return null==(s=(t=this.props).onRemove)?void 0:s.call(t,e)},className:An},N.createElement(na,null)),this.props.onEnter&&N.createElement(li,{keys:"enter",target:this.props.innerRef,onMatch:this.props.onEnter}),this.props.onTab&&N.createElement(li,{keys:["tab"],preventDefault:!1,stopPropagation:!1,target:this.props.innerRef,onMatch:this.props.onTab}),this.props.onShiftTab&&N.createElement(li,{keys:["shift+tab"],preventDefault:!1,stopPropagation:!1,target:this.props.innerRef,onMatch:this.props.onShiftTab}),this.props.onModEnter&&N.createElement(li,{keys:["mod+enter"],preventDefault:!1,stopPropagation:!1,target:this.props.innerRef,onMatch:this.props.onModEnter}))}}var Ir=S(fr);class Cr extends N.PureComponent{constructor(e){super(e),this.input=N.createRef(),this.getValue=()=>this.state.value,this.focus=()=>{var e;null==(e=this.input.current)||e.focus()},this.handleChange=e=>{const t=e.currentTarget.value;if(""===t)return void this.setState({value:null});const s=parseFloat(t);this.setState({value:s})};const{initialValue:t}=e,s=null==t?null:parseFloat(`${t}`);this.state={value:s}}render(){const{value:e}=this.state;return N.createElement("input",{"data-testid":"input--number",ref:this.input,className:Cn,type:"number",value:null==e?"":String(e),placeholder:"null",onChange:this.handleChange})}}var wr=S(Cr);class br extends N.PureComponent{constructor(e){super(e),this.items=[],this.draggedItem=null,this.getValue=()=>this.state.value,this.focus=()=>{var e;const{value:t}=this.state;t&&(null==(e=this.items[Math.max(t.length,0)].current)||e.focus())},this.handleChange=e=>{try{const t=JSON.parse(e.currentTarget.value);Array.isArray(t)&&this.setState({value:t.map((e=>parseInt(e))).filter((e=>!isNaN(e)))})}catch(t){}},this.handleChangeItem=(e,t)=>{const{value:s}=this.state,{field:i}=this.props;let a=i.isInt?parseInt(t.currentTarget.value):parseFloat(t.currentTarget.value);if(isNaN(a)&&(a=null),!Array.isArray(s))throw U({path:"NumberListInput.handleChangeItem",message:"Invalid value",context:{value:s,idx:e,changedItem:a}});const n=[...s];return n.splice(e,1,a),this.setState({value:n})},this.handleChangeNewItem=e=>{const{field:t}=this.props;let s=t.isInt?parseInt(e.currentTarget.value):parseFloat(e.currentTarget.value);isNaN(s)&&(s=null),this.setState({newItem:s})},this.handleAddNewItem=()=>{const{value:e,newItem:t}=this.state;if(!Array.isArray(e))throw U({path:"NumberListInput.handleAddItem",message:"Invalid value",context:{value:e,newItem:t}});this.items.push(N.createRef()),this.setState({value:[...e,t||0],newItem:null},(()=>{var e,t;null==(e=this.items[this.items.length-1].current)||e.focus(),null==(t=this.items[this.items.length-2].current)||t.scrollIntoView(!1)}))},this.handleEnterKeydown=e=>{const{value:t}=this.state;if(!Array.isArray(t))throw U({path:"NumberListInput.handleEnterKeydown",message:"Invalid value",context:{value:t,idx:e}});let s=[...t];s.splice(e+1,0,null),this.items.push(N.createRef()),this.setState({value:s,newItem:null},(()=>{var t,s,i;null==(t=this.items[e+1].current)||t.focus(),null==(s=this.items[e+1].current)||s.scrollIntoView(!1),null==(i=this.items[e+1].current)||i.scrollIntoView({block:"nearest"})}))},this.handleRemoveItem=e=>{var t,s,i,a;const{value:n}=this.state;if(!Array.isArray(n))throw U({path:"NumberListInput.handleRemoveClick",message:"Invalid Value",context:{value:n,idx:e}});this.items.splice(e,1);const r=[...n];r.splice(e,1),null==(s=null==(t=this.items[e-1])?void 0:t.current)||s.focus(),null==(a=null==(i=this.items[e-1])?void 0:i.current)||a.scrollIntoView(),setTimeout((()=>this.setState({value:r})),0)},this.handleTabKeydown=(e,t)=>{var s;const{value:i}=this.state;if(!Array.isArray(i))throw U({path:"NumberListInput.handleTabKeydown",message:"Invalid value",context:{value:i,idx:e}});e===i.length||(t.preventDefault(),t.stopPropagation(),null==(s=this.items[e+1].current)||s.focus())},this.handleShiftTabKeydown=(e,t)=>{var s;0===e||(t.preventDefault(),t.stopPropagation(),null==(s=this.items[e-1].current)||s.focus())},this.handleFinishEditing=()=>{this.props.stopEditing()},this.handleDragStart=e=>{this.draggedItem=this.items[e]},this.handleDragOver=(e,t)=>{t.preventDefault(),this.setState({draggedOverIdx:e})},this.handleDragEnd=e=>{var t,s,i,a;if(!this.draggedItem)return;const{field:n}=this.props,{value:r=[]}=this.state;if(!Array.isArray(r))throw U({path:"NumberListInput.HandleDragEnd",message:"Invalid value",context:{value:r,idx:e}});const l=[...r];let o=n.isInt?parseInt(null!=(s=null==(t=this.draggedItem.current)?void 0:t.value)?s:""):parseFloat(null!=(a=null==(i=this.draggedItem.current)?void 0:i.value)?a:"");isNaN(o)&&(o=null),this.items.splice(e,1),l.splice(e,1),this.state.draggedOverIdx>e?(this.items.splice(this.state.draggedOverIdx-1,0,this.draggedItem),l.splice(this.state.draggedOverIdx-1,0,o)):(this.items.splice(this.state.draggedOverIdx,0,this.draggedItem),l.splice(this.state.draggedOverIdx,0,o)),this.draggedItem=null,this.setState({value:l,draggedOverIdx:-1})};const{initialValue:t}=e;if(!Array.isArray(t))throw U({path:"NumberListInput.constructor",message:"Invalid initialValue",context:{initialValue:t}});this.state={value:t,newItem:null,draggedOverIdx:-1},this.items=Array.from({length:Math.max(t.length,1)}).map((()=>N.createRef())),this.items.push(N.createRef())}render(){const{value:e}=this.state;if(!Array.isArray(e))throw U({path:"NumberListInput.render",message:"Invalid value",context:{value:e}});return N.createElement(N.Fragment,null,N.createElement("div",{"data-testid":"input--number-list",className:Nn},N.createElement("input",{type:"text",className:Ln,value:JSON.stringify(e),onChange:this.handleChange}),N.createElement("ul",{className:L(Rn,"ag-theme-dark")},N.createElement("div",{className:On},N.createElement("div",{className:L(Pn,{[Vn]:0===this.state.draggedOverIdx})}),e.map(((e,t)=>N.createElement(N.Fragment,{key:t},N.createElement(Er,{innerRef:this.items[t],value:null===e?"":String(e),invalid:null===e||Number.isNaN(e),onChange:this.handleChangeItem.bind(this,t),onRemove:this.handleRemoveItem.bind(this,t),onEnter:this.handleEnterKeydown.bind(this,t),onTab:this.handleTabKeydown.bind(this,t),onShiftTab:this.handleShiftTabKeydown.bind(this,t),onModEnter:this.handleFinishEditing.bind(this),onDragStart:this.handleDragStart.bind(this,t),onDragEnd:this.handleDragEnd.bind(this,t),onDragOver:this.handleDragOver.bind(this,t)}),N.createElement("div",{className:L(Pn,{[Vn]:this.state.draggedOverIdx===t+1})}))))),N.createElement(Er,{innerRef:this.items[e.length],value:null===this.state.newItem?"":String(this.state.newItem),invalid:!1,onChange:this.handleChangeNewItem,onAdd:this.handleAddNewItem,onEnter:this.handleAddNewItem,onShiftTab:this.handleShiftTabKeydown.bind(this,e.length),onDragOver:this.handleDragOver.bind(this,e.length)}))))}}class Er extends N.Component{render(){return N.createElement("li",{"data-testid":"input--number-list-item",className:L(Mn,{[kn]:this.props.invalid}),onDragOver:this.props.onDragOver},this.props.onDragStart&&this.props.onDragEnd&&N.createElement(xn,{className:Dn,onDragStart:this.props.onDragStart,onDragEnd:this.props.onDragEnd},N.createElement(Sn,null)),N.createElement("input",{ref:this.props.innerRef,className:Ln,type:"number",value:this.props.value,tabIndex:this.props.tabIndex,onChange:this.props.onChange}),this.props.onAdd&&N.createElement(si,{"data-testid":"input--number-list-item__add-btn",onClick:this.props.onAdd,className:Tn},"Add"),this.props.onRemove&&N.createElement(si,{"data-testid":"input--number-list-item__remove-btn",onClick:e=>{var t,s;return null==(s=(t=this.props).onRemove)?void 0:s.call(t,e)},className:An},N.createElement(na,null)),this.props.onEnter&&N.createElement(li,{keys:"enter",target:this.props.innerRef,onMatch:this.props.onEnter}),this.props.onTab&&N.createElement(li,{keys:["tab"],preventDefault:!1,stopPropagation:!1,target:this.props.innerRef,onMatch:this.props.onTab}),this.props.onShiftTab&&N.createElement(li,{keys:["shift+tab"],preventDefault:!1,stopPropagation:!1,target:this.props.innerRef,onMatch:this.props.onShiftTab}),this.props.onModEnter&&N.createElement(li,{keys:["mod+enter"],preventDefault:!1,stopPropagation:!1,target:this.props.innerRef,onMatch:this.props.onModEnter}))}}var _r=S(br);var xr="_container_hrw1c_1",Sr="_table_hrw1c_11",Nr="_footer_hrw1c_23",Lr="_footerBtnUnderline_hrw1c_30",Rr="_footerBtnMargin_hrw1c_41";var Or="_pill_14n8h_1",Mr="_modelName_14n8h_18",kr="_isNull_14n8h_21",Dr="_isPressed_14n8h_21",Ar="_count_14n8h_30";class Tr extends N.Component{render(){const{type:e,count:t=0,isList:s=!1,isNull:i=!1,isPressed:a=!1,onClick:n}=this.props;return N.createElement("div",{"data-testid":"relation-pill","data-test-null":`${i}`,className:L(Or,{[kr]:i,[Dr]:a}),onClick:n},s&&N.createElement("span",{className:Ar},t),N.createElement("span",{className:Mr},e))}}var Pr="_container_dd10p_1",Vr="_title_dd10p_11",jr="_input_dd10p_16",Fr="_inputPlaceholder_dd10p_32";class Br extends R.exports.Component{constructor(e){super(e),this.handleChangeSearch=e=>{const{field:t,script:s}=this.props,i=Object.values(s.where.values).find((e=>h.exports.last(e.fieldIds)===t.id));if(!i)throw U({path:"TableCellHeaderWithSearch.handleChangeSearch",message:"Unable to find script `where` to update",context:{field:t.serialize(),script:s.serialize(),where:s.where.values}});i.update({enabled:!0,value:e.currentTarget.value}),this.handleSearchDebounced()},this.handleSearch=async()=>{this.props.onSearch()},this.handleSearchDebounced=h.exports.debounce(this.handleSearch,500,{leading:!1,trailing:!0})}render(){var e,t;const{script:s,field:i}=this.props,a=Object.values(s.where.values).find((e=>h.exports.last(e.fieldIds)===i.id));return R.exports.createElement("div",{"data-testid":"header-field-search",className:Pr},R.exports.createElement("div",{className:Vr},i.name),a&&((null==(e=h.exports.last(a.fields))?void 0:e.isScalar)||(null==(t=h.exports.last(a.fields))?void 0:t.isEnum))?R.exports.createElement("input",{className:jr,type:"text",placeholder:`search ${i.name}...`,value:a.value||"",onChange:this.handleChangeSearch}):R.exports.createElement("div",{className:Fr}))}}var Hr=S(Br);var qr="_container_1lgfw_1",Zr="_placeholder_1lgfw_8",Ur="_relation_1lgfw_11",zr="_loading_1lgfw_16";class $r extends N.Component{constructor(){super(...arguments),this.handleClickRelation=()=>{const{api:e,node:t,field:s}=this.props;this.props.resizeRowForRelation(t,s);const i=e.getFocusedCell();i&&e.startEditingCell({rowIndex:i.rowIndex,colKey:i.column})},this.getRenderedValue=()=>{const{node:{data:e},field:t}=this.props,s=e,i=s.value[t.name];return s?t.isRelation?null:t.isJson?JSON.stringify(i||null):void 0===i?t.defaultAsString:null===i?"null":t.isBigInt?t.isList?"["+i.map((e=>e.toString())).join(",")+"]":i.toString():t.isBytes?t.isList?"["+i.map((e=>`"${(e instanceof Uint8Array?_.Buffer.from(e):e).toString("base64")}"`)).join(",")+"]":(i instanceof Uint8Array?_.Buffer.from(i):i).toString("base64"):t.isList?JSON.stringify(i):String(i):""}}render(){const{node:{data:e},field:t}=this.props,s=e;if(!s)return N.createElement("div",{className:zr});const i=s.value[t.name],a=void 0===i,n=null===i;return N.createElement("div",{className:L(qr,{[Zr]:a||n,[Ur]:t.isRelation})},t.isRelation&&N.createElement(Tr,{type:t.type,isList:t.isList,isNull:!i,count:(i||[]).length,onClick:this.handleClickRelation}),this.getRenderedValue())}}var Jr=S($r);var Wr="_container_av89p_1";class Kr extends N.Component{render(){return N.createElement("div",{"data-testid":"empty-overlay",className:Wr},"There are no rows in this table")}}class Gr extends N.Component{constructor(e){var t;if(super(e),this.container=N.createRef(),this.table=N.createRef(),this.getValue=()=>this.state.value,this.focus=()=>{},this.afterGuiAttached=async()=>{var e;if(!this.container.current||!this.table.current)return;const{api:t,node:s,getTableDimensions:i}=this.props;if(!t)return;const a=i(),n=this.container.current.getBoundingClientRect(),r=(null!=(e=s.rowHeight)?e:xl)-xl;this.table.current.style.height=`${r}px`,this.table.current.style.width=a.width-(q.readonly?0:32)-20+"px",this.table.current.style.left=a.left-n.left+(q.readonly?0:32)+10+"px"},this.handleGridReady=async e=>{const{value:t}=this.state,{field:s}=this.props;this.gridApi=e.api,q.readonly||await this.loadedScript.run();const i=t?_e(s.typeAsModel.id,t):null,a=dt.get(i);this.gridApi.setRowData([...a?[a]:[],...this.loadedScript.records.filter((e=>e.id!==i))]),this.selectConnectedRecords()},this.handleScroll=async e=>{var t;const{node:s}=this.props;if(this.gridApi.stopEditing(),"horizontal"===e.direction)return;if(this.loadedScript.recordIds.length>=(this.loadedScript.model.count||0))return;const i=(null!=(t=s.rowHeight)?t:xl)-xl,a=this.loadedScript.pagination.take;!this.loadedScript.running&&e.top+i>=xl*(a-20)&&(this.gridApi.applyTransaction({add:await this.loadedScript.loadMore()}),this.selectConnectedRecords())},this.selectConnectedRecords=async()=>{var e;const{value:t}=this.state,{field:s}=this.props;if(null===t)return;const i=_e(s.typeAsModel.id,t);null==(e=this.gridApi.getRowNode(i))||e.setSelected(!0,!0,!0)},this.handleSelectionChanged=e=>{var t;const{value:s}=this.state,{field:i}=this.props,a=s&&_e(i.typeAsModel.id,s),n=e.api.getSelectedNodes().map((e=>e.id))[0]||null;n?a!==n&&(null==(t=this.gridApi.getRowNode(n))||t.setSelected(!0,!0),this.setState({value:dt.get(n).value})):this.setState({value:null})},this.handleSearch=async()=>{const{value:e}=this.state,{field:t}=this.props;await this.loadedScript.run();if(!!Object.values(this.loadedScript.where.values).find((e=>null!==e.value&&""!==e.value)))this.gridApi.setRowData(this.loadedScript.records);else{const s=e?_e(t.typeAsModel.id,e):null;this.gridApi.setRowData([...e?[dt.get(s)]:[],...this.loadedScript.records.filter((e=>e.id!==s))])}this.selectConnectedRecords()},this.handleClickRelation=()=>{var e;null==(e=this.props.api)||e.stopEditing()},this.handleRowDoubleClicked=e=>{this.handleSelectionChanged(e),this.props.stopEditing()},this.handleViewConnections=()=>{const{field:e}=this.props,{value:t}=this.state;if(null===t)return;if(!e.typeAsModel)return;const s=e.typeAsModel,i=t?_e(e.typeAsModel.id,t):null,a=dt.get(i);if(!a)return;const n=Bt.add({modelId:s.id,preview:!1});s.uniqueIdentifier.fields.map((e=>{n.session.script.where.add({fieldIds:[e.id],operation:"equals",value:a.value[e.name]})})),Bt.switch({id:n.id})},!e.field.typeAsModel)throw U({path:"RelationInput.constructor",message:"Invalid field.typeAsModel",context:{field:e.field.serialize()}});this.state={value:null!=(t=e.initialValue)?t:null},this.loadedScript=Mt.add({name:null,frozen:!0,modelId:e.field.typeAsModel.id,fieldIds:e.field.typeAsModel.fieldIds},{skipPersist:!0}),this.loadedScript.fields.forEach((e=>{e.isScalar&&this.loadedScript.where.add({fieldIds:[e.id],operation:e.isInt||e.isFloat||e.isDecimal?"equals":"contains",value:null})}))}componentWillUnmount(){var e,t;null==(e=this.props.api)||e.resetRowHeights(),null==(t=this.props.api)||t.onRowHeightChanged()}render(){const{value:e}=this.state,{field:t}=this.props,s=t.typeAsModel.fields;return N.createElement(N.Fragment,null,N.createElement("div",{ref:this.container,className:xr},N.createElement(Tr,{type:t.type,isNull:!e,isPressed:!0,onClick:this.handleClickRelation})),N.createElement("div",{"data-testid":"input--relation",ref:this.table,className:L(Sr,"ag-theme-relations")},N.createElement(A,{rowSelection:"single",getRowId:e=>e.data.id,suppressCellFocus:!0,headerHeight:64,components:{TableCellRenderer:Jr,TableCellHeaderWithSearch:Hr,TableEmptyOverlay:Kr},onGridReady:this.handleGridReady,onBodyScroll:this.handleScroll,onSelectionChanged:this.handleSelectionChanged,noRowsOverlayComponent:"TableEmptyOverlay"},N.createElement(T,{colId:"checkbox",headerName:"",editable:!1,resizable:!1,sortable:!1,hide:q.readonly,pinned:!0,suppressNavigable:!0,suppressMovable:!0,maxWidth:32,checkboxSelection:!0}),s.map((e=>N.createElement(T,{key:e.id,editable:!1,resizable:!1,sortable:!1,suppressMovable:!0,headerComponent:"TableCellHeaderWithSearch",headerComponentParams:{field:e,script:this.loadedScript,onSearch:this.handleSearch},cellRenderer:"TableCellRenderer",cellRendererParams:{field:e}})))),N.createElement("div",{className:Nr},N.createElement(si,{className:Rr,green:!0,"data-testid":"open-in-new-tab",disabled:null===e,onClick:this.handleViewConnections},"Open in new tab"))))}}var Qr=S(Gr);class Yr extends N.Component{constructor(e){if(super(e),this.container=N.createRef(),this.table=N.createRef(),this.getValue=()=>this.state.value,this.focus=()=>{},this.afterGuiAttached=async()=>{var e;if(!this.container.current||!this.table.current)return;const{api:t,node:s,getTableDimensions:i}=this.props;if(!t)return;const a=i(),n=this.container.current.getBoundingClientRect(),r=(null!=(e=s.rowHeight)?e:xl)-xl;this.table.current.style.height=`${r}px`,this.table.current.style.width=a.width-(q.readonly?0:32)-20+"px",this.table.current.style.left=a.left-n.left+(q.readonly?0:32)+10+"px"},this.handleGridReady=async e=>{const{value:t=[]}=this.state,{field:s}=this.props;this.gridApi=e.api,q.readonly||await this.loadedScript.run();const i=t.map((e=>_e(s.typeAsModel.id,e))),a=s.getRelationIDFieldName;if(a){const e=t.map((e=>e[`${a}`]));let{error:i,data:n}=await window.transport.request({channel:"prisma",action:"clientRequest",payload:{data:{schemaHash:es.activeProject.schemaHash,modelName:s.typeAsModel.id,operation:"findMany",args:{where:{[a]:{in:e}}}}}});if(i)throw U({path:"runQuery",code:i.code,type:i.type,stack:i.stack,message:`Error in Prisma Client request: \n\n${i.message}`,context:{error:i}});n.forEach((e=>dt.add({modelId:s.typeAsModel.id,value:e})))}this.gridApi.setRowData([...i.map((e=>dt.get(e))),...this.loadedScript.records.filter((e=>!i.includes(e.id)))]),this.selectConnectedRecords()},this.handleScroll=async e=>{var t;const{value:s=[]}=this.state,{node:i,field:a}=this.props;if("horizontal"===e.direction)return;if(this.loadedScript.recordIds.length>=(this.loadedScript.model.count||0))return;const n=!!Object.values(this.loadedScript.where.values).find((e=>{var t;return e.id!==(null==(t=this.whereFilterThatFetchesUnconnectedRecords)?void 0:t.id)&&null!==e.value&&""!==e.value})),r=(null!=(t=i.rowHeight)?t:xl)-xl,l=(n?0:s.length)+this.loadedScript.pagination.take;if(!this.loadedScript.running&&e.top+r>=xl*(l-20)){const e=await this.loadedScript.loadMore(),t=s.map((e=>_e(a.typeAsModel.id,e)));this.gridApi.applyTransaction({add:e.filter((e=>!t.includes(e.id)))}),this.selectConnectedRecords()}},this.selectConnectedRecords=async()=>{const{value:e=[]}=this.state,{field:t}=this.props,s=e.map((e=>_e(t.typeAsModel.id,e)));this.selectedRecordIds=[],this.gridApi.forEachNode((e=>{null!=e.id&&s.includes(e.id)&&(e.setSelected(!0,!1,!0),this.selectedRecordIds.push(e.id))}))},this.handleSelectionChanged=()=>{var e,t;const{value:s=[]}=this.state,{field:i}=this.props,a=s.map((e=>_e(i.typeAsModel.id,e))),n=this.selectedRecordIds,r=this.gridApi.getSelectedNodes().filter((e=>null!=e.id)).map((e=>e.id));if(h.exports.isEqual(n,r))return;let l;if(n.length>r.length){const t=h.exports.difference(n,r);this.selectedRecordIds=this.selectedRecordIds.filter((e=>e!==t[0])),null==(e=this.gridApi.getRowNode(t[0]))||e.setSelected(!1),l=a.filter((e=>e!==t[0]))}else{const e=h.exports.difference(r,n);this.selectedRecordIds.push(e[0]),null==(t=this.gridApi.getRowNode(e[0]))||t.setSelected(!0),l=a.concat([e[0]])}this.setState({value:l.map((e=>dt.get(e).value))})},this.handleClickRelation=()=>{var e;null==(e=this.props.api)||e.stopEditing()},this.handleSearch=async()=>{var e,t;const{value:s=[]}=this.state,{field:i}=this.props,a=!!Object.values(this.loadedScript.where.values).find((e=>{var t;return e.id!==(null==(t=this.whereFilterThatFetchesUnconnectedRecords)?void 0:t.id)&&null!==e.value&&""!==e.value}));if(a?null==(e=this.whereFilterThatFetchesUnconnectedRecords)||e.update({enabled:!1}):null==(t=this.whereFilterThatFetchesUnconnectedRecords)||t.update({enabled:!0}),await this.loadedScript.run(),a)this.gridApi.setRowData(this.loadedScript.records);else{const e=s.map((e=>_e(i.typeAsModel.id,e)));this.gridApi.setRowData([...e.map((e=>dt.get(e))),...this.loadedScript.records.filter((t=>!e.includes(t.id)))])}this.selectConnectedRecords()},this.handleSkipToUnconnected=()=>{const{value:e=[]}=this.state,{field:t}=this.props,s=e.length-1;if(-1===s)return;if(!t.typeAsModel)return;const i=dt.get(_e(t.typeAsModel.id,e[s]));if(!i)return;const a=this.gridApi.getRowNode(i.id);this.gridApi.ensureNodeVisible(a,"top")},this.handleViewConnections=()=>{const{field:e,node:t}=this.props,{value:s=[]}=this.state;if(0===s.length)return;if(!e.isRelation||!e.typeAsModel)return;const i=dt.get(t.id);if(!i)return;const a=e.typeAsModel,n=a.fields.find((t=>t.isRelation&&t.relationName===e.relationName));if(!n)return;const r=i.model.uniqueIdentifier.fields[0],l=Bt.add({modelId:a.id,preview:!1});l.session.script.where.add({fieldIds:[n.id,r.id],operation:"equals",value:String(i.value[r.name])}),Bt.switch({id:l.id})},!e.field.typeAsModel)throw U({path:"RelationListInput.constructor",message:"Invalid field.typeAsModel",context:{field:e.field.serialize()}});const{initialValue:t}=e;this.state={value:null!=t?t:[]},this.loadedScript=Mt.add({name:null,frozen:!0,modelId:e.field.typeAsModel.id,fieldIds:e.field.typeAsModel.fieldIds},{skipPersist:!0}),this.loadedScript.fields.forEach((e=>{e.isScalar&&this.loadedScript.where.add({fieldIds:[e.id],operation:e.isInt||e.isFloat||e.isDecimal?"equals":"contains",value:null})}));const s=e.field.typeAsModel,i=dt.get(e.node.id),a=s.fields.find((t=>t.isRelation&&t.relationName===e.field.relationName));if(s&&i&&a&&i.isCommitted){const e=JSON.stringify(i.model.uniqueIdentifier.fields.reduce(((e,t)=>(t.isBigInt?e[t.name]=i.value[t.name].toString():e[t.name]=i.value[t.name],e)),{}));this.whereFilterThatFetchesUnconnectedRecords=this.loadedScript.where.add({fieldIds:[a.id],operation:"equals",value:a.isList?`{ none: ${e} }`:`{ NOT: ${e} }`})}else this.whereFilterThatFetchesUnconnectedRecords=null;this.selectedRecordIds=[]}componentWillUnmount(){var e,t;null==(e=this.props.api)||e.resetRowHeights(),null==(t=this.props.api)||t.onRowHeightChanged()}render(){const{value:e=[]}=this.state,{field:t}=this.props,s=t.typeAsModel.fields;return N.createElement(N.Fragment,null,N.createElement("div",{ref:this.container,className:xr},N.createElement(Tr,{type:t.type,isList:!0,count:e.length,isNull:!1,isPressed:!0,onClick:this.handleClickRelation})),N.createElement("div",{"data-testid":"input--relation-list",ref:this.table,className:L(Sr,"ag-theme-relations")},N.createElement(A,{rowSelection:"multiple",getRowId:e=>e.data.id,suppressCellFocus:!0,headerHeight:64,components:{TableCellRenderer:Jr,TableCellHeaderWithSearch:Hr,TableEmptyOverlay:Kr},rowMultiSelectWithClick:!0,onGridReady:this.handleGridReady,onBodyScroll:this.handleScroll,onSelectionChanged:this.handleSelectionChanged,noRowsOverlayComponent:"TableEmptyOverlay"},N.createElement(T,{colId:"checkbox",headerName:"",editable:!1,resizable:!1,sortable:!1,pinned:!0,hide:q.readonly,suppressNavigable:!0,maxWidth:32,checkboxSelection:!0}),s.map((e=>N.createElement(T,{key:e.id,editable:!1,resizable:!1,sortable:!1,suppressMovable:!0,headerComponent:"TableCellHeaderWithSearch",headerComponentParams:{field:e,script:this.loadedScript,onSearch:this.handleSearch},cellRenderer:"TableCellRenderer",cellRendererParams:{field:e}})))),N.createElement("div",{className:Nr},N.createElement(si,{"data-testid":"open-in-new-tab",disabled:0===e.length,className:Rr,green:!0,onClick:this.handleViewConnections},"Open in new tab"),N.createElement("button",{className:Lr,onClick:this.handleSkipToUnconnected,hidden:q.readonly},"Skip to unconnected records"))))}}var Xr=S(Yr);class el extends N.PureComponent{constructor(e){var t;super(e),this.input=N.createRef(),this.getValue=()=>this.state.value,this.focus=()=>{var e;null==(e=this.input.current)||e.focus()},this.handleChange=e=>{const{field:t}=this.props,s=e.currentTarget.value;t.isRequired||""!==s?this.setState({value:s}):this.setState({value:null})},this.state={value:null!=(t=e.initialValue)?t:null}}render(){const{value:e}=this.state;return N.createElement("input",{"data-testid":"input--string",ref:this.input,className:Cn,type:"text",value:null==e?"":String(e),placeholder:"null",onChange:this.handleChange})}}var tl=S(el);class sl extends N.PureComponent{constructor(e){super(e),this.items=[],this.draggedItem=null,this.getValue=()=>this.state.value,this.focus=()=>{var e;const{value:t}=this.state;t&&(null==(e=this.items[Math.max(t.length,0)].current)||e.focus())},this.handleChange=e=>{try{const t=JSON.parse(e.currentTarget.value);Array.isArray(t)&&this.setState({value:t.map((e=>String(e)))})}catch(t){}},this.handleChangeItem=(e,t)=>{const{value:s}=this.state,i=String(t.currentTarget.value);if(!Array.isArray(s))throw U({path:"StringListInput.handleChangeItem",message:"Invalid value",context:{value:s,idx:e,changedItem:i}});const a=[...s];return a.splice(e,1,i),this.setState({value:a})},this.handleChangeNewItem=e=>{const t=String(e.currentTarget.value);this.setState({newItem:t})},this.handleAddNewItem=()=>{const{value:e,newItem:t}=this.state;if(!Array.isArray(e))throw U({path:"StringListInput.handleAddItem",message:"Invalid value",context:{value:e,newItem:t}});this.items.push(N.createRef()),this.setState({value:[...e,t||""],newItem:null},(()=>{var e,t;null==(e=this.items[this.items.length-1].current)||e.focus(),null==(t=this.items[this.items.length-2].current)||t.scrollIntoView(!1)}))},this.handleEnterKeydown=e=>{const{value:t}=this.state;if(!Array.isArray(t))throw U({path:"StringListInput.handleEnterKeydown",message:"Invalid value",context:{value:t,idx:e}});let s=[...t];s.splice(e+1,0,""),this.items.push(N.createRef()),this.setState({value:s,newItem:null},(()=>{var t,s,i;null==(t=this.items[e+1].current)||t.focus(),null==(s=this.items[e+1].current)||s.scrollIntoView(!1),null==(i=this.items[e+1].current)||i.scrollIntoView({block:"nearest"})}))},this.handleRemoveItem=(e,t)=>{var s,i,a,n;const{value:r}=this.state;if(t.preventDefault(),t.stopPropagation(),!Array.isArray(r))throw U({path:"StringListInput.handleRemoveClick",message:"Invalid Value",context:{value:r,idx:e}});const l=[...r];l.splice(e,1),this.items.splice(e,1),null==(i=null==(s=this.items[e-1])?void 0:s.current)||i.focus(),null==(n=null==(a=this.items[e-1])?void 0:a.current)||n.scrollIntoView(),setTimeout((()=>this.setState({value:l})),0)},this.handleTabKeydown=(e,t)=>{var s;const{value:i}=this.state;if(!Array.isArray(i))throw U({path:"StringListInput.handleTabKeydown",message:"Invalid value",context:{value:i,idx:e}});e===i.length||(t.preventDefault(),t.stopPropagation(),null==(s=this.items[e+1].current)||s.focus())},this.handleShiftTabKeydown=(e,t)=>{var s;0===e||(t.preventDefault(),t.stopPropagation(),null==(s=this.items[e-1].current)||s.focus())},this.handleFinishEditing=()=>{this.props.stopEditing()},this.handleDragStart=e=>{this.draggedItem=this.items[e]},this.handleDragOver=(e,t)=>{t.preventDefault(),this.setState({draggedOverIdx:e})},this.handleDragEnd=e=>{var t;if(!this.draggedItem)return;const{value:s=[]}=this.state;if(!Array.isArray(s))throw U({path:"StringListInput.HandleDragEnd",message:"Invalid value",context:{value:s,idx:e}});const i=[...s],a=String(null==(t=this.draggedItem.current)?void 0:t.value);this.items.splice(e,1),i.splice(e,1),this.state.draggedOverIdx>e?(this.items.splice(this.state.draggedOverIdx-1,0,this.draggedItem),i.splice(this.state.draggedOverIdx-1,0,a)):(this.items.splice(this.state.draggedOverIdx,0,this.draggedItem),i.splice(this.state.draggedOverIdx,0,a)),this.draggedItem=null,this.setState({value:i,draggedOverIdx:-1})};const{initialValue:t}=e;if(!Array.isArray(t))throw U({path:"StringListInput.constructor",message:"Invalid initialValue",context:{initialValue:t}});this.state={value:t,newItem:null,draggedOverIdx:-1},this.items=Array.from({length:Math.max(t.length,1)}).map((()=>N.createRef())),this.items.push(N.createRef())}render(){const{value:e}=this.state;if(!Array.isArray(e))throw U({path:"StringListInput.render",message:"Invalid value",context:{value:e}});return N.createElement(N.Fragment,null,N.createElement("div",{"data-testid":"input--string-list",className:Nn},N.createElement("input",{type:"text",className:Ln,value:JSON.stringify(e),onChange:this.handleChange}),N.createElement("ul",{className:L(Rn,"ag-theme-dark")},N.createElement("div",{className:On},N.createElement("div",{className:L(Pn,{[Vn]:0===this.state.draggedOverIdx})}),e.map(((e,t)=>N.createElement(N.Fragment,{key:t},N.createElement(il,{innerRef:this.items[t],value:e,onChange:this.handleChangeItem.bind(this,t),onRemove:this.handleRemoveItem.bind(this,t),onEnter:this.handleEnterKeydown.bind(this,t),onTab:this.handleTabKeydown.bind(this,t),onShiftTab:this.handleShiftTabKeydown.bind(this,t),onModEnter:this.handleFinishEditing.bind(this),onDragStart:this.handleDragStart.bind(this,t),onDragEnd:this.handleDragEnd.bind(this,t),onDragOver:this.handleDragOver.bind(this,t)}),N.createElement("div",{className:L(Pn,{[Vn]:this.state.draggedOverIdx===t+1})}))))),N.createElement(il,{innerRef:this.items[e.length],value:this.state.newItem||"",onChange:this.handleChangeNewItem,onAdd:this.handleAddNewItem,onEnter:this.handleAddNewItem,onShiftTab:this.handleShiftTabKeydown.bind(this,e.length),onDragOver:this.handleDragOver.bind(this,e.length)}))))}}class il extends N.Component{render(){return N.createElement("li",{"data-testid":"input--string-list-item",className:Mn,onDragOver:this.props.onDragOver},this.props.onDragStart&&this.props.onDragEnd&&N.createElement(xn,{className:Dn,onDragStart:this.props.onDragStart,onDragEnd:this.props.onDragEnd},N.createElement(Sn,null)),N.createElement("input",{ref:this.props.innerRef,className:Ln,type:"text",value:this.props.value,tabIndex:this.props.tabIndex,onChange:this.props.onChange}),this.props.onAdd&&N.createElement(si,{"data-testid":"input--string-list-item__add-btn",onClick:this.props.onAdd,className:Tn},"Add"),this.props.onRemove&&N.createElement(si,{"data-testid":"input--string-list-item__remove-btn",onClick:this.props.onRemove,className:An},N.createElement(na,null)),this.props.onEnter&&N.createElement(li,{keys:"enter",target:this.props.innerRef,onMatch:this.props.onEnter}),this.props.onTab&&N.createElement(li,{keys:["tab"],preventDefault:!1,stopPropagation:!1,target:this.props.innerRef,onMatch:this.props.onTab}),this.props.onShiftTab&&N.createElement(li,{keys:["shift+tab"],preventDefault:!1,stopPropagation:!1,target:this.props.innerRef,onMatch:this.props.onShiftTab}),this.props.onModEnter&&N.createElement(li,{keys:["mod+enter"],preventDefault:!1,stopPropagation:!1,target:this.props.innerRef,onMatch:this.props.onModEnter}))}}var al=S(sl);var nl="_container_1mf95_1",rl="_invalid_1mf95_6",ll="_phantom_1mf95_10";class ol extends N.Component{constructor(e){super(e),this.container=N.createRef(),this.input=N.createRef(),this.getValue=()=>{var e,t;return null==(t=null==(e=this.input.current)?void 0:e.getValue)?void 0:t.call(e)},this.isPopup=()=>!0,this.handleClickOutside=e=>{var t,s;(null==(t=this.container.current)?void 0:t.contains(e.target))||null==(s=this.props.api)||s.stopEditing()};const{node:{data:t},field:s}=e,i=t;this.stopEditingImmediately=!1,"Backspace"===e.eventKey||"Delete"===e.eventKey?(this.initialValue=s.lowestValidValue,this.stopEditingImmediately=!0):e.charPress?e.field.isScalar&&!e.field.isList&&(this.initialValue=e.charPress):this.initialValue=i.value[s.name]}async componentDidMount(){var e,t,s,i,a;document.addEventListener("click",this.handleClickOutside);const{api:n,node:r,field:l,resizeRowForRelation:o}=this.props;if(this.stopEditingImmediately)return null==(t=null==(e=this.input.current)?void 0:e.setValue)||t.call(e,this.initialValue),await new Promise(requestAnimationFrame),void(null==n||n.stopEditing());o(r,l),null==(i=null==(s=this.input.current)?void 0:s.afterGuiAttached)||i.call(s),null==(a=this.input.current)||a.focus()}componentWillUnmount(){document.removeEventListener("click",this.handleClickOutside)}render(){var e,t;const{node:{data:s},columnApi:i,column:a,field:n}=this.props,r=s,d=null!=(t=null==(e=i.getColumnState().find((e=>e.colId===a.getColId())))?void 0:e.width)?t:200,c=r.invalidFields.find((e=>e.field.id===n.id));return N.createElement("div",{ref:this.container,className:L(nl,{[rl]:!!c}),style:{width:d}},n.isString&&(n.isList?N.createElement(al,o(l({ref:this.input},this.props),{initialValue:this.initialValue})):N.createElement(tl,o(l({ref:this.input},this.props),{initialValue:this.initialValue}))),(n.isInt||n.isFloat||n.isDecimal)&&(n.isList?N.createElement(_r,o(l({ref:this.input},this.props),{initialValue:this.initialValue})):N.createElement(wr,o(l({ref:this.input},this.props),{initialValue:this.initialValue}))),n.isBigInt&&(n.isList?N.createElement(Bn,o(l({ref:this.input},this.props),{initialValue:this.initialValue})):N.createElement(bn,o(l({ref:this.input},this.props),{initialValue:this.initialValue}))),n.isBoolean&&(n.isList?N.createElement(tr,o(l({ref:this.input},this.props),{initialValue:this.initialValue})):N.createElement(Gn,o(l({ref:this.input},this.props),{initialValue:this.initialValue}))),n.isDateTime&&(n.isList?N.createElement(al,o(l({ref:this.input},this.props),{initialValue:this.initialValue})):N.createElement(or,o(l({ref:this.input},this.props),{initialValue:this.initialValue}))),n.isJson&&(n.isList?N.createElement(Ir,o(l({ref:this.input},this.props),{initialValue:this.initialValue})):N.createElement(vr,o(l({ref:this.input},this.props),{initialValue:this.initialValue}))),n.isBytes&&(n.isList?N.createElement(rr,o(l({ref:this.input},this.props),{initialValue:this.initialValue})):N.createElement(ir,o(l({ref:this.input},this.props),{initialValue:this.initialValue}))),n.isEnum&&(n.isList?N.createElement(ur,o(l({ref:this.input},this.props),{initialValue:this.initialValue})):N.createElement(cr,o(l({ref:this.input},this.props),{initialValue:this.initialValue}))),n.isRelation&&(n.isList?N.createElement(Xr,o(l({ref:this.input},this.props),{initialValue:this.initialValue})):N.createElement(Qr,o(l({ref:this.input},this.props),{initialValue:this.initialValue}))),c&&N.createElement("div",{className:ll},c.reason))}}var dl=S(ol);function cl(e){return R.exports.createElement("svg",Object.assign({viewBox:"0 0 24 24",xmlns:"http://www.w3.org/2000/svg"},e),R.exports.createElement("path",{fillRule:"evenodd",clipRule:"evenodd",d:"M7.99999 0H0V24H7.99999V21H4.00001V3H7.99999V0ZM16 0V3H19.9999V21H16V24H24V0H16Z"}))}function hl(e){return R.exports.createElement("svg",Object.assign({viewBox:"0 0 24 24",xmlns:"http://www.w3.org/2000/svg"},e),R.exports.createElement("path",{fillRule:"evenodd",clipRule:"evenodd",d:"M6.85714 5C3.07006 5 0 8.13402 0 12C0 15.866 3.07006 19 6.85714 19H17.143C20.9299 19 24 15.866 24 12C24 8.13402 20.9299 5 17.143 5H6.85714ZM6.85714 17.25C9.69746 17.25 12 14.8995 12 12C12 9.10051 9.69746 6.75 6.85714 6.75C4.01683 6.75 1.7143 9.10051 1.7143 12C1.7143 14.8995 4.01683 17.25 6.85714 17.25Z"}))}function pl(e){return R.exports.createElement("svg",Object.assign({viewBox:"0 0 24 24",fill:"none",xmlns:"http://www.w3.org/2000/svg"},e),R.exports.createElement("path",{fillRule:"evenodd",clipRule:"evenodd",d:"M4 10V18C4 19.1046 4.89543 20 6 20H18C19.1046 20 20 19.1046 20 18V10H4ZM0 6C0 2.68629 2.68629 0 6 0H18C21.3137 0 24 2.68629 24 6V18C24 21.3137 21.3137 24 18 24H6C2.68629 24 0 21.3137 0 18V6Z"}))}function ul(e){return R.exports.createElement("svg",Object.assign({viewBox:"0 0 24 24",xmlns:"http://www.w3.org/2000/svg"},e),R.exports.createElement("path",{fillRule:"evenodd",clipRule:"evenodd",d:"M24 4.8H0V0H24V4.8Z"}),R.exports.createElement("path",{fillRule:"evenodd",clipRule:"evenodd",d:"M16.8 14.4H0V9.60001H16.8V14.4Z"}),R.exports.createElement("path",{fillRule:"evenodd",clipRule:"evenodd",d:"M24 24H0V19.2H24V24Z"}))}function ml(e){return R.exports.createElement("svg",Object.assign({viewBox:"0 0 24 24",xmlns:"http://www.w3.org/2000/svg"},e),R.exports.createElement("path",{fillRule:"evenodd",clipRule:"evenodd",d:"M0 8.0001C0 6.89554 0.89544 6.00015 1.99999 6.00015H22.0001C23.1046 6.00015 24 6.89554 24 8.0001C24 9.10465 23.1046 10.0001 22.0001 10.0001H1.99999C0.89544 10.0001 0 9.10465 0 8.0001Z"}),R.exports.createElement("path",{fillRule:"evenodd",clipRule:"evenodd",d:"M0 15.9999C0 14.8954 0.89544 14 1.99999 14H22.0001C23.1046 14 24 14.8954 24 15.9999C24 17.1046 23.1046 17.9998 22.0001 17.9998H1.99999C0.89544 17.9998 0 17.1046 0 15.9999Z"}),R.exports.createElement("path",{fillRule:"evenodd",clipRule:"evenodd",d:"M9.29671 0.0223986C10.389 0.186247 11.1418 1.20459 10.9779 2.2969L7.97789 22.2965C7.81404 23.3887 6.7957 24.1414 5.70334 23.9777C4.611 23.8138 3.85829 22.7954 4.02216 21.7032L7.02216 1.70355C7.18601 0.611239 8.20435 -0.141449 9.29671 0.0223986Z"}),R.exports.createElement("path",{fillRule:"evenodd",clipRule:"evenodd",d:"M18.2967 0.0223986C19.3891 0.186247 20.1418 1.20459 19.9779 2.2969L16.9779 22.2965C16.8139 23.3887 15.7957 24.1414 14.7033 23.9777C13.611 23.8138 12.8583 22.7954 13.0222 21.7032L16.0222 1.70355C16.186 0.611239 17.2044 -0.141449 18.2967 0.0223986Z"}))}function gl(e){return R.exports.createElement("svg",Object.assign({viewBox:"0 0 24 24",xmlns:"http://www.w3.org/2000/svg"},e),R.exports.createElement("path",{d:"M9.5452 24V21.1961H8.44912C6.82779 21.1961 6.50809 20.7754 6.50809 18.6723V15.1291C6.50809 13.3829 5.38916 12.2613 3.32256 12.1211V11.8917C5.38916 11.7515 6.50809 10.6171 6.50809 8.88371V5.32767C6.50809 3.22464 6.82779 2.80404 8.44912 2.80404H9.5452V0H7.70696C4.40725 0 3.33397 1.15985 3.33397 4.72863V7.54542C3.33397 9.55924 2.51189 10.3367 0 10.222V13.778C2.51189 13.6761 3.33397 14.4535 3.33397 16.4674V19.2713C3.33397 22.8401 4.40725 24 7.70696 24H9.5452Z"}),R.exports.createElement("path",{d:"M16.293 24C19.5929 24 20.6659 22.8401 20.6659 19.2713V16.4674C20.6659 14.4535 21.4882 13.6761 24 13.778V10.222C21.4882 10.3367 20.6659 9.55924 20.6659 7.54542V4.72863C20.6659 1.15985 19.5929 0 16.293 0H14.4548V2.80404H15.5509C17.1722 2.80404 17.4919 3.22464 17.4919 5.32767V8.88371C17.4919 10.6171 18.6108 11.7515 20.6774 11.8917V12.1211C18.6108 12.2613 17.4919 13.3829 17.4919 15.1291V18.6723C17.4919 20.7754 17.1722 21.1961 15.5509 21.1961H14.4548V24H16.293Z"}))}function vl(e){return R.exports.createElement("svg",Object.assign({viewBox:"0 0 24 24",xmlns:"http://www.w3.org/2000/svg"},e),R.exports.createElement("path",{d:"M18.327 24L16.5266 18.3105H7.4735L5.67304 24H0L8.76437 0H15.2018L24 24H18.327ZM15.2697 14.06C13.6051 8.90463 12.6653 5.98911 12.4502 5.31336C12.2463 4.63761 12.0991 4.10355 12.0085 3.71118C11.6349 5.10627 10.5648 8.55585 8.79833 14.06H15.2697Z"}))}var fl="_icon_f25b9_1",yl="_required_f25b9_8";var Il=S((({className:e,string:t=!1,int:s=!1,float:i=!1,boolean:a=!1,dateTime:n=!1,enumerable:r=!1,array:l=!1,required:o=!1})=>{let d;return d=l?cl:t?vl:s||i?ml:a?hl:r?ul:n?pl:gl,N.createElement(N.Fragment,null,N.createElement(d,{className:L(fl,e)}),N.createElement("span",{className:yl},!o&&"?"))}));function Cl(e){return R.exports.createElement("svg",Object.assign({viewBox:"0 0 9 7",xmlns:"http://www.w3.org/2000/svg"},e),R.exports.createElement("path",{d:"M4.5 7L8.39711 0.25H0.602886L4.5 7Z",fill:"currentColor"}))}var wl={container:"_container_e5y85_1",sortable:"_sortable_e5y85_11",title:"_title_e5y85_15",spacer:"_spacer_e5y85_22",sortIndicator:"_sortIndicator_e5y85_26",visible:"_visible_e5y85_34",asc:"_asc_e5y85_37"};class bl extends N.Component{constructor(){super(...arguments),this.state={wasReordered:!1},this.handleReorder=()=>{this.setState({wasReordered:!0})},this.handleSort=()=>{var e;const{wasReordered:t}=this.state,{field:s,script:i}=this.props;this.setState({wasReordered:!1}),s&&s.isSortable&&(t||(null==(e=Bt.activeTab)||e.update({preview:!1}),i.sort.fieldId===s.id&&"asc"===i.sort.order?i.sort.update({fieldId:s.id,order:"desc"}):i.sort.fieldId===s.id&&"desc"===i.sort.order?i.sort.update({fieldId:null,order:"asc"}):i.sort.update({fieldId:s.id,order:"asc"}),i.run(),us.send({command:"sort_change",commandDetails:{field_type:s.type}})))}}componentDidMount(){this.props.column.addEventListener("movingChanged",this.handleReorder)}componentWillUnmount(){this.props.column.removeEventListener("movingChanged",this.handleReorder)}render(){var e,t;const{field:s,script:i,displayName:a,columnApi:n,column:r}=this.props,l=null!=(t=null==(e=n.getColumnState().find((e=>e.colId===r.getColId())))?void 0:e.width)?t:200;return N.createElement("div",{"data-testid":"table__header__cell",className:L(wl.container,{[wl.sortable]:s.isSortable}),style:{width:l},title:`${s.name} (${s.type})`,onClick:this.handleSort},N.createElement("span",{"data-testid":"table__header__cell__title",className:wl.title},a),N.createElement(Il,{required:s.isRequired,array:s.isList,object:s.isRelation,string:s.isString,int:s.isInt||s.isBigInt,float:s.isFloat||s.isDecimal,boolean:s.isBoolean,dateTime:s.isDateTime,enumerable:s.isEnum}),N.createElement("div",{className:wl.spacer}),N.createElement(Cl,{"data-test-asc":i.sort.fieldId===s.id&&"asc"===i.sort.order,"data-test-desc":i.sort.fieldId===s.id&&"desc"===i.sort.order,className:L(wl.sortIndicator,{[wl.visible]:i.sort.fieldId===s.id,[wl.asc]:"asc"===i.sort.order,[wl.desc]:"desc"===i.sort.order})}))}}var El=S(bl);class _l extends N.Component{render(){return N.createElement("div",{"data-testid":"loading-overlay",className:Wr},"Fetching rows in this table...")}}const xl=32;class Sl extends N.Component{constructor(e){super(e),this.table=N.createRef(),this.recordOrder=new Map,this.reactionDisposers=[],this.focus=()=>{var e;null==(e=this.table.current)||e.focus()},this.refresh=()=>{this.loadGridDataDebounced()},this.selectRows=(e=[])=>{this.gridApi.deselectAll(),e.forEach((e=>{var t,s;null==(s=null==(t=this.gridApi)?void 0:t.getRowNode(e))||s.setSelected(!0)}))},this.deleteSelectedRows=()=>{var e;const t=null==(e=Bt.activeTab)?void 0:e.sessionId;if(!t)return;this.gridApi.getSelectedNodes().map((e=>dt.get(e.id))).filter((e=>!!e)).forEach((e=>Os.add({type:"delete",recordId:e.id,sessionId:t,value:{}})))},this.getDimensions=()=>{var e;return null==(e=this.table.current)?void 0:e.getBoundingClientRect()},this.resizeRowForRelation=(e,t)=>{if(!t.typeAsModel)return!1;const s=this.getDimensions();if(!s)return;const i=2*xl,a=64+(s.height-4*xl-64-15-36)+15+36,n=64+i+15+36,r=64+xl*(t.typeAsModel.count||0)+15+36,l=Math.min(Math.max(n,r),a);e.setRowHeight(xl+l),this.gridApi.onRowHeightChanged(),this.gridApi.ensureNodeVisible(e,"top")},this.loadGridData=async()=>{var e;const t=null==(e=Bt.activeTab)?void 0:e.session;t&&t.isScript&&(await t.script.run(),0!==t.script.model.count||0!==t.script.recordIds.length||this.gridApi.showNoRowsOverlay())},this.configureGridColumns=()=>{var e;const t=null==(e=Bt.activeTab)?void 0:e.session;t&&t.isScript&&(this.gridApi.stopEditing(),this.gridApi.setColumnDefs([{colId:"checkbox",headerName:"",editable:!1,resizable:!1,sortable:!1,hide:q.readonly,pinned:!0,suppressMovable:!0,maxWidth:32,checkboxSelection:!0,headerCheckboxSelection:!0},{colId:"view-column",headerName:"",editable:!1,resizable:!1,sortable:!1,pinned:!0,suppressMovable:!0,width:32,cellRenderer:"TriggerButtonRenderer"},...t.script.model.fields.map((e=>{const s=!(e.isScalarListTwoWayMNRelation||q.readonly&&!e.isRelation);return{colId:e.id,headerName:e.name,editable:s,cellEditorPopup:!0,resizable:!0,tooltipValueGetter:s?void 0:()=>"This field is not editable",sortable:!0,hide:!t.script.fieldIds.includes(e.id),valueGetter:t=>t.data.value[e.name],valueSetter:t=>this.handleCellValueChanged(t,e),comparator:(e,t,s,i,a)=>(this.recordOrder.get(s.id)-this.recordOrder.get(i.id)||0)*(a?-1:1),headerComponent:"TableCellHeader",headerComponentParams:{field:e,script:t.script},cellRenderer:"TableCellRenderer",cellRendererParams:{field:e,resizeRowForRelation:this.resizeRowForRelation},cellClassRules:{[vn]:()=>!0,[fn]:({data:t})=>t.dirtyFieldNames.includes(e.name),[yn]:({data:t})=>!!t.invalidFields.find((t=>t.field.id===e.id)),[In]:({data:t})=>void 0===t.value[e.name]||null===t.value[e.name]},cellEditor:"TableCellEditor",cellEditorParams:{field:e,sessionId:t.id,getTableDimensions:this.getDimensions,resizeRowForRelation:this.resizeRowForRelation}}}))]),this.gridApi.ensureColumnVisible(t.script.model.fieldIds[0]))},this.configureReactions=()=>{this.disposeReactions();let e=D(f((()=>{var e;return[Bt.activeTab,null==(e=Bt.activeTab)?void 0:e.session]})),(()=>{this.configureGridColumns(),this.loadGridDataDebounced()}));this.reactionDisposers.push(e),e=D(f((()=>{var e,t,s,i,a;return(null==(t=null==(e=Bt.activeTab)?void 0:e.session)?void 0:t.isScript)?null==(a=null==(i=null==(s=Bt.activeTab)?void 0:s.session)?void 0:i.script)?void 0:a.fields:[]})),(({oldValue:e=[],newValue:t=[]})=>{var s,i;if(!(null==(i=null==(s=Bt.activeTab)?void 0:s.session)?void 0:i.isScript))return;let a=[],n=[];const r=new Map;e.forEach((e=>r.set(e.id,e)));const l=new Map;t.forEach((e=>l.set(e.id,e))),l.forEach(((e,t)=>{r.has(t)||a.push(e),r.delete(t)})),r.forEach((e=>n.push(e))),E((()=>{a.forEach((e=>this.columnApi.setColumnVisible(e.id,!0))),n.forEach((e=>this.columnApi.setColumnVisible(e.id,!1)))}))})),this.reactionDisposers.push(e),e=D(f((()=>{var e,t,s,i,a;return(null==(t=null==(e=Bt.activeTab)?void 0:e.session)?void 0:t.isScript)?null==(a=null==(i=null==(s=Bt.activeTab)?void 0:s.session)?void 0:i.script)?void 0:a.records:[]})),(({oldValue:e=[],newValue:t=[]})=>{var s,i,a,n,r,l;if(!(null==(i=null==(s=Bt.activeTab)?void 0:s.session)?void 0:i.isScript))return;const o=[],d=[],c=[],p=new Map;e.forEach((e=>p.set(e.id,e)));const u=new Map;t.forEach((e=>u.set(e.id,e)));let m=0;this.recordOrder.clear(),u.forEach((e=>{this.recordOrder.set(e.id,m++),p.has(e.id)&&this.gridApi.getRowNode(e.id)?d.push(e):o.push(e),p.delete(e.id)})),p.forEach((e=>{this.gridApi.getRowNode(e.id)&&c.push(e)}));h.exports.findLast(o,(e=>!1===e.isCommitted))&&(this.gridApi.deselectAll(),this.gridApi.ensureIndexVisible(0),this.gridApi.setFocusedCell(Bt.activeTab.session.script.uncommittedRecords.length-1,h.exports.last(o).model.fieldIds[0])),this.columnApi.applyColumnState({state:[],applyOrder:!0}),this.gridApi.applyTransaction({add:o,update:d,remove:c}),this.columnApi.applyColumnState({state:[{colId:null==(n=null==(a=Bt.activeTab)?void 0:a.session)?void 0:n.script.fieldIds[0],sort:null==(l=null==(r=Bt.activeTab)?void 0:r.session)?void 0:l.script.sort.order}],applyOrder:!0})}),!0),this.reactionDisposers.push(e)},this.disposeReactions=()=>{this.reactionDisposers.forEach((e=>e())),this.reactionDisposers=[]},this.handleGridReady=async e=>{this.columnApi=e.columnApi,this.gridApi=e.api,this.configureReactions(),this.configureGridColumns(),this.loadGridDataDebounced()},this.handleScroll=async e=>{var t,s;if("horizontal"===e.direction)return;const i=null==(s=null==(t=Bt.activeTab)?void 0:t.session)?void 0:s.script;if(i.recordIds.length>=(i.model.count||0))return;const a=this.props.height;!i.running&&e.top+a>=32*(i.pagination.take-20)&&i.loadMore()},this.handleSelectionChanged=e=>{var t;null==(t=Bt.activeTab)||t.session.selection.table.update({selectedRecordIds:e.api.getSelectedRows().map((e=>e.id))})},this.handleCellEditingStopped=e=>{const t=this.gridApi.getFocusedCell(),s=e;if(!t||!s)return;if(t.rowIndex===s.rowIndex&&t.column.getColId()!==s.column.getColId())return;if(t.rowIndex===s.rowIndex)return;const i=fe.get(t.column.getColId()),a=fe.get(e.column.getColId());(null==a?void 0:a.isRelation)&&(null==i?void 0:i.isRelation)&&this.gridApi.startEditingCell({rowIndex:t.rowIndex,colKey:t.column.getColId()})},this.handleCellValueChanged=(e,t)=>{var s,i,a,n;const{oldValue:r,newValue:l,node:o}=e,d=null==o?void 0:o.data,c=null==(s=Bt.activeTab)?void 0:s.sessionId;if(!c)return!1;if(h.exports.isEqual(r,l))return!1;if(!(null==(a=null==(i=Bt.activeTab)?void 0:i.session)?void 0:a.isScript))return!1;if(Bt.activeTab.session.script.update({frozen:!1}),Os.add({type:"update",recordId:d.id,sessionId:c,value:{[t.name]:l}}),t.isRelation&&!t.isList){if(!t.typeAsModel)return!1;const e=t.relationFromFieldNames,s=t.relationToFieldNames;let i;i=null==l?null:dt.get(_e(t.typeAsModel.id,l)),Os.add({type:"update",sessionId:c,recordId:null!=(n=d.id)?n:null,value:e.reduce(((e,t,a)=>{var n;return e[t]=null!=(n=null==i?void 0:i.value[s[a]])?n:null,e}),{})})}if(t.isPartOfRelation&&t.relationItIsPartOf){if(!t.relationItIsPartOf.typeAsModel)return!1;const e=t.relationItIsPartOf.relationFromFieldNames,s=t.relationItIsPartOf.relationToFieldNames;Os.add({type:"update",sessionId:c,recordId:d.id,value:{[t.relationItIsPartOf.name]:null==l?null:s.reduce(((t,s,i)=>(t[s]=d.value[e[i]],t)),{})}})}return!0},this.loadGridDataDebounced=h.exports.debounce(this.loadGridData,300,{leading:!1,trailing:!0}),this.handleScrollThrottled=h.exports.throttle(this.handleScroll,100,{leading:!0,trailing:!0})}componentWillUnmount(){this.disposeReactions()}copyToClipboard(){const e=this.gridApi.getFocusedCell();if(!e)return;const t=this.gridApi.getDisplayedRowAtIndex(e.rowIndex);if(!t)return;const s=this.gridApi.getValue(e.column,t);if("object"!=typeof s||null===s)if(s)navigator.clipboard.writeText(s);else{const e=this.gridApi.getSelectedRows().map((e=>I(e.value))),t=JSON.stringify(e);if(0===e.length)return;navigator.clipboard.writeText(t)}}render(){var e;const t=null==(e=Bt.activeTab)?void 0:e.session;return N.createElement(N.Fragment,null,N.createElement("div",{ref:this.table,className:L(mn,"ag-theme-main")},N.createElement(qa,null),N.createElement(A,{rowSelection:"multiple",suppressRowClickSelection:!0,components:{TableLoadingOverlay:_l,TableEmptyOverlay:Kr,TableCellHeader:El,TableCellRenderer:Jr,TableCellEditor:dl,TriggerButtonRenderer:un},rowClassRules:{[gn]:e=>!!t.script.uncommittedRecords.length&&e.node.id===t.script.recordIds[t.script.uncommittedRecords.length]},loadingOverlayComponent:"TableLoadingOverlay",noRowsOverlayComponent:"TableEmptyOverlay",suppressColumnVirtualisation:!!window.Cypress,getRowId:e=>e.data.id,onGridReady:this.handleGridReady,onBodyScroll:this.handleScrollThrottled,onSelectionChanged:this.handleSelectionChanged,onCellEditingStopped:this.handleCellEditingStopped})),N.createElement(li,{keys:"mod+c",target:this.table,preventDefault:!1,stopPropagation:!1,onMatch:e=>{e.preventDefault(),e.stopPropagation(),this.copyToClipboard()}}),N.createElement(li,{keys:"mod+up",target:this.table,preventDefault:!1,stopPropagation:!1,onMatch:e=>{if(this.gridApi.getEditingCells().length>0)return;e.preventDefault(),e.stopPropagation();const t=this.gridApi.getFocusedCell();t&&this.gridApi.setFocusedCell(0,t.column)}}),N.createElement(li,{keys:"mod+down",target:this.table,preventDefault:!1,stopPropagation:!1,onMatch:e=>{if(this.gridApi.getEditingCells().length>0)return;e.preventDefault(),e.stopPropagation();const t=this.gridApi.getFocusedCell();t&&this.gridApi.setFocusedCell(Bt.activeTab.session.script.recordIds.length-1,t.column)}}),N.createElement(li,{keys:"mod+left",target:this.table,preventDefault:!1,stopPropagation:!1,onMatch:e=>{if(this.gridApi.getEditingCells().length>0)return;e.preventDefault(),e.stopPropagation();const t=this.gridApi.getFocusedCell();t&&this.gridApi.setFocusedCell(t.rowIndex,this.columnApi.getColumnState()[1].colId)}}),N.createElement(li,{keys:"mod+right",target:this.table,preventDefault:!1,stopPropagation:!1,onMatch:e=>{if(this.gridApi.getEditingCells().length>0)return;e.preventDefault(),e.stopPropagation();const t=this.columnApi.getColumnState(),s=this.gridApi.getFocusedCell();s&&this.gridApi.setFocusedCell(s.rowIndex,t[t.length-1].colId)}}),N.createElement(li,{keys:"enter",target:this.table,preventDefault:!1,stopPropagation:!1,onMatch:e=>{const t=this.gridApi.getFocusedCell();if("checkbox"===(null==t?void 0:t.column.getColId())){e.preventDefault(),e.stopPropagation();const s=this.gridApi.getRowNode(Bt.activeTab.session.script.recordIds[t.rowIndex]),i=this.gridApi.getSelectedNodes().find((e=>e.id===(null==s?void 0:s.id)));null==s||s.setSelected(!i)}}}))}}var Nl="_stickyItems_1qvgu_1",Ll="_outer_1qvgu_8";const Rl=N.createContext({});class Ol extends N.PureComponent{constructor(e){super(e),this.list=N.createRef(),this.lastScrollTop=0,this.isLoading=!1,this.handleScroll=()=>{const e=this.list.current._outerRef;e.scrollTop!==this.lastScrollTop&&(this.lastScrollTop=e.scrollTop,this.handleHorizontalScrollThrottled())},this.handleHorizontalScroll=()=>{const{itemSize:e,onLoad:t}=this.props;if(this.isLoading||!t)return;const s=this.list.current._outerRef;s.scrollHeight-(s.scrollTop+s.clientHeight)<15*e&&(this.isLoading=!0,t())},this.handleHorizontalScrollThrottled=h.exports.throttle(this.handleHorizontalScroll,100,{leading:!0,trailing:!0})}componentDidUpdate(){this.isLoading=!1}render(){const{className:e,outerElementRef:t,innerElementRef:s,height:i,width:a,itemCount:n,itemKey:r,itemSize:l,itemData:o,itemRenderer:d,stickyIndices:c,stickyItemsClassName:h,overscan:p}=this.props;return N.createElement(Rl.Provider,{value:{stickyIndices:c,stickyItemsClassName:h,itemSize:l,itemData:o,itemKey:r,itemRenderer:d}},N.createElement("div",{"data-testid":"infinite-list",className:e,onScroll:this.handleScroll},N.createElement(P,{ref:this.list,outerRef:t,innerRef:s,height:i,width:a,itemCount:n,itemSize:l,itemKey:r,itemData:o,overscanCount:p,outerElementType:kl,innerElementType:Ml},d)))}}Ol.defaultProps={stickyIndices:[],stickyItemsClassName:"",overscan:10};const Ml=N.forwardRef(((e,t)=>{var s=e,{children:i}=s,a=d(s,["children"]);return N.createElement(Rl.Consumer,null,(({stickyItemsClassName:e,stickyIndices:s=[],itemSize:n,itemData:r,itemKey:d,itemRenderer:c})=>N.createElement("div",l({ref:t},a),N.createElement("div",{className:L(Nl,e)},s.map((e=>N.createElement(c,{key:d(e),index:e,style:{display:"flex",position:"absolute",top:e*n,left:0,width:"100%",height:n},data:o(l({},r),{sticky:!0})})))),N.createElement(N.Fragment,null,N.Children.map(i,((e,t)=>s.includes(t)?null:e))))))})),kl=N.forwardRef(((e,t)=>{var s=e,{children:i,className:a}=s,n=d(s,["children","className"]);return N.createElement("div",l({ref:t,tabIndex:1,className:L(Ll,a)},n),i)}));var Dl=Object.defineProperty,Al=Object.getOwnPropertyDescriptor,Tl=(e,t,s,i)=>{for(var a,n=i>1?void 0:i?Al(t,s):t,r=e.length-1;r>=0;r--)(a=e[r])&&(n=(i?a(t,s,n):a(n))||n);return i&&n&&Dl(t,s,n),n};class Pl{constructor(e){this.sessionId="",c(this),E((()=>{this.sessionId=e.sessionId}))}get session(){return $e.get(this.sessionId)}}Tl([p],Pl.prototype,"sessionId",2),Tl([f],Pl.prototype,"session",1);const Vl=new Pl({sessionId:"model-list-session"}),jl=R.exports.createContext(Vl),Fl=jl.Provider;jl.Consumer;const Bl=jl,Hl=e=>(e.contextType=Bl,e);var ql="_container_wwbam_1";var Zl="_container_fkswg_1",Ul="_one_fkswg_21",zl="_two_fkswg_22",$l="_three_fkswg_23";var Jl=S((({className:e,size:t=3}={})=>N.createElement("div",{className:L(Zl,e)},N.createElement("div",{className:Ul,style:{height:t,width:t}}),N.createElement("div",{className:zl,style:{height:t,width:t}}),N.createElement("div",{className:$l,style:{height:t,width:t}}))));class Wl extends N.PureComponent{constructor(){super(...arguments),this.clickStartCoords={x:0,y:0},this.startClick=e=>{this.clickStartCoords={x:e.clientX,y:e.clientY}},this.finishClick=e=>{if(this.props.onClickButNotDrag&&Math.abs(this.clickStartCoords.x-e.clientX)<5&&Math.abs(this.clickStartCoords.y-e.clientY)<5)return this.props.onClickButNotDrag(e);this.props.onClick&&this.props.onClick(e)}}render(){const e=this.props,{onClickButNotDrag:t,children:s}=e,i=d(e,["onClickButNotDrag","children"]);return N.createElement("div",o(l({},i),{onMouseDown:this.startClick,onMouseUp:this.finishClick,onClick:void 0}),s)}}function Kl(e){return R.exports.createElement("svg",Object.assign({viewBox:"0 0 24 24",xmlns:"http://www.w3.org/2000/svg"},e),R.exports.createElement("path",{d:"m2.314892,2.715466c0,-2.097726 2.320696,-3.364698 4.085258,-2.230334l13.864359,8.912782c1.89413,1.21769 1.89413,3.986482 0,5.204172l-13.864359,8.912782c-1.764597,1.134364 -4.085258,-0.132608 -4.085258,-2.230334l0,-18.569068z"}))}const Gl=(e,{maxLength:t=100}={})=>e.length<=t?e:`${e.slice(0,t-1)}…`,Ql=(e,{maxLength:t}={maxLength:100})=>{if(void 0===e)return"undefined";if(null===e)return"null";if("string"==typeof e)return`"${Gl(e,{maxLength:t-2})}"`;if("number"==typeof e||"boolean"==typeof e)return Gl(`${e}`,{maxLength:t});const s=e=>"string"==typeof e?`"${e}"`:"number"==typeof e||"boolean"==typeof e?`${e}`:Array.isArray(e)?"[ … ]":"{ … }";if(Array.isArray(e)){t-="[ ]".length;const i=[];return e.some((e=>{const a=s(e),n=a.length+", ".length;return!(n{const n=`${i}: ${s(e[i])}`,r=n.length+", ".length;return!(r{const{path:t,isLoading:s,onToggleCollapse:i}=this.props;e.stopPropagation(),s||i(t)},this.handleExpand=e=>{const{isExpanded:t}=this.props;t||this.handleToggleCollapse(e)}}render(){const{path:e,isSelected:t,isExpanded:s,fieldName:i,modelName:a,value:n,isLoading:r,style:l}=this.props,o=e.split("::").length-1;return N.createElement("div",{tabIndex:1,"data-testid":"tree__array",className:L(Yl.container,{[Yl.expanded]:s,[Yl.active]:!s&&t}),style:l},N.createElement("div",{className:Yl.depthGutter,style:{width:16*o}}),N.createElement("div",{"data-testid":"expand-btn",className:Yl.expandButton,onClick:this.handleToggleCollapse},r&&N.createElement(Jl,{size:3,className:Yl.loader}),!r&&n&&n.length>0&&N.createElement(Kl,null)),N.createElement("div",{className:L(Yl.meta,{[Yl.active]:s&&t}),onClick:this.handleToggleCollapse},N.createElement(Il,{className:Yl.icon,array:!0,required:!0}),N.createElement("div",{className:Yl.fieldName},i,":"),N.createElement("div",{className:Yl.fieldType},a)),N.createElement(Wl,{className:Yl.fieldValue,onClickButNotDrag:this.handleExpand},N.createElement(N.Fragment,null,`(${n?n.length:0}) `,r||0===(null==n?void 0:n.length)?"[ ]":Ql(n,{maxLength:150}))))}}var eo=S(Xl);class to extends N.PureComponent{constructor(){super(...arguments),this.handleToggleCollapse=e=>{const{path:t,isLoading:s,onToggleCollapse:i}=this.props;e.stopPropagation(),s||i(t)},this.handleExpand=e=>{const{isExpanded:t}=this.props;t||this.handleToggleCollapse(e)}}render(){const{path:e,isSelected:t,isExpanded:s,startIndex:i,endIndex:a,value:n,isLoading:r,style:l}=this.props,o=e.split("::").length-1;return N.createElement("div",{tabIndex:1,"data-testid":"tree__array",className:L(Yl.container,{[Yl.expanded]:s,[Yl.active]:!s&&t}),style:l},N.createElement("div",{className:Yl.depthGutter,style:{width:16*o}}),N.createElement("div",{"data-testid":"expand-btn",className:Yl.expandButton},r?N.createElement(Jl,{size:3,className:Yl.loader}):N.createElement(Kl,null)),N.createElement("div",{className:L(Yl.meta,{[Yl.active]:s&&t}),onClick:this.handleToggleCollapse},N.createElement(Il,{className:Yl.icon,array:!0,required:!0}),N.createElement("div",{className:Yl.fieldName},`[${i}-${a}]:`)),N.createElement(Wl,{className:Yl.fieldValue,onClickButNotDrag:this.handleExpand},N.createElement(N.Fragment,null,`(${n&&n.length}) `,Ql(n,{maxLength:150}))))}}var so=S(to);var io={container:"_container_1m4mj_1",meta:"_meta_1m4mj_8",fieldValue:"_fieldValue_1m4mj_14",active:"_active_1m4mj_20",icon:"_icon_1m4mj_36",fieldName:"_fieldName_1m4mj_39"};class ao extends N.PureComponent{constructor(){super(...arguments),this.handleClick=e=>{const{path:t,onClick:s}=this.props;e&&e.stopPropagation(),s(t)}}render(){const{path:e,isSelected:t,fieldName:s,value:i,style:a}=this.props,n=e.split("::").length-1;return N.createElement("div",{"data-testid":"tree__enum",style:a,className:L(io.container,{[io.active]:t}),tabIndex:1,onClick:this.handleClick},N.createElement("div",{className:io.depthGutter,style:{width:16*n}}),N.createElement("div",{className:io.meta},N.createElement(Il,{className:io.icon,enumerable:!0,required:!0}),s&&N.createElement("div",{className:io.fieldName},s,":")),N.createElement("div",{className:io.fieldValue},Ql(i)))}}var no=S(ao);var ro={container:"_container_1rxo6_1",meta:"_meta_1rxo6_9",fieldValue:"_fieldValue_1rxo6_14",active:"_active_1rxo6_19",expanded:"_expanded_1rxo6_28",expandButton:"_expandButton_1rxo6_28",loader:"_loader_1rxo6_51",icon:"_icon_1rxo6_65",fieldName:"_fieldName_1rxo6_68",fieldType:"_fieldType_1rxo6_73"};class lo extends N.PureComponent{constructor(){super(...arguments),this.handleToggleCollapse=e=>{const{path:t,isLoading:s,onToggleCollapse:i}=this.props;e.stopPropagation(),s||i(t)},this.handleExpand=e=>{const{isExpanded:t}=this.props;t||this.handleToggleCollapse(e)}}render(){const{path:e,isSelected:t,isExpanded:s,fieldName:i,modelName:a,value:n,isLoading:r,style:l}=this.props,o=e.split("::").length-1;return N.createElement("div",{"data-testid":"tree__object","data-test-expanded":"true",style:l,className:L(ro.container,{[ro.expanded]:s,[ro.active]:!s&&t}),tabIndex:1},N.createElement("div",{className:ro.depthGutter,style:{width:16*o}}),N.createElement("div",{"data-testid":"expand-btn",className:ro.expandButton,onClick:this.handleToggleCollapse},r&&N.createElement(Jl,{size:3,className:ro.loader}),!r&&n&&N.createElement(Kl,null)),N.createElement("div",{className:L(ro.meta,{[ro.active]:s&&t}),onClick:this.handleToggleCollapse},N.createElement(Il,{className:ro.icon,object:!0,required:!0}),i&&N.createElement("div",{className:ro.fieldName},i,":"),N.createElement("div",{className:ro.fieldType},a)),N.createElement(Wl,{className:ro.fieldValue,onClickButNotDrag:this.handleExpand},n?Ql(n,{maxLength:150}):"null"))}}var oo=S(lo);var co={container:"_container_w0wc7_1",meta:"_meta_w0wc7_8",fieldValue:"_fieldValue_w0wc7_14",active:"_active_w0wc7_20",icon:"_icon_w0wc7_36",fieldName:"_fieldName_w0wc7_39"};class ho extends N.PureComponent{constructor(){super(...arguments),this.handleClick=e=>{const{path:t,onClick:s}=this.props;e&&e.stopPropagation(),s(t)}}render(){const{path:e,isSelected:t,fieldName:s,value:i,isString:a,isInt:n,isFloat:r,isBoolean:l,isDateTime:o,style:d}=this.props,c=e.split("::").length-1;return N.createElement("div",{"data-testid":"tree__scalar",style:d,className:L(co.container,{[co.active]:t}),tabIndex:1,onClick:this.handleClick},N.createElement("div",{className:co.depthGutter,style:{width:16*c}}),N.createElement("div",{className:co.meta},((h=this.props).isString||h.isInt||h.isFloat||h.isBoolean||h.isDateTime)&&N.createElement(Il,{className:co.icon,required:!0,string:a,int:n,float:r,boolean:l,dateTime:o}),N.createElement("div",{className:co.fieldName},s,":")),N.createElement("div",{className:co.fieldValue},Ql(i)));var h}}var po=S(ho);class uo extends N.PureComponent{constructor(){super(...arguments),this.isArraySlice=e=>null===e.record&&Array.isArray(e.arraySliceIndices)&&Array.isArray(e.value),this.handleToggleCollapse=e=>{const{selection:t}=this.context.session;this.handleSelect(e),t.tree.isExpanded(e)?t.tree.collapse():t.tree.expand()},this.handleSelect=e=>{const{selection:t}=this.context.session;t.tree.select(e)}}render(){var e,t,s,i,a,n,r,l,o,d,c,h,p;const{selection:u}=this.context.session,{style:m,index:g,data:{pathsToRender:v,recordIds:f}}=this.props,y=v[g],I=Re(y,f),C=u.tree.activePath,w=u.tree.isExpanded(y);return this.isArraySlice(I)?N.createElement(so,{path:y,isSelected:y===C,isExpanded:w,startIndex:I.arraySliceIndices[0],endIndex:I.arraySliceIndices[1],value:I.value,isLoading:!I.value,style:m,onToggleCollapse:this.handleToggleCollapse}):(null==(e=I.field)?void 0:e.isList)||Array.isArray(I.value)?N.createElement(eo,{path:y,isSelected:y===C,isExpanded:w,fieldName:I.field.name,modelName:I.field.typeAsLabel,value:I.value,isLoading:!I.value,style:m,onToggleCollapse:this.handleToggleCollapse}):(null==(t=I.field)?void 0:t.isRelation)||I.record?N.createElement(oo,{path:y,isSelected:y===C,isExpanded:w,fieldName:null==(s=I.field)?void 0:s.name,modelName:I.model.name,value:I.value,isLoading:null===(null==(i=I.record)?void 0:i.value),style:m,onToggleCollapse:this.handleToggleCollapse}):(null==(a=I.field)?void 0:a.isEnum)?N.createElement(no,{path:y,isSelected:y===C,fieldName:null==(n=I.field)?void 0:n.name,value:I.value,style:m,onClick:this.handleSelect}):N.createElement(po,{path:y,isSelected:y===C,fieldName:(null==(r=I.field)?void 0:r.name)||`${I.index}`,value:I.value,isString:(null==(l=I.field)?void 0:l.isString)||!1,isInt:(null==(o=I.field)?void 0:o.isInt)||!1,isFloat:(null==(d=I.field)?void 0:d.isFloat)||(null==(c=I.field)?void 0:c.isDecimal)||!1,isBoolean:(null==(h=I.field)?void 0:h.isBoolean)||!1,isDateTime:(null==(p=I.field)?void 0:p.isDateTime)||!1,style:m,onClick:this.handleSelect})}}var mo=S(Hl(uo));class go extends N.PureComponent{constructor(e){super(e),this.tree=N.createRef(),this.refresh=async()=>{const{session:e}=this.context;await e.script.run()},this._scrollIntoView=()=>{const{height:e}=this.props,t=this.getActivePathIndex(),s=this.tree.current,i=23*t,a=i+23;i<=s.scrollTop&&s.scrollTo({top:i}),a>=s.scrollTop+e&&s.scrollTo({top:a-e})},this.getActivePathIndex=()=>{const{session:e}=this.context;return e.selection.tree.selectionOrder.findIndex((t=>t===e.selection.tree.activePath))},this.handleLoadMore=()=>{const{session:e}=this.context;e.script.loadMore(),e.selection.tree.setSelectionOrder()},this.scrollIntoView=h.exports.throttle(this._scrollIntoView,30,{leading:!0,trailing:!0})}focus(){var e;null==(e=this.tree.current)||e.focus()}componentDidMount(){this.context.session.selection.tree.setSelectionOrder()}render(){const{session:e}=this.context,{height:t,width:s,recordIds:i}=this.props,{tree:a}=e.selection,n=a.selectionOrder;return N.createElement(N.Fragment,null,N.createElement(Ol,{outerElementRef:this.tree,className:ql,height:t-20,width:s-20,itemCount:n.length,itemSize:23,itemData:{pathsToRender:n,recordIds:i},itemKey:e=>n[e],itemRenderer:mo,onLoad:this.handleLoadMore}),N.createElement(li,{keys:"up",target:this.tree,onMatch:e=>{a.move(1,"up"),this.scrollIntoView()}}),N.createElement(li,{keys:"down",target:this.tree,onMatch:e=>{a.move(1,"down"),this.scrollIntoView()}}),N.createElement(li,{keys:"left",target:this.tree,onMatch:e=>{a.isExpanded(a.activePath)?a.collapse():a.jumpToParent(),this.scrollIntoView()}}),N.createElement(li,{keys:"right",target:this.tree,onMatch:e=>{a.expand(),this.scrollIntoView()}}),N.createElement(li,{keys:"space",target:this.tree,onMatch:e=>{a.expand(),this.scrollIntoView()}}))}}var vo=S(Hl(go));var fo="_container_104ha_1";class yo extends N.PureComponent{constructor(){super(...arguments),this.table=N.createRef(),this.tree=N.createRef()}scrollIntoView(){this.table.current.scrollIntoView()}focus(){var e,t;const{session:s}=this.context;"table"===s.script.viewMode&&(null==(e=this.table.current)||e.focus()),"tree"===s.script.viewMode&&(null==(t=this.tree.current)||t.focus())}refresh(){var e,t;const{session:s}=this.context;"table"===s.script.viewMode&&(null==(e=this.table.current)||e.refresh()),"tree"===s.script.viewMode&&(null==(t=this.tree.current)||t.refresh())}selectRows(e){var t;const{session:s}=this.context;"table"===s.script.viewMode&&(null==(t=this.table.current)||t.selectRows(e))}deleteSelectedRows(){var e;const{session:t}=this.context;"table"===t.script.viewMode&&(null==(e=this.table.current)||e.deleteSelectedRows())}render(){const{sessionId:e,session:t}=this.context,{className:s,width:i,height:a}=this.props;return N.createElement("div",{className:L(fo,s),"data-testid":"results"},"tree"===t.script.viewMode&&N.createElement(vo,{ref:this.tree,key:e,width:i,height:a,recordIds:t.script.recordIds}),"table"===t.script.viewMode&&N.createElement(Sl,{ref:this.table,width:i,height:a}))}}var Io=S(Hl(yo));function Co(e){return R.exports.createElement("svg",Object.assign({viewBox:"0 0 10 10",xmlns:"http://www.w3.org/2000/svg"},e),R.exports.createElement("path",{fill:"currentColor",d:"M8.53033 1.46948C7.62352 0.563232 6.37899 0.000732422 4.99687 0.000732422C2.23265 0.000732422 0 2.23823 0 5.00073C0 7.76323 2.23265 10.0007 4.99687 10.0007C7.32958 10.0007 9.27455 8.40698 9.83115 6.25073H8.53033C8.01751 7.70698 6.62914 8.75073 4.99687 8.75073C2.92683 8.75073 1.24453 7.06948 1.24453 5.00073C1.24453 2.93198 2.92683 1.25073 4.99687 1.25073C6.03502 1.25073 6.9606 1.68198 7.63602 2.36323L5.62226 4.37573H10V0.000732422L8.53033 1.46948Z"}))}var wo={container:"_container_3cx2j_1",header:"_header_3cx2j_7",separator:"_separator_3cx2j_15",refreshBtn:"_refreshBtn_3cx2j_22",spin:"_spin_3cx2j_50",pendingActions:"_pendingActions_3cx2j_57"};function bo(e){return R.exports.createElement("svg",Object.assign({viewBox:"0 0 24 24",fill:"none",xmlns:"http://www.w3.org/2000/svg"},e),R.exports.createElement("path",{d:"M12 22C17.5228 22 22 17.5228 22 12C22 6.47715 17.5228 2 12 2C6.47715 2 2 6.47715 2 12C2 17.5228 6.47715 22 12 22Z",stroke:"currentColor",strokeWidth:2,strokeLinecap:"round",strokeLinejoin:"round"}),R.exports.createElement("path",{d:"M12 9V13",stroke:"currentColor",strokeWidth:2,strokeLinecap:"round",strokeLinejoin:"round"}),R.exports.createElement("path",{d:"M12 17H12.01",stroke:"currentColor",strokeWidth:2,strokeLinecap:"round",strokeLinejoin:"round"}))}var Eo="_container_q775b_1",_o="_header_q775b_12",xo="_error_q775b_22",So="_closeButton_q775b_34",No="_footer_q775b_40";class Lo extends N.Component{componentDidMount(){document.getElementById("dialog-root").style.pointerEvents="initial"}componentWillUnmount(){document.getElementById("dialog-root").style.pointerEvents="none"}render(){const{dataTestId:e,className:t,error:s,title:i,primaryButton:a,secondaryButton:n,children:r,onClose:l}=this.props;return N.createElement(Pi,{"data-testid":null!=e?e:"dialog",className:L(Eo,t),domElementId:"dialog-root",darken:!0,onClickOutside:l},N.createElement(N.Fragment,null,i&&N.createElement("div",{className:L(_o,{[xo]:s})},s&&N.createElement(bo,null),i),r,(a||n)&&N.createElement("div",{className:No},a,n),l&&N.createElement(ri,{className:So,onClick:l},N.createElement(ci,null))))}}var Ro=S(Lo);var Oo="_container_sfoat_1",Mo="_content_sfoat_10";class ko extends N.PureComponent{constructor(){super(...arguments),this.handleClose=()=>{this.props.onClose()},this.handleDelete=()=>{this.props.onDeleteRecord(),this.handleCommit(),this.props.onClose()},this.handleCommit=async()=>{const{onSuccess:e,onFailure:t}=this.props;try{await Os.commit(),null==e||e()}catch(s){null==t||t()}us.send({command:"action_commit",commandDetails:{pending_action_count:Os.actions.length}})}}render(){return N.createElement(N.Fragment,null,N.createElement(Ro,{error:!0,title:"Confirm record deletion",className:Oo,onClose:this.handleClose,primaryButton:N.createElement(si,{red:!0,dataTestId:"delete-record-btn-confirm",onClick:this.handleDelete},"Delete")},N.createElement("p",{className:Mo},"You are about to delete the selected record permanently from the dataset.")),N.createElement(li,{keys:"esc",onMatch:this.handleClose}))}}var Do=S(ko);class Ao extends N.PureComponent{constructor(){super(...arguments),this.results=N.createRef(),this.state={isDeletePromptOpen:!1},this.handleCreateRecord=()=>{var e,t;null==(t=null==(e=Bt.activeTab)?void 0:e.session)||t.createUncommittedRecord(),us.send({command:"record_create",commandDetails:{}})},this.handleOpenDeletePrompt=()=>{this.setState({isDeletePromptOpen:!0})},this.handleDeleteRecords=()=>{this.results.current.deleteSelectedRows(),this.results.current.selectRows([]),this.results.current.focus()},this.handleSuccess=()=>{this.results.current.selectRows([]),this.results.current.focus(),this.results.current.refresh()}}render(){var e;const{isDeletePromptOpen:t}=this.state,s=null==(e=Bt.activeTab)?void 0:e.session;if(!s||!(null==s?void 0:s.isScript))return null;const i="tree"===s.script.viewMode||s.script.model.hasScalarListTwoWayMNRelation;return N.createElement("div",{className:wo.container,"data-testid":"databrowser"},N.createElement("div",{className:wo.header},N.createElement(si,{dataTestId:"refresh-btn",className:L(wo.refreshBtn,{[wo.spin]:s.script.running}),disabled:s.script.running,onClick:()=>s.script.run()},N.createElement(Co,null)),N.createElement(ta,null),N.createElement(Gi,null),N.createElement(Xi,null),N.createElement("div",{className:wo.separator}),!q.readonly&&N.createElement(si,{"data-testid":"create-record-btn",onClick:this.handleCreateRecord,disabled:i},"Add record"),s.selection.table.selectedRecordIds.length>0&&N.createElement(N.Fragment,null,N.createElement(si,{"data-testid":"delete-record-btn",red:!0,onClick:()=>this.handleOpenDeletePrompt(),disabled:s.script.model.hasScalarListTwoWayMNRelation},N.createElement(N.Fragment,null,"Delete ",s.selection.table.selectedRecordIds.length," ","record",s.selection.table.selectedRecordIds.length>1?"s":"")),t&&N.createElement(Do,{onClose:()=>this.setState({isDeletePromptOpen:!1}),onDeleteRecord:this.handleDeleteRecords,onSuccess:this.handleSuccess})),N.createElement(aa,{className:wo.pendingActions,onSuccess:this.handleSuccess})),N.createElement(Io,{ref:this.results,className:wo.results,width:window.innerWidth,height:window.innerHeight-36-44}))}}var To=S(Ao);var Po={container:"_container_1pcqt_1",content:"_content_1pcqt_10",description:"_description_1pcqt_20",reportBtn:"_reportBtn_1pcqt_25",detailsBtn:"_detailsBtn_1pcqt_36",open:"_open_1pcqt_49",dump:"_dump_1pcqt_52"};class Vo extends N.PureComponent{constructor(){super(...arguments),this.state={isDetailsOpen:!1},this.handleToggleDetails=()=>{this.setState((e=>({isDetailsOpen:!e.isDetailsOpen})))},this.handleDismiss=()=>{Ee.updateError({visible:!1})}}render(){const{isDetailsOpen:e}=this.state;return N.createElement(Ro,{dataTestId:"client-error-dialog",className:Po.container,error:!0,title:"Prisma Client Error",primaryButton:N.createElement(si,{dataTestId:"dismiss-btn",className:Po.action,onClick:this.handleDismiss},"Dismiss"),secondaryButton:N.createElement("a",{"data-testid":"error-docs-btn",href:"https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client/error-reference#query-engine",target:"_blank",rel:"noreferrer noopener"},"Error Documentation")},N.createElement("div",{className:Po.content,"data-testid":"client-error"},N.createElement("p",{className:Po.description},ys.description),N.createElement(si,{ghost:!0,className:L(Po.detailsBtn,{[Po.open]:e}),onClick:this.handleToggleDetails},N.createElement(N.Fragment,null,N.createElement(Cl,null),e?"Hide":"Show"," details")),e&&N.createElement("pre",{className:Po.dump},ys.dump)))}}var jo=S(Vo);class Fo extends N.PureComponent{constructor(){super(...arguments),this.state={isDetailsOpen:!1,isSendingReport:!1,didFailErrorReport:!1,errorReportId:null,previousError:Ee.previousError},this.handleToggleDetails=()=>{this.setState((e=>({isDetailsOpen:!e.isDetailsOpen})))},this.handleDiscard=()=>{Os.discard(),setTimeout((()=>{window.transport.request({channel:"project",action:"close",payload:{data:null}}),window.location.reload()}),500)},this.handleRestart=()=>{Ee.setPreviousError({type:ys.type}),window.location.reload()},this.handleHardRestart=()=>{window.indexedDB.deleteDatabase("Prisma Studio"),Ee.setPreviousError({type:null}),window.location.reload()}}render(){const{isDetailsOpen:e}=this.state,t=window.location.origin.includes("localhost")?"https://github.com/prisma/studio/issues/new?template=prisma-cli-studio-bug-report.yml":"https://github.com/prisma/studio/issues/new?template=data-browser-bug-report.yml";return N.createElement(Ro,{"data-testid":"fatal-error-dialog",className:Po.container,error:!0,title:"Fatal Error",primaryButton:this.state.previousError.type?N.createElement(si,{dataTestId:"reopen-btn-hard",className:Po.action,onClick:this.handleHardRestart,red:!0},"Force reload Studio"):N.createElement(si,{dataTestId:"reopen-btn",className:Po.action,onClick:this.handleRestart},"Reload Studio"),secondaryButton:this.state.previousError.type?void 0:N.createElement(si,{dataTestId:"dismiss-btn",ghost:!0,className:L(Po.action,Po.discardBtn),onClick:this.handleDiscard},N.createElement(N.Fragment,null,"Discard all unsaved changes and close Studio"))},N.createElement("div",{className:Po.content},N.createElement("p",{className:Po.description},this.state.previousError.type?"A persistent non-recoverable error has occurred. Force reload to clear temporary data and reopen Studio.\n Consider reporting this error to us by opening an issue on GitHub and attaching the error details.":"A non-recoverable error has occurred. Reload Studio to continue.\n Consider reporting this error to us by opening an issue on GitHub\n and attaching the error details."),N.createElement("a",{href:t,target:"_blank",rel:"noreferrer noopener",className:Po.reportBtn},"Report error in a new GitHub issue"),N.createElement(si,{ghost:!0,className:L(Po.detailsBtn,{[Po.open]:e}),onClick:this.handleToggleDetails},N.createElement(N.Fragment,null,N.createElement(Cl,null),e?"Hide":"Show"," details")),e&&N.createElement("pre",{className:Po.dump},ys.dump)))}}var Bo=S(Fo);class Ho extends N.PureComponent{constructor(){super(...arguments),this.handleRestart=()=>{window.location.reload()}}render(){return N.createElement(Ro,{className:Po.container,error:!0,title:"Prisma Schema Changed",primaryButton:N.createElement(si,{className:Po.action,onClick:this.handleRestart},"Reload"),secondaryButton:N.createElement("a",{href:"https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client/error-reference#query-engine",target:"_blank",rel:"noreferrer noopener"},"Error Documentation")},N.createElement("div",{className:Po.content},N.createElement("p",{className:Po.description},ys.description)))}}var qo=S(Ho);var Zo="_container_ud69p_1";class Uo extends N.Component{render(){const e=this.props,{children:t,className:s,style:i}=e,a=d(e,["children","className","style"]);return N.createElement("div",l({className:L(Zo,s),style:i},a),t)}}var zo="_container_serom_1";var $o=S((({type:e})=>N.createElement("div",{"data-testid":"shortcuts-key",className:zo},e)));var Jo="_container_o8wgd_1",Wo="_content_o8wgd_17",Ko="_section_o8wgd_22",Go="_sectionName_o8wgd_28",Qo="_row_o8wgd_34",Yo="_name_o8wgd_39",Xo="_keys_o8wgd_43",ed="_separator_o8wgd_49";class td extends N.PureComponent{constructor(){super(...arguments),this.handleClose=()=>{this.props.onClose()}}render(){const e={sections:[{name:"Results Table",shortcuts:[{name:"Move cell selection",mac:["←","→","↑","↓"],windowsAndLinux:["←","→","↑","↓"]},{name:"Move horizontally",mac:["tab","shift+tab"],windowsAndLinux:["tab","shift+tab"]},{name:"Move vertically",mac:["enter","shift+enter"],windowsAndLinux:["enter","shift+enter"]},{name:"Edit selected cell",mac:["enter"],windowsAndLinux:["enter"]},{name:"Jump to last cell in row",mac:["⌘+→"],windowsAndLinux:["ctrl+→"]},{name:"Jump to first cell in row",mac:["⌘+←"],windowsAndLinux:["ctrl+←"]},{name:"Copy focused cell OR selected rows to clipboard",mac:["⌘+c"],windowsAndLinux:["ctrl+c"]},{name:"Delete selected rows",mac:["⌫"],windowsAndLinux:["del"]},{name:"Commit unsaved changes to Database",mac:["⌘+s"],windowsAndLinux:["ctrl+s"]}]},{name:"Global",shortcuts:[{name:"Show this cheatsheet",mac:["⌘+/"],windowsAndLinux:["ctrl+/"]}]}].filter((e=>!!e))},t=/Mac|iPod|iPhone|iPad/.test(navigator.platform)?"mac":"windowsAndLinux";return N.createElement(N.Fragment,null,N.createElement(Ro,{className:Jo,title:"Shortcuts",onClose:this.handleClose},N.createElement("div",{className:Wo},e.sections.map((e=>N.createElement(Uo,{key:e.name,className:Ko},N.createElement(N.Fragment,null,N.createElement("div",{className:Go},e.name),e.shortcuts.map((e=>N.createElement("div",{key:e.name,className:Qo},N.createElement("div",{className:Yo},e.name),N.createElement("div",{className:Xo},e[t].map(((e,t)=>N.createElement(N.Fragment,{key:t},t>0&&N.createElement("span",{className:ed},"/"),e.split("+").map((e=>N.createElement($o,{key:e,type:e})))))))))))))))),N.createElement(li,{keys:"esc",onMatch:this.handleClose}))}}var sd=S(td);var id={container:"_container_1z063_1",content:"_content_1z063_10",description:"_description_1z063_17"};class ad extends N.Component{handleInstall(){Zs.install()}render(){const{onClose:e}=this.props;return N.createElement(Ro,{className:id.container,title:"Updates ready",primaryButton:N.createElement(si,{green:!0,disabled:Zs.isInstalling,onClick:this.handleInstall},"Install and restart"),secondaryButton:N.createElement(si,{ghost:!0,className:id.laterBtn,onClick:e},"Install Later")},N.createElement("div",{className:id.content},N.createElement("p",{className:id.description},"New updates have been downloaded and are ready to be installed. Doing this will restart Studio.",N.createElement("br",null),N.createElement("br",null),"Your current session will be saved and restored after the installation.")))}}var nd=S(ad);function rd(e){return R.exports.createElement("svg",Object.assign({viewBox:"0 0 24 24",xmlns:"http://www.w3.org/2000/svg"},e),R.exports.createElement("path",{fillRule:"evenodd",clipRule:"evenodd",d:"M19.286 15.9606C19.2271 15.6362 19.2669 15.3017 19.4 15C19.5267 14.7042 19.7373 14.452 20.0055 14.2743C20.2738 14.0966 20.5882 14.0013 20.91 13.9999H21.0001C21.5304 13.9999 22.0391 13.7893 22.4142 13.4142C22.7893 13.0391 23 12.5305 23 12C23 11.4695 22.7893 10.9609 22.4142 10.5858C22.0391 10.2107 21.5304 10.0001 21.0001 10.0001H20.83C20.5082 9.9987 20.1938 9.90341 19.9255 9.72576C19.6572 9.54797 19.4467 9.29579 19.32 9V8.92001C19.1869 8.61839 19.1471 8.28381 19.206 7.95942C19.2648 7.63503 19.4195 7.33569 19.65 7.1L19.71 7.04001C19.8959 6.85426 20.0435 6.63368 20.1441 6.39088C20.2448 6.14809 20.2966 5.88784 20.2966 5.62501C20.2966 5.36218 20.2448 5.10192 20.1441 4.85912C20.0435 4.61632 19.8959 4.39574 19.71 4.21001C19.5243 4.02405 19.3037 3.87653 19.0609 3.77588C18.8181 3.67523 18.5578 3.62343 18.295 3.62343C18.0321 3.62343 17.772 3.67523 17.5292 3.77588C17.2863 3.87653 17.0658 4.02405 16.88 4.21001L16.8201 4.27C16.5844 4.50055 16.285 4.65519 15.9605 4.714C15.6362 4.77282 15.3017 4.73311 15 4.6C14.7042 4.47324 14.452 4.26275 14.2743 3.99446C14.0966 3.72617 14.0013 3.41179 13.9999 3.09V3.00001C13.9999 2.46957 13.7893 1.96086 13.4142 1.58579C13.0391 1.21072 12.5305 1 12 1C11.4695 1 10.9609 1.21072 10.5858 1.58579C10.2107 1.96086 10.0001 2.46957 10.0001 3.00001V3.17C9.99869 3.49179 9.9034 3.80617 9.72575 4.07446C9.54796 4.34275 9.29579 4.55324 9 4.68H8.92C8.61838 4.81311 8.2838 4.85282 7.95941 4.79401C7.63502 4.73519 7.33568 4.58054 7.1 4.35L7.04 4.29001C6.85425 4.10405 6.63368 3.95653 6.39088 3.85588C6.14808 3.75524 5.88784 3.70343 5.625 3.70343C5.36217 3.70343 5.10191 3.75524 4.85912 3.85588C4.61632 3.95653 4.39574 4.10405 4.21001 4.29001C4.02405 4.47576 3.87653 4.69633 3.77588 4.93912C3.67523 5.18191 3.62343 5.44218 3.62343 5.70501C3.62343 5.96784 3.67523 6.22808 3.77588 6.47088C3.87653 6.71368 4.02405 6.93426 4.21001 7.12001L4.27 7.18001C4.50054 7.41569 4.65519 7.71502 4.714 8.03941C4.77282 8.36382 4.73311 8.69838 4.6 9C4.48572 9.31078 4.2806 9.57987 4.01131 9.77251C3.74201 9.96515 3.42099 10.0723 3.09 10.08H3.00001C2.46957 10.08 1.96086 10.2907 1.58579 10.6658C1.21072 11.0408 1 11.5496 1 12.08C1 12.6105 1.21072 13.1191 1.58579 13.4942C1.96086 13.8693 2.46957 14.08 3.00001 14.08H3.17C3.49179 14.0813 3.80617 14.1766 4.07446 14.3543C4.34275 14.5319 4.55323 14.7842 4.68 15.08C4.81311 15.3817 4.85282 15.7162 4.79401 16.0406C4.73519 16.365 4.58054 16.6643 4.34999 16.9L4.29 16.9601C4.10405 17.1458 3.95653 17.3664 3.85588 17.6092C3.75524 17.8519 3.70343 18.1122 3.70343 18.3751C3.70343 18.6378 3.75524 18.8981 3.85588 19.1409C3.95653 19.3836 4.10405 19.6043 4.29 19.7901C4.47575 19.976 4.69633 20.1235 4.93911 20.2242C5.18191 20.3248 5.44217 20.3767 5.705 20.3767C5.96783 20.3767 6.22808 20.3248 6.47088 20.2242C6.71368 20.1235 6.93425 19.976 7.12 19.7901L7.18001 19.73C7.41568 19.4995 7.71502 19.3449 8.03941 19.286C8.36381 19.2272 8.69838 19.2669 9 19.4C9.31077 19.5143 9.57986 19.7194 9.7725 19.9888C9.96514 20.258 10.0722 20.5791 10.0799 20.91V21.0001C10.0799 21.5304 10.2907 22.0392 10.6658 22.4143C11.0408 22.7894 11.5496 23 12.08 23C12.6105 23 13.1191 22.7894 13.4942 22.4143C13.8693 22.0392 14.08 21.5304 14.08 21.0001V20.83C14.0813 20.5082 14.1766 20.1938 14.3543 19.9255C14.5319 19.6573 14.7842 19.4467 15.08 19.32C15.3817 19.1869 15.7162 19.1471 16.0406 19.206C16.3649 19.2648 16.6643 19.4195 16.8999 19.65L16.96 19.7101C17.1458 19.896 17.3663 20.0435 17.6092 20.1441C17.8519 20.2448 18.1122 20.2966 18.375 20.2966C18.6378 20.2966 18.8981 20.2448 19.1409 20.1441C19.3836 20.0435 19.6043 19.896 19.7901 19.7101C19.976 19.5243 20.1235 19.3037 20.2241 19.0609C20.3248 18.8181 20.3766 18.5578 20.3766 18.295C20.3766 18.0321 20.3248 17.772 20.2241 17.5292C20.1235 17.2863 19.976 17.0658 19.7901 16.88L19.73 16.8201C19.4995 16.5844 19.3448 16.2851 19.286 15.9606ZM14.75 12C14.75 13.5188 13.5188 14.75 12 14.75C10.4812 14.75 9.25 13.5188 9.25 12C9.25 10.4812 10.4812 9.25 12 9.25C13.5188 9.25 14.75 10.4812 14.75 12Z",fill:"currentColor"}),R.exports.createElement("path",{d:"M19.4 15L19.8575 15.2018L19.8595 15.197L19.4 15ZM19.286 15.9606L19.778 15.8713L19.778 15.8713L19.286 15.9606ZM20.0055 14.2743L19.7295 13.8574L19.7293 13.8575L20.0055 14.2743ZM20.91 13.9999L20.91 13.4999L20.9079 13.5L20.91 13.9999ZM22.4142 13.4142L22.7678 13.7678L22.7678 13.7678L22.4142 13.4142ZM22.4142 10.5858L22.7678 10.2323L22.7678 10.2323L22.4142 10.5858ZM20.83 10.0001L20.8278 10.5001H20.83V10.0001ZM19.9255 9.72576L19.6493 10.1425L19.6494 10.1426L19.9255 9.72576ZM19.32 9H18.82V9.10264L18.8604 9.19698L19.32 9ZM19.32 8.92001H19.82V8.81459L19.7774 8.71815L19.32 8.92001ZM19.206 7.95942L19.6979 8.04867L19.6979 8.04867L19.206 7.95942ZM19.65 7.1L19.2967 6.74614L19.2924 6.75044L19.65 7.1ZM19.71 7.04001L20.0633 7.39384L20.0634 7.39371L19.71 7.04001ZM20.1441 6.39088L19.6822 6.19941L19.6822 6.19942L20.1441 6.39088ZM20.1441 4.85912L19.6822 5.05059L19.6822 5.05059L20.1441 4.85912ZM19.71 4.21001L19.3563 4.56338L19.3566 4.56372L19.71 4.21001ZM19.0609 3.77588L19.2524 3.31399L19.2524 3.31399L19.0609 3.77588ZM16.88 4.21001L17.2337 4.56344L17.2337 4.56338L16.88 4.21001ZM16.8201 4.27L17.1697 4.62745L17.1737 4.62343L16.8201 4.27ZM15.9605 4.714L15.8714 4.22202L15.8713 4.22203L15.9605 4.714ZM15 4.6L15.2018 4.14253L15.1969 4.14043L15 4.6ZM14.2743 3.99446L13.8574 4.27051L13.8575 4.27066L14.2743 3.99446ZM13.9999 3.09L13.4999 3.09L13.4999 3.09214L13.9999 3.09ZM13.4142 1.58579L13.0606 1.93936L13.0606 1.93936L13.4142 1.58579ZM10.5858 1.58579L10.9394 1.93936L10.9394 1.93936L10.5858 1.58579ZM10.0001 3.17L10.5001 3.17214V3.17H10.0001ZM9.72575 4.07446L10.1425 4.35066L10.1426 4.35051L9.72575 4.07446ZM9 4.68V5.18H9.10262L9.19695 5.13957L9 4.68ZM8.92 4.68V4.18H8.81457L8.71812 4.22257L8.92 4.68ZM7.95941 4.79401L7.8702 5.28599L7.87022 5.28599L7.95941 4.79401ZM7.1 4.35L6.74642 4.70358L6.75036 4.70743L7.1 4.35ZM7.04 4.29001L6.68625 4.64336L6.68645 4.64356L7.04 4.29001ZM6.39088 3.85588L6.58235 3.39399L6.58233 3.39398L6.39088 3.85588ZM4.85912 3.85588L4.66767 3.39398L4.66764 3.39399L4.85912 3.85588ZM4.21001 4.29001L4.56336 4.64376L4.56377 4.64335L4.21001 4.29001ZM3.77588 4.93912L3.314 4.74764L3.31399 4.74765L3.77588 4.93912ZM3.77588 6.47088L4.23776 6.27941L4.23776 6.27941L3.77588 6.47088ZM4.21001 7.12001L4.5636 6.76649L4.56336 6.76626L4.21001 7.12001ZM4.27 7.18001L4.62744 6.83035L4.62359 6.8265L4.27 7.18001ZM4.714 8.03941L4.22202 8.12861L4.22202 8.12862L4.714 8.03941ZM4.6 9L4.14256 8.79813L4.13618 8.8126L4.13072 8.82745L4.6 9ZM3.09 10.08L3.09 10.5801L3.10163 10.5798L3.09 10.08ZM1.58579 10.6658L1.93929 11.0195L1.93936 11.0194L1.58579 10.6658ZM1.58579 13.4942L1.93936 13.1407L1.93936 13.1407L1.58579 13.4942ZM3.17 14.08L3.17213 13.58H3.17V14.08ZM4.07446 14.3543L3.79841 14.7712L3.79841 14.7712L4.07446 14.3543ZM4.68 15.08L4.2204 15.277L4.22255 15.2819L4.68 15.08ZM4.79401 16.0406L5.28599 16.1298L5.28599 16.1298L4.79401 16.0406ZM4.34999 16.9L4.70385 17.2532L4.70742 17.2496L4.34999 16.9ZM4.29 16.9601L4.64337 17.3138L4.64384 17.3133L4.29 16.9601ZM3.85588 17.6092L4.31774 17.8007L4.31777 17.8006L3.85588 17.6092ZM3.85588 19.1409L3.39397 19.3324L3.39402 19.3325L3.85588 19.1409ZM4.29 19.7901L4.6437 19.4367L4.64337 19.4363L4.29 19.7901ZM4.93911 20.2242L4.74763 20.686L4.74764 20.6861L4.93911 20.2242ZM6.47088 20.2242L6.27941 19.7623L6.2794 19.7623L6.47088 20.2242ZM7.12 19.7901L7.4737 20.1435L7.4738 20.1434L7.12 19.7901ZM7.18001 19.73L6.83041 19.3725L6.82621 19.3767L7.18001 19.73ZM8.03941 19.286L7.95016 18.794L7.95016 18.794L8.03941 19.286ZM9 19.4L8.79814 19.8574L8.81261 19.8638L8.82746 19.8693L9 19.4ZM9.7725 19.9888L9.3658 20.2796L9.36587 20.2797L9.7725 19.9888ZM10.0799 20.91L10.5801 20.91L10.5798 20.8984L10.0799 20.91ZM10.6658 22.4143L11.0195 22.0608L11.0194 22.0607L10.6658 22.4143ZM13.4942 22.4143L13.8478 22.7678L13.8478 22.7678L13.4942 22.4143ZM14.08 20.83L13.58 20.8279V20.83H14.08ZM14.3543 19.9255L13.9374 19.6494L13.9374 19.6495L14.3543 19.9255ZM15.08 19.32L15.277 19.7796L15.2818 19.7774L15.08 19.32ZM16.0406 19.206L15.9513 19.6979L15.9513 19.6979L16.0406 19.206ZM16.8999 19.65L17.2535 19.2964L17.2495 19.2925L16.8999 19.65ZM16.96 19.7101L17.3137 19.3566L17.3136 19.3565L16.96 19.7101ZM17.6092 20.1441L17.8007 19.6823L17.8006 19.6822L17.6092 20.1441ZM19.1409 20.1441L19.3324 20.606L19.3325 20.606L19.1409 20.1441ZM19.7901 19.7101L19.4366 19.3564L19.4364 19.3566L19.7901 19.7101ZM20.2241 19.0609L20.686 19.2524L20.686 19.2524L20.2241 19.0609ZM20.2241 17.5292L20.686 17.3377L20.686 17.3377L20.2241 17.5292ZM19.7901 16.88L20.1435 16.5263L20.1432 16.5261L19.7901 16.88ZM19.73 16.8201L19.3725 17.1697L19.3768 17.174L19.73 16.8201ZM18.9425 14.7982C18.7691 15.1912 18.7173 15.6271 18.794 16.0498L19.778 15.8713C19.737 15.6453 19.7646 15.4122 19.8574 15.2018L18.9425 14.7982ZM19.7293 13.8575C19.3799 14.089 19.1056 14.4175 18.9404 14.803L19.8595 15.197C19.9479 14.9909 20.0946 14.8151 20.2817 14.691L19.7293 13.8575ZM20.9079 13.5C20.4888 13.5017 20.0791 13.6258 19.7295 13.8574L20.2816 14.6911C20.4685 14.5674 20.6877 14.5009 20.9121 14.4999L20.9079 13.5ZM21.0001 13.4999H20.91V14.4999H21.0001V13.4999ZM22.0607 13.0606C21.7794 13.342 21.3978 13.4999 21.0001 13.4999V14.4999C21.663 14.4999 22.2989 14.2366 22.7678 13.7678L22.0607 13.0606ZM22.5 12C22.5 12.3979 22.342 12.7793 22.0607 13.0606L22.7678 13.7678C23.2367 13.2989 23.5 12.6631 23.5 12H22.5ZM22.0607 10.9394C22.342 11.2207 22.5 11.6021 22.5 12H23.5C23.5 11.3369 23.2367 10.7011 22.7678 10.2323L22.0607 10.9394ZM21.0001 10.5001C21.3978 10.5001 21.7794 10.6581 22.0607 10.9394L22.7678 10.2323C22.2989 9.76338 21.663 9.50007 21.0001 9.50007V10.5001ZM20.83 10.5001H21.0001V9.50007H20.83V10.5001ZM19.6494 10.1426C19.9991 10.3742 20.4088 10.4983 20.8278 10.5001L20.8321 9.50007C20.6077 9.49912 20.3885 9.43264 20.2016 9.30888L19.6494 10.1426ZM18.8604 9.19698C19.0256 9.58246 19.2999 9.91099 19.6493 10.1425L20.2017 9.30898C20.0146 9.18495 19.8678 9.00913 19.7795 8.80303L18.8604 9.19698ZM18.82 8.92001V9H19.82V8.92001H18.82ZM18.714 7.87016C18.6373 8.29292 18.6891 8.72889 18.8625 9.12187L19.7774 8.71815C19.6846 8.50788 19.6569 8.27469 19.6979 8.04867L18.714 7.87016ZM19.2924 6.75044C18.9922 7.05749 18.7907 7.44748 18.714 7.87017L19.6979 8.04867C19.7389 7.82258 19.8468 7.61389 20.0075 7.44956L19.2924 6.75044ZM19.3568 6.68618L19.2967 6.74617L20.0032 7.45383L20.0633 7.39384L19.3568 6.68618ZM19.6822 6.19942C19.6068 6.3815 19.4961 6.54696 19.3566 6.68631L20.0634 7.39371C20.2958 7.16156 20.4802 6.88587 20.606 6.58235L19.6822 6.19942ZM19.7966 5.62501C19.7966 5.82209 19.7577 6.01728 19.6822 6.19941L20.606 6.58236C20.7318 6.2789 20.7966 5.95359 20.7966 5.62501H19.7966ZM19.6822 5.05059C19.7577 5.23272 19.7966 5.42792 19.7966 5.62501H20.7966C20.7966 5.29643 20.7318 4.97111 20.606 4.66765L19.6822 5.05059ZM19.3566 4.56372C19.4961 4.70305 19.6068 4.86851 19.6822 5.05059L20.606 4.66765C20.4802 4.36414 20.2958 4.08844 20.0634 3.8563L19.3566 4.56372ZM18.8694 4.23777C19.0515 4.31325 19.2169 4.42388 19.3563 4.56338L20.0638 3.85664C19.8316 3.62422 19.5559 3.43981 19.2524 3.31399L18.8694 4.23777ZM18.295 4.12343C18.4921 4.12343 18.6873 4.16228 18.8694 4.23777L19.2524 3.31399C18.9488 3.18818 18.6235 3.12343 18.295 3.12343V4.12343ZM17.7206 4.23777C17.9027 4.16227 18.0978 4.12343 18.295 4.12343V3.12343C17.9664 3.12343 17.6412 3.18818 17.3377 3.31399L17.7206 4.23777ZM17.2337 4.56338C17.3731 4.42388 17.5385 4.31325 17.7206 4.23777L17.3377 3.31399C17.0341 3.43981 16.7585 3.62422 16.5263 3.85664L17.2337 4.56338ZM17.1737 4.62343L17.2337 4.56344L16.5263 3.85658L16.4664 3.91657L17.1737 4.62343ZM16.0497 5.20599C16.4725 5.12936 16.8626 4.92785 17.1697 4.62742L16.4704 3.91258C16.3062 4.07324 16.0976 4.18102 15.8714 4.22202L16.0497 5.20599ZM14.7981 5.05745C15.1912 5.23087 15.6271 5.28263 16.0498 5.20598L15.8713 4.22203C15.6453 4.26302 15.4121 4.23536 15.2018 4.14255L14.7981 5.05745ZM13.8575 4.27066C14.089 4.6201 14.4176 4.89437 14.803 5.05957L15.1969 4.14043C14.9909 4.05211 14.8151 3.90541 14.691 3.71827L13.8575 4.27066ZM13.4999 3.09214C13.5017 3.51128 13.6258 3.92088 13.8574 4.27051L14.6911 3.71842C14.5674 3.53147 14.5009 3.31231 14.4999 3.08787L13.4999 3.09214ZM13.4999 3.00001V3.09H14.4999V3.00001H13.4999ZM13.0606 1.93936C13.3419 2.22063 13.4999 2.60214 13.4999 3.00001H14.4999C14.4999 2.337 14.2366 1.7011 13.7677 1.23223L13.0606 1.93936ZM12 1.5C12.3978 1.5 12.7793 1.65802 13.0606 1.93936L13.7677 1.23223C13.2989 0.763416 12.6631 0.5 12 0.5V1.5ZM10.9394 1.93936C11.2207 1.65802 11.6022 1.5 12 1.5V0.5C11.3369 0.5 10.7011 0.763416 10.2323 1.23223L10.9394 1.93936ZM10.5001 3.00001C10.5001 2.60214 10.6581 2.22063 10.9394 1.93936L10.2323 1.23223C9.76337 1.7011 9.50006 2.337 9.50006 3.00001H10.5001ZM10.5001 3.17V3.00001H9.50006V3.17H10.5001ZM10.1426 4.35051C10.3742 4.00088 10.4983 3.59128 10.5001 3.17214L9.50007 3.16786C9.49911 3.39231 9.43265 3.61146 9.30886 3.79842L10.1426 4.35051ZM9.19695 5.13957C9.58244 4.97437 9.91098 4.7001 10.1425 4.35066L9.30896 3.79827C9.18494 3.98541 9.00914 4.1321 8.80305 4.22042L9.19695 5.13957ZM8.92 5.18H9V4.18H8.92V5.18ZM7.87022 5.28599C8.29291 5.36262 8.72887 5.31088 9.12188 5.13743L8.71812 4.22257C8.5079 4.31534 8.2747 4.34302 8.0486 4.30203L7.87022 5.28599ZM6.75036 4.70743C7.05747 5.00783 7.44751 5.20934 7.8702 5.28599L8.04862 4.30204C7.82253 4.26104 7.6139 4.15325 7.44963 3.99257L6.75036 4.70743ZM6.68645 4.64356L6.74645 4.70356L7.45354 3.99644L7.39355 3.93645L6.68645 4.64356ZM6.19941 4.31776C6.3815 4.39325 6.54694 4.50389 6.68625 4.64336L7.39375 3.93665C7.16157 3.70421 6.88585 3.51981 6.58235 3.39399L6.19941 4.31776ZM5.625 4.20343C5.82212 4.20343 6.01731 4.24229 6.19943 4.31777L6.58233 3.39398C6.27885 3.2682 5.95355 3.20343 5.625 3.20343V4.20343ZM5.05057 4.31777C5.23268 4.24229 5.42789 4.20343 5.625 4.20343V3.20343C5.29646 3.20343 4.97115 3.26819 4.66767 3.39398L5.05057 4.31777ZM4.56377 4.64335C4.70306 4.50389 4.86849 4.39325 5.05059 4.31776L4.66764 3.39399C4.36414 3.51981 4.08842 3.70421 3.85624 3.93666L4.56377 4.64335ZM4.23776 5.1306C4.31325 4.94851 4.42389 4.78307 4.56336 4.64376L3.85665 3.93626C3.62421 4.16844 3.43981 4.44415 3.314 4.74764L4.23776 5.1306ZM4.12343 5.70501C4.12343 5.50787 4.16228 5.31267 4.23776 5.13059L3.31399 4.74765C3.18817 5.05116 3.12343 5.37648 3.12343 5.70501H4.12343ZM4.23776 6.27941C4.16228 6.09732 4.12343 5.90214 4.12343 5.70501H3.12343C3.12343 6.03354 3.18817 6.35885 3.31399 6.66235L4.23776 6.27941ZM4.56336 6.76626C4.42389 6.62694 4.31325 6.4615 4.23776 6.27941L3.31399 6.66235C3.43981 6.96586 3.62421 7.24157 3.85665 7.47376L4.56336 6.76626ZM4.62359 6.8265L4.5636 6.76649L3.85641 7.47352L3.9164 7.53352L4.62359 6.8265ZM5.20598 7.95022C5.12935 7.52752 4.92783 7.13747 4.62742 6.83037L3.91258 7.52965C4.07325 7.69391 4.18103 7.90253 4.22202 8.12861L5.20598 7.95022ZM5.05743 9.20188C5.23088 8.80887 5.28262 8.37292 5.20598 7.95021L4.22202 8.12862C4.26302 8.35472 4.23534 8.5879 4.14256 8.79813L5.05743 9.20188ZM4.30221 10.1792C4.65304 9.9282 4.92035 9.57757 5.06928 9.17256L4.13072 8.82745C4.05109 9.04399 3.90816 9.23154 3.7204 9.36584L4.30221 10.1792ZM3.10163 10.5798C3.53294 10.5698 3.95127 10.4302 4.30221 10.1792L3.7204 9.36584C3.53275 9.50008 3.30904 9.57473 3.07837 9.58009L3.10163 10.5798ZM3.00001 10.58H3.09V9.57996H3.00001V10.58ZM1.93936 11.0194C2.22069 10.738 2.60223 10.58 3.00001 10.58V9.57996C2.33691 9.57996 1.70104 9.84346 1.23223 10.3123L1.93936 11.0194ZM1.5 12.08C1.5 11.6821 1.65806 11.3006 1.93929 11.0195L1.23229 10.3122C0.763381 10.781 0.5 11.417 0.5 12.08H1.5ZM1.93936 13.1407C1.65802 12.8593 1.5 12.4779 1.5 12.08H0.5C0.5 12.7431 0.763415 13.3789 1.23223 13.8478L1.93936 13.1407ZM3.00001 13.58C2.60214 13.58 2.22063 13.422 1.93936 13.1407L1.23222 13.8478C1.7011 14.3167 2.337 14.58 3.00001 14.58V13.58ZM3.17 13.58H3.00001V14.58H3.17V13.58ZM4.35051 13.9374C4.00088 13.7059 3.59127 13.5818 3.17213 13.58L3.16786 14.58C3.3923 14.5809 3.61146 14.6474 3.79841 14.7712L4.35051 13.9374ZM5.13956 14.883C4.97441 14.4977 4.70016 14.1689 4.35051 13.9374L3.79841 14.7712C3.98534 14.895 4.13206 15.0708 4.22043 15.277L5.13956 14.883ZM5.28599 16.1298C5.36262 15.7071 5.31087 15.2712 5.13744 14.8782L4.22255 15.2819C4.31535 15.4922 4.34301 15.7253 4.30203 15.9514L5.28599 16.1298ZM4.70742 17.2496C5.00783 16.9425 5.20934 16.5525 5.28599 16.1298L4.30203 15.9514C4.26104 16.1774 4.15325 16.3861 3.99257 16.5503L4.70742 17.2496ZM4.64384 17.3133L4.70383 17.2532L3.99616 16.5467L3.93616 16.6068L4.64384 17.3133ZM4.31777 17.8006C4.39324 17.6186 4.50388 17.4531 4.64337 17.3138L3.93663 16.6063C3.70422 16.8385 3.51981 17.1142 3.39398 17.4177L4.31777 17.8006ZM4.20343 18.3751C4.20343 18.1778 4.2423 17.9826 4.31774 17.8007L3.39401 17.4177C3.26818 17.7211 3.20343 18.0465 3.20343 18.3751H4.20343ZM4.31778 18.9495C4.24228 18.7673 4.20343 18.5721 4.20343 18.3751H3.20343C3.20343 18.7035 3.26819 19.0289 3.39397 19.3324L4.31778 18.9495ZM4.64337 19.4363C4.50394 19.2971 4.39325 19.1315 4.31773 18.9494L3.39402 19.3325C3.5198 19.6358 3.70416 19.9116 3.93663 20.1438L4.64337 19.4363ZM5.13059 19.7623C4.94852 19.6868 4.78305 19.5761 4.6437 19.4367L3.93631 20.1435C4.16845 20.3758 4.44414 20.5602 4.74763 20.686L5.13059 19.7623ZM5.705 19.8767C5.50792 19.8767 5.31272 19.8378 5.13059 19.7623L4.74764 20.6861C5.0511 20.8118 5.37642 20.8767 5.705 20.8767V19.8767ZM6.2794 19.7623C6.09727 19.8378 5.90208 19.8767 5.705 19.8767V20.8767C6.03359 20.8767 6.35889 20.8118 6.66235 20.6861L6.2794 19.7623ZM6.7663 19.4367C6.62695 19.5761 6.46149 19.6868 6.27941 19.7623L6.66235 20.6861C6.96586 20.5602 7.24155 20.3758 7.4737 20.1435L6.7663 19.4367ZM6.82621 19.3767L6.7662 19.4368L7.4738 20.1434L7.53381 20.0833L6.82621 19.3767ZM7.95016 18.794C7.52747 18.8707 7.13748 19.0723 6.83044 19.3725L7.52957 20.0875C7.69388 19.9268 7.90256 19.819 8.12866 19.778L7.95016 18.794ZM9.20186 18.9425C8.80888 18.7691 8.37292 18.7173 7.95016 18.794L8.12866 19.778C8.3547 19.737 8.58788 19.7646 8.79814 19.8574L9.20186 18.9425ZM10.1792 19.6979C9.92824 19.347 9.57759 19.0796 9.17254 18.9307L8.82746 19.8693C9.04396 19.9489 9.23149 20.0918 9.3658 20.2796L10.1792 19.6979ZM10.5798 20.8984C10.5698 20.4671 10.4302 20.0487 10.1791 19.6978L9.36587 20.2797C9.50006 20.4673 9.57472 20.691 9.58008 20.9216L10.5798 20.8984ZM10.5799 21.0001V20.91H9.57995V21.0001H10.5799ZM11.0194 22.0607C10.738 21.7793 10.5799 21.3978 10.5799 21.0001H9.57995C9.57995 21.6631 9.84346 22.299 10.3123 22.7678L11.0194 22.0607ZM12.08 22.5C11.6821 22.5 11.3006 22.342 11.0195 22.0608L10.3122 22.7678C10.781 23.2367 11.417 23.5 12.08 23.5V22.5ZM13.1407 22.0607C12.8593 22.342 12.4779 22.5 12.08 22.5V23.5C12.7431 23.5 13.3789 23.2367 13.8478 22.7678L13.1407 22.0607ZM13.58 21.0001C13.58 21.3978 13.422 21.7794 13.1407 22.0607L13.8478 22.7678C14.3167 22.2989 14.58 21.663 14.58 21.0001H13.58ZM13.58 20.83V21.0001H14.58V20.83H13.58ZM13.9374 19.6495C13.7059 19.9991 13.5818 20.4088 13.58 20.8279L14.58 20.8321C14.5809 20.6077 14.6474 20.3885 14.7712 20.2016L13.9374 19.6495ZM14.883 18.8604C14.4977 19.0256 14.1689 19.2999 13.9374 19.6494L14.7712 20.2016C14.8949 20.0146 15.0708 19.8679 15.277 19.7795L14.883 18.8604ZM16.1298 18.714C15.7071 18.6373 15.2712 18.6891 14.8782 18.8625L15.2818 19.7774C15.4922 19.6846 15.7253 19.6569 15.9513 19.6979L16.1298 18.714ZM17.2495 19.2925C16.9425 18.9922 16.5525 18.7907 16.1298 18.714L15.9513 19.6979C16.1774 19.739 16.3861 19.8468 16.5504 20.0075L17.2495 19.2925ZM17.3136 19.3565L17.2535 19.2964L16.5464 20.0035L16.6065 20.0636L17.3136 19.3565ZM17.8006 19.6822C17.6185 19.6068 17.4531 19.4961 17.3137 19.3566L16.6064 20.0635C16.8385 20.2958 17.1142 20.4802 17.4177 20.606L17.8006 19.6822ZM18.375 19.7966C18.1779 19.7966 17.9827 19.7577 17.8007 19.6823L17.4176 20.606C17.7211 20.7318 18.0464 20.7966 18.375 20.7966V19.7966ZM18.9495 19.6822C18.7673 19.7578 18.5721 19.7966 18.375 19.7966V20.7966C18.7036 20.7966 19.0289 20.7318 19.3324 20.606L18.9495 19.6822ZM19.4364 19.3566C19.2971 19.4961 19.1315 19.6068 18.9494 19.6823L19.3325 20.606C19.6358 20.4802 19.9115 20.2958 20.1437 20.0635L19.4364 19.3566ZM19.7623 18.8695C19.6868 19.0515 19.5761 19.217 19.4366 19.3564L20.1435 20.0637C20.3758 19.8316 20.5602 19.5559 20.686 19.2524L19.7623 18.8695ZM19.8766 18.295C19.8766 18.492 19.8378 18.6873 19.7623 18.8695L20.686 19.2524C20.8118 18.9489 20.8766 18.6236 20.8766 18.295H19.8766ZM19.7623 17.7206C19.8378 17.9028 19.8766 18.0979 19.8766 18.295H20.8766C20.8766 17.9664 20.8118 17.6412 20.686 17.3377L19.7623 17.7206ZM19.4366 17.2337C19.5761 17.3731 19.6868 17.5385 19.7623 17.7206L20.686 17.3377C20.5602 17.0341 20.3758 16.7585 20.1435 16.5263L19.4366 17.2337ZM19.3768 17.174L19.4369 17.234L20.1432 16.5261L20.0831 16.4661L19.3768 17.174ZM18.794 16.0498C18.8707 16.4726 19.0722 16.8626 19.3725 17.1696L20.0875 16.4705C19.9268 16.3062 19.819 16.0975 19.778 15.8713L18.794 16.0498ZM12 15.25C13.795 15.25 15.25 13.795 15.25 12H14.25C14.25 13.2427 13.2427 14.25 12 14.25V15.25ZM8.75 12C8.75 13.795 10.205 15.25 12 15.25V14.25C10.7573 14.25 9.75 13.2427 9.75 12H8.75ZM12 8.75C10.205 8.75 8.75 10.205 8.75 12H9.75C9.75 10.7573 10.7573 9.75 12 9.75V8.75ZM15.25 12C15.25 10.205 13.795 8.75 12 8.75V9.75C13.2427 9.75 14.25 10.7573 14.25 12H15.25Z",fill:"currentColor"}))}var ld="_button_1t4fm_7",od="_dot_1t4fm_14",dd="_menu_1t4fm_26",cd="_menuItem_1t4fm_31",hd="_highlight_1t4fm_41";class pd extends N.Component{constructor(){super(...arguments),this.button=N.createRef(),this.state={isOpen:!1,isUpdateReadyDialogOpen:!1,isShortcutDialogOpen:!1},this.handleToggle=()=>{E((()=>{this.setState((e=>({isOpen:!e.isOpen})))}))},this.handleClose=()=>{E((()=>{this.setState({isOpen:!1})}))},this.handleSwitchTheme=()=>{E((()=>{zt.apply("light"===zt.theme?"dark":"light"),this.handleClose()}))},this.handleUpdateCheck=async()=>{this.handleClose(),await Zs.check()},this.handleUpdateDownload=async()=>{this.handleClose(),await Zs.download()},this.handleUpdateInstall=()=>{E((()=>{this.setState({isUpdateReadyDialogOpen:!0}),this.handleClose()}))},this.handleViewShortcuts=()=>{this.setState({isOpen:!1,isShortcutDialogOpen:!0})}}componentDidMount(){let e=D(f((()=>Zs.isUpdateReady)),(({newValue:t})=>{t&&(e(),E((()=>{this.setState({isUpdateReadyDialogOpen:!0})})))}))}render(){const{isOpen:e,isUpdateReadyDialogOpen:t,isShortcutDialogOpen:s}=this.state;return N.createElement(N.Fragment,null,N.createElement(si,{innerRef:this.button,className:L(ld,{[od]:!Zs.isUpToDate||Zs.isUpdateReady}),ghost:!0,onClick:this.handleToggle,"data-testid":"settings-dialog","data-align":"right"},N.createElement(rd,null)),e&&N.createElement(ji,{target:this.button,onClickOutside:this.handleClose,targetOffsetX:0,targetOffsetY:37,align:"right"},N.createElement("ul",{className:dd},N.createElement("li",{className:`${cd} embedded-hidden`,onClick:this.handleSwitchTheme},"light"===zt.theme?"Dark theme":"Light theme"),Zs.hasCheckedForUpdates&&!Zs.isUpToDate&&!Zs.isDownloading&&!Zs.isUpdateReady&&N.createElement("li",{className:L(cd,{[hd]:!0}),onClick:this.handleUpdateDownload},"Download v",Zs.latestVersion),Zs.isDownloading&&N.createElement("li",{className:L(cd,{[hd]:!0}),onClick:this.handleUpdateDownload},"Downloading v",Zs.latestVersion),Zs.isUpdateReady&&N.createElement("li",{className:L(cd,{[hd]:!0}),onClick:this.handleUpdateInstall},"Install v",Zs.latestVersion),q.updates&&N.createElement("li",{className:cd,onClick:this.handleUpdateCheck},"Check for updates"),N.createElement("li",{className:cd},N.createElement("a",{href:"https://github.com/prisma/studio/releases",target:"_blank",rel:"noreferrer noopener"},"View changelog")),N.createElement("li",{className:cd,onClick:this.handleViewShortcuts,"data-testid":"view-shortcuts"},"View shortcuts"))),t&&N.createElement(nd,{onClose:()=>this.setState({isUpdateReadyDialogOpen:!1})}),s&&N.createElement(sd,{onClose:()=>this.setState({isShortcutDialogOpen:!1})}))}}var ud=S(pd);var md={container:"_container_18ph6_1",title:"_title_18ph6_11",active:"_active_18ph6_14",preview:"_preview_18ph6_23",modelListTabButton:"_modelListTabButton_18ph6_27",closeButton:"_closeButton_18ph6_50",dirtyIndicator:"_dirtyIndicator_18ph6_59"};var gd={container:"_container_os6jn_1",content:"_content_os6jn_10",description:"_description_os6jn_19"};class vd extends N.Component{render(){const{onCancel:e,onDiscard:t,tabHasFilters:s,tabIsDirty:i}=this.props,a=(s&&i?"Unsaved changes on a filtered view":s&&"Filtered view")||i&&"Unsaved changes",n=(s&&i?"This tab has unsaved changes and filters applied. Do you still want to close it?":s&&"This tab has filters applied. Do you still want to close it?")||i&&"This tab contains unsaved changes. Do you want to discard them?",r=(s&&i?"Discard changes":s&&"Close filtered view")||i&&"Discard changes";return N.createElement(Ro,{dataTestId:"tab-discard-dialog",className:gd.container,title:a,primaryButton:N.createElement(si,{"data-testid":"discard-btn",red:!0,onClick:t},r),secondaryButton:N.createElement(si,{"data-testid":"cancel-btn",ghost:!0,className:gd.cancelBtn,onClick:e},"Cancel")},N.createElement("div",{className:gd.content},N.createElement("p",{className:gd.description},n)))}}var fd=S(vd);class yd extends N.PureComponent{constructor(e){super(e),this.container=N.createRef(),this.handleClick=()=>{Bt.switch({id:this.props.id})},this.handleDoubleClick=()=>{const e=Bt.get(this.props.id);e&&e.preview&&e.update({preview:!1})},this.handleClose=e=>{e&&e.stopPropagation(),e&&e.preventDefault();const t=Bt.get(this.props.id);t&&(t.isDirty||t.hasFilters?this.setState({isCloseDialogOpen:!0}):(Bt.remove(this.props.id),this.setState({isCloseDialogOpen:!1})))},this.handleDiscardChanges=()=>{Bt.remove(this.props.id),this.setState({isCloseDialogOpen:!1})},this.handleCancelClose=()=>{this.setState({isCloseDialogOpen:!1})},this.state={isCloseDialogOpen:!1},this.reaction=D(f((()=>Bt.activeTabId)),(({newValue:t})=>{var s;t===e.id&&(null==(s=this.container.current)||s.scrollIntoView())}))}componentWillUnmount(){this.reaction()}render(){const{isCloseDialogOpen:e}=this.state,{id:t}=this.props,s=Bt.get(t),i=Bt.activeTabId===t,a=Bt.regularTabCount>1;if(!s||!s.session)return null;const n=null==s?void 0:s.isDirty,r=null==s?void 0:s.hasFilters;return N.createElement("div",{ref:this.container,"data-testid":"tab","data-test-active":i,"data-test-dirty":n||r,"data-test-preview":s.preview,className:L(md.container,{[md.active]:i,[md.preview]:s.preview}),onClick:this.handleClick,onDoubleClick:this.handleDoubleClick},s.session.isModelList&&a&&N.createElement("div",{"data-testid":"clear-all-btn",className:md.modelListTabButton,onClick:()=>Bt.clearAllTabs()},"Clear All"),s.session.isScript&&N.createElement(N.Fragment,null,N.createElement("div",{"data-testid":"title",className:md.title},s.title),N.createElement(ri,{"data-testid":"close-btn",className:L(md.closeButton,{[md.dirty]:n||r}),onClick:this.handleClose},n?N.createElement("div",{className:md.dirtyIndicator}):N.createElement(na,null)),e&&N.createElement(fd,{tabHasFilters:r,tabIsDirty:n,onCancel:this.handleCancelClose,onDiscard:this.handleDiscardChanges})),N.createElement(li,{keys:"mod+w",onMatch:()=>this.handleClose()}))}}var Id=S(yd);var Cd="_container_5y03b_1",wd="_clearTabsButton_5y03b_11";var bd=S((()=>{const{setIsOpen:e}=nn(),t=Bt.openTabs,s=t.length>1;return 0===t.length?(e(!0),N.createElement("div",{"data-testid":"tab-bar","data-tabs":"empty",className:Cd})):N.createElement("div",{"data-testid":"tab-bar",className:Cd},t.map((e=>N.createElement(Id,{key:e.id,id:e.id}))),s&&N.createElement("div",{"data-testid":"clear-all-btn",className:wd,onClick:()=>Bt.clearAllTabs()},"Close all"))}));var Ed="_container_1ud7d_1";var _d=S((({className:e})=>{const{isMaximized:t}=nn();return N.createElement("div",{"data-testid":"header",className:L(Ed,e)},N.createElement(on,null),N.createElement(bd,null),t&&N.createElement(ln,null),N.createElement(rn,null),N.createElement(ud,null))}));var xd="_header_1asv1_20",Sd="_search_1asv1_40",Nd="_section_1asv1_50",Ld="_allModels_1asv1_54",Rd="_sectionTitle_1asv1_59",Od="_list_1asv1_64",Md="_model_1asv1_69",kd="_active_1asv1_75",Dd="_name_1asv1_81",Ad="_spacer_1asv1_86",Td="_count_1asv1_89",Pd="_empty_1asv1_104";class Vd extends N.PureComponent{constructor(){var e;super(...arguments),this.state={searchValue:"",highlightedSection:"recent",highlightedIdx:0},this.input=N.createRef(),this.recentModelRefs=((null==(e=es.activeProject)?void 0:e.recentModelIds)||[]).map((e=>N.createRef())),this.allModelRefs=Object.keys(ds.values).map((e=>N.createRef())),this.filteredModelRefs=[],this.getRecentModels=()=>{var e;return(null==(e=es.activeProject)?void 0:e.recentModels)||[]},this.getAllModels=()=>h.exports.orderBy(Object.values(ds.values),["name"]),this.getFilteredModels=e=>this.getAllModels().filter((t=>t.name.toLowerCase().includes(e.toLowerCase()))),this.scrollToHighlightedIdx=()=>{var e,t,s,i,a,n;const{highlightedSection:r,highlightedIdx:l}=this.state;"recent"===r?null==(t=null==(e=this.recentModelRefs[l])?void 0:e.current)||t.scrollIntoView({behavior:"smooth",block:"nearest"}):"all"===r?null==(i=null==(s=this.allModelRefs[l])?void 0:s.current)||i.scrollIntoView({behavior:"smooth",block:"nearest"}):"filtered"===r&&(null==(n=null==(a=this.filteredModelRefs[l])?void 0:a.current)||n.scrollIntoView({behavior:"smooth",block:"nearest"}))},this.handleSelectModel=e=>{var t;const s=ds.get(e);if(!s)return;null==(t=es.activeProject)||t.addRecentModel(s.id);let i=Object.values(Bt.values).find((e=>{var t;return(null==(t=e.session)?void 0:t.isScript)&&e.session.script.model.id===s.id&&e.session.script.frozen}))||null;return i?(i.update({preview:!1}),void Bt.switch({id:i.id})):(i=Bt.previewTab,i?(i.load({modelId:s.id}),i.update({preview:!1}),void Bt.switch({id:i.id})):(i=Bt.add({modelId:s.id,preview:!1}),void Bt.switch({id:i.id})))},this.handleSelectHighlightedModel=()=>{var e,t,s;const{highlightedSection:i,highlightedIdx:a,searchValue:n}=this.state;"recent"===i?this.handleSelectModel(null==(e=this.getRecentModels()[a])?void 0:e.id):"all"===i?this.handleSelectModel(null==(t=this.getAllModels()[a])?void 0:t.id):"filtered"===i&&this.handleSelectModel(null==(s=this.getFilteredModels(n)[a])?void 0:s.id)},this.handleSearch=e=>{var t;this.filteredModelRefs=this.getFilteredModels(e).map((e=>N.createRef()));const s=(null==(t=es.activeProject)?void 0:t.recentModels)||[];""===e?this.setState({searchValue:e,highlightedSection:s.length>0?"recent":"all",highlightedIdx:0}):this.setState({searchValue:e,highlightedSection:"filtered",highlightedIdx:0})},this.handleHighlightPrev=()=>{this.setState((e=>{var t;let s=e.highlightedSection,i=e.highlightedIdx;if("recent"===e.highlightedSection)e.highlightedIdx-1<0||(i-=1);else if("all"===e.highlightedSection)if(e.highlightedIdx-1<0){const e=(null==(t=es.activeProject)?void 0:t.recentModels)||[];0===e.length||(s="recent",i=e.length-1)}else i-=1;else"filtered"===e.highlightedSection&&(e.highlightedIdx-1<0||(i-=1));return{highlightedSection:s,highlightedIdx:i}}),(()=>this.scrollToHighlightedIdx()))},this.handleHighlightNext=()=>{this.setState((e=>{var t;let s=e.highlightedSection,i=e.highlightedIdx;if("recent"===e.highlightedSection){const a=(null==(t=es.activeProject)?void 0:t.recentModels)||[];e.highlightedIdx+1>=a.length?(s="all",i=0):i+=1}else if("all"===e.highlightedSection){const t=Object.values(ds.values);e.highlightedIdx+1>=t.length||(i+=1)}else if("filtered"===e.highlightedSection){const t=this.getFilteredModels(e.searchValue);e.highlightedIdx+1>=t.length||(i+=1)}return{highlightedSection:s,highlightedIdx:i}}),(()=>this.scrollToHighlightedIdx()))}}render(){var e;const{searchValue:t,highlightedSection:s,highlightedIdx:i}=this.state;null==(e=es.activeProject)||e.recentModels;const a=this.getAllModels(),n=this.getFilteredModels(t);return N.createElement(N.Fragment,null,N.createElement("header",{className:xd},N.createElement(pi,null),N.createElement(di,{"data-testid":"model-list-search",innerRef:this.input,type:"text",className:Sd,focusOnMount:!0,value:t,onChange:this.handleSearch,placeholder:"Search models"})),""===t&&N.createElement("section",{"data-testid":"model-list",className:L(Nd,Ld)},N.createElement("div",{className:Rd},"All Models"),N.createElement("ul",{className:Od},a.map(((e,t)=>N.createElement(jd,{key:e.id,ref:this.allModelRefs[t],name:e.name,count:e.count,isActive:"all"===s&&i===t,onClick:()=>this.handleSelectModel(e.id)}))))),""!==t&&N.createElement("section",{"data-testid":"filtered-model-list",className:L(Nd,Ld)},N.createElement("div",{className:Rd},"Matches"),N.createElement("ul",{className:Od},n.map(((e,t)=>N.createElement(jd,{key:e.id,ref:this.filteredModelRefs[t],name:e.name,count:e.count,isActive:"filtered"===s&&i===t,onClick:()=>{var t;this.handleSelectModel(e.id),null==(t=Bt.activeTab)||t.update({preview:!1})}})))),0===n.length&&N.createElement("div",{className:Pd},"No matches")),N.createElement(li,{keys:["command+shift+[","command+option+right"],target:this.input,onMatch:()=>Bt.switch({direction:"right"})}),N.createElement(li,{keys:["command+shift+]","command+option+left"],target:this.input,onMatch:()=>Bt.switch({direction:"left"})}),N.createElement(li,{keys:"up",target:this.input,onMatch:()=>this.handleHighlightPrev()}),N.createElement(li,{keys:"down",target:this.input,onMatch:()=>this.handleHighlightNext()}),N.createElement(li,{keys:"enter",target:this.input,onMatch:()=>this.handleSelectHighlightedModel()}),N.createElement(li,{keys:"cmd+enter",target:this.input,onMatch:()=>this.handleSelectHighlightedModel()}))}}const jd=R.exports.forwardRef((({name:e,count:t=0,isActive:s=!1,onClick:i},a)=>N.createElement("li",{ref:a,className:L(Md,{[kd]:s}),onClick:i},N.createElement("div",{"data-testid":"model-name",className:Dd},e),N.createElement("div",{className:Ad}),N.createElement("div",{"data-testid":"model-record-count",className:Td},null!=t?t:""))));var Fd=S(Vd);var Bd="_container_6vbeo_1";class Hd extends N.Component{render(){return N.createElement("div",{"data-testid":"no-model-selected",className:Bd},"Select a model to view its data")}}var qd="_containerStudio_1xpfk_9",Zd="_header_1xpfk_17",Ud="_body_1xpfk_22";class zd extends N.PureComponent{constructor(){super(...arguments),this.state={error:!1}}componentDidCatch(e){ys.update({type:"fatal",description:e.message,dump:e.stack||""}),Ee.updateError({visible:!0}),U({path:"Studio.componentDidCatch",message:"Caught an error during rendering",nativeError:e})}static getDerivedStateFromError(e){return{error:!0,errorMessage:e.message}}render(){var e,t;const{error:s}=this.state;return s?N.createElement(Bo,null):N.createElement(an,null,N.createElement(dn,null,N.createElement(Fd,null)),N.createElement(cn,null),N.createElement(hn,null,N.createElement("div",{className:qd},N.createElement(_d,{className:Zd}),N.createElement("div",{className:Ud},(null==(t=null==(e=Bt.activeTab)?void 0:e.session)?void 0:t.isScript)?N.createElement(To,null):N.createElement(Hd,null)),Ee.error.visible&&"client"===ys.type&&N.createElement(jo,null),Ee.error.visible&&"fatal"===ys.type&&N.createElement(Bo,null),Ee.error.visible&&"schemaDrift"===ys.type&&N.createElement(qo,null))),N.createElement("div",{id:"modal-root"}),N.createElement("div",{id:"dropdown-root"}),N.createElement("div",{id:"dialog-root"}))}}var $d=S(zd);var Jd="_container_1d62f_1",Wd="_tab1_1d62f_11",Kd="_tab2_1d62f_17",Gd="_tabEmptySpace_1d62f_22",Qd="_filter1_1d62f_28",Yd="_filter2_1d62f_29",Xd="_filter3_1d62f_30",ec="_filter4_1d62f_31",tc="_separator_1d62f_55",sc="_button1_1d62f_61",ic="_btnSpace_1d62f_69",ac="_table_1d62f_90";class nc extends N.PureComponent{render(){return N.createElement("div",{"data-testid":"skeleton",className:Jd},N.createElement("div",{className:Wd,style:{paddingLeft:32}}),N.createElement("div",{className:Kd}),N.createElement("div",{className:Gd}),N.createElement("div",{className:Qd}),N.createElement("div",{className:Yd}),N.createElement("div",{className:Xd}),N.createElement("div",{className:ec}),N.createElement("div",{className:tc}),N.createElement("div",{className:sc}),N.createElement("div",{className:ic}," Getting things ready..."),N.createElement("div",{className:ac}))}}var rc=S(nc);var lc="_container_om25j_1";class oc extends N.Component{constructor(){super(...arguments),this.state={isShortcutDialogOpen:!1}}async componentDidMount(){Zs.hasCheckedForUpdates||await Zs.check()}render(){const{isShortcutDialogOpen:e}=this.state;return N.createElement(N.Fragment,null,N.createElement("div",{id:"studio-container",className:L(lc,{"theme--light":"light"===zt.theme,"theme--dark":"dark"===zt.theme})},Ws.ready&&Bt.activeTab?N.createElement(Fl,{value:new Pl({sessionId:Bt.activeTab.sessionId})},N.createElement($d,null)):N.createElement(rc,null)),N.createElement(li,{keys:"mod+/",onMatch:()=>this.setState((e=>({isShortcutDialogOpen:!e.isShortcutDialogOpen})))}),e&&N.createElement(sd,{onClose:()=>this.setState({isShortcutDialogOpen:!1})}))}}var dc=S(oc);window.databrowser=async function(e){await q.update(e),await Ws.initTransport(),Ws.init();const t=document.createElement("div");t.id="root",document.body.appendChild(t),V(t).render(N.createElement(dc))},window.splash=async function(e){await q.update(e),await Ws.initTransport();const t=document.createElement("div");t.id="root",document.body.appendChild(t),V(t).render(N.createElement(_i))}; diff --git a/backend/node_modules/prisma/build/public/assets/inter-all-400-normal.4c1f8a0d.woff b/backend/node_modules/prisma/build/public/assets/inter-all-400-normal.4c1f8a0d.woff new file mode 100644 index 0000000000000000000000000000000000000000..c4c689dc22a31ffd0924be0aa4a21d9816d12e90 --- /dev/null +++ b/backend/node_modules/prisma/build/public/assets/inter-all-400-normal.4c1f8a0d.woff @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4c1f8a0d5ef1e04d7e14d194a4ef624345e7c7c1cdb4ff61d4552e32a60ac1d0 +size 121716 diff --git a/backend/node_modules/prisma/build/public/assets/inter-all-600-normal.d0a7c8a9.woff b/backend/node_modules/prisma/build/public/assets/inter-all-600-normal.d0a7c8a9.woff new file mode 100644 index 0000000000000000000000000000000000000000..e5337c1bbbdc199e5d6b82630bfac2eb6fa32713 --- /dev/null +++ b/backend/node_modules/prisma/build/public/assets/inter-all-600-normal.d0a7c8a9.woff @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d0a7c8a993b9310ebb74a893fa564133bc129f6af41126eb98d207c813b96093 +size 131632 diff --git a/backend/node_modules/prisma/build/public/assets/inter-cyrillic-400-normal.ac97a49e.woff2 b/backend/node_modules/prisma/build/public/assets/inter-cyrillic-400-normal.ac97a49e.woff2 new file mode 100644 index 0000000000000000000000000000000000000000..9b199dff899668583e9fd9be972c8677041695fd Binary files /dev/null and b/backend/node_modules/prisma/build/public/assets/inter-cyrillic-400-normal.ac97a49e.woff2 differ diff --git a/backend/node_modules/prisma/build/public/assets/inter-cyrillic-600-normal.2c917f10.woff2 b/backend/node_modules/prisma/build/public/assets/inter-cyrillic-600-normal.2c917f10.woff2 new file mode 100644 index 0000000000000000000000000000000000000000..ecdbc38c546dabdd515727cbfb84ed8f58ca576b Binary files /dev/null and b/backend/node_modules/prisma/build/public/assets/inter-cyrillic-600-normal.2c917f10.woff2 differ diff --git a/backend/node_modules/prisma/build/public/assets/inter-cyrillic-ext-400-normal.f21a6a97.woff2 b/backend/node_modules/prisma/build/public/assets/inter-cyrillic-ext-400-normal.f21a6a97.woff2 new file mode 100644 index 0000000000000000000000000000000000000000..0a28013d59e2e6286dc52cba03280dc07e1b9cea Binary files /dev/null and b/backend/node_modules/prisma/build/public/assets/inter-cyrillic-ext-400-normal.f21a6a97.woff2 differ diff --git a/backend/node_modules/prisma/build/public/assets/inter-cyrillic-ext-600-normal.bb31f197.woff2 b/backend/node_modules/prisma/build/public/assets/inter-cyrillic-ext-600-normal.bb31f197.woff2 new file mode 100644 index 0000000000000000000000000000000000000000..27e3db5b943fc43df0042be4b99b0e287ad1c1e6 Binary files /dev/null and b/backend/node_modules/prisma/build/public/assets/inter-cyrillic-ext-600-normal.bb31f197.woff2 differ diff --git a/backend/node_modules/prisma/build/public/assets/inter-greek-400-normal.e9163df8.woff2 b/backend/node_modules/prisma/build/public/assets/inter-greek-400-normal.e9163df8.woff2 new file mode 100644 index 0000000000000000000000000000000000000000..3d2f76d320e068ae382e6744cde6284cd8a51687 Binary files /dev/null and b/backend/node_modules/prisma/build/public/assets/inter-greek-400-normal.e9163df8.woff2 differ diff --git a/backend/node_modules/prisma/build/public/assets/inter-greek-600-normal.e644d70f.woff2 b/backend/node_modules/prisma/build/public/assets/inter-greek-600-normal.e644d70f.woff2 new file mode 100644 index 0000000000000000000000000000000000000000..c7c46778f9f68d4d7566560c677ff5335b29842d Binary files /dev/null and b/backend/node_modules/prisma/build/public/assets/inter-greek-600-normal.e644d70f.woff2 differ diff --git a/backend/node_modules/prisma/build/public/assets/inter-greek-ext-400-normal.43addcc8.woff2 b/backend/node_modules/prisma/build/public/assets/inter-greek-ext-400-normal.43addcc8.woff2 new file mode 100644 index 0000000000000000000000000000000000000000..2133c2aa0f35ecfda7b95b494141f9fc90b0b0c8 Binary files /dev/null and b/backend/node_modules/prisma/build/public/assets/inter-greek-ext-400-normal.43addcc8.woff2 differ diff --git a/backend/node_modules/prisma/build/public/assets/inter-greek-ext-600-normal.7f437016.woff2 b/backend/node_modules/prisma/build/public/assets/inter-greek-ext-600-normal.7f437016.woff2 new file mode 100644 index 0000000000000000000000000000000000000000..fe5f44b8c893a759712781a9c4bcb601ac72f83f Binary files /dev/null and b/backend/node_modules/prisma/build/public/assets/inter-greek-ext-600-normal.7f437016.woff2 differ diff --git a/backend/node_modules/prisma/build/public/assets/inter-latin-400-normal.27ae72da.woff2 b/backend/node_modules/prisma/build/public/assets/inter-latin-400-normal.27ae72da.woff2 new file mode 100644 index 0000000000000000000000000000000000000000..b5db4467bc7bf15cc032d9825ff1606c4bf72a62 Binary files /dev/null and b/backend/node_modules/prisma/build/public/assets/inter-latin-400-normal.27ae72da.woff2 differ diff --git a/backend/node_modules/prisma/build/public/assets/inter-latin-600-normal.87d718a2.woff2 b/backend/node_modules/prisma/build/public/assets/inter-latin-600-normal.87d718a2.woff2 new file mode 100644 index 0000000000000000000000000000000000000000..924ae728dd9e205bd4e7aff5a1449c54a357a93a Binary files /dev/null and b/backend/node_modules/prisma/build/public/assets/inter-latin-600-normal.87d718a2.woff2 differ diff --git a/backend/node_modules/prisma/build/public/assets/inter-latin-ext-400-normal.5b02c69a.woff2 b/backend/node_modules/prisma/build/public/assets/inter-latin-ext-400-normal.5b02c69a.woff2 new file mode 100644 index 0000000000000000000000000000000000000000..ef110cb8c89c1913a1a5ad5236bb9c9da8308a9c Binary files /dev/null and b/backend/node_modules/prisma/build/public/assets/inter-latin-ext-400-normal.5b02c69a.woff2 differ diff --git a/backend/node_modules/prisma/build/public/assets/inter-latin-ext-600-normal.88feb9e4.woff2 b/backend/node_modules/prisma/build/public/assets/inter-latin-ext-600-normal.88feb9e4.woff2 new file mode 100644 index 0000000000000000000000000000000000000000..67c318eaf94269aa08989f9bd3114fd5cb60e1d8 Binary files /dev/null and b/backend/node_modules/prisma/build/public/assets/inter-latin-ext-600-normal.88feb9e4.woff2 differ diff --git a/backend/node_modules/prisma/build/public/assets/inter-vietnamese-600-normal.8185dacd.woff2 b/backend/node_modules/prisma/build/public/assets/inter-vietnamese-600-normal.8185dacd.woff2 new file mode 100644 index 0000000000000000000000000000000000000000..38a59103b63cfe57e5d23ed5744aebd2b3df217d Binary files /dev/null and b/backend/node_modules/prisma/build/public/assets/inter-vietnamese-600-normal.8185dacd.woff2 differ diff --git a/backend/node_modules/prisma/build/public/assets/jetbrains-mono-all-400-normal.f86807b7.woff b/backend/node_modules/prisma/build/public/assets/jetbrains-mono-all-400-normal.f86807b7.woff new file mode 100644 index 0000000000000000000000000000000000000000..3ac25e3574eaabdc8c7ac4f517b899937888fab6 Binary files /dev/null and b/backend/node_modules/prisma/build/public/assets/jetbrains-mono-all-400-normal.f86807b7.woff differ diff --git a/backend/node_modules/prisma/build/public/assets/jetbrains-mono-cyrillic-400-normal.1ae57fe2.woff2 b/backend/node_modules/prisma/build/public/assets/jetbrains-mono-cyrillic-400-normal.1ae57fe2.woff2 new file mode 100644 index 0000000000000000000000000000000000000000..ec297c5f2e2c8af845a3707bf672736928100fae Binary files /dev/null and b/backend/node_modules/prisma/build/public/assets/jetbrains-mono-cyrillic-400-normal.1ae57fe2.woff2 differ diff --git a/backend/node_modules/prisma/build/public/assets/jetbrains-mono-latin-400-normal.80a5dc9e.woff2 b/backend/node_modules/prisma/build/public/assets/jetbrains-mono-latin-400-normal.80a5dc9e.woff2 new file mode 100644 index 0000000000000000000000000000000000000000..84d1c996cd483ec2bd3587880fbecaedc3ee07ad Binary files /dev/null and b/backend/node_modules/prisma/build/public/assets/jetbrains-mono-latin-400-normal.80a5dc9e.woff2 differ diff --git a/backend/node_modules/prisma/build/public/assets/jetbrains-mono-latin-ext-400-normal.6315c53c.woff2 b/backend/node_modules/prisma/build/public/assets/jetbrains-mono-latin-ext-400-normal.6315c53c.woff2 new file mode 100644 index 0000000000000000000000000000000000000000..37c99bf34dc01101bf1a5e24531b2b4a18511f36 Binary files /dev/null and b/backend/node_modules/prisma/build/public/assets/jetbrains-mono-latin-ext-400-normal.6315c53c.woff2 differ diff --git a/backend/node_modules/prisma/build/public/assets/logotype.a960b169.svg b/backend/node_modules/prisma/build/public/assets/logotype.a960b169.svg new file mode 100644 index 0000000000000000000000000000000000000000..7c65c04a6ff408b801dc52a9478ac1b4f3353f11 --- /dev/null +++ b/backend/node_modules/prisma/build/public/assets/logotype.a960b169.svg @@ -0,0 +1,4 @@ + + + + diff --git a/backend/node_modules/prisma/build/public/assets/maximize.ce1a88fc.svg b/backend/node_modules/prisma/build/public/assets/maximize.ce1a88fc.svg new file mode 100644 index 0000000000000000000000000000000000000000..956b1be7b5a2290ec705477c7d29b1a7a203abb4 --- /dev/null +++ b/backend/node_modules/prisma/build/public/assets/maximize.ce1a88fc.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/backend/node_modules/prisma/build/public/assets/minimize.23fe727a.svg b/backend/node_modules/prisma/build/public/assets/minimize.23fe727a.svg new file mode 100644 index 0000000000000000000000000000000000000000..e63610952826209d20f9a2c305e094740d703007 --- /dev/null +++ b/backend/node_modules/prisma/build/public/assets/minimize.23fe727a.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/backend/node_modules/prisma/build/public/assets/moon.387ab66c.svg b/backend/node_modules/prisma/build/public/assets/moon.387ab66c.svg new file mode 100644 index 0000000000000000000000000000000000000000..45b9eb34d4197ed1140bc8fb2bf6567cd299285e --- /dev/null +++ b/backend/node_modules/prisma/build/public/assets/moon.387ab66c.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/backend/node_modules/prisma/build/public/assets/number.85ddf96b.svg b/backend/node_modules/prisma/build/public/assets/number.85ddf96b.svg new file mode 100644 index 0000000000000000000000000000000000000000..63b2359278e1a1ad033b2e18e6e6e5e807fd3073 --- /dev/null +++ b/backend/node_modules/prisma/build/public/assets/number.85ddf96b.svg @@ -0,0 +1,7 @@ + + + + + + diff --git a/backend/node_modules/prisma/build/public/assets/object.0ba944a6.svg b/backend/node_modules/prisma/build/public/assets/object.0ba944a6.svg new file mode 100644 index 0000000000000000000000000000000000000000..c356985d9490eb851a8d21d9db2145e18cf9711c --- /dev/null +++ b/backend/node_modules/prisma/build/public/assets/object.0ba944a6.svg @@ -0,0 +1,5 @@ + + + + diff --git a/backend/node_modules/prisma/build/public/assets/panel-left.a81e4b97.svg b/backend/node_modules/prisma/build/public/assets/panel-left.a81e4b97.svg new file mode 100644 index 0000000000000000000000000000000000000000..b1a53155de4bb6af28430a4c363b89e8dd2fd8d6 --- /dev/null +++ b/backend/node_modules/prisma/build/public/assets/panel-left.a81e4b97.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/backend/node_modules/prisma/build/public/assets/play.8811691e.svg b/backend/node_modules/prisma/build/public/assets/play.8811691e.svg new file mode 100644 index 0000000000000000000000000000000000000000..ded6cd45aace0b9148f149681abe268ac7a8a792 --- /dev/null +++ b/backend/node_modules/prisma/build/public/assets/play.8811691e.svg @@ -0,0 +1,6 @@ + + + \ No newline at end of file diff --git a/backend/node_modules/prisma/build/public/assets/plus.8fbf7ad3.svg b/backend/node_modules/prisma/build/public/assets/plus.8fbf7ad3.svg new file mode 100644 index 0000000000000000000000000000000000000000..164f96e4b0f2fdd6b9665812ba11cf2328ef5d18 --- /dev/null +++ b/backend/node_modules/prisma/build/public/assets/plus.8fbf7ad3.svg @@ -0,0 +1,4 @@ + + + diff --git a/backend/node_modules/prisma/build/public/assets/refresh.d5448ccc.svg b/backend/node_modules/prisma/build/public/assets/refresh.d5448ccc.svg new file mode 100644 index 0000000000000000000000000000000000000000..2e7e0fa81aedb383545e5a1ea75bd8a8efc27fe4 --- /dev/null +++ b/backend/node_modules/prisma/build/public/assets/refresh.d5448ccc.svg @@ -0,0 +1,4 @@ + + + \ No newline at end of file diff --git a/backend/node_modules/prisma/build/public/assets/search.2ed766ce.svg b/backend/node_modules/prisma/build/public/assets/search.2ed766ce.svg new file mode 100644 index 0000000000000000000000000000000000000000..724b384ca2648bd273eb05c839b5126059dfff79 --- /dev/null +++ b/backend/node_modules/prisma/build/public/assets/search.2ed766ce.svg @@ -0,0 +1,7 @@ + + + + \ No newline at end of file diff --git a/backend/node_modules/prisma/build/public/assets/settings.5ad25af2.svg b/backend/node_modules/prisma/build/public/assets/settings.5ad25af2.svg new file mode 100644 index 0000000000000000000000000000000000000000..c80509b9071da2060c7bf60738d9679705bf8ed9 --- /dev/null +++ b/backend/node_modules/prisma/build/public/assets/settings.5ad25af2.svg @@ -0,0 +1,8 @@ + + + + \ No newline at end of file diff --git a/backend/node_modules/prisma/build/public/assets/string.ea615a24.svg b/backend/node_modules/prisma/build/public/assets/string.ea615a24.svg new file mode 100644 index 0000000000000000000000000000000000000000..69e8115317393bd48c8346d8489e3e1b985bb943 --- /dev/null +++ b/backend/node_modules/prisma/build/public/assets/string.ea615a24.svg @@ -0,0 +1,4 @@ + + + diff --git a/backend/node_modules/prisma/build/public/assets/sun.89774753.svg b/backend/node_modules/prisma/build/public/assets/sun.89774753.svg new file mode 100644 index 0000000000000000000000000000000000000000..75de1700a7429f84c191df0414978a5207f42dd6 --- /dev/null +++ b/backend/node_modules/prisma/build/public/assets/sun.89774753.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/backend/node_modules/prisma/build/public/assets/tick-indeterminate.aec8a44d.svg b/backend/node_modules/prisma/build/public/assets/tick-indeterminate.aec8a44d.svg new file mode 100644 index 0000000000000000000000000000000000000000..590f76d9c7bd4901fc93147e3842df4194a6aaad --- /dev/null +++ b/backend/node_modules/prisma/build/public/assets/tick-indeterminate.aec8a44d.svg @@ -0,0 +1,3 @@ + + + diff --git a/backend/node_modules/prisma/build/public/assets/tick.8cbb6a93.svg b/backend/node_modules/prisma/build/public/assets/tick.8cbb6a93.svg new file mode 100644 index 0000000000000000000000000000000000000000..22012b4d1a7b09d6cfa41394d4c34c686c0d0331 --- /dev/null +++ b/backend/node_modules/prisma/build/public/assets/tick.8cbb6a93.svg @@ -0,0 +1,4 @@ + + + diff --git a/backend/node_modules/prisma/build/public/assets/vendor.js b/backend/node_modules/prisma/build/public/assets/vendor.js new file mode 100644 index 0000000000000000000000000000000000000000..8113e6ee2d6ec2858d4f18e40812b3e563ebc216 --- /dev/null +++ b/backend/node_modules/prisma/build/public/assets/vendor.js @@ -0,0 +1,441 @@ +var e=Object.defineProperty,t=Object.defineProperties,n=Object.getOwnPropertyDescriptors,r=Object.getOwnPropertySymbols,o=Object.prototype.hasOwnProperty,i=Object.prototype.propertyIsEnumerable,s=(t,n,r)=>n in t?e(t,n,{enumerable:!0,configurable:!0,writable:!0,value:r}):t[n]=r,a="undefined"!=typeof globalThis?globalThis:"undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof self?self:{},l={exports:{}},u={},c=Symbol.for("react.element"),p=Symbol.for("react.portal"),d=Symbol.for("react.fragment"),h=Symbol.for("react.strict_mode"),f=Symbol.for("react.profiler"),g=Symbol.for("react.provider"),v=Symbol.for("react.context"),y=Symbol.for("react.forward_ref"),m=Symbol.for("react.suspense"),C=Symbol.for("react.memo"),w=Symbol.for("react.lazy"),E=Symbol.iterator;var b={isMounted:function(){return!1},enqueueForceUpdate:function(){},enqueueReplaceState:function(){},enqueueSetState:function(){}},R=Object.assign,_={};function S(e,t,n){this.props=e,this.context=t,this.refs=_,this.updater=n||b}function O(){}function P(e,t,n){this.props=e,this.context=t,this.refs=_,this.updater=n||b}S.prototype.isReactComponent={},S.prototype.setState=function(e,t){if("object"!=typeof e&&"function"!=typeof e&&null!=e)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,e,t,"setState")},S.prototype.forceUpdate=function(e){this.updater.enqueueForceUpdate(this,e,"forceUpdate")},O.prototype=S.prototype;var T=P.prototype=new O;T.constructor=P,R(T,S.prototype),T.isPureReactComponent=!0;var A=Array.isArray,D=Object.prototype.hasOwnProperty,N={current:null},I={key:!0,ref:!0,__self:!0,__source:!0};function M(e,t,n){var r,o={},i=null,s=null;if(null!=t)for(r in void 0!==t.ref&&(s=t.ref),void 0!==t.key&&(i=""+t.key),t)D.call(t,r)&&!I.hasOwnProperty(r)&&(o[r]=t[r]);var a=arguments.length-2;if(1===a)o.children=n;else if(1>>1,i=e[r];if(!(0>>1;ro(l,n))uo(c,l)?(e[r]=c,e[u]=n,r=u):(e[r]=l,e[a]=n,r=a);else{if(!(uo(c,n)))break e;e[r]=c,e[u]=n,r=u}}}return t}function o(e,t){var n=e.sortIndex-t.sortIndex;return 0!==n?n:e.id-t.id}if("object"==typeof performance&&"function"==typeof performance.now){var i=performance;e.unstable_now=function(){return i.now()}}else{var s=Date,a=s.now();e.unstable_now=function(){return s.now()-a}}var l=[],u=[],c=1,p=null,d=3,h=!1,f=!1,g=!1,v="function"==typeof setTimeout?setTimeout:null,y="function"==typeof clearTimeout?clearTimeout:null,m="undefined"!=typeof setImmediate?setImmediate:null;function C(e){for(var o=n(u);null!==o;){if(null===o.callback)r(u);else{if(!(o.startTime<=e))break;r(u),o.sortIndex=o.expirationTime,t(l,o)}o=n(u)}}function w(e){if(g=!1,C(e),!f)if(null!==n(l))f=!0,I(E);else{var t=n(u);null!==t&&M(w,t.startTime-e)}}function E(t,o){f=!1,g&&(g=!1,y(S),S=-1),h=!0;var i=d;try{for(C(o),p=n(l);null!==p&&(!(p.expirationTime>o)||t&&!T());){var s=p.callback;if("function"==typeof s){p.callback=null,d=p.priorityLevel;var a=s(p.expirationTime<=o);o=e.unstable_now(),"function"==typeof a?p.callback=a:p===n(l)&&r(l),C(o)}else r(l);p=n(l)}if(null!==p)var c=!0;else{var v=n(u);null!==v&&M(w,v.startTime-o),c=!1}return c}finally{p=null,d=i,h=!1}}"undefined"!=typeof navigator&&void 0!==navigator.scheduling&&void 0!==navigator.scheduling.isInputPending&&navigator.scheduling.isInputPending.bind(navigator.scheduling);var b,R=!1,_=null,S=-1,O=5,P=-1;function T(){return!(e.unstable_now()-Pe||125s?(r.sortIndex=i,t(u,r),null===n(l)&&r===n(u)&&(g?(y(S),S=-1):g=!0,M(w,i-s))):(r.sortIndex=a,t(l,r),f||h||(f=!0,I(E))),r},e.unstable_shouldYield=T,e.unstable_wrapCallback=function(e){var t=d;return function(){var n=d;d=t;try{return e.apply(this,arguments)}finally{d=n}}}}(q),Y.exports=q; +/** + * @license React + * react-dom.production.min.js + * + * Copyright (c) Facebook, Inc. and its affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ +var $=l.exports,X=Y.exports;function Q(e){for(var t="https://reactjs.org/docs/error-decoder.html?invariant="+e,n=1;n
')||this;return n.params=t,n}return jl(t,e),t.prototype.postConstruct=function(){this.gridOptionsWrapper.setDomData(this.getGui(),t.DOM_KEY_POPUP_EDITOR_WRAPPER,!0),this.addKeyDownListener()},t.prototype.addKeyDownListener=function(){var e=this,t=this.getGui(),n=this.params;this.addManagedListener(t,"keydown",(function(t){Rr(e.gridOptionsWrapper,t,n.node,n.column,!0)||n.onKeyDown(t)}))},t.DOM_KEY_POPUP_EDITOR_WRAPPER="popupEditorWrapper",function(e,t,n,r){var o,i=arguments.length,s=i<3?t:null===r?r=Object.getOwnPropertyDescriptor(t,n):r;if("object"==typeof Reflect&&"function"==typeof Reflect.decorate)s=Reflect.decorate(e,t,n,r);else for(var a=e.length-1;a>=0;a--)(o=e[a])&&(s=(i<3?o(s):i>3?o(t,n,s):o(t,n))||s);i>3&&s&&Object.defineProperty(t,n,s)}([U],t.prototype,"postConstruct",null),t}(gi),zl=function(){var e=function(t,n){return(e=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(e,t){e.__proto__=t}||function(e,t){for(var n in t)t.hasOwnProperty(n)&&(e[n]=t[n])})(t,n)};return function(t,n){function r(){this.constructor=t}e(t,n),t.prototype=null===n?Object.create(n):(r.prototype=n.prototype,new r)}}(),Kl=function(e){function t(t,n,r,o,i){var s=e.call(this)||this;s.rendererVersion=0,s.editorVersion=0,s.beans=t,s.column=n.getColumn(),s.rowNode=n.getRowNode(),s.rowCtrl=n.getRowCtrl(),s.eRow=o,s.setTemplate('
');var a=s.getGui();s.forceWrapper=n.isForceWrapper(),s.refreshWrapper(!1);var l=function(e,t,n){var r=n||a;null!=t&&""!=t?r.setAttribute(e,t):r.removeAttribute(e)},u={addOrRemoveCssClass:function(e,t){return s.addOrRemoveCssClass(e,t)},setUserStyles:function(e){return hn(a,e)},getFocusableElement:function(){return s.getFocusableElement()},setTabIndex:function(e){return l("tabindex",e.toString())},setRole:function(e){return In(a,e)},setColId:function(e){return l("col-id",e)},setTitle:function(e){return l("title",e)},setIncludeSelection:function(e){return s.includeSelection=e},setIncludeRowDrag:function(e){return s.includeRowDrag=e},setIncludeDndSource:function(e){return s.includeDndSource=e},setRenderDetails:function(e,t,n){return s.setRenderDetails(e,t,n)},setEditDetails:function(e,t,n){return s.setEditDetails(e,t,n)},getCellEditor:function(){return s.cellEditor||null},getCellRenderer:function(){return s.cellRenderer||null},getParentOfValue:function(){return s.getParentOfValue()}};return s.cellCtrl=n,n.setComp(u,s.getGui(),s.eCellWrapper,r,i),s}return zl(t,e),t.prototype.getParentOfValue=function(){return this.eCellValue?this.eCellValue:this.eCellWrapper?this.eCellWrapper:this.getGui()},t.prototype.setRenderDetails=function(e,t,n){if(!(this.cellEditor&&!this.cellEditorPopupWrapper)){this.firstRender=null==this.firstRender;var r=this.refreshWrapper(!1);if(e)!(n||r)&&this.refreshCellRenderer(e)||(this.destroyRenderer(),this.createCellRendererInstance(e));else this.destroyRenderer(),this.insertValueWithoutCellRenderer(t)}},t.prototype.setEditDetails=function(e,t,n){e?this.createCellEditorInstance(e,t,n):this.destroyEditor()},t.prototype.removeControls=function(){this.checkboxSelectionComp=this.beans.context.destroyBean(this.checkboxSelectionComp),this.dndSourceComp=this.beans.context.destroyBean(this.dndSourceComp),this.rowDraggingComp=this.beans.context.destroyBean(this.rowDraggingComp)},t.prototype.refreshWrapper=function(e){var t=this.includeRowDrag||this.includeDndSource||this.includeSelection,n=t||this.forceWrapper,r=n&&null==this.eCellWrapper;r&&(this.eCellWrapper=an(''),this.getGui().appendChild(this.eCellWrapper));var o=!n&&null!=this.eCellWrapper;o&&(on(this.eCellWrapper),this.eCellWrapper=void 0),this.addOrRemoveCssClass("ag-cell-value",!n);var i=!e&&n,s=i&&null==this.eCellValue;s&&(this.eCellValue=an(''),this.eCellWrapper.appendChild(this.eCellValue));var a=!i&&null!=this.eCellValue;a&&(on(this.eCellValue),this.eCellValue=void 0);var l=r||o||s||a;return l&&this.removeControls(),!e&&t&&this.addControls(),l},t.prototype.addControls=function(){var e=this.eCellValue.id="cell-"+this.getCompId(),t=[];this.includeRowDrag&&null==this.rowDraggingComp&&(this.rowDraggingComp=this.cellCtrl.createRowDragComp(),this.rowDraggingComp&&this.eCellWrapper.insertBefore(this.rowDraggingComp.getGui(),this.eCellValue)),this.includeDndSource&&null==this.dndSourceComp&&(this.dndSourceComp=this.cellCtrl.createDndSource(),this.eCellWrapper.insertBefore(this.dndSourceComp.getGui(),this.eCellValue)),this.includeSelection&&(null==this.checkboxSelectionComp&&(this.checkboxSelectionComp=this.cellCtrl.createSelectionCheckbox(),this.eCellWrapper.insertBefore(this.checkboxSelectionComp.getGui(),this.eCellValue)),t.push(this.checkboxSelectionComp.getCheckboxId())),t.push(e),Vn(this.getGui(),t.join(" "))},t.prototype.createCellEditorInstance=function(e,t,n){var o=this,i=this.editorVersion,s=e.newAgStackInstance();if(s){var a=e.params;s.then((function(e){return o.afterCellEditorCreated(i,e,a,t,n)})),r(this.cellEditor)&&a.cellStartedEdit&&this.cellCtrl.focusCell(!0)}},t.prototype.insertValueWithoutCellRenderer=function(e){var t=this.getParentOfValue();rn(t);var n=null!=e?Ye(e):null;null!=n&&(t.innerHTML=n)},t.prototype.destroyEditorAndRenderer=function(){this.destroyRenderer(),this.destroyEditor()},t.prototype.destroyRenderer=function(){var e=this.beans.context;this.cellRenderer=e.destroyBean(this.cellRenderer),on(this.cellRendererGui),this.cellRendererGui=null,this.rendererVersion++},t.prototype.destroyEditor=function(){var e=this.beans.context;this.hideEditorPopup&&this.hideEditorPopup(),this.hideEditorPopup=void 0,this.cellEditor=e.destroyBean(this.cellEditor),this.cellEditorPopupWrapper=e.destroyBean(this.cellEditorPopupWrapper),on(this.cellEditorGui),this.cellEditorGui=null,this.editorVersion++},t.prototype.refreshCellRenderer=function(e){if(null==this.cellRenderer||null==this.cellRenderer.refresh)return!1;if(this.cellRendererClass!==e.componentClass)return!1;var t=this.cellRenderer.refresh(e.params);return!0===t||void 0===t},t.prototype.createCellRendererInstance=function(e){var t=this,n=this.beans.gridOptionsWrapper.isAngularCompileRows(),r=this.beans.gridOptionsWrapper.isSuppressAnimationFrame(),o=!n&&!r,i=this.rendererVersion,s=e.componentClass,a=function(){if(!(t.rendererVersion!==i||!t.isAlive())){var n=e.newAgStackInstance(),r=t.afterCellRendererCreated.bind(t,i,s);n&&n.then(r)}};o&&this.firstRender?this.beans.animationFrameService.createTask(a,this.rowNode.rowIndex,"createTasksP2"):a()},t.prototype.getCtrl=function(){return this.cellCtrl},t.prototype.getRowCtrl=function(){return this.rowCtrl},t.prototype.getCellRenderer=function(){return this.cellRenderer},t.prototype.getCellEditor=function(){return this.cellEditor},t.prototype.afterCellRendererCreated=function(e,t,n){if(!this.isAlive()||e!==this.rendererVersion)this.beans.context.destroyBean(n);else if(this.cellRenderer=n,this.cellRendererClass=t,this.cellRendererGui=this.cellRenderer.getGui(),null!=this.cellRendererGui){var r=this.getParentOfValue();rn(r),r.appendChild(this.cellRendererGui)}},t.prototype.afterCellEditorCreated=function(e,t,n,r,o){if(e!==this.editorVersion)this.beans.context.destroyBean(t);else{if(t.isCancelBeforeStart&&t.isCancelBeforeStart())return this.beans.context.destroyBean(t),void this.cellCtrl.stopEditing();if(!t.getGui)return console.warn("AG Grid: cellEditor for column "+this.column.getId()+" is missing getGui() method"),void this.beans.context.destroyBean(t);this.cellEditor=t,this.cellEditorGui=t.getGui(),r||void 0!==t.isPopup&&t.isPopup()?(r||this.cellCtrl.hackSayEditingInPopup(),this.addPopupCellEditor(n,o)):this.addInCellEditor(),t.afterGuiAttached&&t.afterGuiAttached()}},t.prototype.addInCellEditor=function(){var e=this.getGui(),t=this.beans.gridOptionsWrapper.getDocument();(e.contains(t.activeElement)&&e.focus(),this.destroyRenderer(),this.refreshWrapper(!0),this.clearParentOfValue(),this.cellEditorGui)&&this.getParentOfValue().appendChild(this.cellEditorGui)},t.prototype.addPopupCellEditor=function(e,t){var n=this;this.beans.gridOptionsWrapper.isFullRowEdit()&&console.warn("AG Grid: popup cellEditor does not work with fullRowEdit - you cannot use them both - either turn off fullRowEdit, or stop using popup editors.");var r=this.cellEditor;this.cellEditorPopupWrapper=this.beans.context.createBean(new Ul(e));var o=this.cellEditorPopupWrapper.getGui();this.cellEditorGui&&o.appendChild(this.cellEditorGui);var i=this.beans.popupService,s=this.beans.gridOptionsWrapper.isStopEditingWhenCellsLoseFocus(),a=null!=t?t:r.getPopupPosition?r.getPopupPosition():"over",l={column:this.column,rowNode:this.rowNode,type:"popupCellEditor",eventSource:this.getGui(),ePopup:o,keepWithinBounds:!0},u="under"===a?i.positionPopupUnderComponent.bind(i,l):i.positionPopupOverComponent.bind(i,l),c=this.beans.gridOptionsWrapper.getLocaleTextFunc(),p=i.addPopup({modal:s,eChild:o,closeOnEsc:!0,closedCallback:function(){n.cellCtrl.onPopupEditorClosed()},anchorToElement:this.getGui(),positionCallback:u,ariaLabel:c("ariaLabelCellEditor","Cell Editor")});p&&(this.hideEditorPopup=p.hideFunc)},t.prototype.detach=function(){this.eRow.removeChild(this.getGui())},t.prototype.destroy=function(){this.cellCtrl.stopEditing(),this.destroyEditorAndRenderer(),this.removeControls(),e.prototype.destroy.call(this)},t.prototype.clearParentOfValue=function(){var e=this.getGui(),t=this.beans.gridOptionsWrapper.getDocument();e.contains(t.activeElement)&&e.focus({preventScroll:!0}),rn(this.getParentOfValue())},t}(Yr),Yl=function(){var e=function(t,n){return(e=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(e,t){e.__proto__=t}||function(e,t){for(var n in t)t.hasOwnProperty(n)&&(e[n]=t[n])})(t,n)};return function(t,n){function r(){this.constructor=t}e(t,n),t.prototype=null===n?Object.create(n):(r.prototype=n.prototype,new r)}}(),ql=function(e){function t(t,n,r){var o=e.call(this)||this;o.cellComps={},o.beans=n,o.rowCtrl=t,o.setTemplate('
');var i=o.getGui(),s=i.style,a={setDomOrder:function(e){return o.domOrder=e},setCellCtrls:function(e){return o.setCellCtrls(e)},showFullWidth:function(e){return o.showFullWidth(e)},getFullWidthCellRenderer:function(){return o.getFullWidthCellRenderer()},addOrRemoveCssClass:function(e,t){return o.addOrRemoveCssClass(e,t)},setUserStyles:function(e){return hn(i,e)},setTop:function(e){return s.top=e},setTransform:function(e){return s.transform=e},setRowIndex:function(e){return i.setAttribute("row-index",e)},setRole:function(e){return In(i,e)},setRowId:function(e){return i.setAttribute("row-id",e)},setRowBusinessKey:function(e){return i.setAttribute("row-business-key",e)},setTabIndex:function(e){return i.setAttribute("tabindex",e.toString())}};return t.setComp(a,o.getGui(),r),o}return Yl(t,e),t.prototype.getInitialStyle=function(){var e=this.rowCtrl.getInitialTransform(),t=this.rowCtrl.getInitialRowTop();return e?"transform: "+e:"top: "+t},t.prototype.showFullWidth=function(e){var t=this,n=e.newAgStackInstance();n&&n.then((function(e){if(t.isAlive()){var n=e.getGui();t.getGui().appendChild(n),t.rowCtrl.setupDetailRowAutoHeight(n),t.setFullWidthRowComp(e)}else t.beans.context.destroyBean(e)}))},t.prototype.setCellCtrls=function(e){var t=this,n=Object.assign({},this.cellComps);e.forEach((function(e){var r=e.getInstanceId();null==t.cellComps[r]?t.newCellComp(e):n[r]=null}));var r=w(n).filter((function(e){return null!=e}));this.destroyCells(r),this.ensureDomOrder(e)},t.prototype.ensureDomOrder=function(e){var t=this;if(this.domOrder){var n=[];e.forEach((function(e){var r=t.cellComps[e.getInstanceId()];r&&n.push(r.getGui())})),pn(this.getGui(),n)}},t.prototype.newCellComp=function(e){var t=new Kl(this.beans,e,this.rowCtrl.isPrintLayout(),this.getGui(),this.rowCtrl.isEditing());this.cellComps[e.getInstanceId()]=t,this.getGui().appendChild(t.getGui())},t.prototype.destroy=function(){e.prototype.destroy.call(this),this.destroyAllCells()},t.prototype.destroyAllCells=function(){var e=w(this.cellComps).filter((function(e){return null!=e}));this.destroyCells(e)},t.prototype.setFullWidthRowComp=function(e){var t=this;this.fullWidthCellRenderer&&console.error("AG Grid - should not be setting fullWidthRowComponent twice"),this.fullWidthCellRenderer=e,this.addDestroyFunc((function(){t.fullWidthCellRenderer=t.beans.context.destroyBean(t.fullWidthCellRenderer)}))},t.prototype.getFullWidthCellRenderer=function(){return this.fullWidthCellRenderer},t.prototype.destroyCells=function(e){var t=this;e.forEach((function(e){if(e){var n=e.getCtrl().getInstanceId();t.cellComps[n]===e&&(e.detach(),e.destroy(),t.cellComps[n]=null)}}))},t}(Yr),$l=function(){var e=function(t,n){return(e=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(e,t){e.__proto__=t}||function(e,t){for(var n in t)t.hasOwnProperty(n)&&(e[n]=t[n])})(t,n)};return function(t,n){function r(){this.constructor=t}e(t,n),t.prototype=null===n?Object.create(n):(r.prototype=n.prototype,new r)}}(),Xl=function(){return(Xl=Object.assign||function(e){for(var t,n=1,r=arguments.length;n=0;a--)(o=e[a])&&(s=(i<3?o(s):i>3?o(t,n,s):o(t,n))||s);return i>3&&s&&Object.defineProperty(t,n,s),s};var Zl,Jl=function(t){function n(){var n,r,o,i,s=t.call(this,(n=Yr.elementGettingCreated.getAttribute("name"),r=Tl.getRowContainerCssClasses(n),o=n===e.RowContainerName.CENTER,i=n===e.RowContainerName.TOP_CENTER||n===e.RowContainerName.BOTTOM_CENTER,o?'':i?'':'
'))||this;return s.rowComps={},s.name=Yr.elementGettingCreated.getAttribute("name"),s.type=_l(s.name),s}return $l(n,t),n.prototype.postConstruct=function(){var e=this,t={setViewportHeight:function(t){return e.eViewport.style.height=t},setRowCtrls:function(t){return e.setRowCtrls(t)},setDomOrder:function(t){e.domOrder=t},setContainerWidth:function(t){return e.eContainer.style.width=t}};this.createManagedBean(new Tl(this.name)).setComp(t,this.eContainer,this.eViewport,this.eWrapper)},n.prototype.preDestroy=function(){this.setRowCtrls([])},n.prototype.setRowCtrls=function(e){var t=this,n=Xl({},this.rowComps);this.rowComps={},this.lastPlacedElement=null;e.forEach((function(e){var r=e.getInstanceId(),o=n[r];if(o)t.rowComps[r]=o,delete n[r],t.ensureDomOrder(o.getGui());else{var i=t.newRowComp(e);t.rowComps[r]=i,t.appendRow(i.getGui())}})),w(n).forEach((function(e){t.eContainer.removeChild(e.getGui()),e.destroy()})),In(this.eContainer,e.length?"rowgroup":"presentation")},n.prototype.appendRow=function(e){this.domOrder?dn(this.eContainer,e,this.lastPlacedElement):this.eContainer.appendChild(e),this.lastPlacedElement=e},n.prototype.ensureDomOrder=function(e){this.domOrder&&(cn(this.eContainer,e,this.lastPlacedElement),this.lastPlacedElement=e)},n.prototype.newRowComp=function(e){return Tl.getPinned(this.name),new ql(e,this.beans,this.type)},Ql([Y("beans")],n.prototype,"beans",void 0),Ql([qr("eViewport")],n.prototype,"eViewport",void 0),Ql([qr("eContainer")],n.prototype,"eContainer",void 0),Ql([qr("eWrapper")],n.prototype,"eWrapper",void 0),Ql([U],n.prototype,"postConstruct",null),Ql([z],n.prototype,"preDestroy",null),n}(Yr),eu=function(e,t,n,r){var o,i=arguments.length,s=i<3?t:null===r?r=Object.getOwnPropertyDescriptor(t,n):r;if("object"==typeof Reflect&&"function"==typeof Reflect.decorate)s=Reflect.decorate(e,t,n,r);else for(var a=e.length-1;a>=0;a--)(o=e[a])&&(s=(i<3?o(s):i>3?o(t,n,s):o(t,n))||s);return i>3&&s&&Object.defineProperty(t,n,s),s},tu=function(){function e(e){this.columnsToAggregate=[],this.columnsToGroup=[],this.columnsToPivot=[],this.pinned=e}return e.prototype.onDragEnter=function(e){var t=this;if(this.clearColumnsList(),!this.gridOptionsWrapper.isFunctionsReadOnly()){var n=e.dragItem.columns;n&&n.forEach((function(e){e.isPrimary()&&(e.isAnyFunctionActive()||(e.isAllowValue()?t.columnsToAggregate.push(e):e.isAllowRowGroup()?t.columnsToGroup.push(e):e.isAllowPivot()&&t.columnsToPivot.push(e)))}))}},e.prototype.getIconName=function(){return this.columnsToAggregate.length+this.columnsToGroup.length+this.columnsToPivot.length>0?this.pinned?Bi.ICON_PINNED:Bi.ICON_MOVE:null},e.prototype.onDragLeave=function(e){this.clearColumnsList()},e.prototype.clearColumnsList=function(){this.columnsToAggregate.length=0,this.columnsToGroup.length=0,this.columnsToPivot.length=0},e.prototype.onDragging=function(e){},e.prototype.onDragStop=function(e){this.columnsToAggregate.length>0&&this.columnModel.addValueColumns(this.columnsToAggregate,"toolPanelDragAndDrop"),this.columnsToGroup.length>0&&this.columnModel.addRowGroupColumns(this.columnsToGroup,"toolPanelDragAndDrop"),this.columnsToPivot.length>0&&this.columnModel.addPivotColumns(this.columnsToPivot,"toolPanelDragAndDrop")},eu([Y("columnModel")],e.prototype,"columnModel",void 0),eu([Y("gridOptionsWrapper")],e.prototype,"gridOptionsWrapper",void 0),e}(),nu=function(e,t,n,r){var o,i=arguments.length,s=i<3?t:null===r?r=Object.getOwnPropertyDescriptor(t,n):r;if("object"==typeof Reflect&&"function"==typeof Reflect.decorate)s=Reflect.decorate(e,t,n,r);else for(var a=e.length-1;a>=0;a--)(o=e[a])&&(s=(i<3?o(s):i>3?o(t,n,s):o(t,n))||s);return i>3&&s&&Object.defineProperty(t,n,s),s},ru=function(){function t(e,t){this.needToMoveLeft=!1,this.needToMoveRight=!1,this.pinned=e,this.eContainer=t,this.centerContainer=!n(e)}return t.prototype.init=function(){var e=this;this.ctrlsService.whenReady((function(){e.gridBodyCon=e.ctrlsService.getGridBodyCtrl()}))},t.prototype.getIconName=function(){return this.pinned?Bi.ICON_PINNED:Bi.ICON_MOVE},t.prototype.onDragEnter=function(t){var n=t.dragItem.columns;if(t.dragSource.type===e.DragSourceType.ToolPanel)this.setColumnsVisible(n,!0,"uiColumnDragged");else{var r=t.dragItem.visibleState,o=(n||[]).filter((function(e){return r[e.getId()]}));this.setColumnsVisible(o,!0,"uiColumnDragged")}this.setColumnsPinned(n,this.pinned,"uiColumnDragged"),this.onDragging(t,!0)},t.prototype.onDragLeave=function(e){if(!this.gridOptionsWrapper.isSuppressDragLeaveHidesColumns()&&!e.fromNudge){var t=e.dragSource.getDragItem().columns;this.setColumnsVisible(t,!1,"uiColumnDragged")}this.ensureIntervalCleared()},t.prototype.setColumnsVisible=function(e,t,n){if(void 0===n&&(n="api"),e){var r=e.filter((function(e){return!e.getColDef().lockVisible}));this.columnModel.setColumnsVisible(r,t,n)}},t.prototype.setColumnsPinned=function(e,t,n){if(void 0===n&&(n="api"),e){var r=e.filter((function(e){return!e.getColDef().lockPinned}));this.columnModel.setColumnsPinned(r,t,n)}},t.prototype.onDragStop=function(){this.ensureIntervalCleared()},t.prototype.normaliseX=function(e){this.gridOptionsWrapper.isEnableRtl()&&(e=this.eContainer.clientWidth-e);return this.centerContainer&&(e+=this.ctrlsService.getCenterRowContainerCtrl().getCenterViewportScrollLeft()),e},t.prototype.checkCenterForScrolling=function(e){if(this.centerContainer){var t=this.ctrlsService.getCenterRowContainerCtrl().getCenterViewportScrollLeft(),n=t+this.ctrlsService.getCenterRowContainerCtrl().getCenterWidth();this.gridOptionsWrapper.isEnableRtl()?(this.needToMoveRight=en-50):(this.needToMoveLeft=en-50),this.needToMoveLeft||this.needToMoveRight?this.ensureIntervalStarted():this.ensureIntervalCleared()}},t.prototype.onDragging=function(e,t){var n=this;if(void 0===t&&(t=!1),this.lastDraggingEvent=e,!r(e.hDirection)){var o=this.normaliseX(e.x);t||this.checkCenterForScrolling(o);var i=this.normaliseDirection(e.hDirection),s=e.dragSource.type,a=e.dragSource.getDragItem().columns;a=a.filter((function(e){return!e.getColDef().lockPinned||e.getPinned()==n.pinned})),this.attemptMoveColumns(s,a,i,o,t)}},t.prototype.normaliseDirection=function(t){if(!this.gridOptionsWrapper.isEnableRtl())return t;switch(t){case e.HorizontalDirection.Left:return e.HorizontalDirection.Right;case e.HorizontalDirection.Right:return e.HorizontalDirection.Left;default:console.error("AG Grid: Unknown direction "+t)}},t.prototype.calculateOldIndex=function(e){var t=this.columnModel.getAllGridColumns(),n=ce(e.map((function(e){return t.indexOf(e)}))),r=n[0];return le(n)-r!==n.length-1?null:r},t.prototype.attemptMoveColumns=function(t,n,r,o,i){var s=r===e.HorizontalDirection.Left,a=r===e.HorizontalDirection.Right,l=n.slice();this.columnModel.sortColumnsLikeGridColumns(l);var u=this.calculateValidMoves(l,a,o),c=this.calculateOldIndex(l);if(0!==u.length){var p=u[0],d=null!==c&&!i;if(t==e.DragSourceType.HeaderCell&&(d=null!==c),d){if(s&&p>=c)return;if(a&&p<=c)return}for(var h=0;h0){for(var d=0;d0){var h=a[u-1];r=l.indexOf(h)+1}else-1===(r=l.indexOf(a[0]))&&(r=0);var f=[r],g=function(e,t){return e-t};if(t){for(var v=r+1,y=i.length-1;v<=y;)f.push(v),v++;f.sort(g)}else{v=r,y=i.length-1;for(var m=i[v];v<=y&&this.isColumnHidden(o,m);)v++,f.push(v),m=i[v];v=r-1;for(;v>=0;)f.push(v),v--;f.sort(g).reverse()}return f},t.prototype.isColumnHidden=function(e,t){return e.indexOf(t)<0},t.prototype.ensureIntervalStarted=function(){this.movingIntervalId||(this.intervalCount=0,this.failedMoveAttempts=0,this.movingIntervalId=window.setInterval(this.moveInterval.bind(this),100),this.needToMoveLeft?this.dragAndDropService.setGhostIcon(Bi.ICON_LEFT,!0):this.dragAndDropService.setGhostIcon(Bi.ICON_RIGHT,!0))},t.prototype.ensureIntervalCleared=function(){this.movingIntervalId&&(window.clearInterval(this.movingIntervalId),this.movingIntervalId=null,this.dragAndDropService.setGhostIcon(Bi.ICON_MOVE))},t.prototype.moveInterval=function(){var e;this.intervalCount++,(e=10+5*this.intervalCount)>100&&(e=100);var t=null,n=this.gridBodyCon.getScrollFeature();if(this.needToMoveLeft?t=n.scrollHorizontally(-e):this.needToMoveRight&&(t=n.scrollHorizontally(e)),0!==t)this.onDragging(this.lastDraggingEvent),this.failedMoveAttempts=0;else{this.failedMoveAttempts++;var r=this.lastDraggingEvent.dragItem.columns.filter((function(e){return!e.getColDef().lockPinned}));if(r.length>0&&(this.dragAndDropService.setGhostIcon(Bi.ICON_PINNED),this.failedMoveAttempts>7)){var o=this.needToMoveLeft?ne.PINNED_LEFT:ne.PINNED_RIGHT;this.setColumnsPinned(r,o,"uiColumnDragged"),this.dragAndDropService.nudge()}}},nu([Y("columnModel")],t.prototype,"columnModel",void 0),nu([Y("dragAndDropService")],t.prototype,"dragAndDropService",void 0),nu([Y("gridOptionsWrapper")],t.prototype,"gridOptionsWrapper",void 0),nu([Y("ctrlsService")],t.prototype,"ctrlsService",void 0),nu([U],t.prototype,"init",null),t}(),ou=function(){var e=function(t,n){return(e=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(e,t){e.__proto__=t}||function(e,t){for(var n in t)t.hasOwnProperty(n)&&(e[n]=t[n])})(t,n)};return function(t,n){function r(){this.constructor=t}e(t,n),t.prototype=null===n?Object.create(n):(r.prototype=n.prototype,new r)}}(),iu=function(e,t,n,r){var o,i=arguments.length,s=i<3?t:null===r?r=Object.getOwnPropertyDescriptor(t,n):r;if("object"==typeof Reflect&&"function"==typeof Reflect.decorate)s=Reflect.decorate(e,t,n,r);else for(var a=e.length-1;a>=0;a--)(o=e[a])&&(s=(i<3?o(s):i>3?o(t,n,s):o(t,n))||s);return i>3&&s&&Object.defineProperty(t,n,s),s},su=function(t){function n(e,n){var r=t.call(this)||this;return r.pinned=e,r.eContainer=n,r}return ou(n,t),n.prototype.postConstruct=function(){var e=this;this.ctrlsService.whenReady((function(t){switch(e.pinned){case ne.PINNED_LEFT:e.eSecondaryContainers=[[t.gridBodyCtrl.getBodyViewportElement(),t.leftRowContainerCtrl.getContainerElement()],[t.bottomLeftRowContainerCtrl.getContainerElement()],[t.topLeftRowContainerCtrl.getContainerElement()]];break;case ne.PINNED_RIGHT:e.eSecondaryContainers=[[t.gridBodyCtrl.getBodyViewportElement(),t.rightRowContainerCtrl.getContainerElement()],[t.bottomRightRowContainerCtrl.getContainerElement()],[t.topRightRowContainerCtrl.getContainerElement()]];break;default:e.eSecondaryContainers=[[t.gridBodyCtrl.getBodyViewportElement(),t.centerRowContainerCtrl.getViewportElement()],[t.bottomCenterRowContainerCtrl.getViewportElement()],[t.topCenterRowContainerCtrl.getViewportElement()]]}}))},n.prototype.isInterestedIn=function(t){return t===e.DragSourceType.HeaderCell||t===e.DragSourceType.ToolPanel&&this.gridOptionsWrapper.isAllowDragFromColumnsToolPanel()},n.prototype.getSecondaryContainers=function(){return this.eSecondaryContainers},n.prototype.getContainer=function(){return this.eContainer},n.prototype.init=function(){this.moveColumnFeature=this.createManagedBean(new ru(this.pinned,this.eContainer)),this.bodyDropPivotTarget=this.createManagedBean(new tu(this.pinned)),this.dragAndDropService.addDropTarget(this)},n.prototype.getIconName=function(){return this.currentDropListener.getIconName()},n.prototype.isDropColumnInPivotMode=function(t){return this.columnModel.isPivotMode()&&t.dragSource.type===e.DragSourceType.ToolPanel},n.prototype.onDragEnter=function(e){this.currentDropListener=this.isDropColumnInPivotMode(e)?this.bodyDropPivotTarget:this.moveColumnFeature,this.currentDropListener.onDragEnter(e)},n.prototype.onDragLeave=function(e){this.currentDropListener.onDragLeave(e)},n.prototype.onDragging=function(e){this.currentDropListener.onDragging(e)},n.prototype.onDragStop=function(e){this.currentDropListener.onDragStop(e)},iu([Y("dragAndDropService")],n.prototype,"dragAndDropService",void 0),iu([Y("columnModel")],n.prototype,"columnModel",void 0),iu([Y("ctrlsService")],n.prototype,"ctrlsService",void 0),iu([U],n.prototype,"postConstruct",null),iu([U],n.prototype,"init",null),n}(Le),au=function(e,t){var n="function"==typeof Symbol&&e[Symbol.iterator];if(!n)return e;var r,o,i=n.call(e),s=[];try{for(;(void 0===t||t-- >0)&&!(r=i.next()).done;)s.push(r.value)}catch(a){o={error:a}}finally{try{r&&!r.done&&(n=i.return)&&n.call(i)}finally{if(o)throw o.error}}return s},lu=function(){function e(){}return e.getHeaderClassesFromColDef=function(e,t,n,o){return r(e)?[]:this.getColumnClassesFromCollDef(e.headerClass,e,t,n,o)},e.getToolPanelClassesFromColDef=function(e,t,n,o){return r(e)?[]:this.getColumnClassesFromCollDef(e.toolPanelClass,e,t,n,o)},e.getClassParams=function(e,t,n,r){return{colDef:e,column:n,columnGroup:r,api:t.getApi(),columnApi:t.getColumnApi(),context:t.getContext()}},e.getColumnClassesFromCollDef=function(e,t,n,o,i){if(r(e))return[];var s;"function"==typeof e?s=e(this.getClassParams(t,n,o,i)):s=e;return"string"==typeof s?[s]:Array.isArray(s)?function(){for(var e=[],t=0;t=0;a--)(o=e[a])&&(s=(i<3?o(s):i>3?o(t,n,s):o(t,n))||s);return i>3&&s&&Object.defineProperty(t,n,s),s},pu=function(e){function t(n){var r=e.call(this,t.TEMPLATE,n)||this;return r.headerCompVersion=0,r.column=n.getColumnGroupChild(),r.pinned=n.getPinned(),r}return uu(t,e),t.prototype.postConstruct=function(){var e=this,t=this.getGui(),n=function(e,n,r){var o=r||t;null!=n&&""!=n?o.setAttribute(e,n):o.removeAttribute(e)},r={setWidth:function(e){return t.style.width=e},addOrRemoveCssClass:function(t,n){return e.addOrRemoveCssClass(t,n)},setColId:function(e){return n("col-id",e)},setTitle:function(e){return n("title",e)},setAriaDescription:function(e){return kn(t,e)},setAriaSort:function(e){return e?Zn(t,e):Jn(t)},setUserCompDetails:function(t){return e.setUserCompDetails(t)},getUserCompInstance:function(){return e.headerComp}};this.ctrl.setComp(r,this.getGui(),this.eResize);var o=this.ctrl.getSelectAllGui();this.eResize.insertAdjacentElement("afterend",o)},t.prototype.destroyHeaderComp=function(){this.headerComp&&(this.getGui().removeChild(this.headerCompGui),this.headerComp=this.destroyBean(this.headerComp),this.headerCompGui=void 0)},t.prototype.setUserCompDetails=function(e){var t=this;this.headerCompVersion++;var n=this.headerCompVersion;e.newAgStackInstance().then((function(e){return t.afterCompCreated(n,e)}))},t.prototype.afterCompCreated=function(e,t){e==this.headerCompVersion&&this.isAlive()?(this.destroyHeaderComp(),this.headerComp=t,this.headerCompGui=t.getGui(),this.getGui().appendChild(this.headerCompGui),this.ctrl.setDragSource(this.headerCompGui)):this.destroyBean(t)},t.TEMPLATE='
\n \n
',cu([qr("eResize")],t.prototype,"eResize",void 0),cu([U],t.prototype,"postConstruct",null),cu([z],t.prototype,"destroyHeaderComp",null),t}(js),du=function(){var e=function(t,n){return(e=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(e,t){e.__proto__=t}||function(e,t){for(var n in t)t.hasOwnProperty(n)&&(e[n]=t[n])})(t,n)};return function(t,n){function r(){this.constructor=t}e(t,n),t.prototype=null===n?Object.create(n):(r.prototype=n.prototype,new r)}}(),hu=function(e,t,n,r){var o,i=arguments.length,s=i<3?t:null===r?r=Object.getOwnPropertyDescriptor(t,n):r;if("object"==typeof Reflect&&"function"==typeof Reflect.decorate)s=Reflect.decorate(e,t,n,r);else for(var a=e.length-1;a>=0;a--)(o=e[a])&&(s=(i<3?o(s):i>3?o(t,n,s):o(t,n))||s);return i>3&&s&&Object.defineProperty(t,n,s),s},fu=function(e){function t(n){return e.call(this,t.TEMPLATE,n)||this}return du(t,e),t.prototype.postConstruct=function(){var e=this,t=this.getGui(),n=function(e,n){return null!=n?t.setAttribute(e,n):t.removeAttribute(e)},r={addOrRemoveCssClass:function(t,n){return e.addOrRemoveCssClass(t,n)},addOrRemoveResizableCssClass:function(t,n){return e.eResize.classList.toggle(t,n)},setWidth:function(e){return t.style.width=e},setColId:function(e){return t.setAttribute("col-id",e)},setAriaExpanded:function(e){return n("aria-expanded",e)},setTitle:function(e){return n("title",e)},setUserCompDetails:function(t){return e.setUserCompDetails(t)}};this.ctrl.setComp(r,t,this.eResize)},t.prototype.setUserCompDetails=function(e){var t=this;e.newAgStackInstance().then((function(e){return t.afterHeaderCompCreated(e)}))},t.prototype.afterHeaderCompCreated=function(e){var t=this,n=function(){return t.destroyBean(e)};this.isAlive()?(this.getGui().appendChild(e.getGui()),this.addDestroyFunc(n),this.ctrl.setDragSource(e.getGui())):n()},t.TEMPLATE='
\n \n
',hu([Y("userComponentFactory")],t.prototype,"userComponentFactory",void 0),hu([qr("eResize")],t.prototype,"eResize",void 0),hu([U],t.prototype,"postConstruct",null),t}(js),gu=function(){var e=function(t,n){return(e=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(e,t){e.__proto__=t}||function(e,t){for(var n in t)t.hasOwnProperty(n)&&(e[n]=t[n])})(t,n)};return function(t,n){function r(){this.constructor=t}e(t,n),t.prototype=null===n?Object.create(n):(r.prototype=n.prototype,new r)}}(),vu=function(e,t,n,r){var o,i=arguments.length,s=i<3?t:null===r?r=Object.getOwnPropertyDescriptor(t,n):r;if("object"==typeof Reflect&&"function"==typeof Reflect.decorate)s=Reflect.decorate(e,t,n,r);else for(var a=e.length-1;a>=0;a--)(o=e[a])&&(s=(i<3?o(s):i>3?o(t,n,s):o(t,n))||s);return i>3&&s&&Object.defineProperty(t,n,s),s}; +/** + * @ag-grid-community/core - Advanced Data Grid / Data Table supporting Javascript / Typescript / React / Angular / Vue + * @version v27.3.0 + * @link https://www.ag-grid.com/ + * @license MIT + */(Zl=e.HeaderRowType||(e.HeaderRowType={})).COLUMN_GROUP="group",Zl.COLUMN="column",Zl.FLOATING_FILTER="filter";var yu,mu=function(t){function n(n){var r=t.call(this)||this;r.headerComps={};var o=n.getType()==e.HeaderRowType.COLUMN_GROUP?"ag-header-row-column-group":n.getType()==e.HeaderRowType.FLOATING_FILTER?"ag-header-row-column-filter":"ag-header-row-column";return r.setTemplate('
'),r.ctrl=n,r}return gu(n,t),n.prototype.init=function(){var e=this,t={setTransform:function(t){return e.getGui().style.transform=t},setHeight:function(t){return e.getGui().style.height=t},setTop:function(t){return e.getGui().style.top=t},setHeaderCtrls:function(t){return e.setHeaderCtrls(t)},setWidth:function(t){return e.getGui().style.width=t},setAriaRowIndex:function(t){return qn(e.getGui(),t)}};this.ctrl.setComp(t)},n.prototype.destroyHeaderCtrls=function(){this.setHeaderCtrls([])},n.prototype.setHeaderCtrls=function(e){var t=this;if(this.isAlive()){var n=this.headerComps;if(this.headerComps={},e.forEach((function(e){var r=e.getInstanceId(),o=n[r];delete n[r],null==o&&(o=t.createHeaderComp(e),t.getGui().appendChild(o.getGui())),t.headerComps[r]=o})),h(n,(function(e,n){t.getGui().removeChild(n.getGui()),t.destroyBean(n)})),this.gridOptionsWrapper.isEnsureDomOrder()){var r=w(this.headerComps);r.sort((function(e,t){return e.getCtrl().getColumnGroupChild().getLeft()-t.getCtrl().getColumnGroupChild().getLeft()}));var o=r.map((function(e){return e.getGui()}));pn(this.getGui(),o)}}},n.prototype.createHeaderComp=function(t){var n;switch(this.ctrl.getType()){case e.HeaderRowType.COLUMN_GROUP:n=new fu(t);break;case e.HeaderRowType.FLOATING_FILTER:n=new Ks(t);break;default:n=new pu(t)}return this.createBean(n),n.setParentComponent(this),n},vu([U],n.prototype,"init",null),vu([z],n.prototype,"destroyHeaderCtrls",null),n}(Yr),Cu=function(){var e=function(t,n){return(e=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(e,t){e.__proto__=t}||function(e,t){for(var n in t)t.hasOwnProperty(n)&&(e[n]=t[n])})(t,n)};return function(t,n){function r(){this.constructor=t}e(t,n),t.prototype=null===n?Object.create(n):(r.prototype=n.prototype,new r)}}(),wu=0,Eu=function(e){function t(t,n){var r=e.call(this)||this;return r.lastFocusEvent=null,r.columnGroupChild=t,r.parentRowCtrl=n,r.instanceId=t.getUniqueId()+"-"+wu++,r}return Cu(t,e),t.prototype.shouldStopEventPropagation=function(e){var t=this.focusService.getFocusedHeader(),n=t.headerRowIndex,r=t.column;return _r(this.gridOptionsWrapper,e,n,r)},t.prototype.setGui=function(e){this.eGui=e,this.addDomData()},t.prototype.addDomData=function(){var e=this,n=t.DOM_DATA_KEY_HEADER_CTRL;this.gridOptionsWrapper.setDomData(this.eGui,n,this),this.addDestroyFunc((function(){return e.gridOptionsWrapper.setDomData(e.eGui,n,null)}))},t.prototype.getGui=function(){return this.eGui},t.prototype.focus=function(e){return!!this.eGui&&(this.lastFocusEvent=e||null,this.eGui.focus(),!0)},t.prototype.getRowIndex=function(){return this.parentRowCtrl.getRowIndex()},t.prototype.getParentRowCtrl=function(){return this.parentRowCtrl},t.prototype.getPinned=function(){return this.parentRowCtrl.getPinned()},t.prototype.getInstanceId=function(){return this.instanceId},t.prototype.getColumnGroupChild=function(){return this.columnGroupChild},t.DOM_DATA_KEY_HEADER_CTRL="headerCtrl",function(e,t,n,r){var o,i=arguments.length,s=i<3?t:null===r?r=Object.getOwnPropertyDescriptor(t,n):r;if("object"==typeof Reflect&&"function"==typeof Reflect.decorate)s=Reflect.decorate(e,t,n,r);else for(var a=e.length-1;a>=0;a--)(o=e[a])&&(s=(i<3?o(s):i>3?o(t,n,s):o(t,n))||s);i>3&&s&&Object.defineProperty(t,n,s)}([Y("focusService")],t.prototype,"focusService",void 0),t}(Le); +/** + * @ag-grid-community/core - Advanced Data Grid / Data Table supporting Javascript / Typescript / React / Angular / Vue + * @version v27.3.0 + * @link https://www.ag-grid.com/ + * @license MIT + */( +/** + * @ag-grid-community/core - Advanced Data Grid / Data Table supporting Javascript / Typescript / React / Angular / Vue + * @version v27.3.0 + * @link https://www.ag-grid.com/ + * @license MIT + */ +yu=e.ClientSideRowModelSteps||(e.ClientSideRowModelSteps={})).EVERYTHING="group",yu.FILTER="filter",yu.SORT="sort",yu.MAP="map",yu.AGGREGATE="aggregate",yu.FILTER_AGGREGATES="filter_aggregates",yu.PIVOT="pivot",yu.NOTHING="nothing"; +/** + * @ag-grid-community/core - Advanced Data Grid / Data Table supporting Javascript / Typescript / React / Angular / Vue + * @version v27.3.0 + * @link https://www.ag-grid.com/ + * @license MIT + */ +var bu=function(e,t,n,r){var o,i=arguments.length,s=i<3?t:null===r?r=Object.getOwnPropertyDescriptor(t,n):r;if("object"==typeof Reflect&&"function"==typeof Reflect.decorate)s=Reflect.decorate(e,t,n,r);else for(var a=e.length-1;a>=0;a--)(o=e[a])&&(s=(i<3?o(s):i>3?o(t,n,s):o(t,n))||s);return i>3&&s&&Object.defineProperty(t,n,s),s};function Ru(e){var t=e;return null!=t&&null!=t.getFrameworkComponentInstance?t.getFrameworkComponentInstance():e}var _u,Su=function(){function t(){this.detailGridInfoMap={},this.destroyCalled=!1}return t.prototype.registerOverlayWrapperComp=function(e){this.overlayWrapperComp=e},t.prototype.registerSideBarComp=function(e){this.sideBarComp=e},t.prototype.init=function(){var e=this;switch(this.rowModel.getType()){case ne.ROW_MODEL_TYPE_CLIENT_SIDE:this.clientSideRowModel=this.rowModel;break;case ne.ROW_MODEL_TYPE_INFINITE:this.infiniteRowModel=this.rowModel;break;case ne.ROW_MODEL_TYPE_SERVER_SIDE:this.serverSideRowModel=this.rowModel}this.ctrlsService.whenReady((function(){e.gridBodyCtrl=e.ctrlsService.getGridBodyCtrl()}))},t.prototype.__getAlignedGridService=function(){return this.alignedGridsService},t.prototype.__getContext=function(){return this.context},t.prototype.addDetailGridInfo=function(e,t){this.detailGridInfoMap[e]=t},t.prototype.removeDetailGridInfo=function(e){this.detailGridInfoMap[e]=void 0},t.prototype.getDetailGridInfo=function(e){return this.detailGridInfoMap[e]},t.prototype.forEachDetailGridInfo=function(e){var t=0;h(this.detailGridInfoMap,(function(r,o){n(o)&&(e(o,t),t++)}))},t.prototype.getDataAsCsv=function(t){if(re.assertRegistered(e.ModuleNames.CsvExportModule,"api.getDataAsCsv"))return this.csvCreator.getDataAsCsv(t)},t.prototype.exportDataAsCsv=function(t){re.assertRegistered(e.ModuleNames.CsvExportModule,"api.exportDataAsCSv")&&this.csvCreator.exportDataAsCsv(t)},t.prototype.getExcelExportMode=function(e){var t=this.gridOptionsWrapper.getDefaultExportParams("excel");return Object.assign({exportMode:"xlsx"},t,e).exportMode},t.prototype.getDataAsExcel=function(t){if(re.assertRegistered(e.ModuleNames.ExcelExportModule,"api.getDataAsExcel")){var n=this.getExcelExportMode(t);if(this.excelCreator.getFactoryMode(n)!==e.ExcelFactoryMode.MULTI_SHEET)return this.excelCreator.getDataAsExcel(t);console.warn("AG Grid: The Excel Exporter is currently on Multi Sheet mode. End that operation by calling `api.getMultipleSheetAsExcel()` or `api.exportMultipleSheetsAsExcel()`")}},t.prototype.exportDataAsExcel=function(t){if(re.assertRegistered(e.ModuleNames.ExcelExportModule,"api.exportDataAsExcel")){var n=this.getExcelExportMode(t);this.excelCreator.getFactoryMode(n)!==e.ExcelFactoryMode.MULTI_SHEET?this.excelCreator.exportDataAsExcel(t):console.warn("AG Grid: The Excel Exporter is currently on Multi Sheet mode. End that operation by calling `api.getMultipleSheetAsExcel()` or `api.exportMultipleSheetsAsExcel()`")}},t.prototype.getSheetDataForExcel=function(t){if(re.assertRegistered(e.ModuleNames.ExcelExportModule,"api.getSheetDataForExcel")){var n=this.getExcelExportMode(t);return this.excelCreator.setFactoryMode(e.ExcelFactoryMode.MULTI_SHEET,n),this.excelCreator.getSheetDataForExcel(t)}},t.prototype.getMultipleSheetsAsExcel=function(t){if(re.assertRegistered(e.ModuleNames.ExcelExportModule,"api.getMultipleSheetsAsExcel"))return this.excelCreator.getMultipleSheetsAsExcel(t)},t.prototype.exportMultipleSheetsAsExcel=function(t){if(re.assertRegistered(e.ModuleNames.ExcelExportModule,"api.exportMultipleSheetsAsExcel"))return this.excelCreator.exportMultipleSheetsAsExcel(t)},t.prototype.setEnterpriseDatasource=function(e){console.warn("AG Grid: since version 18.x, api.setEnterpriseDatasource() should be replaced with api.setServerSideDatasource()"),this.setServerSideDatasource(e)},t.prototype.setGridAriaProperty=function(e,t){if(e){var n=this.ctrlsService.getGridBodyCtrl().getGui(),r="aria-"+e;null===t?n.removeAttribute(r):n.setAttribute(r,t)}},t.prototype.setServerSideDatasource=function(e){this.serverSideRowModel?this.serverSideRowModel.setDatasource(e):console.warn("AG Grid: you can only use an enterprise datasource when gridOptions.rowModelType is '"+ne.ROW_MODEL_TYPE_SERVER_SIDE+"'")},t.prototype.setDatasource=function(e){this.gridOptionsWrapper.isRowModelInfinite()?this.rowModel.setDatasource(e):console.warn("AG Grid: you can only use a datasource when gridOptions.rowModelType is '"+ne.ROW_MODEL_TYPE_INFINITE+"'")},t.prototype.setViewportDatasource=function(e){this.gridOptionsWrapper.isRowModelViewport()?this.rowModel.setViewportDatasource(e):console.warn("AG Grid: you can only use a viewport datasource when gridOptions.rowModelType is '"+ne.ROW_MODEL_TYPE_VIEWPORT+"'")},t.prototype.setRowData=function(e){null==this.immutableService?console.warn("AG Grid: you can only set rowData when using the Client Side Row Model"):this.immutableService.isActive()?this.immutableService.setRowData(e):(this.selectionService.reset(),this.clientSideRowModel.setRowData(e))},t.prototype.setFloatingTopRowData=function(e){console.warn("AG Grid: since v12, api.setFloatingTopRowData() is now api.setPinnedTopRowData()"),this.setPinnedTopRowData(e)},t.prototype.setFloatingBottomRowData=function(e){console.warn("AG Grid: since v12, api.setFloatingBottomRowData() is now api.setPinnedBottomRowData()"),this.setPinnedBottomRowData(e)},t.prototype.getFloatingTopRowCount=function(){return console.warn("AG Grid: since v12, api.getFloatingTopRowCount() is now api.getPinnedTopRowCount()"),this.getPinnedTopRowCount()},t.prototype.getFloatingBottomRowCount=function(){return console.warn("AG Grid: since v12, api.getFloatingBottomRowCount() is now api.getPinnedBottomRowCount()"),this.getPinnedBottomRowCount()},t.prototype.getFloatingTopRow=function(e){return console.warn("AG Grid: since v12, api.getFloatingTopRow() is now api.getPinnedTopRow()"),this.getPinnedTopRow(e)},t.prototype.getFloatingBottomRow=function(e){return console.warn("AG Grid: since v12, api.getFloatingBottomRow() is now api.getPinnedBottomRow()"),this.getPinnedBottomRow(e)},t.prototype.setPinnedTopRowData=function(e){this.pinnedRowModel.setPinnedTopRowData(e)},t.prototype.setPinnedBottomRowData=function(e){this.pinnedRowModel.setPinnedBottomRowData(e)},t.prototype.getPinnedTopRowCount=function(){return this.pinnedRowModel.getPinnedTopRowCount()},t.prototype.getPinnedBottomRowCount=function(){return this.pinnedRowModel.getPinnedBottomRowCount()},t.prototype.getPinnedTopRow=function(e){return this.pinnedRowModel.getPinnedTopRow(e)},t.prototype.getPinnedBottomRow=function(e){return this.pinnedRowModel.getPinnedBottomRow(e)},t.prototype.setColumnDefs=function(e,t){void 0===t&&(t="api"),this.columnModel.setColumnDefs(e,t)},t.prototype.setAutoGroupColumnDef=function(e,t){this.gridOptionsWrapper.setProperty("autoGroupColumnDef",e,!0)},t.prototype.setDefaultColDef=function(e,t){this.gridOptionsWrapper.setProperty("defaultColDef",e,!0)},t.prototype.expireValueCache=function(){this.valueCache.expire()},t.prototype.getVerticalPixelRange=function(){return this.gridBodyCtrl.getScrollFeature().getVScrollPosition()},t.prototype.getHorizontalPixelRange=function(){return this.gridBodyCtrl.getScrollFeature().getHScrollPosition()},t.prototype.setAlwaysShowHorizontalScroll=function(e){this.gridOptionsWrapper.setProperty("alwaysShowHorizontalScroll",e)},t.prototype.setAlwaysShowVerticalScroll=function(e){this.gridOptionsWrapper.setProperty("alwaysShowVerticalScroll",e)},t.prototype.refreshToolPanel=function(){this.sideBarComp&&this.sideBarComp.refresh()},t.prototype.refreshCells=function(e){void 0===e&&(e={}),Array.isArray(e)?console.warn("since AG Grid v11.1, refreshCells() now takes parameters, please see the documentation."):this.rowRenderer.refreshCells(e)},t.prototype.flashCells=function(e){void 0===e&&(e={}),this.rowRenderer.flashCells(e)},t.prototype.redrawRows=function(e){void 0===e&&(e={});var t=e?e.rowNodes:void 0;this.rowRenderer.redrawRows(t)},t.prototype.setFunctionsReadOnly=function(e){this.gridOptionsWrapper.setProperty("functionsReadOnly",e)},t.prototype.refreshHeader=function(){this.ctrlsService.getHeaderRowContainerCtrls().forEach((function(e){return e.refresh()}))},t.prototype.isAnyFilterPresent=function(){return this.filterManager.isAnyFilterPresent()},t.prototype.isColumnFilterPresent=function(){return this.filterManager.isColumnFilterPresent()||this.filterManager.isAggregateFilterPresent()},t.prototype.isQuickFilterPresent=function(){return this.filterManager.isQuickFilterPresent()},t.prototype.getModel=function(){return this.rowModel},t.prototype.setRowNodeExpanded=function(e,t){e&&e.setExpanded(t)},t.prototype.onGroupExpandedOrCollapsed=function(t){r(this.clientSideRowModel)&&console.warn("AG Grid: cannot call onGroupExpandedOrCollapsed unless using normal row model"),n(t)&&console.warn("AG Grid: api.onGroupExpandedOrCollapsed - refreshFromIndex parameter is no longer used, the grid will refresh all rows"),this.clientSideRowModel.refreshModel({step:e.ClientSideRowModelSteps.MAP})},t.prototype.refreshInMemoryRowModel=function(e){console.warn("ag-grid: since version 18.x, api.refreshInMemoryRowModel() should be replaced with api.refreshClientSideRowModel()"),this.refreshClientSideRowModel(e)},t.prototype.refreshClientSideRowModel=function(t){r(this.clientSideRowModel)&&console.warn("cannot call refreshClientSideRowModel unless using normal row model");var o=e.ClientSideRowModelSteps.EVERYTHING,i={group:e.ClientSideRowModelSteps.EVERYTHING,filter:e.ClientSideRowModelSteps.FILTER,map:e.ClientSideRowModelSteps.MAP,aggregate:e.ClientSideRowModelSteps.AGGREGATE,sort:e.ClientSideRowModelSteps.SORT,pivot:e.ClientSideRowModelSteps.PIVOT};if(n(t)&&(o=i[t]),r(o))console.error("AG Grid: invalid step "+t+", available steps are "+Object.keys(i).join(", "));else{var s={step:o,keepRenderedRows:!0,keepEditingRows:!0,animate:!this.gridOptionsWrapper.isSuppressAnimationFrame()};this.clientSideRowModel.refreshModel(s)}},t.prototype.isAnimationFrameQueueEmpty=function(){return this.animationFrameService.isQueueEmpty()},t.prototype.flushAllAnimationFrames=function(){this.animationFrameService.flushAllFrames()},t.prototype.getRowNode=function(e){return this.rowModel.getRowNode(e)},t.prototype.getSizesForCurrentTheme=function(){return{rowHeight:this.gridOptionsWrapper.getRowHeightAsNumber(),headerHeight:this.gridOptionsWrapper.getHeaderHeight()}},t.prototype.expandAll=function(){this.clientSideRowModel?this.clientSideRowModel.expandOrCollapseAll(!0):this.serverSideRowModel?this.serverSideRowModel.expandAll(!0):console.warn("AG Grid: expandAll only works with Client Side Row Model and Server Side Row Model")},t.prototype.collapseAll=function(){this.clientSideRowModel?this.clientSideRowModel.expandOrCollapseAll(!1):this.serverSideRowModel?this.serverSideRowModel.expandAll(!1):console.warn("AG Grid: collapseAll only works with Client Side Row Model and Server Side Row Model")},t.prototype.getToolPanelInstance=function(e){if(this.sideBarComp)return Ru(this.sideBarComp.getToolPanelInstance(e));console.warn("AG Grid: toolPanel is only available in AG Grid Enterprise")},t.prototype.addVirtualRowListener=function(e,t,n){"string"!=typeof e&&console.warn("AG Grid: addVirtualRowListener is deprecated, please use addRenderedRowListener."),this.addRenderedRowListener(e,t,n)},t.prototype.addRenderedRowListener=function(e,t,n){"virtualRowSelected"===e&&console.warn("AG Grid: event virtualRowSelected is deprecated, to register for individual row\n selection events, add a listener directly to the row node."),this.rowRenderer.addRenderedRowListener(e,t,n)},t.prototype.setQuickFilter=function(e){this.filterManager.setQuickFilter(e)},t.prototype.selectIndex=function(e,t,n){console.warn("AG Grid: do not use api for selection, call node.setSelected(value) instead"),n&&console.warn("AG Grid: suppressEvents is no longer supported, stop listening for the event if you no longer want it"),this.selectionService.selectIndex(e,t)},t.prototype.deselectIndex=function(e,t){void 0===t&&(t=!1),console.warn("AG Grid: do not use api for selection, call node.setSelected(value) instead"),t&&console.warn("AG Grid: suppressEvents is no longer supported, stop listening for the event if you no longer want it"),this.selectionService.deselectIndex(e)},t.prototype.selectNode=function(e,t,n){void 0===t&&(t=!1),void 0===n&&(n=!1),console.warn("AG Grid: API for selection is deprecated, call node.setSelected(value) instead"),n&&console.warn("AG Grid: suppressEvents is no longer supported, stop listening for the event if you no longer want it"),e.setSelectedParams({newValue:!0,clearSelection:!t})},t.prototype.deselectNode=function(e,t){void 0===t&&(t=!1),console.warn("AG Grid: API for selection is deprecated, call node.setSelected(value) instead"),t&&console.warn("AG Grid: suppressEvents is no longer supported, stop listening for the event if you no longer want it"),e.setSelectedParams({newValue:!1})},t.prototype.selectAll=function(){this.selectionService.selectAllRowNodes()},t.prototype.deselectAll=function(){this.selectionService.deselectAllRowNodes()},t.prototype.selectAllFiltered=function(){this.selectionService.selectAllRowNodes(!0)},t.prototype.deselectAllFiltered=function(){this.selectionService.deselectAllRowNodes(!0)},t.prototype.recomputeAggregates=function(){r(this.clientSideRowModel)&&console.warn("cannot call recomputeAggregates unless using normal row model"),console.warn("recomputeAggregates is deprecated, please call api.refreshClientSideRowModel('aggregate') instead"),this.clientSideRowModel.refreshModel({step:e.ClientSideRowModelSteps.AGGREGATE})},t.prototype.sizeColumnsToFit=function(){this.gridBodyCtrl.sizeColumnsToFit()},t.prototype.showLoadingOverlay=function(){this.overlayWrapperComp.showLoadingOverlay()},t.prototype.showNoRowsOverlay=function(){this.overlayWrapperComp.showNoRowsOverlay()},t.prototype.hideOverlay=function(){this.overlayWrapperComp.hideOverlay()},t.prototype.isNodeSelected=function(e){return console.warn("AG Grid: no need to call api.isNodeSelected(), just call node.isSelected() instead"),e.isSelected()},t.prototype.getSelectedNodesById=function(){return console.error("AG Grid: since version 3.4, getSelectedNodesById no longer exists, use getSelectedNodes() instead"),null},t.prototype.getSelectedNodes=function(){return this.selectionService.getSelectedNodes()},t.prototype.getSelectedRows=function(){return this.selectionService.getSelectedRows()},t.prototype.getBestCostNodeSelection=function(){return this.selectionService.getBestCostNodeSelection()},t.prototype.getRenderedNodes=function(){return this.rowRenderer.getRenderedNodes()},t.prototype.ensureColIndexVisible=function(e){console.warn("AG Grid: ensureColIndexVisible(index) no longer supported, use ensureColumnVisible(colKey) instead.")},t.prototype.ensureColumnVisible=function(e,t){void 0===t&&(t="auto"),this.gridBodyCtrl.getScrollFeature().ensureColumnVisible(e,t)},t.prototype.ensureIndexVisible=function(e,t){this.gridBodyCtrl.getScrollFeature().ensureIndexVisible(e,t)},t.prototype.ensureNodeVisible=function(e,t){void 0===t&&(t=null),this.gridBodyCtrl.getScrollFeature().ensureNodeVisible(e,t)},t.prototype.forEachLeafNode=function(e){r(this.clientSideRowModel)&&console.warn("cannot call forEachNode unless using normal row model"),this.clientSideRowModel.forEachLeafNode(e)},t.prototype.forEachNode=function(e){this.rowModel.forEachNode(e)},t.prototype.forEachNodeAfterFilter=function(e){r(this.clientSideRowModel)&&console.warn("cannot call forEachNodeAfterFilter unless using normal row model"),this.clientSideRowModel.forEachNodeAfterFilter(e)},t.prototype.forEachNodeAfterFilterAndSort=function(e){r(this.clientSideRowModel)&&console.warn("cannot call forEachNodeAfterFilterAndSort unless using normal row model"),this.clientSideRowModel.forEachNodeAfterFilterAndSort(e)},t.prototype.getFilterInstance=function(e,t){var n=this.getFilterInstanceImpl(e,(function(e){if(t){var n=Ru(e);t(n)}}));return Ru(n)},t.prototype.getFilterInstanceImpl=function(e,t){var n=this.columnModel.getPrimaryColumn(e);if(n){var r=this.filterManager.getFilterComponent(n,"NO_UI"),o=r&&r.resolveNow(null,(function(e){return e}));return o?setTimeout(t,0,o):r&&r.then((function(e){t(e)})),o}},t.prototype.destroyFilter=function(e){var t=this.columnModel.getPrimaryColumn(e);if(t)return this.filterManager.destroyFilter(t,"filterDestroyed")},t.prototype.getStatusPanel=function(e){if(this.statusBarService)return Ru(this.statusBarService.getStatusPanel(e))},t.prototype.getColumnDef=function(e){var t=this.columnModel.getPrimaryColumn(e);return t?t.getColDef():null},t.prototype.getColumnDefs=function(){return this.columnModel.getColumnDefs()},t.prototype.onFilterChanged=function(){this.filterManager.onFilterChanged()},t.prototype.onSortChanged=function(){this.sortController.onSortChanged("api")},t.prototype.setFilterModel=function(e){this.filterManager.setFilterModel(e)},t.prototype.getFilterModel=function(){return this.filterManager.getFilterModel()},t.prototype.getFocusedCell=function(){return this.focusService.getFocusedCell()},t.prototype.clearFocusedCell=function(){return this.focusService.clearFocusedCell()},t.prototype.setFocusedCell=function(e,t,n){this.focusService.setFocusedCell(e,t,n,!0)},t.prototype.setSuppressRowDrag=function(e){this.gridOptionsWrapper.setProperty(ra.PROP_SUPPRESS_ROW_DRAG,e)},t.prototype.setSuppressMoveWhenRowDragging=function(e){this.gridOptionsWrapper.setProperty(ra.PROP_SUPPRESS_MOVE_WHEN_ROW_DRAG,e)},t.prototype.setSuppressRowClickSelection=function(e){this.gridOptionsWrapper.setProperty(ra.PROP_SUPPRESS_ROW_CLICK_SELECTION,e)},t.prototype.addRowDropZone=function(e){this.gridBodyCtrl.getRowDragFeature().addRowDropZone(e)},t.prototype.removeRowDropZone=function(e){var t=this.dragAndDropService.findExternalZone(e);t&&this.dragAndDropService.removeDropTarget(t)},t.prototype.getRowDropZoneParams=function(e){return this.gridBodyCtrl.getRowDragFeature().getRowDropZone(e)},t.prototype.setHeaderHeight=function(e){this.gridOptionsWrapper.setProperty(ra.PROP_HEADER_HEIGHT,e)},t.prototype.setDomLayout=function(e){this.gridOptionsWrapper.setProperty(ra.PROP_DOM_LAYOUT,e)},t.prototype.setEnableCellTextSelection=function(e){this.gridBodyCtrl.setCellTextSelection(e)},t.prototype.setFillHandleDirection=function(e){this.gridOptionsWrapper.setProperty(ra.PROP_FILL_HANDLE_DIRECTION,e)},t.prototype.setGroupHeaderHeight=function(e){this.gridOptionsWrapper.setProperty(ra.PROP_GROUP_HEADER_HEIGHT,e)},t.prototype.setFloatingFiltersHeight=function(e){this.gridOptionsWrapper.setProperty(ra.PROP_FLOATING_FILTERS_HEIGHT,e)},t.prototype.setPivotHeaderHeight=function(e){this.gridOptionsWrapper.setProperty(ra.PROP_PIVOT_HEADER_HEIGHT,e)},t.prototype.setPivotGroupHeaderHeight=function(e){this.gridOptionsWrapper.setProperty(ra.PROP_PIVOT_GROUP_HEADER_HEIGHT,e)},t.prototype.setIsExternalFilterPresent=function(e){this.gridOptionsWrapper.setProperty(ra.PROP_IS_EXTERNAL_FILTER_PRESENT,e)},t.prototype.setDoesExternalFilterPass=function(e){this.gridOptionsWrapper.setProperty(ra.PROP_DOES_EXTERNAL_FILTER_PASS,e)},t.prototype.setNavigateToNextCell=function(e){this.gridOptionsWrapper.setProperty(ra.PROP_NAVIGATE_TO_NEXT_CELL,e)},t.prototype.setTabToNextCell=function(e){this.gridOptionsWrapper.setProperty(ra.PROP_TAB_TO_NEXT_CELL,e)},t.prototype.setTabToNextHeader=function(e){this.gridOptionsWrapper.setProperty(ra.PROP_TAB_TO_NEXT_HEADER,e)},t.prototype.setNavigateToNextHeader=function(e){this.gridOptionsWrapper.setProperty(ra.PROP_NAVIGATE_TO_NEXT_HEADER,e)},t.prototype.setGroupRowAggNodes=function(e){this.gridOptionsWrapper.setProperty(ra.PROP_GROUP_ROW_AGG_NODES,e)},t.prototype.setGetGroupRowAgg=function(e){this.gridOptionsWrapper.setProperty(ra.PROP_GET_GROUP_ROW_AGG,e)},t.prototype.setGetBusinessKeyForNode=function(e){this.gridOptionsWrapper.setProperty(ra.PROP_GET_BUSINESS_KEY_FOR_NODE,e)},t.prototype.setGetChildCount=function(e){this.gridOptionsWrapper.setProperty(ra.PROP_GET_CHILD_COUNT,e)},t.prototype.setProcessRowPostCreate=function(e){this.gridOptionsWrapper.setProperty(ra.PROP_PROCESS_ROW_POST_CREATE,e)},t.prototype.setGetRowNodeId=function(e){this.gridOptionsWrapper.setProperty(ra.PROP_GET_ROW_NODE_ID,e)},t.prototype.setGetRowId=function(e){this.gridOptionsWrapper.setProperty(ra.PROP_GET_ROW_ID,e)},t.prototype.setGetRowClass=function(e){this.gridOptionsWrapper.setProperty(ra.PROP_GET_ROW_CLASS,e)},t.prototype.setIsFullWidthCell=function(e){this.gridOptionsWrapper.setProperty(ra.PROP_IS_FULL_WIDTH_CELL,e)},t.prototype.setIsFullWidthRow=function(e){this.gridOptionsWrapper.setProperty(ra.PROP_IS_FULL_WIDTH_ROW,e)},t.prototype.setIsRowSelectable=function(e){this.gridOptionsWrapper.setProperty(ra.PROP_IS_ROW_SELECTABLE,e)},t.prototype.setIsRowMaster=function(e){this.gridOptionsWrapper.setProperty(ra.PROP_IS_ROW_MASTER,e)},t.prototype.setPostSort=function(e){this.gridOptionsWrapper.setProperty(ra.PROP_POST_SORT,e)},t.prototype.setPostSortRows=function(e){this.gridOptionsWrapper.setProperty(ra.PROP_POST_SORT_ROWS,e)},t.prototype.setGetDocument=function(e){this.gridOptionsWrapper.setProperty(ra.PROP_GET_DOCUMENT,e)},t.prototype.setGetContextMenuItems=function(e){this.gridOptionsWrapper.setProperty(ra.PROP_GET_CONTEXT_MENU_ITEMS,e)},t.prototype.setGetMainMenuItems=function(e){this.gridOptionsWrapper.setProperty(ra.PROP_GET_MAIN_MENU_ITEMS,e)},t.prototype.setProcessCellForClipboard=function(e){this.gridOptionsWrapper.setProperty(ra.PROP_PROCESS_CELL_FOR_CLIPBOARD,e)},t.prototype.setSendToClipboard=function(e){this.gridOptionsWrapper.setProperty(ra.PROP_SEND_TO_CLIPBOARD,e)},t.prototype.setProcessCellFromClipboard=function(e){this.gridOptionsWrapper.setProperty(ra.PROP_PROCESS_CELL_FROM_CLIPBOARD,e)},t.prototype.setProcessSecondaryColDef=function(e){this.gridOptionsWrapper.setProperty(ra.PROP_PROCESS_TO_SECONDARY_COLDEF,e)},t.prototype.setProcessSecondaryColGroupDef=function(e){this.gridOptionsWrapper.setProperty(ra.PROP_PROCESS_SECONDARY_COL_GROUP_DEF,e)},t.prototype.setPostProcessPopup=function(e){this.gridOptionsWrapper.setProperty(ra.PROP_POST_PROCESS_POPUP,e)},t.prototype.setDefaultGroupOrderComparator=function(e){this.gridOptionsWrapper.setProperty(ra.PROP_DEFAULT_GROUP_ORDER_COMPARATOR,e)},t.prototype.setInitialGroupOrderComparator=function(e){this.gridOptionsWrapper.setProperty(ra.PROP_INITIAL_GROUP_ORDER_COMPARATOR,e)},t.prototype.setGetChartToolbarItems=function(e){this.gridOptionsWrapper.setProperty(ra.PROP_GET_CHART_TOOLBAR_ITEMS,e)},t.prototype.setPaginationNumberFormatter=function(e){this.gridOptionsWrapper.setProperty(ra.PROP_PAGINATION_NUMBER_FORMATTER,e)},t.prototype.setGetServerSideStoreParams=function(e){this.gridOptionsWrapper.setProperty(ra.PROP_GET_SERVER_SIDE_STORE_PARAMS,e)},t.prototype.setIsServerSideGroupOpenByDefault=function(e){this.gridOptionsWrapper.setProperty(ra.PROP_IS_SERVER_SIDE_GROUPS_OPEN_BY_DEFAULT,e)},t.prototype.setIsApplyServerSideTransaction=function(e){this.gridOptionsWrapper.setProperty(ra.PROP_IS_APPLY_SERVER_SIDE_TRANSACTION,e)},t.prototype.setIsServerSideGroup=function(e){this.gridOptionsWrapper.setProperty(ra.PROP_IS_SERVER_SIDE_GROUP,e)},t.prototype.setGetServerSideGroupKey=function(e){this.gridOptionsWrapper.setProperty(ra.PROP_GET_SERVER_SIDE_GROUP_KEY,e)},t.prototype.setGetRowStyle=function(e){this.gridOptionsWrapper.setProperty(ra.PROP_GET_ROW_STYLE,e)},t.prototype.setGetRowHeight=function(e){this.gridOptionsWrapper.setProperty(ra.PROP_GET_ROW_HEIGHT,e)},t.prototype.isSideBarVisible=function(){return!!this.sideBarComp&&this.sideBarComp.isDisplayed()},t.prototype.setSideBarVisible=function(e){this.sideBarComp?this.sideBarComp.setDisplayed(e):e&&console.warn("AG Grid: sideBar is not loaded")},t.prototype.setSideBarPosition=function(e){this.sideBarComp?this.sideBarComp.setSideBarPosition(e):console.warn("AG Grid: sideBar is not loaded")},t.prototype.openToolPanel=function(e){this.sideBarComp?this.sideBarComp.openToolPanel(e):console.warn("AG Grid: toolPanel is only available in AG Grid Enterprise")},t.prototype.closeToolPanel=function(){this.sideBarComp?this.sideBarComp.close():console.warn("AG Grid: toolPanel is only available in AG Grid Enterprise")},t.prototype.getOpenedToolPanel=function(){return this.sideBarComp?this.sideBarComp.openedItem():null},t.prototype.getSideBar=function(){return this.gridOptionsWrapper.getSideBar()},t.prototype.setSideBar=function(e){this.gridOptionsWrapper.setProperty("sideBar",Ys.parse(e))},t.prototype.setSuppressClipboardPaste=function(e){this.gridOptionsWrapper.setProperty(ra.PROP_SUPPRESS_CLIPBOARD_PASTE,e)},t.prototype.isToolPanelShowing=function(){return this.sideBarComp.isToolPanelShowing()},t.prototype.doLayout=function(){A((function(){return console.warn("AG Grid - since version 25.1, doLayout was taken out, as it's not needed. The grid responds to grid size changes automatically")}),"doLayoutDeprecated")},t.prototype.resetRowHeights=function(){if(n(this.clientSideRowModel)){if(this.columnModel.isAutoRowHeightActive())return void console.warn("AG Grid: calling gridApi.resetRowHeights() makes no sense when using Auto Row Height.");this.clientSideRowModel.resetRowHeights()}},t.prototype.setGroupRemoveSingleChildren=function(e){this.gridOptionsWrapper.setProperty(ra.PROP_GROUP_REMOVE_SINGLE_CHILDREN,e)},t.prototype.setGroupRemoveLowestSingleChildren=function(e){this.gridOptionsWrapper.setProperty(ra.PROP_GROUP_REMOVE_LOWEST_SINGLE_CHILDREN,e)},t.prototype.onRowHeightChanged=function(){this.clientSideRowModel?this.clientSideRowModel.onRowHeightChanged():this.serverSideRowModel&&this.serverSideRowModel.onRowHeightChanged()},t.prototype.getValue=function(e,t){var n=this.columnModel.getPrimaryColumn(e);return r(n)&&(n=this.columnModel.getGridColumn(e)),r(n)?null:this.valueService.getValue(n,t)},t.prototype.addEventListener=function(e,t){var n=this.gridOptionsWrapper.useAsyncEvents();this.eventService.addEventListener(e,t,n)},t.prototype.addGlobalListener=function(e){var t=this.gridOptionsWrapper.useAsyncEvents();this.eventService.addGlobalListener(e,t)},t.prototype.removeEventListener=function(e,t){var n=this.gridOptionsWrapper.useAsyncEvents();this.eventService.removeEventListener(e,t,n)},t.prototype.removeGlobalListener=function(e){var t=this.gridOptionsWrapper.useAsyncEvents();this.eventService.removeGlobalListener(e,t)},t.prototype.dispatchEvent=function(e){this.eventService.dispatchEvent(e)},t.prototype.destroy=function(){if(!this.destroyCalled){this.destroyCalled=!0;var e=this.ctrlsService.getGridCtrl();e&&e.destroyGridUi(),this.context.destroy()}},t.prototype.cleanDownReferencesToAvoidMemoryLeakInCaseApplicationIsKeepingReferenceToDestroyedGrid=function(){setTimeout(R.bind(window,this,"Grid API"),100)},t.prototype.warnIfDestroyed=function(e){return this.destroyCalled&&console.warn("AG Grid: Grid API method "+e+" was called on a grid that was destroyed."),this.destroyCalled},t.prototype.resetQuickFilter=function(){this.warnIfDestroyed("resetQuickFilter")||this.rowModel.forEachNode((function(e){return e.quickFilterAggregateText=null}))},t.prototype.getRangeSelections=function(){return console.warn("AG Grid: in v20.1.x, api.getRangeSelections() is gone, please use getCellRanges() instead.\n We had to change how cell selections works a small bit to allow charting to integrate. The return type of\n getCellRanges() is a bit different, please check the AG Grid documentation."),null},t.prototype.getCellRanges=function(){return this.rangeService?this.rangeService.getCellRanges():(console.warn("AG Grid: cell range selection is only available in AG Grid Enterprise"),null)},t.prototype.camelCaseToHumanReadable=function(e){return qe(e)},t.prototype.addRangeSelection=function(e){console.warn("AG Grid: As of version 21.x, range selection changed slightly to allow charting integration. Please call api.addCellRange() instead of api.addRangeSelection()")},t.prototype.addCellRange=function(e){this.rangeService||console.warn("AG Grid: cell range selection is only available in AG Grid Enterprise"),this.rangeService.addCellRange(e)},t.prototype.clearRangeSelection=function(){this.rangeService||console.warn("AG Grid: cell range selection is only available in AG Grid Enterprise"),this.rangeService.removeAllCellRanges()},t.prototype.undoCellEditing=function(){this.undoRedoService.undo()},t.prototype.redoCellEditing=function(){this.undoRedoService.redo()},t.prototype.getCurrentUndoSize=function(){return this.undoRedoService.getCurrentUndoStackSize()},t.prototype.getCurrentRedoSize=function(){return this.undoRedoService.getCurrentRedoStackSize()},t.prototype.getChartModels=function(){if(re.assertRegistered(e.ModuleNames.RangeSelectionModule,"api.getChartModels")&&re.assertRegistered(e.ModuleNames.GridChartsModule,"api.getChartModels"))return this.chartService.getChartModels()},t.prototype.getChartRef=function(t){if(re.assertRegistered(e.ModuleNames.RangeSelectionModule,"api.getChartRef")&&re.assertRegistered(e.ModuleNames.GridChartsModule,"api.getChartRef"))return this.chartService.getChartRef(t)},t.prototype.getChartImageDataURL=function(t){if(re.assertRegistered(e.ModuleNames.RangeSelectionModule,"api.getChartImageDataURL")&&re.assertRegistered(e.ModuleNames.GridChartsModule,"api.getChartImageDataURL"))return this.chartService.getChartImageDataURL(t)},t.prototype.createRangeChart=function(t){if(re.assertRegistered(e.ModuleNames.RangeSelectionModule,"api.createRangeChart")&&re.assertRegistered(e.ModuleNames.GridChartsModule,"api.createRangeChart"))return this.chartService.createRangeChart(t)},t.prototype.createCrossFilterChart=function(t){if(re.assertRegistered(e.ModuleNames.RangeSelectionModule,"api.createCrossFilterChart")&&re.assertRegistered(e.ModuleNames.GridChartsModule,"api.createCrossFilterChart"))return this.chartService.createCrossFilterChart(t)},t.prototype.restoreChart=function(t,n){if(re.assertRegistered(e.ModuleNames.RangeSelectionModule,"api.restoreChart")&&re.assertRegistered(e.ModuleNames.GridChartsModule,"api.restoreChart"))return this.chartService.restoreChart(t,n)},t.prototype.createPivotChart=function(t){if(re.assertRegistered(e.ModuleNames.RangeSelectionModule,"api.createPivotChart")&&re.assertRegistered(e.ModuleNames.GridChartsModule,"api.createPivotChart"))return this.chartService.createPivotChart(t)},t.prototype.copySelectedRowsToClipboard=function(e){this.clipboardService||console.warn("AG Grid: clipboard is only available in AG Grid Enterprise"),this.clipboardService.copySelectedRowsToClipboard(e)},t.prototype.copySelectedRangeToClipboard=function(e){this.clipboardService||console.warn("AG Grid: clipboard is only available in AG Grid Enterprise"),this.clipboardService.copySelectedRangeToClipboard(e)},t.prototype.copySelectedRangeDown=function(){this.clipboardService||console.warn("AG Grid: clipboard is only available in AG Grid Enterprise"),this.clipboardService.copyRangeDown()},t.prototype.showColumnMenuAfterButtonClick=function(e,t){var n=this.columnModel.getGridColumn(e);this.menuFactory.showMenuAfterButtonClick(n,t,"columnMenu")},t.prototype.showColumnMenuAfterMouseClick=function(e,t){var n=this.columnModel.getGridColumn(e);n||(n=this.columnModel.getPrimaryColumn(e)),n?this.menuFactory.showMenuAfterMouseEvent(n,t):console.error("AG Grid: column '"+e+"' not found")},t.prototype.hidePopupMenu=function(){this.contextMenuFactory&&this.contextMenuFactory.hideActiveMenu(),this.menuFactory.hideActiveMenu()},t.prototype.setPopupParent=function(e){this.gridOptionsWrapper.setProperty(ra.PROP_POPUP_PARENT,e)},t.prototype.tabToNextCell=function(e){return this.navigationService.tabToNextCell(!1,e)},t.prototype.tabToPreviousCell=function(e){return this.navigationService.tabToNextCell(!0,e)},t.prototype.getCellRendererInstances=function(e){return void 0===e&&(e={}),this.rowRenderer.getCellRendererInstances(e).map(Ru)},t.prototype.getCellEditorInstances=function(e){return void 0===e&&(e={}),this.rowRenderer.getCellEditorInstances(e).map(Ru)},t.prototype.getEditingCells=function(){return this.rowRenderer.getEditingCells()},t.prototype.stopEditing=function(e){void 0===e&&(e=!1),this.rowRenderer.stopEditing(e)},t.prototype.startEditingCell=function(e){var t=this.columnModel.getGridColumn(e.colKey);if(t){var n={rowIndex:e.rowIndex,rowPinned:e.rowPinned||null,column:t};null==e.rowPinned&&this.gridBodyCtrl.getScrollFeature().ensureIndexVisible(e.rowIndex);var r=this.navigationService.getCellByPosition(n);r&&r.startRowOrCellEdit(e.key,e.charPress)}else console.warn("AG Grid: no column found for "+e.colKey)},t.prototype.addAggFunc=function(e,t){this.aggFuncService&&this.aggFuncService.addAggFunc(e,t)},t.prototype.addAggFuncs=function(e){this.aggFuncService&&this.aggFuncService.addAggFuncs(e)},t.prototype.clearAggFuncs=function(){this.aggFuncService&&this.aggFuncService.clear()},t.prototype.applyServerSideTransaction=function(e){if(this.serverSideTransactionManager)return this.serverSideTransactionManager.applyTransaction(e);console.warn("AG Grid: Cannot apply Server Side Transaction if not using the Server Side Row Model.")},t.prototype.applyServerSideTransactionAsync=function(e,t){if(this.serverSideTransactionManager)return this.serverSideTransactionManager.applyTransactionAsync(e,t);console.warn("AG Grid: Cannot apply Server Side Transaction if not using the Server Side Row Model.")},t.prototype.retryServerSideLoads=function(){this.serverSideRowModel?this.serverSideRowModel.retryLoads():console.warn("AG Grid: API retryServerSideLoads() can only be used when using Server-Side Row Model.")},t.prototype.flushServerSideAsyncTransactions=function(){if(this.serverSideTransactionManager)return this.serverSideTransactionManager.flushAsyncTransactions();console.warn("AG Grid: Cannot flush Server Side Transaction if not using the Server Side Row Model.")},t.prototype.applyTransaction=function(e){if(this.clientSideRowModel){var t=this.clientSideRowModel.updateRowData(e);return this.rowRenderer.refreshFullWidthRows(t.update),this.gridOptionsWrapper.isSuppressChangeDetection()||this.rowRenderer.refreshCells(),t}console.error("AG Grid: updateRowData() only works with ClientSideRowModel. Working with InfiniteRowModel was deprecated in v23.1 and removed in v24.1")},t.prototype.setDeltaSort=function(e){this.gridOptionsWrapper.setProperty("deltaSort",e)},t.prototype.updateRowData=function(e){return A((function(){return console.warn("AG Grid: as of v23.1, grid API updateRowData(transaction) is now called applyTransaction(transaction). updateRowData is deprecated and will be removed in a future major release.")}),"updateRowData deprecated"),this.applyTransaction(e)},t.prototype.applyTransactionAsync=function(e,t){this.clientSideRowModel?this.clientSideRowModel.batchUpdateRowData(e,t):console.error("AG Grid: api.applyTransactionAsync() only works with ClientSideRowModel.")},t.prototype.flushAsyncTransactions=function(){this.clientSideRowModel?this.clientSideRowModel.flushAsyncTransactions():console.error("AG Grid: api.applyTransactionAsync() only works with ClientSideRowModel.")},t.prototype.batchUpdateRowData=function(e,t){A((function(){return console.warn("AG Grid: as of v23.1, grid API batchUpdateRowData(transaction, callback) is now called applyTransactionAsync(transaction, callback). batchUpdateRowData is deprecated and will be removed in a future major release.")}),"batchUpdateRowData deprecated"),this.applyTransactionAsync(e,t)},t.prototype.insertItemsAtIndex=function(e,t,n){console.warn("AG Grid: insertItemsAtIndex() is deprecated, use updateRowData(transaction) instead."),this.updateRowData({add:t,addIndex:e,update:null,remove:null})},t.prototype.removeItems=function(e,t){console.warn("AG Grid: removeItems() is deprecated, use updateRowData(transaction) instead.");var n=e.map((function(e){return e.data}));this.updateRowData({add:null,addIndex:null,update:null,remove:n})},t.prototype.addItems=function(e,t){console.warn("AG Grid: addItems() is deprecated, use updateRowData(transaction) instead."),this.updateRowData({add:e,addIndex:null,update:null,remove:null})},t.prototype.refreshVirtualPageCache=function(){console.warn("AG Grid: refreshVirtualPageCache() is now called refreshInfiniteCache(), please call refreshInfiniteCache() instead"),this.refreshInfiniteCache()},t.prototype.refreshInfinitePageCache=function(){console.warn("AG Grid: refreshInfinitePageCache() is now called refreshInfiniteCache(), please call refreshInfiniteCache() instead"),this.refreshInfiniteCache()},t.prototype.refreshInfiniteCache=function(){this.infiniteRowModel?this.infiniteRowModel.refreshCache():console.warn("AG Grid: api.refreshInfiniteCache is only available when rowModelType='infinite'.")},t.prototype.purgeVirtualPageCache=function(){console.warn("AG Grid: purgeVirtualPageCache() is now called purgeInfiniteCache(), please call purgeInfiniteCache() instead"),this.purgeInfinitePageCache()},t.prototype.purgeInfinitePageCache=function(){console.warn("AG Grid: purgeInfinitePageCache() is now called purgeInfiniteCache(), please call purgeInfiniteCache() instead"),this.purgeInfiniteCache()},t.prototype.purgeInfiniteCache=function(){this.infiniteRowModel?this.infiniteRowModel.purgeCache():console.warn("AG Grid: api.purgeInfiniteCache is only available when rowModelType='infinite'.")},t.prototype.purgeEnterpriseCache=function(e){console.warn("ag-grid: since version 18.x, api.purgeEnterpriseCache() should be replaced with api.purgeServerSideCache()"),this.purgeServerSideCache(e)},t.prototype.purgeServerSideCache=function(e){void 0===e&&(e=[]),this.serverSideRowModel?(console.warn("AG Grid: since v25.0, api.purgeServerSideCache is deprecated. Please use api.refreshServerSideStore({purge: true}) instead."),this.refreshServerSideStore({route:e,purge:!0})):console.warn("AG Grid: api.purgeServerSideCache is only available when rowModelType='serverSide'.")},t.prototype.refreshServerSideStore=function(e){this.serverSideRowModel?this.serverSideRowModel.refreshStore(e):console.warn("AG Grid: api.refreshServerSideStore is only available when rowModelType='serverSide'.")},t.prototype.getServerSideStoreState=function(){return this.serverSideRowModel?this.serverSideRowModel.getStoreState():(console.warn("AG Grid: api.getServerSideStoreState is only available when rowModelType='serverSide'."),[])},t.prototype.getVirtualRowCount=function(){return console.warn("AG Grid: getVirtualRowCount() is now called getInfiniteRowCount(), please call getInfiniteRowCount() instead"),this.getInfiniteRowCount()},t.prototype.getInfiniteRowCount=function(){if(this.infiniteRowModel)return this.infiniteRowModel.getRowCount();console.warn("AG Grid: api.getVirtualRowCount is only available when rowModelType='virtual'.")},t.prototype.isMaxRowFound=function(){return console.warn("AG Grid: api.isLastRowIndexKnown is deprecated, please use api.isLastRowIndexKnown()"),this.isLastRowIndexKnown()},t.prototype.isLastRowIndexKnown=function(){if(this.infiniteRowModel)return this.infiniteRowModel.isLastRowIndexKnown();console.warn("AG Grid: api.isMaxRowFound is only available when rowModelType='virtual'.")},t.prototype.setVirtualRowCount=function(e,t){console.warn("AG Grid: setVirtualRowCount() is now called setInfiniteRowCount(), please call setInfiniteRowCount() instead"),this.setRowCount(e,t)},t.prototype.setInfiniteRowCount=function(e,t){console.warn("AG Grid: setInfiniteRowCount() is now called setRowCount(), please call setRowCount() instead"),this.setRowCount(e,t)},t.prototype.setRowCount=function(e,t){this.infiniteRowModel?this.infiniteRowModel.setRowCount(e,t):console.warn("AG Grid: api.setRowCount is only available for Infinite Row Model.")},t.prototype.getVirtualPageState=function(){return console.warn("AG Grid: getVirtualPageState() is now called getCacheBlockState(), please call getCacheBlockState() instead"),this.getCacheBlockState()},t.prototype.getInfinitePageState=function(){return console.warn("AG Grid: getInfinitePageState() is now called getCacheBlockState(), please call getCacheBlockState() instead"),this.getCacheBlockState()},t.prototype.getCacheBlockState=function(){return this.rowNodeBlockLoader.getBlockState()},t.prototype.checkGridSize=function(){console.warn("in AG Grid v25.2.0, checkGridSize() was removed, as it was legacy and didn't do anything uesful.")},t.prototype.getFirstRenderedRow=function(){return console.warn("in AG Grid v12, getFirstRenderedRow() was renamed to getFirstDisplayedRow()"),this.getFirstDisplayedRow()},t.prototype.getFirstDisplayedRow=function(){return this.rowRenderer.getFirstVirtualRenderedRow()},t.prototype.getLastRenderedRow=function(){return console.warn("in AG Grid v12, getLastRenderedRow() was renamed to getLastDisplayedRow()"),this.getLastDisplayedRow()},t.prototype.getLastDisplayedRow=function(){return this.rowRenderer.getLastVirtualRenderedRow()},t.prototype.getDisplayedRowAtIndex=function(e){return this.rowModel.getRow(e)},t.prototype.getDisplayedRowCount=function(){return this.rowModel.getRowCount()},t.prototype.paginationIsLastPageFound=function(){return this.paginationProxy.isLastPageFound()},t.prototype.paginationGetPageSize=function(){return this.paginationProxy.getPageSize()},t.prototype.paginationSetPageSize=function(e){this.gridOptionsWrapper.setProperty("paginationPageSize",e)},t.prototype.paginationGetCurrentPage=function(){return this.paginationProxy.getCurrentPage()},t.prototype.paginationGetTotalPages=function(){return this.paginationProxy.getTotalPages()},t.prototype.paginationGetRowCount=function(){return this.paginationProxy.getMasterRowCount()},t.prototype.paginationGoToNextPage=function(){this.paginationProxy.goToNextPage()},t.prototype.paginationGoToPreviousPage=function(){this.paginationProxy.goToPreviousPage()},t.prototype.paginationGoToFirstPage=function(){this.paginationProxy.goToFirstPage()},t.prototype.paginationGoToLastPage=function(){this.paginationProxy.goToLastPage()},t.prototype.paginationGoToPage=function(e){this.paginationProxy.goToPage(e)},t.prototype.setRowClass=function(e){this.gridOptionsWrapper.setProperty(ra.PROP_ROW_CLASS,e)},bu([q("immutableService")],t.prototype,"immutableService",void 0),bu([q("csvCreator")],t.prototype,"csvCreator",void 0),bu([q("excelCreator")],t.prototype,"excelCreator",void 0),bu([Y("rowRenderer")],t.prototype,"rowRenderer",void 0),bu([Y("navigationService")],t.prototype,"navigationService",void 0),bu([Y("filterManager")],t.prototype,"filterManager",void 0),bu([Y("columnModel")],t.prototype,"columnModel",void 0),bu([Y("selectionService")],t.prototype,"selectionService",void 0),bu([Y("gridOptionsWrapper")],t.prototype,"gridOptionsWrapper",void 0),bu([Y("valueService")],t.prototype,"valueService",void 0),bu([Y("alignedGridsService")],t.prototype,"alignedGridsService",void 0),bu([Y("eventService")],t.prototype,"eventService",void 0),bu([Y("pinnedRowModel")],t.prototype,"pinnedRowModel",void 0),bu([Y("context")],t.prototype,"context",void 0),bu([Y("rowModel")],t.prototype,"rowModel",void 0),bu([Y("sortController")],t.prototype,"sortController",void 0),bu([Y("paginationProxy")],t.prototype,"paginationProxy",void 0),bu([Y("focusService")],t.prototype,"focusService",void 0),bu([Y("dragAndDropService")],t.prototype,"dragAndDropService",void 0),bu([q("rangeService")],t.prototype,"rangeService",void 0),bu([q("clipboardService")],t.prototype,"clipboardService",void 0),bu([q("aggFuncService")],t.prototype,"aggFuncService",void 0),bu([Y("menuFactory")],t.prototype,"menuFactory",void 0),bu([q("contextMenuFactory")],t.prototype,"contextMenuFactory",void 0),bu([Y("valueCache")],t.prototype,"valueCache",void 0),bu([Y("animationFrameService")],t.prototype,"animationFrameService",void 0),bu([q("statusBarService")],t.prototype,"statusBarService",void 0),bu([q("chartService")],t.prototype,"chartService",void 0),bu([q("undoRedoService")],t.prototype,"undoRedoService",void 0),bu([q("rowNodeBlockLoader")],t.prototype,"rowNodeBlockLoader",void 0),bu([q("ssrmTransactionManager")],t.prototype,"serverSideTransactionManager",void 0),bu([Y("ctrlsService")],t.prototype,"ctrlsService",void 0),bu([q("frameworkComponentWrapper")],t.prototype,"frameworkComponentWrapper",void 0),bu([U],t.prototype,"init",null),bu([z],t.prototype,"cleanDownReferencesToAvoidMemoryLeakInCaseApplicationIsKeepingReferenceToDestroyedGrid",null),t=bu([K("gridApi")],t)}(),Ou=function(){var e=function(t,n){return(e=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(e,t){e.__proto__=t}||function(e,t){for(var n in t)t.hasOwnProperty(n)&&(e[n]=t[n])})(t,n)};return function(t,n){function r(){this.constructor=t}e(t,n),t.prototype=null===n?Object.create(n):(r.prototype=n.prototype,new r)}}(),Pu=function(e){function t(t,n,r,o){var i=e.call(this)||this;return i.columnOrGroup=t,i.eCell=n,i.ariaEl=i.eCell.querySelector("[role=columnheader]")||i.eCell,i.colsSpanning=o,i.beans=r,i}return Ou(t,e),t.prototype.setColsSpanning=function(e){this.colsSpanning=e,this.onLeftChanged()},t.prototype.getColumnOrGroup=function(){return this.beans.gridOptionsWrapper.isEnableRtl()&&this.colsSpanning?le(this.colsSpanning):this.columnOrGroup},t.prototype.postConstruct=function(){this.addManagedListener(this.columnOrGroup,se.EVENT_LEFT_CHANGED,this.onLeftChanged.bind(this)),this.setLeftFirstTime(),this.addManagedListener(this.eventService,He.EVENT_DISPLAYED_COLUMNS_WIDTH_CHANGED,this.onLeftChanged.bind(this)),this.addManagedListener(this.beans.gridOptionsWrapper,ra.PROP_DOM_LAYOUT,this.onLeftChanged.bind(this))},t.prototype.setLeftFirstTime=function(){var e=this.beans.gridOptionsWrapper.isSuppressColumnMoveAnimation(),t=n(this.columnOrGroup.getOldLeft());this.beans.columnAnimationService.isActive()&&t&&!e?this.animateInLeft():this.onLeftChanged()},t.prototype.animateInLeft=function(){var e=this,t=this.getColumnOrGroup(),n=t.getLeft(),r=t.getOldLeft(),o=this.modifyLeftForPrintLayout(t,r),i=this.modifyLeftForPrintLayout(t,n);this.setLeft(o),this.actualLeft=i,this.beans.columnAnimationService.executeNextVMTurn((function(){e.actualLeft===i&&e.setLeft(i)}))},t.prototype.onLeftChanged=function(){var e=this.getColumnOrGroup(),t=e.getLeft();this.actualLeft=this.modifyLeftForPrintLayout(e,t),this.setLeft(this.actualLeft)},t.prototype.modifyLeftForPrintLayout=function(e,t){if(!(this.beans.gridOptionsWrapper.getDomLayout()===ne.DOM_LAYOUT_PRINT))return t;if(e.getPinned()===ne.PINNED_LEFT)return t;var n=this.beans.columnModel.getDisplayedColumnsLeftWidth();return e.getPinned()===ne.PINNED_RIGHT?n+this.beans.columnModel.getBodyContainerWidth()+t:n+t},t.prototype.setLeft=function(e){var t;if(n(e)&&(this.eCell.style.left=e+"px"),this.columnOrGroup instanceof se)t=this.columnOrGroup;else{var r=this.columnOrGroup.getLeafColumns();if(!r.length)return;r.length>1&&Qn(this.ariaEl,r.length),t=r[0]}var o=this.beans.columnModel.getAriaColumnIndex(t);Xn(this.ariaEl,o)},function(e,t,n,r){var o,i=arguments.length,s=i<3?t:null===r?r=Object.getOwnPropertyDescriptor(t,n):r;if("object"==typeof Reflect&&"function"==typeof Reflect.decorate)s=Reflect.decorate(e,t,n,r);else for(var a=e.length-1;a>=0;a--)(o=e[a])&&(s=(i<3?o(s):i>3?o(t,n,s):o(t,n))||s);i>3&&s&&Object.defineProperty(t,n,s)}([U],t.prototype,"postConstruct",null),t}(Le),Tu=function(){var e=function(t,n){return(e=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(e,t){e.__proto__=t}||function(e,t){for(var n in t)t.hasOwnProperty(n)&&(e[n]=t[n])})(t,n)};return function(t,n){function r(){this.constructor=t}e(t,n),t.prototype=null===n?Object.create(n):(r.prototype=n.prototype,new r)}}(),Au=function(e,t,n,r){var o,i=arguments.length,s=i<3?t:null===r?r=Object.getOwnPropertyDescriptor(t,n):r;if("object"==typeof Reflect&&"function"==typeof Reflect.decorate)s=Reflect.decorate(e,t,n,r);else for(var a=e.length-1;a>=0;a--)(o=e[a])&&(s=(i<3?o(s):i>3?o(t,n,s):o(t,n))||s);return i>3&&s&&Object.defineProperty(t,n,s),s},Du=function(e){function t(t,n){var r=e.call(this)||this;return r.columns=t,r.element=n,r}return Tu(t,e),t.prototype.postConstruct=function(){this.gridOptionsWrapper.isColumnHoverHighlight()&&this.addMouseHoverListeners()},t.prototype.addMouseHoverListeners=function(){this.addManagedListener(this.element,"mouseout",this.onMouseOut.bind(this)),this.addManagedListener(this.element,"mouseover",this.onMouseOver.bind(this))},t.prototype.onMouseOut=function(){this.columnHoverService.clearMouseOver()},t.prototype.onMouseOver=function(){this.columnHoverService.setMouseOver(this.columns)},Au([Y("columnHoverService")],t.prototype,"columnHoverService",void 0),Au([U],t.prototype,"postConstruct",null),t}(Le),Nu=function(){var e=function(t,n){return(e=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(e,t){e.__proto__=t}||function(e,t){for(var n in t)t.hasOwnProperty(n)&&(e[n]=t[n])})(t,n)};return function(t,n){function r(){this.constructor=t}e(t,n),t.prototype=null===n?Object.create(n):(r.prototype=n.prototype,new r)}}(),Iu=function(e,t,n,r){var o,i=arguments.length,s=i<3?t:null===r?r=Object.getOwnPropertyDescriptor(t,n):r;if("object"==typeof Reflect&&"function"==typeof Reflect.decorate)s=Reflect.decorate(e,t,n,r);else for(var a=e.length-1;a>=0;a--)(o=e[a])&&(s=(i<3?o(s):i>3?o(t,n,s):o(t,n))||s);return i>3&&s&&Object.defineProperty(t,n,s),s},Mu=function(e){function t(t,n){var r=e.call(this,t,n)||this;return r.column=t,r}return Nu(t,e),t.prototype.setComp=function(t,n,r,o){e.prototype.setGui.call(this,n),this.comp=t,this.eButtonShowMainFilter=r,this.eFloatingFilterBody=o;var i=this.column.getColDef(),s=!!i.filter||!!i.filterFramework,a=!!i.floatingFilter;this.active=s&&a,this.setupWidth(),this.setupLeft(),this.setupHover(),this.setupFocus(),this.setupUserComp(),this.setupSyncWithFilter(),this.setupUi(),this.addManagedListener(this.eButtonShowMainFilter,"click",this.showParentFilter.bind(this))},t.prototype.setupUi=function(){if(this.comp.addOrRemoveButtonWrapperCssClass("ag-hidden",!this.active||this.suppressFilterButton),this.active){this.comp.addOrRemoveBodyCssClass("ag-floating-filter-full-body",this.suppressFilterButton),this.comp.addOrRemoveBodyCssClass("ag-floating-filter-body",!this.suppressFilterButton);var e=wr("filter",this.gridOptionsWrapper,this.column);e&&this.eButtonShowMainFilter.appendChild(e)}},t.prototype.setupFocus=function(){this.createManagedBean(new uo(this.eGui,{shouldStopEventPropagation:this.shouldStopEventPropagation.bind(this),onTabKeyDown:this.onTabKeyDown.bind(this),handleKeyDown:this.handleKeyDown.bind(this),onFocusIn:this.onFocusIn.bind(this)}))},t.prototype.onTabKeyDown=function(e){if(!(this.gridOptionsWrapper.getDocument().activeElement===this.eGui)){var t=this.focusService.findNextFocusableElement(this.eGui,null,e.shiftKey);if(t)return this.beans.headerNavigationService.scrollToColumn(this.column),e.preventDefault(),void t.focus();var n=this.findNextColumnWithFloatingFilter(e.shiftKey);n&&this.focusService.focusHeaderPosition({headerPosition:{headerRowIndex:this.getParentRowCtrl().getRowIndex(),column:n},event:e})&&e.preventDefault()}},t.prototype.findNextColumnWithFloatingFilter=function(e){var t=this.beans.columnModel,n=this.column;do{if(!(n=e?t.getDisplayedColBefore(n):t.getDisplayedColAfter(n)))break}while(!n.getColDef().filter||!n.getColDef().floatingFilter);return n},t.prototype.handleKeyDown=function(e){var t=this.gridOptionsWrapper.getDocument().activeElement===this.eGui;switch(e.key){case io.UP:case io.DOWN:t||e.preventDefault();case io.LEFT:case io.RIGHT:if(t)return;e.stopPropagation();case io.ENTER:t&&this.focusService.focusInto(this.eGui)&&e.preventDefault();break;case io.ESCAPE:t||this.eGui.focus()}},t.prototype.onFocusIn=function(e){if(!this.eGui.contains(e.relatedTarget)){var t=!!e.relatedTarget&&!e.relatedTarget.classList.contains("ag-floating-filter"),n=!!e.relatedTarget&&qt(e.relatedTarget,"ag-floating-filter");if(t&&n&&e.target===this.eGui){var r=this.lastFocusEvent,o=!(!r||r.key!==io.TAB);if(r&&o){var i=r.shiftKey;this.focusService.focusInto(this.eGui,i)}}var s=this.getRowIndex();this.beans.focusService.setFocusedHeader(s,this.column)}},t.prototype.setupHover=function(){var e=this;this.createManagedBean(new Du([this.column],this.eGui));var t=function(){if(e.gridOptionsWrapper.isColumnHoverHighlight()){var t=e.columnHoverService.isHovered(e.column);e.comp.addOrRemoveCssClass("ag-column-hover",t)}};this.addManagedListener(this.eventService,He.EVENT_COLUMN_HOVER_CHANGED,t),t()},t.prototype.setupLeft=function(){var e=new Pu(this.column,this.eGui,this.beans);this.createManagedBean(e)},t.prototype.setupUserComp=function(){var e=this;if(this.active){var t=this.column.getColDef(),n=this.filterManager.createFilterParams(this.column,t),r=this.userComponentFactory.mergeParamsWithApplicationProvidedParams(t,Rs,n),o=this.userComponentFactory.getDefaultFloatingFilterType(t);null==o&&(o="agReadOnlyFloatingFilter");var i={column:this.column,filterParams:r,currentParentModel:function(){return e.currentParentModel()},parentFilterInstance:function(t){return e.parentFilterInstance(t)},showParentFilter:function(){return e.showParentFilter()},suppressFilterButton:!1};this.suppressFilterButton=!!t.floatingFilterComponentParams&&!!t.floatingFilterComponentParams.suppressFilterButton;var s=this.userComponentFactory.getFloatingFilterCompDetails(t,i,o);s&&this.comp.setCompDetails(s)}},t.prototype.currentParentModel=function(){var e=this.getFilterComponent(!1);return e?e.resolveNow(null,(function(e){return e&&e.getModel()})):null},t.prototype.getFilterComponent=function(e){return void 0===e&&(e=!0),this.filterManager.getFilterComponent(this.column,"NO_UI",e)},t.prototype.parentFilterInstance=function(e){var t=this.getFilterComponent();null!=t&&t.then((function(t){e(Ru(t))}))},t.prototype.showParentFilter=function(){var e=this.suppressFilterButton?this.eFloatingFilterBody:this.eButtonShowMainFilter;this.menuFactory.showMenuAfterButtonClick(this.column,e,"floatingFilter","filterMenuTab",["filterMenuTab"])},t.prototype.setupSyncWithFilter=function(){var e=this;if(this.active){var t=function(t){var n=e.comp.getFloatingFilterComp();if(n){var r=e.currentParentModel();n.then((function(e){e&&e.onParentModelChanged(r,t)}))}};this.addManagedListener(this.column,se.EVENT_FILTER_CHANGED,t),this.filterManager.isFilterActive(this.column)&&t(null)}},t.prototype.setupWidth=function(){var e=this,t=function(){var t=e.column.getActualWidth()+"px";e.comp.setWidth(t)};this.addManagedListener(this.column,se.EVENT_WIDTH_CHANGED,t),t()},Iu([Y("userComponentFactory")],t.prototype,"userComponentFactory",void 0),Iu([Y("filterManager")],t.prototype,"filterManager",void 0),Iu([Y("columnHoverService")],t.prototype,"columnHoverService",void 0),Iu([Y("gridApi")],t.prototype,"gridApi",void 0),Iu([Y("menuFactory")],t.prototype,"menuFactory",void 0),Iu([Y("beans")],t.prototype,"beans",void 0),t}(Eu),Fu=function(){var e=function(t,n){return(e=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(e,t){e.__proto__=t}||function(e,t){for(var n in t)t.hasOwnProperty(n)&&(e[n]=t[n])})(t,n)};return function(t,n){function r(){this.constructor=t}e(t,n),t.prototype=null===n?Object.create(n):(r.prototype=n.prototype,new r)}}(),xu=function(e,t,n,r){var o,i=arguments.length,s=i<3?t:null===r?r=Object.getOwnPropertyDescriptor(t,n):r;if("object"==typeof Reflect&&"function"==typeof Reflect.decorate)s=Reflect.decorate(e,t,n,r);else for(var a=e.length-1;a>=0;a--)(o=e[a])&&(s=(i<3?o(s):i>3?o(t,n,s):o(t,n))||s);return i>3&&s&&Object.defineProperty(t,n,s),s},Lu=function(e){function t(t,n,r,o,i){var s=e.call(this)||this;return s.pinned=t,s.column=n,s.eResize=r,s.comp=o,s.ctrl=i,s}return Fu(t,e),t.prototype.postConstruct=function(){var e,t,n=this,r=this.column.getColDef(),o=[],i=function(){o.forEach((function(e){return e()})),o.length=0},s=function(){var s=n.column.isResizable(),a=!n.gridOptionsWrapper.isSuppressAutoSize()&&!r.suppressAutoSize;(s!==e||a!==t)&&(e=s,t=a,i(),function(){if(zt(n.eResize,e),e){var r=n.horizontalResizeService.addResizeBar({eResizeBar:n.eResize,onResizeStart:n.onResizeStart.bind(n),onResizing:n.onResizing.bind(n,!1),onResizeEnd:n.onResizing.bind(n,!0)});if(o.push(r),t){var i=n.gridOptionsWrapper.isSkipHeaderOnAutoSize(),s=function(){n.columnModel.autoSizeColumn(n.column,i,"uiColumnResized")};n.eResize.addEventListener("dblclick",s);var a=new ai(n.eResize);a.addEventListener(ai.EVENT_DOUBLE_TAP,s),n.addDestroyFunc((function(){n.eResize.removeEventListener("dblclick",s),a.removeEventListener(ai.EVENT_DOUBLE_TAP,s),a.destroy()}))}}}())};s(),this.addDestroyFunc(i),this.ctrl.addRefreshFunction(s)},t.prototype.onResizing=function(e,t){var n=this.normaliseResizeAmount(t),r=[{key:this.column,newWidth:this.resizeStartWidth+n}];this.columnModel.setColumnWidths(r,this.resizeWithShiftKey,e,"uiColumnDragged"),e&&this.comp.addOrRemoveCssClass("ag-column-resizing",!1)},t.prototype.onResizeStart=function(e){this.resizeStartWidth=this.column.getActualWidth(),this.resizeWithShiftKey=e,this.comp.addOrRemoveCssClass("ag-column-resizing",!0)},t.prototype.normaliseResizeAmount=function(e){var t=e,n=this.pinned!==ne.PINNED_LEFT,r=this.pinned===ne.PINNED_RIGHT;return this.gridOptionsWrapper.isEnableRtl()?n&&(t*=-1):r&&(t*=-1),t},xu([Y("horizontalResizeService")],t.prototype,"horizontalResizeService",void 0),xu([Y("columnModel")],t.prototype,"columnModel",void 0),xu([U],t.prototype,"postConstruct",null),t}(Le),Gu=function(){var e=function(t,n){return(e=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(e,t){e.__proto__=t}||function(e,t){for(var n in t)t.hasOwnProperty(n)&&(e[n]=t[n])})(t,n)};return function(t,n){function r(){this.constructor=t}e(t,n),t.prototype=null===n?Object.create(n):(r.prototype=n.prototype,new r)}}(),ku=function(e){function t(t,n,r){void 0===n&&(n="ag-checkbox"),void 0===r&&(r="checkbox");var o=e.call(this,t,n,r)||this;return o.labelAlignment="right",o.selected=!1,o.readOnly=!1,o.passive=!1,o}return Gu(t,e),t.prototype.addInputListeners=function(){this.addManagedListener(this.eInput,"click",this.onCheckboxClick.bind(this)),this.addManagedListener(this.eLabel,"click",this.toggle.bind(this))},t.prototype.getNextValue=function(){return void 0===this.selected||!this.selected},t.prototype.setPassive=function(e){this.passive=e},t.prototype.isReadOnly=function(){return this.readOnly},t.prototype.setReadOnly=function(e){this.eWrapper.classList.toggle("ag-disabled",e),this.eInput.disabled=e,this.readOnly=e},t.prototype.setDisabled=function(t){return this.eWrapper.classList.toggle("ag-disabled",t),e.prototype.setDisabled.call(this,t)},t.prototype.toggle=function(){if(!this.eInput.disabled){var e=this.isSelected(),t=this.getNextValue();this.passive?this.dispatchChange(t,e):this.setValue(t)}},t.prototype.getValue=function(){return this.isSelected()},t.prototype.setValue=function(e,t){return this.refreshSelectedClass(e),this.setSelected(e,t),this},t.prototype.setName=function(e){return this.getInputElement().name=e,this},t.prototype.isSelected=function(){return this.selected},t.prototype.setSelected=function(e,t){this.isSelected()!==e&&(this.previousValue=this.isSelected(),e=this.selected="boolean"==typeof e?e:void 0,this.eInput.checked=e,this.eInput.indeterminate=void 0===e,t||this.dispatchChange(this.selected,this.previousValue))},t.prototype.dispatchChange=function(e,n,r){this.dispatchEvent({type:t.EVENT_CHANGED,selected:e,previousValue:n,event:r});var o=this.getInputElement(),i={type:He.EVENT_CHECKBOX_CHANGED,id:o.id,name:o.name,selected:e,previousValue:n};this.eventService.dispatchEvent(i)},t.prototype.onCheckboxClick=function(e){if(!this.passive&&!this.eInput.disabled){var t=this.isSelected(),n=this.selected=e.target.checked;this.refreshSelectedClass(n),this.dispatchChange(n,t,e)}},t.prototype.refreshSelectedClass=function(e){this.eWrapper.classList.toggle("ag-checked",!0===e),this.eWrapper.classList.toggle("ag-indeterminate",null==e)},t}(To),Vu=function(){var e=function(t,n){return(e=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(e,t){e.__proto__=t}||function(e,t){for(var n in t)t.hasOwnProperty(n)&&(e[n]=t[n])})(t,n)};return function(t,n){function r(){this.constructor=t}e(t,n),t.prototype=null===n?Object.create(n):(r.prototype=n.prototype,new r)}}(),Hu=function(e,t,n,r){var o,i=arguments.length,s=i<3?t:null===r?r=Object.getOwnPropertyDescriptor(t,n):r;if("object"==typeof Reflect&&"function"==typeof Reflect.decorate)s=Reflect.decorate(e,t,n,r);else for(var a=e.length-1;a>=0;a--)(o=e[a])&&(s=(i<3?o(s):i>3?o(t,n,s):o(t,n))||s);return i>3&&s&&Object.defineProperty(t,n,s),s},Wu=function(e){function t(t){var n=e.call(this)||this;n.cbSelectAllVisible=!1,n.processingEventFromCheckbox=!1,n.column=t;var r=t.getColDef();return n.filteredOnly=!!r&&!!r.headerCheckboxSelectionFilteredOnly,n}return Vu(t,e),t.prototype.onSpaceKeyPressed=function(e){var t=this.cbSelectAll,n=this.gridOptionsWrapper.getDocument();t.isDisplayed()&&!t.getGui().contains(n.activeElement)&&(e.preventDefault(),t.setValue(!t.getValue()))},t.prototype.getCheckboxGui=function(){return this.cbSelectAll.getGui()},t.prototype.setComp=function(e){this.headerCellCtrl=e,this.cbSelectAll=this.createManagedBean(new ku),this.cbSelectAll.addCssClass("ag-header-select-all"),In(this.cbSelectAll.getGui(),"presentation"),this.showOrHideSelectAll(),this.addManagedListener(this.eventService,He.EVENT_NEW_COLUMNS_LOADED,this.showOrHideSelectAll.bind(this)),this.addManagedListener(this.eventService,He.EVENT_DISPLAYED_COLUMNS_CHANGED,this.showOrHideSelectAll.bind(this)),this.addManagedListener(this.eventService,He.EVENT_SELECTION_CHANGED,this.onSelectionChanged.bind(this)),this.addManagedListener(this.eventService,He.EVENT_MODEL_UPDATED,this.onModelChanged.bind(this)),this.addManagedListener(this.cbSelectAll,ku.EVENT_CHANGED,this.onCbSelectAll.bind(this)),this.cbSelectAll.getInputElement().setAttribute("tabindex","-1"),this.refreshSelectAllLabel()},t.prototype.showOrHideSelectAll=function(){this.cbSelectAllVisible=this.isCheckboxSelection(),this.cbSelectAll.setDisplayed(this.cbSelectAllVisible),this.cbSelectAllVisible&&(this.checkRightRowModelType(),this.updateStateOfCheckbox()),this.refreshSelectAllLabel()},t.prototype.onModelChanged=function(){this.cbSelectAllVisible&&this.updateStateOfCheckbox()},t.prototype.onSelectionChanged=function(){this.cbSelectAllVisible&&this.updateStateOfCheckbox()},t.prototype.getNextCheckboxState=function(e){return(0!==e.selected||0!==e.notSelected)&&(e.selected>0&&e.notSelected>0?null:e.selected>0)},t.prototype.updateStateOfCheckbox=function(){if(!this.processingEventFromCheckbox){this.processingEventFromCheckbox=!0;var e=this.getSelectionCount(),t=this.getNextCheckboxState(e);this.cbSelectAll.setValue(t),this.refreshSelectAllLabel(),this.processingEventFromCheckbox=!1}},t.prototype.refreshSelectAllLabel=function(){if(this.cbSelectAllVisible){var e=this.gridOptionsWrapper.getLocaleTextFunc(),t=this.cbSelectAll.getValue()?e("ariaChecked","checked"):e("ariaUnchecked","unchecked"),n=e("ariaRowSelectAll","Press Space to toggle all rows selection");this.headerCellCtrl.setAriaDescriptionProperty("selectAll",n+" ("+t+")")}else this.headerCellCtrl.setAriaDescriptionProperty("selectAll",null);this.headerCellCtrl.refreshAriaDescription()},t.prototype.getSelectionCount=function(){var e=this,t=0,n=0,r=function(r){e.gridOptionsWrapper.isGroupSelectsChildren()&&r.group||(r.isSelected()?t++:r.selectable&&n++)};return this.filteredOnly?this.gridApi.forEachNodeAfterFilter(r):this.gridApi.forEachNode(r),{notSelected:n,selected:t}},t.prototype.checkRightRowModelType=function(){var e=this.rowModel.getType();e===ne.ROW_MODEL_TYPE_CLIENT_SIDE||console.warn("AG Grid: selectAllCheckbox is only available if using normal row model, you are using "+e)},t.prototype.onCbSelectAll=function(){this.processingEventFromCheckbox||this.cbSelectAllVisible&&(this.cbSelectAll.getValue()?this.selectionService.selectAllRowNodes(this.filteredOnly):this.selectionService.deselectAllRowNodes(this.filteredOnly))},t.prototype.isCheckboxSelection=function(){var e=this.column.getColDef().headerCheckboxSelection;"function"==typeof e&&(e=e({column:this.column,colDef:this.column.getColDef(),columnApi:this.columnApi,api:this.gridApi,context:this.gridOptionsWrapper.getContext()}));return!!e&&(this.gridOptionsWrapper.isRowModelServerSide()?(console.warn("AG Grid: headerCheckboxSelection is not supported for Server Side Row Model"),!1):this.gridOptionsWrapper.isRowModelInfinite()?(console.warn("AG Grid: headerCheckboxSelection is not supported for Infinite Row Model"),!1):!this.gridOptionsWrapper.isRowModelViewport()||(console.warn("AG Grid: headerCheckboxSelection is not supported for Viewport Row Model"),!1))},Hu([Y("gridApi")],t.prototype,"gridApi",void 0),Hu([Y("columnApi")],t.prototype,"columnApi",void 0),Hu([Y("rowModel")],t.prototype,"rowModel",void 0),Hu([Y("selectionService")],t.prototype,"selectionService",void 0),t}(Le),Bu=function(){var e=function(t,n){return(e=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(e,t){e.__proto__=t}||function(e,t){for(var n in t)t.hasOwnProperty(n)&&(e[n]=t[n])})(t,n)};return function(t,n){function r(){this.constructor=t}e(t,n),t.prototype=null===n?Object.create(n):(r.prototype=n.prototype,new r)}}(),ju=function(e,t,n,r){var o,i=arguments.length,s=i<3?t:null===r?r=Object.getOwnPropertyDescriptor(t,n):r;if("object"==typeof Reflect&&"function"==typeof Reflect.decorate)s=Reflect.decorate(e,t,n,r);else for(var a=e.length-1;a>=0;a--)(o=e[a])&&(s=(i<3?o(s):i>3?o(t,n,s):o(t,n))||s);return i>3&&s&&Object.defineProperty(t,n,s),s},Uu=function(t){function n(e,n){var r=t.call(this,e,n)||this;return r.refreshFunctions=[],r.userHeaderClasses=new Set,r.ariaDescriptionProperties=new Map,r.column=e,r}return Bu(n,t),n.prototype.setComp=function(e,n,r){var o=this;t.prototype.setGui.call(this,n),this.comp=e,this.colDefVersion=this.columnModel.getColDefVersion(),this.updateState(),this.setupWidth(),this.setupMovingCss(),this.setupMenuClass(),this.setupSortableClass(),this.addColumnHoverListener(),this.setupFilterCss(),this.setupColId(),this.setupClassesFromColDef(),this.setupTooltip(),this.addActiveHeaderMouseListeners(),this.setupSelectAll(),this.setupUserComp(),this.refreshAria(),this.createManagedBean(new Lu(this.getPinned(),this.column,r,e,this)),this.createManagedBean(new Du([this.column],n)),this.createManagedBean(new Pu(this.column,n,this.beans)),this.createManagedBean(new uo(n,{shouldStopEventPropagation:function(e){return o.shouldStopEventPropagation(e)},onTabKeyDown:function(){return null},handleKeyDown:this.handleKeyDown.bind(this),onFocusIn:this.onFocusIn.bind(this),onFocusOut:this.onFocusOut.bind(this)})),this.addManagedListener(this.eventService,He.EVENT_NEW_COLUMNS_LOADED,this.onNewColumnsLoaded.bind(this)),this.addManagedListener(this.eventService,He.EVENT_COLUMN_VALUE_CHANGED,this.onColumnValueChanged.bind(this)),this.addManagedListener(this.eventService,He.EVENT_COLUMN_ROW_GROUP_CHANGED,this.onColumnRowGroupChanged.bind(this)),this.addManagedListener(this.eventService,He.EVENT_COLUMN_PIVOT_CHANGED,this.onColumnPivotChanged.bind(this))},n.prototype.setupUserComp=function(){var e=this.lookupUserCompDetails();this.setCompDetails(e)},n.prototype.setCompDetails=function(e){this.userCompDetails=e,this.comp.setUserCompDetails(e)},n.prototype.lookupUserCompDetails=function(){var e=this.createParams(),t=this.column.getColDef();return this.userComponentFactory.getHeaderCompDetails(t,e)},n.prototype.createParams=function(){var e=this,t=this.column.getColDef();return{column:this.column,displayName:this.displayName,enableSorting:t.sortable,enableMenu:this.menuEnabled,showColumnMenu:function(t){e.gridApi.showColumnMenuAfterButtonClick(e.column,t)},progressSort:function(t){e.sortController.progressSort(e.column,!!t,"uiColumnSorted")},setSort:function(t,n){e.sortController.setSortForColumn(e.column,t,!!n,"uiColumnSorted")},api:this.gridApi,columnApi:this.columnApi,context:this.gridOptionsWrapper.getContext(),eGridHeader:this.getGui()}},n.prototype.setupSelectAll=function(){this.selectAllFeature=this.createManagedBean(new Wu(this.column)),this.selectAllFeature.setComp(this)},n.prototype.getSelectAllGui=function(){return this.selectAllFeature.getCheckboxGui()},n.prototype.handleKeyDown=function(e){e.key===io.SPACE&&this.selectAllFeature.onSpaceKeyPressed(e),e.key===io.ENTER&&this.onEnterKeyPressed(e)},n.prototype.onEnterKeyPressed=function(e){var t=this.comp.getUserCompInstance();if(t)if(e.ctrlKey||e.metaKey)this.menuEnabled&&t.showMenu&&(e.preventDefault(),t.showMenu());else if(this.sortable){var n=e.shiftKey;this.sortController.progressSort(this.column,n,"uiColumnSorted")}},n.prototype.isMenuEnabled=function(){return this.menuEnabled},n.prototype.onFocusIn=function(e){if(!this.getGui().contains(e.relatedTarget)){var t=this.getRowIndex();this.focusService.setFocusedHeader(t,this.column)}this.setActiveHeader(!0)},n.prototype.onFocusOut=function(e){this.getGui().contains(e.relatedTarget)||this.setActiveHeader(!1)},n.prototype.setupTooltip=function(){var e=this,t={getColumn:function(){return e.column},getColDef:function(){return e.column.getColDef()},getGui:function(){return e.eGui},getLocation:function(){return"header"},getTooltipValue:function(){return e.column.getColDef().headerTooltip}},n=this.createManagedBean(new Fa(t,this.beans));n.setComp(this.comp),this.refreshFunctions.push((function(){return n.refreshToolTip()}))},n.prototype.setupClassesFromColDef=function(){var e=this,t=function(){var t=e.column.getColDef(),n=e.gridOptionsWrapper,r=lu.getHeaderClassesFromColDef(t,n,e.column,null),o=e.userHeaderClasses;e.userHeaderClasses=new Set(r),r.forEach((function(t){o.has(t)?o.delete(t):e.comp.addOrRemoveCssClass(t,!0)})),o.forEach((function(t){return e.comp.addOrRemoveCssClass(t,!1)}))};this.refreshFunctions.push(t),t()},n.prototype.setDragSource=function(t){var n=this;this.dragSourceElement=t,this.removeDragSource(),t&&this.draggable&&(this.moveDragSource={type:e.DragSourceType.HeaderCell,eElement:t,defaultIconName:Bi.ICON_HIDE,getDragItem:function(){return n.createDragItem()},dragItemName:this.displayName,onDragStarted:function(){return n.column.setMoving(!0,"uiColumnMoved")},onDragStopped:function(){return n.column.setMoving(!1,"uiColumnMoved")}},this.dragAndDropService.addDragSource(this.moveDragSource,!0))},n.prototype.createDragItem=function(){var e={};return e[this.column.getId()]=this.column.isVisible(),{columns:[this.column],visibleState:e}},n.prototype.removeDragSource=function(){this.moveDragSource&&(this.dragAndDropService.removeDragSource(this.moveDragSource),this.moveDragSource=void 0)},n.prototype.onNewColumnsLoaded=function(){var e=this.columnModel.getColDefVersion();e!=this.colDefVersion&&(this.colDefVersion=e,this.refresh())},n.prototype.updateState=function(){var e=this.column.getColDef();this.menuEnabled=this.menuFactory.isMenuEnabled(this.column)&&!e.suppressMenu,this.sortable=e.sortable,this.displayName=this.calculateDisplayName(),this.draggable=this.workOutDraggable()},n.prototype.addRefreshFunction=function(e){this.refreshFunctions.push(e)},n.prototype.refresh=function(){this.updateState(),this.refreshHeaderComp(),this.refreshAria(),this.refreshFunctions.forEach((function(e){return e()}))},n.prototype.refreshHeaderComp=function(){var e=this.lookupUserCompDetails();!!(null!=this.comp.getUserCompInstance()&&this.userCompDetails.componentClass==e.componentClass)&&this.attemptHeaderCompRefresh(e.params)?this.setDragSource(this.dragSourceElement):this.setCompDetails(e)},n.prototype.attemptHeaderCompRefresh=function(e){var t=this.comp.getUserCompInstance();return!!t&&(!!t.refresh&&t.refresh(e))},n.prototype.calculateDisplayName=function(){return this.columnModel.getDisplayNameForColumn(this.column,"header",!0)},n.prototype.checkDisplayName=function(){this.displayName!==this.calculateDisplayName()&&this.refresh()},n.prototype.workOutDraggable=function(){var e=this.column.getColDef();return!!(!this.gridOptionsWrapper.isSuppressMovableColumns()&&!e.suppressMovable&&!e.lockPosition)||!!e.enableRowGroup||!!e.enablePivot},n.prototype.onColumnRowGroupChanged=function(){this.checkDisplayName()},n.prototype.onColumnPivotChanged=function(){this.checkDisplayName()},n.prototype.onColumnValueChanged=function(){this.checkDisplayName()},n.prototype.setupWidth=function(){var e=this,t=function(){e.comp.setWidth(e.column.getActualWidth()+"px")};this.addManagedListener(this.column,se.EVENT_WIDTH_CHANGED,t),t()},n.prototype.setupMovingCss=function(){var e=this,t=function(){e.comp.addOrRemoveCssClass("ag-header-cell-moving",e.column.isMoving())};this.addManagedListener(this.column,se.EVENT_MOVING_CHANGED,t),t()},n.prototype.setupMenuClass=function(){var e=this,t=function(){e.comp.addOrRemoveCssClass("ag-column-menu-visible",e.column.isMenuVisible())};this.addManagedListener(this.column,se.EVENT_MENU_VISIBLE_CHANGED,t),t()},n.prototype.setupSortableClass=function(){var e=this,t=function(){e.comp.addOrRemoveCssClass("ag-header-cell-sortable",!!e.sortable)};t(),this.addRefreshFunction(t),this.addManagedListener(this.column,se.EVENT_SORT_CHANGED,this.refreshAriaSort.bind(this))},n.prototype.refreshAriaSort=function(){if(this.sortable){var e=this.gridOptionsWrapper.getLocaleTextFunc();this.comp.setAriaSort(Mn(this.column)),this.setAriaDescriptionProperty("sort",e("ariaSortableColumn","Press ENTER to sort."))}else this.comp.setAriaSort(),this.setAriaDescriptionProperty("sort",null)},n.prototype.refreshAriaMenu=function(){if(this.menuEnabled){var e=this.gridOptionsWrapper.getLocaleTextFunc();this.setAriaDescriptionProperty("menu",e("ariaMenuColumn","Press CTRL ENTER to open column menu."))}else this.setAriaDescriptionProperty("menu",null)},n.prototype.setAriaDescriptionProperty=function(e,t){null!=t?this.ariaDescriptionProperties.set(e,t):this.ariaDescriptionProperties.delete(e)},n.prototype.refreshAriaDescription=function(){var e=Array.from(this.ariaDescriptionProperties.values());this.comp.setAriaDescription(e.length?e.join(" "):void 0)},n.prototype.refreshAria=function(){this.refreshAriaSort(),this.refreshAriaMenu(),this.refreshAriaDescription()},n.prototype.addColumnHoverListener=function(){var e=this,t=function(){if(e.gridOptionsWrapper.isColumnHoverHighlight()){var t=e.columnHoverService.isHovered(e.column);e.comp.addOrRemoveCssClass("ag-column-hover",t)}};this.addManagedListener(this.eventService,He.EVENT_COLUMN_HOVER_CHANGED,t),t()},n.prototype.setupFilterCss=function(){var e=this,t=function(){e.comp.addOrRemoveCssClass("ag-header-cell-filtered",e.column.isFilterActive())};this.addManagedListener(this.column,se.EVENT_FILTER_ACTIVE_CHANGED,t),t()},n.prototype.setupColId=function(){this.comp.setColId(this.column.getColId())},n.prototype.addActiveHeaderMouseListeners=function(){var e=this,t=function(t){return e.setActiveHeader("mouseenter"===t.type)};this.addManagedListener(this.getGui(),"mouseenter",t),this.addManagedListener(this.getGui(),"mouseleave",t)},n.prototype.setActiveHeader=function(e){this.comp.addOrRemoveCssClass("ag-header-active",e)},ju([Y("columnModel")],n.prototype,"columnModel",void 0),ju([Y("columnHoverService")],n.prototype,"columnHoverService",void 0),ju([Y("beans")],n.prototype,"beans",void 0),ju([Y("sortController")],n.prototype,"sortController",void 0),ju([Y("menuFactory")],n.prototype,"menuFactory",void 0),ju([Y("dragAndDropService")],n.prototype,"dragAndDropService",void 0),ju([Y("gridApi")],n.prototype,"gridApi",void 0),ju([Y("columnApi")],n.prototype,"columnApi",void 0),ju([Y("userComponentFactory")],n.prototype,"userComponentFactory",void 0),ju([z],n.prototype,"removeDragSource",null),n}(Eu),zu=function(){var e=function(t,n){return(e=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(e,t){e.__proto__=t}||function(e,t){for(var n in t)t.hasOwnProperty(n)&&(e[n]=t[n])})(t,n)};return function(t,n){function r(){this.constructor=t}e(t,n),t.prototype=null===n?Object.create(n):(r.prototype=n.prototype,new r)}}(),Ku=function(e,t,n,r){var o,i=arguments.length,s=i<3?t:null===r?r=Object.getOwnPropertyDescriptor(t,n):r;if("object"==typeof Reflect&&"function"==typeof Reflect.decorate)s=Reflect.decorate(e,t,n,r);else for(var a=e.length-1;a>=0;a--)(o=e[a])&&(s=(i<3?o(s):i>3?o(t,n,s):o(t,n))||s);return i>3&&s&&Object.defineProperty(t,n,s),s},Yu=function(e){function t(t,n,r,o){var i=e.call(this)||this;return i.eResize=n,i.comp=t,i.pinned=r,i.columnGroup=o,i}return zu(t,e),t.prototype.postConstruct=function(){var e=this;if(this.columnGroup.isResizable()){var t=this.horizontalResizeService.addResizeBar({eResizeBar:this.eResize,onResizeStart:this.onResizeStart.bind(this),onResizing:this.onResizing.bind(this,!1),onResizeEnd:this.onResizing.bind(this,!0)});if(this.addDestroyFunc(t),!this.gridOptionsWrapper.isSuppressAutoSize()){var n=this.gridOptionsWrapper.isSkipHeaderOnAutoSize();this.eResize.addEventListener("dblclick",(function(){var t=[];e.columnGroup.getDisplayedLeafColumns().forEach((function(e){e.getColDef().suppressAutoSize||t.push(e.getColId())})),t.length>0&&e.columnModel.autoSizeColumns({columns:t,skipHeader:n,stopAtGroup:e.columnGroup,source:"uiColumnResized"}),e.resizeLeafColumnsToFit()}))}}else this.comp.addOrRemoveResizableCssClass("ag-hidden",!0)},t.prototype.onResizeStart=function(e){var t=this;this.calculateInitialValues();var n=null;if(e&&(n=this.columnModel.getDisplayedGroupAfter(this.columnGroup)),n){var r=n.getDisplayedLeafColumns();this.resizeTakeFromCols=r.filter((function(e){return e.isResizable()})),this.resizeTakeFromStartWidth=0,this.resizeTakeFromCols.forEach((function(e){return t.resizeTakeFromStartWidth+=e.getActualWidth()})),this.resizeTakeFromRatios=[],this.resizeTakeFromCols.forEach((function(e){return t.resizeTakeFromRatios.push(e.getActualWidth()/t.resizeTakeFromStartWidth)}))}else this.resizeTakeFromCols=null,this.resizeTakeFromStartWidth=null,this.resizeTakeFromRatios=null;this.comp.addOrRemoveCssClass("ag-column-resizing",!0)},t.prototype.onResizing=function(e,t){var n=this.normaliseDragChange(t),r=this.resizeStartWidth+n;this.resizeColumns(r,e)},t.prototype.resizeLeafColumnsToFit=function(){var e=this.autoWidthCalculator.getPreferredWidthForColumnGroup(this.columnGroup);this.calculateInitialValues(),e>this.resizeStartWidth&&this.resizeColumns(e,!0)},t.prototype.resizeColumns=function(e,t){void 0===t&&(t=!0);var n=[];if(n.push({columns:this.resizeCols,ratios:this.resizeRatios,width:e}),this.resizeTakeFromCols){var r=e-this.resizeStartWidth;n.push({columns:this.resizeTakeFromCols,ratios:this.resizeTakeFromRatios,width:this.resizeTakeFromStartWidth-r})}this.columnModel.resizeColumnSets({resizeSets:n,finished:t,source:"uiColumnDragged"}),t&&this.comp.addOrRemoveCssClass("ag-column-resizing",!1)},t.prototype.calculateInitialValues=function(){var e=this,t=this.columnGroup.getDisplayedLeafColumns();this.resizeCols=t.filter((function(e){return e.isResizable()})),this.resizeStartWidth=0,this.resizeCols.forEach((function(t){return e.resizeStartWidth+=t.getActualWidth()})),this.resizeRatios=[],this.resizeCols.forEach((function(t){return e.resizeRatios.push(t.getActualWidth()/e.resizeStartWidth)}))},t.prototype.normaliseDragChange=function(e){var t=e;return this.gridOptionsWrapper.isEnableRtl()?this.pinned!==ne.PINNED_LEFT&&(t*=-1):this.pinned===ne.PINNED_RIGHT&&(t*=-1),t},Ku([Y("horizontalResizeService")],t.prototype,"horizontalResizeService",void 0),Ku([Y("autoWidthCalculator")],t.prototype,"autoWidthCalculator",void 0),Ku([Y("columnModel")],t.prototype,"columnModel",void 0),Ku([U],t.prototype,"postConstruct",null),t}(Le),qu=function(){var e=function(t,n){return(e=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(e,t){e.__proto__=t}||function(e,t){for(var n in t)t.hasOwnProperty(n)&&(e[n]=t[n])})(t,n)};return function(t,n){function r(){this.constructor=t}e(t,n),t.prototype=null===n?Object.create(n):(r.prototype=n.prototype,new r)}}(),$u=function(e){function t(t,n){var r=e.call(this)||this;return r.removeChildListenersFuncs=[],r.columnGroup=n,r.comp=t,r}return qu(t,e),t.prototype.postConstruct=function(){this.addListenersToChildrenColumns(),this.addManagedListener(this.columnGroup,me.EVENT_DISPLAYED_CHILDREN_CHANGED,this.onDisplayedChildrenChanged.bind(this)),this.onWidthChanged(),this.addDestroyFunc(this.removeListenersOnChildrenColumns.bind(this))},t.prototype.addListenersToChildrenColumns=function(){var e=this;this.removeListenersOnChildrenColumns();var t=this.onWidthChanged.bind(this);this.columnGroup.getLeafColumns().forEach((function(n){n.addEventListener(se.EVENT_WIDTH_CHANGED,t),n.addEventListener(se.EVENT_VISIBLE_CHANGED,t),e.removeChildListenersFuncs.push((function(){n.removeEventListener(se.EVENT_WIDTH_CHANGED,t),n.removeEventListener(se.EVENT_VISIBLE_CHANGED,t)}))}))},t.prototype.removeListenersOnChildrenColumns=function(){this.removeChildListenersFuncs.forEach((function(e){return e()})),this.removeChildListenersFuncs=[]},t.prototype.onDisplayedChildrenChanged=function(){this.addListenersToChildrenColumns(),this.onWidthChanged()},t.prototype.onWidthChanged=function(){this.comp.setWidth(this.columnGroup.getActualWidth()+"px")},function(e,t,n,r){var o,i=arguments.length,s=i<3?t:null===r?r=Object.getOwnPropertyDescriptor(t,n):r;if("object"==typeof Reflect&&"function"==typeof Reflect.decorate)s=Reflect.decorate(e,t,n,r);else for(var a=e.length-1;a>=0;a--)(o=e[a])&&(s=(i<3?o(s):i>3?o(t,n,s):o(t,n))||s);i>3&&s&&Object.defineProperty(t,n,s)}([U],t.prototype,"postConstruct",null),t}(Le),Xu=function(){var e=function(t,n){return(e=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(e,t){e.__proto__=t}||function(e,t){for(var n in t)t.hasOwnProperty(n)&&(e[n]=t[n])})(t,n)};return function(t,n){function r(){this.constructor=t}e(t,n),t.prototype=null===n?Object.create(n):(r.prototype=n.prototype,new r)}}(),Qu=function(e,t,n,r){var o,i=arguments.length,s=i<3?t:null===r?r=Object.getOwnPropertyDescriptor(t,n):r;if("object"==typeof Reflect&&"function"==typeof Reflect.decorate)s=Reflect.decorate(e,t,n,r);else for(var a=e.length-1;a>=0;a--)(o=e[a])&&(s=(i<3?o(s):i>3?o(t,n,s):o(t,n))||s);return i>3&&s&&Object.defineProperty(t,n,s),s},Zu=function(t){function n(e,n){var r=t.call(this,e,n)||this;return r.columnGroup=e,r}return Xu(n,t),n.prototype.setComp=function(e,n,r){t.prototype.setGui.call(this,n),this.comp=e,this.displayName=this.columnModel.getDisplayNameForColumnGroup(this.columnGroup,"header"),this.addClasses(),this.addAttributes(),this.setupMovingCss(),this.setupExpandable(),this.setupTooltip(),this.setupUserComp();var o=this.getParentRowCtrl().getPinned(),i=this.columnGroup.getProvidedColumnGroup().getLeafColumns();this.createManagedBean(new Du(i,n)),this.createManagedBean(new Pu(this.columnGroup,n,this.beans)),this.createManagedBean(new $u(e,this.columnGroup)),this.groupResizeFeature=this.createManagedBean(new Yu(e,r,o,this.columnGroup)),this.createManagedBean(new uo(n,{shouldStopEventPropagation:this.shouldStopEventPropagation.bind(this),onTabKeyDown:function(){},handleKeyDown:this.handleKeyDown.bind(this),onFocusIn:this.onFocusIn.bind(this)}))},n.prototype.resizeLeafColumnsToFit=function(){this.groupResizeFeature.onResizeStart(!1),this.groupResizeFeature.resizeLeafColumnsToFit()},n.prototype.setupUserComp=function(){var e=this,t=this.displayName,n={displayName:this.displayName,columnGroup:this.columnGroup,setExpanded:function(t){e.columnModel.setColumnGroupOpened(e.columnGroup.getProvidedColumnGroup(),t,"gridInitializing")},api:this.gridApi,columnApi:this.columnApi,context:this.gridOptionsWrapper.getContext()};if(!t){for(var r=this.columnGroup,o=r.getLeafColumns();r.getParent()&&r.getParent().getLeafColumns().length===o.length;)r=r.getParent();var i=r.getColGroupDef();i&&(t=i.headerName),t||(t=o?this.columnModel.getDisplayNameForColumn(o[0],"header",!0):"")}var s=this.userComponentFactory.getHeaderGroupCompDetails(n);this.comp.setUserCompDetails(s)},n.prototype.setupTooltip=function(){var e=this,t=this.columnGroup.getColGroupDef(),n={getColumn:function(){return e.columnGroup},getGui:function(){return e.eGui},getLocation:function(){return"headerGroup"},getTooltipValue:function(){return t&&t.headerTooltip}};t&&(n.getColDef=function(){return t}),this.createManagedBean(new Fa(n,this.beans)).setComp(this.comp)},n.prototype.setupExpandable=function(){var e=this.columnGroup.getProvidedColumnGroup();this.refreshExpanded(),this.addManagedListener(e,Ce.EVENT_EXPANDABLE_CHANGED,this.refreshExpanded.bind(this)),this.addManagedListener(e,Ce.EVENT_EXPANDED_CHANGED,this.refreshExpanded.bind(this))},n.prototype.refreshExpanded=function(){var e=this.columnGroup;this.expandable=e.isExpandable();var t=e.isExpanded();this.expandable?this.comp.setAriaExpanded(t?"true":"false"):this.comp.setAriaExpanded(void 0)},n.prototype.addAttributes=function(){this.comp.setColId(this.columnGroup.getUniqueId())},n.prototype.addClasses=function(){var e=this,t=this.columnGroup.getColGroupDef(),n=lu.getHeaderClassesFromColDef(t,this.gridOptionsWrapper,null,this.columnGroup);n.push(this.columnGroup.isPadding()?"ag-header-group-cell-no-group":"ag-header-group-cell-with-group"),n.forEach((function(t){return e.comp.addOrRemoveCssClass(t,!0)}))},n.prototype.setupMovingCss=function(){var e=this,t=this.columnGroup.getProvidedColumnGroup().getLeafColumns(),n=function(){return e.comp.addOrRemoveCssClass("ag-header-cell-moving",e.columnGroup.isMoving())};t.forEach((function(t){e.addManagedListener(t,se.EVENT_MOVING_CHANGED,n)})),n()},n.prototype.onFocusIn=function(e){if(!this.eGui.contains(e.relatedTarget)){var t=this.getRowIndex();this.beans.focusService.setFocusedHeader(t,this.columnGroup)}},n.prototype.handleKeyDown=function(e){var t=this.gridOptionsWrapper.getDocument().activeElement===this.eGui;if(this.expandable&&t&&e.key===io.ENTER){var n=this.columnGroup,r=!n.isExpanded();this.columnModel.setColumnGroupOpened(n.getProvidedColumnGroup(),r,"uiColumnExpanded")}},n.prototype.setDragSource=function(t){var n=this;if(!this.isSuppressMoving()){var r=this.columnGroup.getProvidedColumnGroup().getLeafColumns(),o={type:e.DragSourceType.HeaderCell,eElement:t,defaultIconName:Bi.ICON_HIDE,dragItemName:this.displayName,getDragItem:this.getDragItemForGroup.bind(this),onDragStarted:function(){return r.forEach((function(e){return e.setMoving(!0,"uiColumnDragged")}))},onDragStopped:function(){return r.forEach((function(e){return e.setMoving(!1,"uiColumnDragged")}))}};this.dragAndDropService.addDragSource(o,!0),this.addDestroyFunc((function(){return n.dragAndDropService.removeDragSource(o)}))}},n.prototype.getDragItemForGroup=function(){var e=this.columnGroup.getProvidedColumnGroup().getLeafColumns(),t={};e.forEach((function(e){return t[e.getId()]=e.isVisible()}));var n=[];return this.columnModel.getAllDisplayedColumns().forEach((function(t){e.indexOf(t)>=0&&(n.push(t),pe(e,t))})),e.forEach((function(e){return n.push(e)})),{columns:n,visibleState:t}},n.prototype.isSuppressMoving=function(){var e=!1;return this.columnGroup.getLeafColumns().forEach((function(t){(t.getColDef().suppressMovable||t.getColDef().lockPosition)&&(e=!0)})),e||this.gridOptionsWrapper.isSuppressMovableColumns()},Qu([Y("beans")],n.prototype,"beans",void 0),Qu([Y("columnModel")],n.prototype,"columnModel",void 0),Qu([Y("dragAndDropService")],n.prototype,"dragAndDropService",void 0),Qu([Y("userComponentFactory")],n.prototype,"userComponentFactory",void 0),Qu([Y("gridApi")],n.prototype,"gridApi",void 0),Qu([Y("columnApi")],n.prototype,"columnApi",void 0),n}(Eu),Ju=function(){var e=function(t,n){return(e=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(e,t){e.__proto__=t}||function(e,t){for(var n in t)t.hasOwnProperty(n)&&(e[n]=t[n])})(t,n)};return function(t,n){function r(){this.constructor=t}e(t,n),t.prototype=null===n?Object.create(n):(r.prototype=n.prototype,new r)}}(),ec=function(e,t,n,r){var o,i=arguments.length,s=i<3?t:null===r?r=Object.getOwnPropertyDescriptor(t,n):r;if("object"==typeof Reflect&&"function"==typeof Reflect.decorate)s=Reflect.decorate(e,t,n,r);else for(var a=e.length-1;a>=0;a--)(o=e[a])&&(s=(i<3?o(s):i>3?o(t,n,s):o(t,n))||s);return i>3&&s&&Object.defineProperty(t,n,s),s},tc=0,nc=function(t){function n(e,n,r){var o=t.call(this)||this;return o.instanceId=tc++,o.headerCellCtrls={},o.rowIndex=e,o.pinned=n,o.type=r,o}return Ju(n,t),n.prototype.getInstanceId=function(){return this.instanceId},n.prototype.setComp=function(e){this.comp=e,this.onRowHeightChanged(),this.onVirtualColumnsChanged(),this.setWidth(),this.addEventListeners(),Nt()&&this.comp.setTransform("translateZ(0)"),e.setAriaRowIndex(this.rowIndex+1)},n.prototype.addEventListeners=function(){this.addManagedListener(this.eventService,He.EVENT_COLUMN_RESIZED,this.onColumnResized.bind(this)),this.addManagedListener(this.gridOptionsWrapper,ra.PROP_DOM_LAYOUT,this.onDisplayedColumnsChanged.bind(this)),this.addManagedListener(this.eventService,He.EVENT_DISPLAYED_COLUMNS_CHANGED,this.onDisplayedColumnsChanged.bind(this)),this.addManagedListener(this.eventService,He.EVENT_VIRTUAL_COLUMNS_CHANGED,this.onVirtualColumnsChanged.bind(this)),this.addManagedListener(this.gridOptionsWrapper,ra.PROP_HEADER_HEIGHT,this.onRowHeightChanged.bind(this)),this.addManagedListener(this.gridOptionsWrapper,ra.PROP_PIVOT_HEADER_HEIGHT,this.onRowHeightChanged.bind(this)),this.addManagedListener(this.gridOptionsWrapper,ra.PROP_GROUP_HEADER_HEIGHT,this.onRowHeightChanged.bind(this)),this.addManagedListener(this.gridOptionsWrapper,ra.PROP_PIVOT_GROUP_HEADER_HEIGHT,this.onRowHeightChanged.bind(this)),this.addManagedListener(this.gridOptionsWrapper,ra.PROP_FLOATING_FILTERS_HEIGHT,this.onRowHeightChanged.bind(this))},n.prototype.getHeaderCellCtrl=function(e){return c(this.headerCellCtrls).find((function(t){return t.getColumnGroupChild()===e}))},n.prototype.onDisplayedColumnsChanged=function(){this.onVirtualColumnsChanged(),this.setWidth()},n.prototype.getType=function(){return this.type},n.prototype.onColumnResized=function(){this.setWidth()},n.prototype.setWidth=function(){var e=this.getWidthForRow();this.comp.setWidth(e+"px")},n.prototype.getWidthForRow=function(){return this.gridOptionsWrapper.getDomLayout()===ne.DOM_LAYOUT_PRINT?null!=this.pinned?0:this.columnModel.getContainerWidth(ne.PINNED_RIGHT)+this.columnModel.getContainerWidth(ne.PINNED_LEFT)+this.columnModel.getContainerWidth(null):this.columnModel.getContainerWidth(this.pinned)},n.prototype.onRowHeightChanged=function(){var e,t,n=this.columnModel.getHeaderRowCount(),r=[],o=0;this.columnModel.hasFloatingFilters()&&(n++,o=1),this.columnModel.isPivotMode()?(e=this.gridOptionsWrapper.getPivotGroupHeaderHeight(),t=this.gridOptionsWrapper.getPivotHeaderHeight()):(e=this.gridOptionsWrapper.getGroupHeaderHeight(),t=this.gridOptionsWrapper.getHeaderHeight());for(var i=n-(1+o),s=0;s=0;a--)(o=e[a])&&(s=(i<3?o(s):i>3?o(t,n,s):o(t,n))||s);return i>3&&s&&Object.defineProperty(t,n,s),s},ic=function(e,t){var n="function"==typeof Symbol&&e[Symbol.iterator];if(!n)return e;var r,o,i=n.call(e),s=[];try{for(;(void 0===t||t-- >0)&&!(r=i.next()).done;)s.push(r.value)}catch(a){o={error:a}}finally{try{r&&!r.done&&(n=i.return)&&n.call(i)}finally{if(o)throw o.error}}return s},sc=function(t){function n(e){var n=t.call(this)||this;return n.groupsRowCtrls=[],n.pinned=e,n}return rc(n,t),n.prototype.setComp=function(e,t){this.comp=e,this.setupCenterWidth(),this.setupPinnedWidth(),this.setupDragAndDrop(t),this.addManagedListener(this.eventService,He.EVENT_GRID_COLUMNS_CHANGED,this.onGridColumnsChanged.bind(this)),this.ctrlsService.registerHeaderContainer(this,this.pinned),this.columnModel.isReady()&&this.refresh()},n.prototype.setupDragAndDrop=function(e){var t=new su(this.pinned,e);this.createManagedBean(t)},n.prototype.refresh=function(t){var n=this;void 0===t&&(t=!1);var r,o=new Fr,i=this.focusService.getFocusHeaderToUseAfterRefresh();!function(){var t=n.columnModel.getHeaderRowCount()-1;n.groupsRowCtrls=n.destroyBeans(n.groupsRowCtrls);for(var r=0;r=0;a--)(o=e[a])&&(s=(i<3?o(s):i>3?o(t,n,s):o(t,n))||s);return i>3&&s&&Object.defineProperty(t,n,s),s},uc=function(e){function t(t){var n=e.call(this)||this;return n.headerRowComps={},n.rowCompsList=[],n.pinned=t,n}return ac(t,e),t.prototype.init=function(){var e=this;this.selectAndSetTemplate();var t={addOrRemoveCssClass:function(t,n){return e.addOrRemoveCssClass(t,n)},setCtrls:function(t){return e.setCtrls(t)},setCenterWidth:function(t){return e.eCenterContainer.style.width=t},setContainerTransform:function(t){return e.eCenterContainer.style.transform=t},setPinnedContainerWidth:function(t){var n=e.getGui();n.style.width=t,n.style.maxWidth=t,n.style.minWidth=t}};this.createManagedBean(new sc(this.pinned)).setComp(t,this.getGui())},t.prototype.selectAndSetTemplate=function(){var e=this.pinned==ne.PINNED_LEFT,n=this.pinned==ne.PINNED_RIGHT,r=e?t.PINNED_LEFT_TEMPLATE:n?t.PINNED_RIGHT_TEMPLATE:t.CENTER_TEMPLATE;this.setTemplate(r),this.eRowContainer=this.eCenterContainer?this.eCenterContainer:this.getGui()},t.prototype.destroyRowComps=function(){this.setCtrls([])},t.prototype.destroyRowComp=function(e){this.destroyBean(e),this.eRowContainer.removeChild(e.getGui())},t.prototype.setCtrls=function(e){var t,n=this,r=this.headerRowComps;this.headerRowComps={},this.rowCompsList=[];e.forEach((function(e){var o=e.getInstanceId(),i=r[o];delete r[o];var s=i||n.createBean(new mu(e));n.headerRowComps[o]=s,n.rowCompsList.push(s),function(e){var r=e.getGui();r.parentElement!=n.eRowContainer&&n.eRowContainer.appendChild(r),t&&cn(n.eRowContainer,r,t),t=r}(s)})),w(r).forEach((function(e){return n.destroyRowComp(e)}))},t.PINNED_LEFT_TEMPLATE='