From 639e79cd3268bb44c952c6a63a6199b4586ee4e2 Mon Sep 17 00:00:00 2001 From: terwer Date: Sat, 6 May 2023 01:08:50 +0800 Subject: [PATCH] feat(zhi-core): smallest runnable kernel --- packages/zhi-core/src/lib/core/Bootstrap.ts | 46 + packages/zhi-core/src/lib/core/lifecycle.ts | 164 + packages/zhi-core/src/lib/zhi.ts | 138 +- .../zhi-loader/public/config/zhi-schema.js | 154 + .../zhi-loader/public/config/zhi.example.js | 89 + packages/zhi-loader/public/config/zhi.js | 56 + .../public/core/plugin-system/README.md | 4 + .../public/core/plugin-system/plugin.js | 14444 ++++++++++++++++ .../core/plugin-system/zhi-plugin-loader.js | 158 + 9 files changed, 15252 insertions(+), 1 deletion(-) create mode 100644 packages/zhi-core/src/lib/core/Bootstrap.ts create mode 100644 packages/zhi-core/src/lib/core/lifecycle.ts create mode 100644 packages/zhi-loader/public/config/zhi-schema.js create mode 100644 packages/zhi-loader/public/config/zhi.example.js create mode 100644 packages/zhi-loader/public/config/zhi.js create mode 100644 packages/zhi-loader/public/core/plugin-system/README.md create mode 100644 packages/zhi-loader/public/core/plugin-system/plugin.js create mode 100644 packages/zhi-loader/public/core/plugin-system/zhi-plugin-loader.js diff --git a/packages/zhi-core/src/lib/core/Bootstrap.ts b/packages/zhi-core/src/lib/core/Bootstrap.ts new file mode 100644 index 00000000..3eb48dc4 --- /dev/null +++ b/packages/zhi-core/src/lib/core/Bootstrap.ts @@ -0,0 +1,46 @@ +/* + * Copyright (c) 2023, Terwer . All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. Terwer designates this + * particular file as subject to the "Classpath" exception as provided + * by Terwer in the LICENSE file that accompanied this code. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Terwer, Shenzhen, Guangdong, China, youweics@163.com + * or visit www.terwer.space if you need additional information or have any + * questions. + */ + +import Lifecycle from "./lifecycle" +import DependencyItem from "../models/DependencyItem" + +/** + * zhi主题唯一激活入口 + * + * @author terwer + * @since 0.1.0 + */ +class Bootstrap { + private static lifecycle = new Lifecycle() + + /** + * 主题激活 + */ + public static async start(): Promise { + return await this.lifecycle.load() + } +} + +export default Bootstrap diff --git a/packages/zhi-core/src/lib/core/lifecycle.ts b/packages/zhi-core/src/lib/core/lifecycle.ts new file mode 100644 index 00000000..fb0a91ab --- /dev/null +++ b/packages/zhi-core/src/lib/core/lifecycle.ts @@ -0,0 +1,164 @@ +/* + * Copyright (c) 2023, Terwer . All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. Terwer designates this + * particular file as subject to the "Classpath" exception as provided + * by Terwer in the LICENSE file that accompanied this code. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Terwer, Shenzhen, Guangdong, China, youweics@163.com + * or visit www.terwer.space if you need additional information or have any + * questions. + */ + +import DependencyItem from "../models/DependencyItem" +import { SiyuanDevice } from "@siyuan-community/zhi-device" +import ZhiCoreUtil from "../util/ZhiCoreUtil" + +/** + * zhi主题统一生命周期管理 + * + * @author terwer + * @version 0.1.0 + * @since 0.1.0 + */ +class Lifecycle { + private readonly logger + private readonly common + private ZHI_JSON_SCHEMA = "config/zhi-schema.js" + private ZHI_JSON = "config/zhi.js" + + constructor() { + this.logger = ZhiCoreUtil.zhiLog("lifecycle") + this.common = ZhiCoreUtil.zhiCommon() + } + + /** + * 加载依赖，核心加载顺序按照下面描述的顺序加载，内部的加载顺序由 order 字段决定， + * 所有依赖定义在主题根目录的 `zhi.json` + * + * ``` + * 加载顺序如下： + * 1 核心模块-require-hacker、infra、browser-window、插件系统、内部插件 + * 2 后端模块 + * 3 前端模块 + * 4 第三方库 + * ``` + */ + public async load() { + const allImports = [] + + // json-schema 校验 + // json读取 + // const { default: data } = await import("/appearance/themes/zhi/zhi.js");data + // const { default: data } = await import("/appearance/themes/zhi/zhi.json", { assert: { type: "json" } });data + const zhiSchemaPath = SiyuanDevice.getZhiThemeImportJsPath(this.ZHI_JSON_SCHEMA) + const { default: zhiSchema } = await import(zhiSchemaPath) + const zhiJsonPath = SiyuanDevice.getZhiThemeImportJsPath(this.ZHI_JSON) + const { default: zhiJson } = await import(zhiJsonPath) + this.logger.debug("zhiSchema=>", zhiSchema) + this.logger.debug("zhiJson=>", zhiJson) + const valiResult = this.common.jsonUtil.validateObjectSchema(zhiSchema, zhiJson) + if (!valiResult.valid) { + throw new Error( + `${this.ZHI_JSON} is not valid, error msg: ${valiResult.error ?? "None"}, please check ${this.ZHI_JSON_SCHEMA}` + ) + } else { + this.logger.info(`Success, ${this.ZHI_JSON} is ok`) + } + + // 解析json + // 核心模块 + const cores = zhiJson.dependencies.core + const coreModuleImports = await this.loadCoreModules(cores) + // 后端模块 + const servers = zhiJson.dependencies.server + const backendImports = await this.loadBackendModules(servers) + // 前端模块 + const webs = zhiJson.dependencies.web + const frontendImports = await this.loadFrontendModules(webs) + // 第三方组件 + const vendors = zhiJson.dependencies.vendor + const vendorImports = await this.loadVendors(vendors) + + return allImports.concat(coreModuleImports).concat(backendImports).concat(frontendImports).concat(vendorImports) + } + + /** + * 加载核心模块 + * + * @private + */ + private async loadCoreModules(deps: object[]): Promise { + const coreModulesImports: DependencyItem[] = deps.map((dep: object) => { + const dependency = new DependencyItem() + dependency.fromJson(dep) + return dependency + }) + + this.logger.info(`Registered ${coreModulesImports.length} Core modules`) + return coreModulesImports + } + + /** + * 加载后端模块 + * + * @private + */ + private async loadBackendModules(deps: object[]): Promise { + const backendModulesImports: DependencyItem[] = deps.map((dep: object) => { + const dependency = new DependencyItem() + dependency.fromJson(dep) + return dependency + }) + + this.logger.info(`Registered ${backendModulesImports.length} Backend modules`) + return backendModulesImports + } + + /** + * 加载前端模块 + * + * @private + */ + private async loadFrontendModules(deps: object[]): Promise { + const frontendModulesImports: DependencyItem[] = deps.map((dep: object) => { + const dependency = new DependencyItem() + dependency.fromJson(dep) + return dependency + }) + + this.logger.info(`Registered ${frontendModulesImports.length} Frontend modules`) + return frontendModulesImports + } + + /** + * 加载第三方库 + * + * @private + */ + private async loadVendors(deps: object[]): Promise { + const vendorImports: DependencyItem[] = deps.map((dep: object) => { + const dependency = new DependencyItem() + dependency.fromJson(dep) + return dependency + }) + + this.logger.info(`Registered ${vendorImports.length} Vendors`) + return vendorImports + } +} + +export default Lifecycle diff --git a/packages/zhi-core/src/lib/zhi.ts b/packages/zhi-core/src/lib/zhi.ts index d13cd128..1fe812f1 100644 --- a/packages/zhi-core/src/lib/zhi.ts +++ b/packages/zhi-core/src/lib/zhi.ts @@ -23,11 +23,14 @@ * questions. */ -import { DeviceTypeEnum } from "@siyuan-community/zhi-device" +import { BasePathTypeEnum, DeviceTypeEnum, SiyuanDevice } from "@siyuan-community/zhi-device" import ZhiCoreUtil from "./util/ZhiCoreUtil" +import DependencyItem from "./models/DependencyItem" +import Bootstrap from "./core/Bootstrap" class Zhi { private readonly logger + private readonly common private readonly runAs @@ -50,10 +53,16 @@ class Zhi { */ constructor(runAs: DeviceTypeEnum) { this.logger = ZhiCoreUtil.zhiLog("zhi-core") + this.common = ZhiCoreUtil.zhiCommon() this.runAs = runAs ?? DeviceTypeEnum.DeviceType_Node } + private async main(args: string[]): Promise { + this.logger.debug("Parsing args...", args) + return await Bootstrap.start() + } + /** * 主流程加载 */ @@ -61,6 +70,133 @@ class Zhi { try { this.logger.info(`Zhi Theme runAs ${this.runAs}`) + // 平台检测 + if ( + this.runAs !== DeviceTypeEnum.DeviceType_Siyuan_MainWin && + this.runAs !== DeviceTypeEnum.DeviceType_Siyuan_Browser + ) { + this.logger.warn( + `Zhi Theme can only run as ${DeviceTypeEnum.DeviceType_Siyuan_MainWin} or ${DeviceTypeEnum.DeviceType_Siyuan_Browser}` + ) + return + } + + // 检测内核版本 + const kernelVersion = SiyuanDevice.siyuanWindow().siyuan.config.system.kernelVersion + if (this.common.versionUtil.lesser(kernelVersion, this.SUPPORTED_THEME_VERSION)) { + const errMsg = this.common.strUtil.f( + "Your siyuan-note kernel version {0} is not supported by zhi theme, style will look weird, you must install siyuan-note {1}+ to use zhi-theme", + kernelVersion, + this.SUPPORTED_THEME_VERSION + ) + this.logger.error(errMsg) + // this.kernelApi.pushErrMsg({ + // msg: errMsg, + // }) + return + } + + if (this.common.versionUtil.lesser(kernelVersion, this.SUPPORTED_KERNEL_VERSION)) { + const warnMsg = this.common.strUtil.f( + "Your siyuan-note kernel version {0} is too low, plugin system will not work, you must install siyuan-note {1}+ to use plugin feature", + kernelVersion, + this.SUPPORTED_KERNEL_VERSION + ) + this.logger.warn(warnMsg) + // this.kernelApi.pushMsg({ + // msg: warnMsg, + // }) + return + } + + // 挂载一个日志对象，方便后续动态使用 + if (typeof window !== "undefined") { + ;(window as any).zhiLog = ZhiCoreUtil.zhiLog("zhi-core") + this.logger.info("ZhiLog mounted") + } + // 挂载一个require对象 + if (typeof window !== "undefined") { + ;(window as any).zhiRequire = function (libpath: string) { + return SiyuanDevice.requireLib(libpath, false, BasePathTypeEnum.BasePathType_ZhiTheme) + } + this.logger.info("zhiRequire mounted") + } + // 挂载一个import对象 + if (typeof window !== "undefined") { + ;(window as any).zhiImportPath = async function (libpath: string) { + return SiyuanDevice.getImportJsPath(libpath, BasePathTypeEnum.BasePathType_ZhiTheme) + } + this.logger.info("zhiImportPath mounted") + } + + // 初始化第三方依赖 + // import + // browser esm path: "/[libpath]" + // electron esm path: "/[libpath]" + // custom-path X + // + // require + // browser X + // electron cjs path: "[abspath][libpath]" + // custom-path require-hacker + const dynamicImports = await this.main([]) + for (const item of dynamicImports) { + // 类型校验 + if (item.format !== "esm" && item.format !== "cjs" && item.format !== "js") { + this.logger.warn("Only esm, cjs supported, skip this lib!", item.libpath) + continue + } + + // 运行环境校验 + if (!item.runAs.includes(this.runAs)) { + this.logger.debug( + `I'm sorry because current runtime is ${this.runAs}, while lib's define runtime is ${item.runAs}` + ) + this.logger.warn(`This lib can only run at ${item.runAs}, will skip!Lib is=>${item.libpath}`) + continue + } + + this.logger.info(`Loading modules form zhi => ${item.libpath}`) + let lib + if (item.importType == "import") { + const libPath = SiyuanDevice.getImportJsPath(item.libpath, item.baseType) + lib = await import(libPath) + this.logger.debug(`Importing lib ${item.libpath} with basePath of ${item.baseType} ...`) + } else { + lib = SiyuanDevice.requireLib(item.libpath, false, item.baseType) + this.logger.debug(`Requiring lib ${item.libpath} with basePath of ${item.baseType} ...`) + } + // 如果有初始化方法，进行初始化 + if (lib) { + const libObj = lib + this.logger.debug(`Current ${item.importType} lib ${item.libpath} Obj=>`, typeof libObj) + if (typeof libObj == "function") { + await libObj() + this.logger.info(`Inited ${item.libpath} with default function`) + } else { + if (libObj.init) { + const res = await libObj.init() + if (res) { + this.logger.info(`Detected output from ${item.importType} lib ${item.libpath}=>`, res) + } + this.logger.info(`Inited ${item.libpath} with init function`) + } else { + if (libObj.default) { + const res = await libObj.default() + if (res) { + this.logger.info(`Detected output from ${item.importType} lib ${item.libpath}=>`, res) + } + this.logger.info(`Inited ${item.libpath} with default function`) + } + this.logger.info(`No init method for ${item.importType} ${item.libpath}`) + } + } + } else { + this.logger.debug(`Lib entry is not a function => ${item.importType} ${item.libpath}`, lib) + } + this.logger.info(`Success ${item.importType} ${item.libpath}`) + } + this.logger.info("Zhi Theme inited") } catch (e) { this.logger.error("Zhi Theme load error=>", e) diff --git a/packages/zhi-loader/public/config/zhi-schema.js b/packages/zhi-loader/public/config/zhi-schema.js new file mode 100644 index 00000000..8faa448d --- /dev/null +++ b/packages/zhi-loader/public/config/zhi-schema.js @@ -0,0 +1,154 @@ +/* + * Copyright (c) 2023, Terwer . All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. Terwer designates this + * particular file as subject to the "Classpath" exception as provided + * by Terwer in the LICENSE file that accompanied this code. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Terwer, Shenzhen, Guangdong, China, youweics@163.com + * or visit www.terwer.space if you need additional information or have any + * questions. + */ + +const schema = { + type: "object", + properties: { + dependencies: { + type: "object", + properties: { + core: { + type: "array", + items: { + type: "object", + properties: { + libpath: { + type: "string", + }, + baseType: { + type: "string", + }, + format: { + type: "string", + }, + importType: { + type: "string", + }, + runAs: { + type: "array", + items: { + type: "string", + }, + }, + }, + required: ["libpath", "baseType", "format", "importType", "runAs"], + }, + }, + server: { + type: "array", + items: { + type: "object", + properties: { + libpath: { + type: "string", + }, + baseType: { + type: "string", + }, + format: { + type: "string", + }, + importType: { + type: "string", + }, + runAs: { + type: "array", + items: { + type: "string", + }, + }, + }, + required: ["libpath", "baseType", "format", "importType", "runAs"], + }, + }, + web: { + type: "array", + items: { + type: "object", + properties: { + libpath: { + type: "string", + }, + baseType: { + type: "string", + }, + format: { + type: "string", + }, + importType: { + type: "string", + }, + runAs: { + type: "array", + items: { + type: "string", + }, + }, + }, + required: ["libpath", "baseType", "format", "importType", "runAs"], + }, + }, + vendor: { + type: "array", + items: { + type: "object", + properties: { + name: { + type: "string", + }, + enabled: { + type: "boolean", + }, + }, + required: ["name", "enabled"], + }, + }, + plugin: { + type: "array", + items: { + type: "object", + properties: { + name: { + type: "string", + }, + enabled: { + type: "boolean", + }, + }, + required: ["name", "enabled"], + }, + }, + }, + required: ["core", "server", "web", "vendor", "plugin"], + }, + }, + required: ["dependencies"], +} + +export default { + $schema: "http://json-schema.org/draft-07/schema#", + $id: "https://terwer.space/zhi-schema.json", + ...schema, +} diff --git a/packages/zhi-loader/public/config/zhi.example.js b/packages/zhi-loader/public/config/zhi.example.js new file mode 100644 index 00000000..1bfc9ab7 --- /dev/null +++ b/packages/zhi-loader/public/config/zhi.example.js @@ -0,0 +1,89 @@ +/* + * Copyright (c) 2023, Terwer . All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. Terwer designates this + * particular file as subject to the "Classpath" exception as provided + * by Terwer in the LICENSE file that accompanied this code. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Terwer, Shenzhen, Guangdong, China, youweics@163.com + * or visit www.terwer.space if you need additional information or have any + * questions. + */ + +export default { + dependencies: { + core: [ + { + libpath: "core/plugin-system/plugin.js", + baseType: "ZhiTheme", + format: "esm", + importType: "import", + runAs: ["Siyuan_MainWindow", "Siyuan_Browser"], + order: 1, + }, + { + libpath: "core/plugin-system/zhi-plugin-loader.js", + baseType: "ZhiTheme", + format: "esm", + importType: "import", + runAs: ["Siyuan_MainWindow", "Siyuan_Browser"], + order: 2, + }, + ], + server: [ + { + libpath: "server/electron/index.js", + baseType: "ZhiTheme", + format: "esm", + importType: "import", + runAs: ["Siyuan_MainWindow"], + order: 3, + }, + { + libpath: "server/cmd/index.js", + baseType: "ZhiTheme", + format: "esm", + importType: "import", + runAs: ["Siyuan_MainWindow"], + order: 4, + }, + { + libpath: "server/infra/index.js", + baseType: "ZhiTheme", + format: "esm", + importType: "import", + runAs: ["Siyuan_MainWindow"], + order: 5, + }, + { + libpath: "server/custom/start.js", + baseType: "ZhiTheme", + format: "esm", + importType: "import", + runAs: ["Siyuan_MainWindow"], + order: 6, + }, + ], + web: [], + vendor: [], + plugin: [], + }, + blog: { + server: { + post: "3333", + }, + }, +} diff --git a/packages/zhi-loader/public/config/zhi.js b/packages/zhi-loader/public/config/zhi.js new file mode 100644 index 00000000..0a61b62c --- /dev/null +++ b/packages/zhi-loader/public/config/zhi.js @@ -0,0 +1,56 @@ +/* + * Copyright (c) 2023, Terwer . All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. Terwer designates this + * particular file as subject to the "Classpath" exception as provided + * by Terwer in the LICENSE file that accompanied this code. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Terwer, Shenzhen, Guangdong, China, youweics@163.com + * or visit www.terwer.space if you need additional information or have any + * questions. + */ + +export default { + dependencies: { + core: [ + { + libpath: "core/plugin-system/plugin.js", + baseType: "ZhiTheme", + format: "esm", + importType: "import", + runAs: ["Siyuan_MainWindow", "Siyuan_Browser"], + order: 0, + }, + { + libpath: "core/plugin-system/zhi-plugin-loader.js", + baseType: "ZhiTheme", + format: "esm", + importType: "import", + runAs: ["Siyuan_MainWindow", "Siyuan_Browser"], + order: 1, + }, + ], + server: [], + web: [], + vendor: [], + plugin: [], + }, + blog: { + server: { + post: "3333", + }, + }, +} diff --git a/packages/zhi-loader/public/core/plugin-system/README.md b/packages/zhi-loader/public/core/plugin-system/README.md new file mode 100644 index 00000000..4fcab73a --- /dev/null +++ b/packages/zhi-loader/public/core/plugin-system/README.md @@ -0,0 +1,4 @@ +## How to update plugin system + +- Download the latest `插件系统` widget in the siyuan-note bazaar +- Copy `plugin.js` to `zhi/assets/plugin.js` diff --git a/packages/zhi-loader/public/core/plugin-system/plugin.js b/packages/zhi-loader/public/core/plugin-system/plugin.js new file mode 100644 index 00000000..760a3444 --- /dev/null +++ b/packages/zhi-loader/public/core/plugin-system/plugin.js @@ -0,0 +1,14444 @@ +!(function () { + "use strict" + try { + if ("undefined" != typeof document) { + var e = document.createElement("style") + e.appendChild( + document.createTextNode( + ".command.svelte-1bq7axd{padding:8px 12px}.command.svelte-1bq7axd:hover{cursor:pointer;background-color:#0003;color:var(--b3-theme-primary)}.command-selected.svelte-1bq7axd{color:var(--b3-theme-primary);background-color:#0003}.command-plugin.svelte-1bq7axd{font-size:14px}.command-shortcut.svelte-1bq7axd{font-size:12px;color:var(--color-text-3)}.plugin.svelte-bwhxpp span.remove.svelte-bwhxpp{display:none;color:var(--b3-theme-error);margin-left:4px}.plugin.svelte-bwhxpp:hover span.remove.svelte-bwhxpp{display:inline;cursor:pointer}.plugin.svelte-bwhxpp:hover span.remove.svelte-bwhxpp:hover{text-decoration:underline}.plugin-info.svelte-bj9chc{display:flex;align-items:center}.plugin-detail.svelte-bj9chc{margin-top:12px;width:100%}.plugin-name.svelte-bj9chc{display:inline;margin-right:6px;font-size:24px}.plugin-key.svelte-bj9chc{display:inline;font-size:16px}.plugin-manifest.svelte-bj9chc{margin-top:12px}.plugin-readme.svelte-bj9chc{margin-top:20px}.go-back.svelte-bj9chc{margin-left:12px;font-size:12px;height:24px}.go-back-icon.svelte-bj9chc{height:12px;width:12px;margin-right:4px}" + ) + ), + document.head.appendChild(e) + } + } catch (t) { + console.error("vite-plugin-css-injected-by-js", t) + } +})() +var _a +var commonjsGlobal = + typeof globalThis !== "undefined" + ? globalThis + : typeof window !== "undefined" + ? window + : typeof global !== "undefined" + ? global + : typeof self !== "undefined" + ? self + : {} +/*! ***************************************************************************** +Copyright (C) Microsoft. All rights reserved. +Licensed under the Apache License, Version 2.0 (the "License"); you may not use +this file except in compliance with the License. You may obtain a copy of the +License at http://www.apache.org/licenses/LICENSE-2.0 + +THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED +WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE, +MERCHANTABLITY OR NON-INFRINGEMENT. + +See the Apache Version 2.0 License for specific language governing permissions +and limitations under the License. +***************************************************************************** */ +var Reflect$1 +;(function (Reflect2) { + ;(function (factory2) { + var root = + typeof commonjsGlobal === "object" + ? commonjsGlobal + : typeof self === "object" + ? self + : typeof this === "object" + ? this + : Function("return this;")() + var exporter = makeExporter(Reflect2) + if (typeof root.Reflect === "undefined") { + root.Reflect = Reflect2 + } else { + exporter = makeExporter(root.Reflect, exporter) + } + factory2(exporter) + function makeExporter(target, previous) { + return function (key, value) { + if (typeof target[key] !== "function") { + Object.defineProperty(target, key, { configurable: true, writable: true, value }) + } + if (previous) previous(key, value) + } + } + })(function (exporter) { + var hasOwn = Object.prototype.hasOwnProperty + var supportsSymbol = typeof Symbol === "function" + var toPrimitiveSymbol = + supportsSymbol && typeof Symbol.toPrimitive !== "undefined" ? Symbol.toPrimitive : "@@toPrimitive" + var iteratorSymbol = supportsSymbol && typeof Symbol.iterator !== "undefined" ? Symbol.iterator : "@@iterator" + var supportsCreate = typeof Object.create === "function" + var supportsProto = { __proto__: [] } instanceof Array + var downLevel = !supportsCreate && !supportsProto + var HashMap = { + // create an object in dictionary mode (a.k.a. "slow" mode in v8) + create: supportsCreate + ? function () { + return MakeDictionary(/* @__PURE__ */ Object.create(null)) + } + : supportsProto + ? function () { + return MakeDictionary({ __proto__: null }) + } + : function () { + return MakeDictionary({}) + }, + has: downLevel + ? function (map, key) { + return hasOwn.call(map, key) + } + : function (map, key) { + return key in map + }, + get: downLevel + ? function (map, key) { + return hasOwn.call(map, key) ? map[key] : void 0 + } + : function (map, key) { + return map[key] + }, + } + var functionPrototype = Object.getPrototypeOf(Function) + var usePolyfill = + typeof process === "object" && process.env && process.env["REFLECT_METADATA_USE_MAP_POLYFILL"] === "true" + var _Map = + !usePolyfill && typeof Map === "function" && typeof Map.prototype.entries === "function" + ? Map + : CreateMapPolyfill() + var _Set = + !usePolyfill && typeof Set === "function" && typeof Set.prototype.entries === "function" + ? Set + : CreateSetPolyfill() + var _WeakMap = !usePolyfill && typeof WeakMap === "function" ? WeakMap : CreateWeakMapPolyfill() + var Metadata2 = new _WeakMap() + function decorate(decorators, target, propertyKey, attributes) { + if (!IsUndefined(propertyKey)) { + if (!IsArray(decorators)) throw new TypeError() + if (!IsObject(target)) throw new TypeError() + if (!IsObject(attributes) && !IsUndefined(attributes) && !IsNull(attributes)) throw new TypeError() + if (IsNull(attributes)) attributes = void 0 + propertyKey = ToPropertyKey(propertyKey) + return DecorateProperty(decorators, target, propertyKey, attributes) + } else { + if (!IsArray(decorators)) throw new TypeError() + if (!IsConstructor(target)) throw new TypeError() + return DecorateConstructor(decorators, target) + } + } + exporter("decorate", decorate) + function metadata(metadataKey, metadataValue) { + function decorator(target, propertyKey) { + if (!IsObject(target)) throw new TypeError() + if (!IsUndefined(propertyKey) && !IsPropertyKey(propertyKey)) throw new TypeError() + OrdinaryDefineOwnMetadata(metadataKey, metadataValue, target, propertyKey) + } + return decorator + } + exporter("metadata", metadata) + function defineMetadata(metadataKey, metadataValue, target, propertyKey) { + if (!IsObject(target)) throw new TypeError() + if (!IsUndefined(propertyKey)) propertyKey = ToPropertyKey(propertyKey) + return OrdinaryDefineOwnMetadata(metadataKey, metadataValue, target, propertyKey) + } + exporter("defineMetadata", defineMetadata) + function hasMetadata(metadataKey, target, propertyKey) { + if (!IsObject(target)) throw new TypeError() + if (!IsUndefined(propertyKey)) propertyKey = ToPropertyKey(propertyKey) + return OrdinaryHasMetadata(metadataKey, target, propertyKey) + } + exporter("hasMetadata", hasMetadata) + function hasOwnMetadata(metadataKey, target, propertyKey) { + if (!IsObject(target)) throw new TypeError() + if (!IsUndefined(propertyKey)) propertyKey = ToPropertyKey(propertyKey) + return OrdinaryHasOwnMetadata(metadataKey, target, propertyKey) + } + exporter("hasOwnMetadata", hasOwnMetadata) + function getMetadata(metadataKey, target, propertyKey) { + if (!IsObject(target)) throw new TypeError() + if (!IsUndefined(propertyKey)) propertyKey = ToPropertyKey(propertyKey) + return OrdinaryGetMetadata(metadataKey, target, propertyKey) + } + exporter("getMetadata", getMetadata) + function getOwnMetadata(metadataKey, target, propertyKey) { + if (!IsObject(target)) throw new TypeError() + if (!IsUndefined(propertyKey)) propertyKey = ToPropertyKey(propertyKey) + return OrdinaryGetOwnMetadata(metadataKey, target, propertyKey) + } + exporter("getOwnMetadata", getOwnMetadata) + function getMetadataKeys(target, propertyKey) { + if (!IsObject(target)) throw new TypeError() + if (!IsUndefined(propertyKey)) propertyKey = ToPropertyKey(propertyKey) + return OrdinaryMetadataKeys(target, propertyKey) + } + exporter("getMetadataKeys", getMetadataKeys) + function getOwnMetadataKeys(target, propertyKey) { + if (!IsObject(target)) throw new TypeError() + if (!IsUndefined(propertyKey)) propertyKey = ToPropertyKey(propertyKey) + return OrdinaryOwnMetadataKeys(target, propertyKey) + } + exporter("getOwnMetadataKeys", getOwnMetadataKeys) + function deleteMetadata(metadataKey, target, propertyKey) { + if (!IsObject(target)) throw new TypeError() + if (!IsUndefined(propertyKey)) propertyKey = ToPropertyKey(propertyKey) + var metadataMap = GetOrCreateMetadataMap( + target, + propertyKey, + /*Create*/ + false + ) + if (IsUndefined(metadataMap)) return false + if (!metadataMap.delete(metadataKey)) return false + if (metadataMap.size > 0) return true + var targetMetadata = Metadata2.get(target) + targetMetadata.delete(propertyKey) + if (targetMetadata.size > 0) return true + Metadata2.delete(target) + return true + } + exporter("deleteMetadata", deleteMetadata) + function DecorateConstructor(decorators, target) { + for (var i = decorators.length - 1; i >= 0; --i) { + var decorator = decorators[i] + var decorated = decorator(target) + if (!IsUndefined(decorated) && !IsNull(decorated)) { + if (!IsConstructor(decorated)) throw new TypeError() + target = decorated + } + } + return target + } + function DecorateProperty(decorators, target, propertyKey, descriptor) { + for (var i = decorators.length - 1; i >= 0; --i) { + var decorator = decorators[i] + var decorated = decorator(target, propertyKey, descriptor) + if (!IsUndefined(decorated) && !IsNull(decorated)) { + if (!IsObject(decorated)) throw new TypeError() + descriptor = decorated + } + } + return descriptor + } + function GetOrCreateMetadataMap(O, P2, Create) { + var targetMetadata = Metadata2.get(O) + if (IsUndefined(targetMetadata)) { + if (!Create) return void 0 + targetMetadata = new _Map() + Metadata2.set(O, targetMetadata) + } + var metadataMap = targetMetadata.get(P2) + if (IsUndefined(metadataMap)) { + if (!Create) return void 0 + metadataMap = new _Map() + targetMetadata.set(P2, metadataMap) + } + return metadataMap + } + function OrdinaryHasMetadata(MetadataKey, O, P2) { + var hasOwn2 = OrdinaryHasOwnMetadata(MetadataKey, O, P2) + if (hasOwn2) return true + var parent = OrdinaryGetPrototypeOf(O) + if (!IsNull(parent)) return OrdinaryHasMetadata(MetadataKey, parent, P2) + return false + } + function OrdinaryHasOwnMetadata(MetadataKey, O, P2) { + var metadataMap = GetOrCreateMetadataMap( + O, + P2, + /*Create*/ + false + ) + if (IsUndefined(metadataMap)) return false + return ToBoolean(metadataMap.has(MetadataKey)) + } + function OrdinaryGetMetadata(MetadataKey, O, P2) { + var hasOwn2 = OrdinaryHasOwnMetadata(MetadataKey, O, P2) + if (hasOwn2) return OrdinaryGetOwnMetadata(MetadataKey, O, P2) + var parent = OrdinaryGetPrototypeOf(O) + if (!IsNull(parent)) return OrdinaryGetMetadata(MetadataKey, parent, P2) + return void 0 + } + function OrdinaryGetOwnMetadata(MetadataKey, O, P2) { + var metadataMap = GetOrCreateMetadataMap( + O, + P2, + /*Create*/ + false + ) + if (IsUndefined(metadataMap)) return void 0 + return metadataMap.get(MetadataKey) + } + function OrdinaryDefineOwnMetadata(MetadataKey, MetadataValue, O, P2) { + var metadataMap = GetOrCreateMetadataMap( + O, + P2, + /*Create*/ + true + ) + metadataMap.set(MetadataKey, MetadataValue) + } + function OrdinaryMetadataKeys(O, P2) { + var ownKeys = OrdinaryOwnMetadataKeys(O, P2) + var parent = OrdinaryGetPrototypeOf(O) + if (parent === null) return ownKeys + var parentKeys = OrdinaryMetadataKeys(parent, P2) + if (parentKeys.length <= 0) return ownKeys + if (ownKeys.length <= 0) return parentKeys + var set = new _Set() + var keys = [] + for (var _i = 0, ownKeys_1 = ownKeys; _i < ownKeys_1.length; _i++) { + var key = ownKeys_1[_i] + var hasKey = set.has(key) + if (!hasKey) { + set.add(key) + keys.push(key) + } + } + for (var _a2 = 0, parentKeys_1 = parentKeys; _a2 < parentKeys_1.length; _a2++) { + var key = parentKeys_1[_a2] + var hasKey = set.has(key) + if (!hasKey) { + set.add(key) + keys.push(key) + } + } + return keys + } + function OrdinaryOwnMetadataKeys(O, P2) { + var keys = [] + var metadataMap = GetOrCreateMetadataMap( + O, + P2, + /*Create*/ + false + ) + if (IsUndefined(metadataMap)) return keys + var keysObj = metadataMap.keys() + var iterator2 = GetIterator(keysObj) + var k2 = 0 + while (true) { + var next = IteratorStep(iterator2) + if (!next) { + keys.length = k2 + return keys + } + var nextValue = IteratorValue(next) + try { + keys[k2] = nextValue + } catch (e) { + try { + IteratorClose(iterator2) + } finally { + throw e + } + } + k2++ + } + } + function Type(x) { + if (x === null) return 1 + switch (typeof x) { + case "undefined": + return 0 + case "boolean": + return 2 + case "string": + return 3 + case "symbol": + return 4 + case "number": + return 5 + case "object": + return x === null ? 1 : 6 + default: + return 6 + } + } + function IsUndefined(x) { + return x === void 0 + } + function IsNull(x) { + return x === null + } + function IsSymbol(x) { + return typeof x === "symbol" + } + function IsObject(x) { + return typeof x === "object" ? x !== null : typeof x === "function" + } + function ToPrimitive(input, PreferredType) { + switch (Type(input)) { + case 0: + return input + case 1: + return input + case 2: + return input + case 3: + return input + case 4: + return input + case 5: + return input + } + var hint = PreferredType === 3 ? "string" : PreferredType === 5 ? "number" : "default" + var exoticToPrim = GetMethod(input, toPrimitiveSymbol) + if (exoticToPrim !== void 0) { + var result = exoticToPrim.call(input, hint) + if (IsObject(result)) throw new TypeError() + return result + } + return OrdinaryToPrimitive(input, hint === "default" ? "number" : hint) + } + function OrdinaryToPrimitive(O, hint) { + if (hint === "string") { + var toString_1 = O.toString + if (IsCallable(toString_1)) { + var result = toString_1.call(O) + if (!IsObject(result)) return result + } + var valueOf = O.valueOf + if (IsCallable(valueOf)) { + var result = valueOf.call(O) + if (!IsObject(result)) return result + } + } else { + var valueOf = O.valueOf + if (IsCallable(valueOf)) { + var result = valueOf.call(O) + if (!IsObject(result)) return result + } + var toString_2 = O.toString + if (IsCallable(toString_2)) { + var result = toString_2.call(O) + if (!IsObject(result)) return result + } + } + throw new TypeError() + } + function ToBoolean(argument) { + return !!argument + } + function ToString(argument) { + return "" + argument + } + function ToPropertyKey(argument) { + var key = ToPrimitive( + argument, + 3 + /* String */ + ) + if (IsSymbol(key)) return key + return ToString(key) + } + function IsArray(argument) { + return Array.isArray + ? Array.isArray(argument) + : argument instanceof Object + ? argument instanceof Array + : Object.prototype.toString.call(argument) === "[object Array]" + } + function IsCallable(argument) { + return typeof argument === "function" + } + function IsConstructor(argument) { + return typeof argument === "function" + } + function IsPropertyKey(argument) { + switch (Type(argument)) { + case 3: + return true + case 4: + return true + default: + return false + } + } + function GetMethod(V, P2) { + var func = V[P2] + if (func === void 0 || func === null) return void 0 + if (!IsCallable(func)) throw new TypeError() + return func + } + function GetIterator(obj) { + var method = GetMethod(obj, iteratorSymbol) + if (!IsCallable(method)) throw new TypeError() + var iterator2 = method.call(obj) + if (!IsObject(iterator2)) throw new TypeError() + return iterator2 + } + function IteratorValue(iterResult) { + return iterResult.value + } + function IteratorStep(iterator2) { + var result = iterator2.next() + return result.done ? false : result + } + function IteratorClose(iterator2) { + var f = iterator2["return"] + if (f) f.call(iterator2) + } + function OrdinaryGetPrototypeOf(O) { + var proto = Object.getPrototypeOf(O) + if (typeof O !== "function" || O === functionPrototype) return proto + if (proto !== functionPrototype) return proto + var prototype2 = O.prototype + var prototypeProto = prototype2 && Object.getPrototypeOf(prototype2) + if (prototypeProto == null || prototypeProto === Object.prototype) return proto + var constructor = prototypeProto.constructor + if (typeof constructor !== "function") return proto + if (constructor === O) return proto + return constructor + } + function CreateMapPolyfill() { + var cacheSentinel = {} + var arraySentinel = [] + var MapIterator = + /** @class */ + (function () { + function MapIterator2(keys, values, selector) { + this._index = 0 + this._keys = keys + this._values = values + this._selector = selector + } + MapIterator2.prototype["@@iterator"] = function () { + return this + } + MapIterator2.prototype[iteratorSymbol] = function () { + return this + } + MapIterator2.prototype.next = function () { + var index = this._index + if (index >= 0 && index < this._keys.length) { + var result = this._selector(this._keys[index], this._values[index]) + if (index + 1 >= this._keys.length) { + this._index = -1 + this._keys = arraySentinel + this._values = arraySentinel + } else { + this._index++ + } + return { value: result, done: false } + } + return { value: void 0, done: true } + } + MapIterator2.prototype.throw = function (error2) { + if (this._index >= 0) { + this._index = -1 + this._keys = arraySentinel + this._values = arraySentinel + } + throw error2 + } + MapIterator2.prototype.return = function (value) { + if (this._index >= 0) { + this._index = -1 + this._keys = arraySentinel + this._values = arraySentinel + } + return { value, done: true } + } + return MapIterator2 + })() + return ( + /** @class */ + (function () { + function Map2() { + this._keys = [] + this._values = [] + this._cacheKey = cacheSentinel + this._cacheIndex = -2 + } + Object.defineProperty(Map2.prototype, "size", { + get: function () { + return this._keys.length + }, + enumerable: true, + configurable: true, + }) + Map2.prototype.has = function (key) { + return ( + this._find( + key, + /*insert*/ + false + ) >= 0 + ) + } + Map2.prototype.get = function (key) { + var index = this._find( + key, + /*insert*/ + false + ) + return index >= 0 ? this._values[index] : void 0 + } + Map2.prototype.set = function (key, value) { + var index = this._find( + key, + /*insert*/ + true + ) + this._values[index] = value + return this + } + Map2.prototype.delete = function (key) { + var index = this._find( + key, + /*insert*/ + false + ) + if (index >= 0) { + var size = this._keys.length + for (var i = index + 1; i < size; i++) { + this._keys[i - 1] = this._keys[i] + this._values[i - 1] = this._values[i] + } + this._keys.length-- + this._values.length-- + if (key === this._cacheKey) { + this._cacheKey = cacheSentinel + this._cacheIndex = -2 + } + return true + } + return false + } + Map2.prototype.clear = function () { + this._keys.length = 0 + this._values.length = 0 + this._cacheKey = cacheSentinel + this._cacheIndex = -2 + } + Map2.prototype.keys = function () { + return new MapIterator(this._keys, this._values, getKey3) + } + Map2.prototype.values = function () { + return new MapIterator(this._keys, this._values, getValue) + } + Map2.prototype.entries = function () { + return new MapIterator(this._keys, this._values, getEntry) + } + Map2.prototype["@@iterator"] = function () { + return this.entries() + } + Map2.prototype[iteratorSymbol] = function () { + return this.entries() + } + Map2.prototype._find = function (key, insert2) { + if (this._cacheKey !== key) { + this._cacheIndex = this._keys.indexOf((this._cacheKey = key)) + } + if (this._cacheIndex < 0 && insert2) { + this._cacheIndex = this._keys.length + this._keys.push(key) + this._values.push(void 0) + } + return this._cacheIndex + } + return Map2 + })() + ) + function getKey3(key, _2) { + return key + } + function getValue(_2, value) { + return value + } + function getEntry(key, value) { + return [key, value] + } + } + function CreateSetPolyfill() { + return ( + /** @class */ + (function () { + function Set2() { + this._map = new _Map() + } + Object.defineProperty(Set2.prototype, "size", { + get: function () { + return this._map.size + }, + enumerable: true, + configurable: true, + }) + Set2.prototype.has = function (value) { + return this._map.has(value) + } + Set2.prototype.add = function (value) { + return this._map.set(value, value), this + } + Set2.prototype.delete = function (value) { + return this._map.delete(value) + } + Set2.prototype.clear = function () { + this._map.clear() + } + Set2.prototype.keys = function () { + return this._map.keys() + } + Set2.prototype.values = function () { + return this._map.values() + } + Set2.prototype.entries = function () { + return this._map.entries() + } + Set2.prototype["@@iterator"] = function () { + return this.keys() + } + Set2.prototype[iteratorSymbol] = function () { + return this.keys() + } + return Set2 + })() + ) + } + function CreateWeakMapPolyfill() { + var UUID_SIZE = 16 + var keys = HashMap.create() + var rootKey = CreateUniqueKey() + return ( + /** @class */ + (function () { + function WeakMap2() { + this._key = CreateUniqueKey() + } + WeakMap2.prototype.has = function (target) { + var table = GetOrCreateWeakMapTable( + target, + /*create*/ + false + ) + return table !== void 0 ? HashMap.has(table, this._key) : false + } + WeakMap2.prototype.get = function (target) { + var table = GetOrCreateWeakMapTable( + target, + /*create*/ + false + ) + return table !== void 0 ? HashMap.get(table, this._key) : void 0 + } + WeakMap2.prototype.set = function (target, value) { + var table = GetOrCreateWeakMapTable( + target, + /*create*/ + true + ) + table[this._key] = value + return this + } + WeakMap2.prototype.delete = function (target) { + var table = GetOrCreateWeakMapTable( + target, + /*create*/ + false + ) + return table !== void 0 ? delete table[this._key] : false + } + WeakMap2.prototype.clear = function () { + this._key = CreateUniqueKey() + } + return WeakMap2 + })() + ) + function CreateUniqueKey() { + var key + do key = "@@WeakMap@@" + CreateUUID() + while (HashMap.has(keys, key)) + keys[key] = true + return key + } + function GetOrCreateWeakMapTable(target, create) { + if (!hasOwn.call(target, rootKey)) { + if (!create) return void 0 + Object.defineProperty(target, rootKey, { value: HashMap.create() }) + } + return target[rootKey] + } + function FillRandomBytes(buffer, size) { + for (var i = 0; i < size; ++i) buffer[i] = (Math.random() * 255) | 0 + return buffer + } + function GenRandomBytes(size) { + if (typeof Uint8Array === "function") { + if (typeof crypto !== "undefined") return crypto.getRandomValues(new Uint8Array(size)) + if (typeof msCrypto !== "undefined") return msCrypto.getRandomValues(new Uint8Array(size)) + return FillRandomBytes(new Uint8Array(size), size) + } + return FillRandomBytes(new Array(size), size) + } + function CreateUUID() { + var data = GenRandomBytes(UUID_SIZE) + data[6] = (data[6] & 79) | 64 + data[8] = (data[8] & 191) | 128 + var result = "" + for (var offset = 0; offset < UUID_SIZE; ++offset) { + var byte = data[offset] + if (offset === 4 || offset === 6 || offset === 8) result += "-" + if (byte < 16) result += "0" + result += byte.toString(16).toLowerCase() + } + return result + } + } + function MakeDictionary(obj) { + obj.__ = void 0 + delete obj.__ + return obj + } + }) +})(Reflect$1 || (Reflect$1 = {})) +const VERSION$1 = "0.7.0" +const VERSION_URL = "https://gitee.com/zuoez02/siyuan-plugin-system/raw/main/VERSION" +const SCRIPT_URL = "https://gitee.com/zuoez02/siyuan-plugin-system/raw/main/main.js" +const PLUGIN_SYS_ABS_PATH = "/data/widgets/插件系统/plugin.js" +const config = () => ({ token: window.siyuan.config.api.token }) +const TYPES = { + StorageManager: "StorageManager", + PluginSystem: "PluginSystem", + SystemManager: "PluginSystemLocalManager", + PluginLoader: "PluginLoader", + PluginFileManager: "PluginFileManager", + EventBus: "EventBus", + Shortcut: "Shortcut", + CommandManager: "CommandManager", + Store: "Store", + SettingManager: "SettingManager", +} +async function request$1(url2, data) { + let resData = null + await fetch(url2, { + body: JSON.stringify(data), + method: "POST", + headers: { + Authorization: `Token ${config().token}`, + }, + }).then(function (response) { + resData = response.json() + }) + return resData +} +async function parseBody(response) { + let r = await response + return r.code === 0 ? r.data : null +} +async function transactions(protyle, transactions2 = []) { + const url2 = "/api/transactions" + const ws_url = new URL(protyle.ws.ws.url) + const data = { + app: ws_url.searchParams.get("app"), + session: ws_url.searchParams.get("id"), + transactions: transactions2, + } + return parseBody(request$1(url2, data)) +} +async function sql(sql2) { + let sqldata = { + stmt: sql2, + } + let url2 = "/api/query/sql" + return parseBody(request$1(url2, sqldata)) +} +async function lsNotebooks(sql2) { + let sqldata = { stmt: sql2 } + let url2 = "/api/notebook/lsNotebooks" + return parseBody(request$1(url2, sqldata)) +} +async function getAnchor(anchorText, name2) { + anchorText = anchorText.replace("((", "").replace("))", "") + let sqlScript = `select * from blocks where id = '${anchorText}'` + let sqlRes = await sql(sqlScript) + let anchor = "" + if (sqlRes) { + try { + if (sqlRes[0][name2]) { + anchor = sqlRes[0][name2] + } else if (sqlRes[0]["content"]) { + anchor = sqlRes[0]["content"] + } else { + anchor = anchorText + } + } catch (e) { + anchor = "解析错误" + } + } + return anchor +} +async function openNotebook(notebookId) { + let data = { + notebook: notebookId, + } + let url2 = "/api/notebook/openNotebook" + return parseBody(request$1(url2, data)) +} +async function closeNotebook(notebookId) { + let data = { + notebook: notebookId, + } + let url2 = "/api/notebook/closeNotebook" + return parseBody(request$1(url2, data)) +} +async function renameNotebook(notebookId, notebookNewName) { + let data = { + notebook: notebookId, + name: notebookNewName, + } + let url2 = "/api/notebook/renameNotebook" + return parseBody(request$1(url2, data)) +} +async function createNotebook(notebookName) { + let data = { + name: notebookName, + } + let url2 = "/api/notebook/createNotebook" + return parseBody(request$1(url2, data)) +} +async function removeNotebook(notebookId) { + let data = { notebook: notebookId } + let url2 = "/api/notebook/removeNotebook" + return parseBody(request$1(url2, data)) +} +async function getNotebookConf(notebookId) { + let data = { notebook: notebookId } + let url2 = "/api/notebook/getNotebookConf" + return parseBody(request$1(url2, data)) +} +async function setNotebookConf(notebookId) { + let data = { notebook: notebookId } + let url2 = "/api/notebook/setNotebookConf" + return parseBody(request$1(url2, data)) +} +async function renameDoc(notebookId, path, title) { + let data = { + notebook: notebookId, + path, + title, + } + let url2 = "/api/filetree/renameDoc" + return parseBody(request$1(url2, data)) +} +async function removeDoc(notebookId, path) { + let data = { + notebook: notebookId, + path, + } + let url2 = "/api/filetree/removeDoc" + return parseBody(request$1(url2, data)) +} +async function moveDoc(srcNotebookId, srcPath, targetNotebookId, targetPath) { + let data = { + fromNotebook: srcNotebookId, + fromPath: srcPath, + toNotebook: targetNotebookId, + toPath: targetPath, + } + let url2 = "/api/filetree/moveDoc" + return parseBody(request$1(url2, data)) +} +async function getHPathByPath(notebookId, path) { + let data = { + Notebook: notebookId, + Path: path, + } + let url2 = "/api/filetree/getHPathByPath" + return parseBody(request$1(url2, data)) +} +async function getHPathByID(ID) { + let data = { + id: ID, + } + let url2 = "/api/filetree/getHPathByID" + return parseBody(request$1(url2, data)) +} +async function getBlockAttrs(blockId) { + let data = { + id: blockId, + } + let url2 = "/api/attr/getBlockAttrs" + return parseBody(request$1(url2, data)) +} +async function getBlockByID(blockId) { + let sqlScript = `select * from blocks where id ='${blockId}'` + let data = await sql(sqlScript) + return data[0] +} +async function getBlockKramdown(blockId) { + const data = { + id: blockId, + } + const url2 = "/api/block/getBlockKramdown" + return parseBody(request$1(url2, data)) +} +async function getBlockBreadcrumb(ID) { + const data = { + id: ID, + } + const url2 = "/api/block/getBlockBreadcrumb" + return parseBody(request$1(url2, data)) +} +async function setBlockAttrs(blockId, attrs) { + let url2 = "/api/attr/setBlockAttrs" + return parseBody( + request$1(url2, { + id: blockId, + attrs, + }) + ) +} +async function exportMdContent(docId) { + let data = { + id: docId, + } + let url2 = "/api/export/exportMdContent" + return parseBody(request$1(url2, data)) +} +async function getDocOutline(docId) { + let data = { + id: docId, + } + let url2 = "/api/outline/getDocOutline" + return parseBody(request$1(url2, data)) +} +async function listDocsByPath(path) { + let data = { + path, + } + let url2 = "/api/filetree/listDocsByPath" + return parseBody(request$1(url2, data)) +} +async function getBacklink(id2) { + let data = { + id: id2, + beforeLen: 10, + k: "", + mk: "", + } + let url2 = "/api/ref/getBacklink" + return parseBody(request$1(url2, data)) +} +async function searchEmbedBlock(excludeIds, sql2) { + let data = { + stmt: sql2, + excludeIDs: excludeIds, + } + let url2 = "/api/search/searchEmbedBlock" + return parseBody(request$1(url2, data)) +} +async function getDoc(id2) { + let data = { + id: id2, + k: "", + mode: 2, + size: 36, + } + let url2 = "/api/filetree/getDoc" + return parseBody(request$1(url2, data)) +} +async function getFocusedDoc(id2) { + let data = { + id: id2, + k: "", + mode: 0, + size: 36, + } + let url2 = "/api/filetree/getDoc" + return parseBody(request$1(url2, data)) +} +async function getTag() { + let data = {} + let url2 = "/api/tag/getTag" + return parseBody(request$1(url2, data)) +} +async function getLocalGraph(k2, id2, conf, reqId) { + let data = { + id: id2, + k: k2, + conf, + reqId, + } + let url2 = "/api/graph/getLocalGraph" + return parseBody(request$1(url2, data)) +} +async function getGraph(k2, conf, reqId) { + let data = { + k: k2, + conf, + reqId, + } + let url2 = "/api/graph/getGraph" + return parseBody(request$1(url2, data)) +} +async function searchDocs(k2) { + let data = { + k: k2, + } + let url2 = "/api/filetree/searchDocs" + return parseBody(request$1(url2, data)) +} +async function searchBlock(query) { + let data = { + query, + } + let url2 = "/api/search/searchBlock" + return parseBody(request$1(url2, data)) +} +async function searchTemplate(k2) { + let data = { + k: k2, + } + let url2 = "/api/search/searchTemplate" + return parseBody(request$1(url2, data)) +} +async function createDocWithMd(notebook, path, markdown) { + let data = { + notebook, + path, + markdown, + } + let url2 = "/api/filetree/createDocWithMd" + return parseBody(request$1(url2, data)) +} +async function docSaveAsTemplate(id2, overwrite = false) { + let url2 = "/api/template/docSaveAsTemplate" + let data = { + id: id2, + overwrite, + } + return parseBody(request$1(url2, data)) +} +async function render(data) { + let url2 = "/api/template/render" + return parseBody(request$1(url2, data)) +} +async function insertBlock(previousID, dataType, data) { + let url2 = "/api/block/insertBlock" + return parseBody( + request$1( + (url2 = url2), + (data = { + previousID, + dataType, + data, + }) + ) + ) +} +async function prependBlock(parentID, dataType, data) { + let url2 = "/api/block/prependBlock" + return parseBody( + request$1( + (url2 = url2), + (data = { + parentID, + dataType, + data, + }) + ) + ) +} +async function appendBlock(parentID, dataType, data) { + let url2 = "/api/block/appendBlock" + return parseBody( + request$1( + (url2 = url2), + (data = { + parentID, + dataType, + data, + }) + ) + ) +} +async function updateBlock(id2, dataType, data) { + let url2 = "/api/block/updateBlock" + return parseBody( + request$1( + (url2 = url2), + (data = { + id: id2, + dataType, + data, + }) + ) + ) +} +async function deleteBlock(id2) { + let url2 = "/api/block/deleteBlock" + return parseBody(request$1(url2, { id: id2 })) +} +async function moveBlock(id2, previousID, parentID) { + let url2 = "/api/block/moveBlock" + return parseBody(request$1(url2, { id: id2, previousID, parentID })) +} +async function getSysFonts() { + let url2 = "/api/system/getSysFonts" + return parseBody(request$1(url2, null)) +} +async function getFile(path, type = "text") { + const response = await fetch("/api/file/getFile", { + method: "POST", + headers: { + Authorization: `Token ${config().token}`, + }, + body: JSON.stringify({ + path, + }), + }) + if (response.status === 200) { + if (type === "text") { + return await response.text() + } + if (type === "json") { + return (await response.json()).data + } + } + return null +} +async function putFile(path, filedata, isDir = false, modTime = Date.now()) { + let blob = new Blob([filedata]) + let file = new File([blob], path.split("/").pop()) + let formdata = new FormData() + formdata.append("path", path) + formdata.append("file", file) + formdata.append("isDir", String(isDir)) + formdata.append("modTime", String(modTime)) + const response = await fetch("/api/file/putFile", { + body: formdata, + method: "POST", + headers: { + Authorization: `Token ${config().token}`, + }, + }) + if (response.status === 200) return await response.json() + else return null +} +async function readDir(path) { + const response = await fetch("/api/file/readDir", { + method: "POST", + headers: { + Authorization: `Token ${config().token}`, + }, + body: JSON.stringify({ + path, + }), + }) + if (response.status === 200) { + return (await response.json()).data + } + return null +} +async function removeFile(path) { + const response = await fetch("/api/file/removeFile", { + method: "POST", + headers: { + Authorization: `Token ${config().token}`, + }, + body: JSON.stringify({ + path, + }), + }) + if (response.status === 200) return + else return null +} +const language = (_a = window.theme) == null ? void 0 : _a.languageMode +async function pushMsg(message = null, text2 = null, timeout = 7e3) { + const url2 = "/api/notification/pushMsg" + const data = { + msg: message ? message[language] || message.other : text2, + timeout, + } + return parseBody(request$1(url2, data)) +} +async function pushErrMsg(message = null, text2 = null, timeout = 7e3) { + const url2 = "/api/notification/pushErrMsg" + const data = { + msg: message ? message[language] || message.other : text2, + timeout, + } + return parseBody(request$1(url2, data)) +} +async function setStorageVal(key, val) { + const url2 = "/api/storage/setLocalStorageVal" + const data = { + app: genUUID(), + key, + val, + } + return parseBody(request$1(url2, data)) +} +async function getLocalStorage() { + const url2 = "/api/storage/getLocalStorage" + return parseBody(request$1(url2, null)) +} +async function renderSprig(sprig) { + let url2 = "/api/template/renderSprig" + return parseBody(request$1(url2, { template: sprig })) +} +async function getBazzarWidget() { + const url2 = "/api/bazaar/getBazaarWidget" + return parseBody(request$1(url2, null)) +} +const serverApi = /* @__PURE__ */ Object.freeze( + /* @__PURE__ */ Object.defineProperty( + { + __proto__: null, + appendBlock, + closeNotebook, + createDocWithMd, + createNotebook, + deleteBlock, + docSaveAsTemplate, + exportMdContent, + getAnchor, + getBacklink, + getBazzarWidget, + getBlockAttrs, + getBlockBreadcrumb, + getBlockByID, + getBlockKramdown, + getDoc, + getDocOutline, + getFile, + getFocusedDoc, + getGraph, + getHPathByID, + getHPathByPath, + getLocalGraph, + getLocalStorage, + getNotebookConf, + getSysFonts, + getTag, + insertBlock, + listDocsByPath, + lsNotebooks, + moveBlock, + moveDoc, + openNotebook, + parseBody, + prependBlock, + pushErrMsg, + pushMsg, + putFile, + readDir, + removeDoc, + removeFile, + removeNotebook, + renameDoc, + renameNotebook, + render, + renderSprig, + request: request$1, + searchBlock, + searchDocs, + searchEmbedBlock, + searchTemplate, + setBlockAttrs, + setNotebookConf, + setStorageVal, + sql, + transactions, + updateBlock, + }, + Symbol.toStringTag, + { value: "Module" } + ) +) +class Notification { + constructor(option) { + this.option = option + } + show() { + if (this.option.type === "error") { + pushErrMsg(null, this.option.message, this.option.timeout) + } else { + pushMsg(null, this.option.message, this.option.timeout) + } + } +} +var z = Object.defineProperty +var D = (i, e, t2) => + e in i ? z(i, e, { enumerable: true, configurable: true, writable: true, value: t2 }) : (i[e] = t2) +var _$1 = (i, e, t2) => (D(i, typeof e != "symbol" ? e + "" : e, t2), t2) +var P = + typeof globalThis < "u" + ? globalThis + : typeof window < "u" + ? window + : typeof global < "u" + ? global + : typeof self < "u" + ? self + : {}, + b = {}, + W = { + get exports() { + return b + }, + set exports(i) { + b = i + }, + } +;(function (i) { + ;(function (e, t2) { + i.exports ? (i.exports = t2()) : (e.log = t2()) + })(P, function () { + var e = function () {}, + t2 = "undefined", + l = typeof window !== t2 && typeof window.navigator !== t2 && /Trident\/|MSIE /.test(window.navigator.userAgent), + p = ["trace", "debug", "info", "warn", "error"] + function c(a2, s) { + var f = a2[s] + if (typeof f.bind == "function") return f.bind(a2) + try { + return Function.prototype.bind.call(f, a2) + } catch { + return function () { + return Function.prototype.apply.apply(f, [a2, arguments]) + } + } + } + function g() { + console.log && + (console.log.apply + ? console.log.apply(console, arguments) + : Function.prototype.apply.apply(console.log, [console, arguments])), + console.trace && console.trace() + } + function w(a2) { + return ( + a2 === "debug" && (a2 = "log"), + typeof console === t2 + ? false + : a2 === "trace" && l + ? g + : console[a2] !== void 0 + ? c(console, a2) + : console.log !== void 0 + ? c(console, "log") + : e + ) + } + function E(a2, s) { + for (var f = 0; f < p.length; f++) { + var o = p[f] + this[o] = f < a2 ? e : this.methodFactory(o, a2, s) + } + this.log = this.debug + } + function F(a2, s, f) { + return function () { + typeof console !== t2 && (E.call(this, s, f), this[a2].apply(this, arguments)) + } + } + function r(a2, s, f) { + return w(a2) || F.apply(this, arguments) + } + function v(a2, s, f) { + var o = this, + O + s = s ?? "WARN" + var u = "loglevel" + typeof a2 == "string" ? (u += ":" + a2) : typeof a2 == "symbol" && (u = void 0) + function C(n) { + var d = (p[n] || "silent").toUpperCase() + if (!(typeof window === t2 || !u)) { + try { + window.localStorage[u] = d + return + } catch {} + try { + window.document.cookie = encodeURIComponent(u) + "=" + d + ";" + } catch {} + } + } + function k2() { + var n + if (!(typeof window === t2 || !u)) { + try { + n = window.localStorage[u] + } catch {} + if (typeof n === t2) + try { + var d = window.document.cookie, + m = d.indexOf(encodeURIComponent(u) + "=") + m !== -1 && (n = /^([^;]+)/.exec(d.slice(m))[1]) + } catch {} + return o.levels[n] === void 0 && (n = void 0), n + } + } + function V() { + if (!(typeof window === t2 || !u)) { + try { + window.localStorage.removeItem(u) + return + } catch {} + try { + window.document.cookie = encodeURIComponent(u) + "=; expires=Thu, 01 Jan 1970 00:00:00 UTC" + } catch {} + } + } + ;(o.name = a2), + (o.levels = { + TRACE: 0, + DEBUG: 1, + INFO: 2, + WARN: 3, + ERROR: 4, + SILENT: 5, + }), + (o.methodFactory = f || r), + (o.getLevel = function () { + return O + }), + (o.setLevel = function (n, d) { + if ( + (typeof n == "string" && o.levels[n.toUpperCase()] !== void 0 && (n = o.levels[n.toUpperCase()]), + typeof n == "number" && n >= 0 && n <= o.levels.SILENT) + ) { + if (((O = n), d !== false && C(n), E.call(o, n, a2), typeof console === t2 && n < o.levels.SILENT)) + return "No console available for logging" + } else throw "log.setLevel() called with invalid level: " + n + }), + (o.setDefaultLevel = function (n) { + ;(s = n), k2() || o.setLevel(n, false) + }), + (o.resetLevel = function () { + o.setLevel(s, false), V() + }), + (o.enableAll = function (n) { + o.setLevel(o.levels.TRACE, n) + }), + (o.disableAll = function (n) { + o.setLevel(o.levels.SILENT, n) + }) + var y = k2() + y == null && (y = s), o.setLevel(y, false) + } + var L = new v(), + h = {} + L.getLogger = function (s) { + if ((typeof s != "symbol" && typeof s != "string") || s === "") + throw new TypeError("You must supply a name when creating a logger.") + var f = h[s] + return f || (f = h[s] = new v(s, L.getLevel(), L.methodFactory)), f + } + var G = typeof window !== t2 ? window.log : void 0 + return ( + (L.noConflict = function () { + return typeof window !== t2 && window.log === L && (window.log = G), L + }), + (L.getLoggers = function () { + return h + }), + (L.default = L), + L + ) + }) +})(W) +var R = {}, + B = { + get exports() { + return R + }, + set exports(i) { + R = i + }, + } +;(function (i) { + ;(function (e, t2) { + i.exports ? (i.exports = t2()) : (e.prefix = t2(e)) + })(P, function (e) { + var t2 = function (r) { + for (var v = 1, L = arguments.length, h; v < L; v++) + for (h in arguments[v]) Object.prototype.hasOwnProperty.call(arguments[v], h) && (r[h] = arguments[v][h]) + return r + }, + l = { + template: "[%t] %l:", + levelFormatter: function (r) { + return r.toUpperCase() + }, + nameFormatter: function (r) { + return r || "root" + }, + timestampFormatter: function (r) { + return r.toTimeString().replace(/.*(\d{2}:\d{2}:\d{2}).*/, "$1") + }, + format: void 0, + }, + p, + c = {}, + g = function (r) { + if (!r || !r.getLogger) throw new TypeError("Argument is not a root logger") + p = r + }, + w = function (r, v) { + if (!r || !r.setLevel) throw new TypeError("Argument is not a logger") + var L = r.methodFactory, + h = r.name || "", + G = c[h] || c[""] || l + function a2(s, f, o) { + var O = L(s, f, o), + u = c[o] || c[""], + C = u.template.indexOf("%t") !== -1, + k2 = u.template.indexOf("%l") !== -1, + V = u.template.indexOf("%n") !== -1 + return function () { + for (var y = "", n = arguments.length, d = Array(n), m = 0; m < n; m++) d[m] = arguments[m] + if (h || !c[o]) { + var x = u.timestampFormatter(new Date()), + U = u.levelFormatter(s), + A = u.nameFormatter(o) + u.format + ? (y += u.format(U, A, x)) + : ((y += u.template), + C && (y = y.replace(/%t/, x)), + k2 && (y = y.replace(/%l/, U)), + V && (y = y.replace(/%n/, A))), + d.length && typeof d[0] == "string" ? (d[0] = y + " " + d[0]) : d.unshift(y) + } + O.apply(void 0, d) + } + } + return ( + c[h] || (r.methodFactory = a2), + (v = v || {}), + v.template && (v.format = void 0), + (c[h] = t2({}, G, v)), + r.setLevel(r.getLevel()), + p || + r.warn( + "It is necessary to call the function reg() of loglevel-plugin-prefix before calling apply. From the next release, it will throw an error. See more: https://github.com/kutuluk/loglevel-plugin-prefix/blob/master/README.md" + ), + r + ) + }, + E = { + reg: g, + apply: w, + }, + F + return ( + e && + ((F = e.prefix), + (E.noConflict = function () { + return e.prefix === E && (e.prefix = F), E + })), + E + ) + }) +})(B) +class T {} +_$1(T, "LOG_LEVEL_KEY", "VITE_LOG_LEVEL"), _$1(T, "LOG_PREFIX_KEY", "VITE_LOG_PREFIX") +var S = /* @__PURE__ */ ((i) => ( + (i.LOG_LEVEL_DEBUG = "DEBUG"), + (i.LOG_LEVEL_INFO = "INFO"), + (i.LOG_LEVEL_WARN = "WARN"), + (i.LOG_LEVEL_ERROR = "ERROR"), + i +))(S || {}) +function K() { + const i = Error.prepareStackTrace + Error.prepareStackTrace = (t2, l) => l + const e = new Error().stack.slice(1) + return (Error.prepareStackTrace = i), e +} +class I { + /** + * 解析日志级别为枚举 + * + * @param enumObj 枚举对象 + * @param value 配置的值 + */ + static stringToEnumValue(e, t2) { + return e[Object.keys(e).filter((l) => e[l].toString() === t2)[0]] + } + /** + * 获取配置的日志级别 + */ + static getEnvLevel(e) { + if (!e) return + const t2 = e.getEnvOrDefault(T.LOG_LEVEL_KEY, S.LOG_LEVEL_INFO), + l = I.stringToEnumValue(S, t2.toUpperCase()) + return ( + l || + console.warn( + "[zhi-log] LOG_LEVEL is invalid in you .env file.Must be either debug, info, warn or error, fallback to default info level" + ), + l + ) + } + /** + * 获取默认日志 + */ + static getEnvLogger(e) { + if (e) return e.getEnv(T.LOG_PREFIX_KEY) + } +} +class Y { + constructor(e, t2, l) { + _$1(this, "consoleLogger", "console") + _$1(this, "stackSize", 1) + _$1(this, "getLogger", (e2) => { + let t3 + if (e2) t3 = e2 + else { + const l2 = this.getCallStack(), + p2 = [], + c2 = [] + for (let g = 0; g < l2.length; g++) { + const w = l2[g], + E = w.getFileName() ?? "none" + if (g > this.stackSize - 1) break + const F = E + "-" + w.getLineNumber() + ":" + w.getColumnNumber() + p2.push(F) + } + c2.length > 0 && (t3 = p2.join(" -> ")) + } + return (!t3 || t3.trim().length === 0) && (t3 = this.consoleLogger), b.getLogger(t3) + }) + this.stackSize = 1 + let p + e ? (p = e) : (p = I.getEnvLevel(l)), (p = p ?? S.LOG_LEVEL_INFO), b.setLevel(p) + const c = { + gray: (g) => g.toString(), + green: (g) => g.toString(), + yellow: (g) => g.toString(), + red: (g) => g.toString(), + } + R.reg(b), + R.apply(b, { + format(g, w, E) { + const r = ["[" + (t2 ?? I.getEnvLogger(l) ?? "zhi") + "]"] + switch ((r.push(c.gray("[") + c.green(E).toString() + c.gray("]")), g)) { + case S.LOG_LEVEL_DEBUG: + r.push(c.gray(g.toUpperCase().toString())) + break + case S.LOG_LEVEL_INFO: + r.push(c.green(g.toUpperCase().toString())) + break + case S.LOG_LEVEL_WARN: + r.push(c.yellow(g.toUpperCase().toString())) + break + case S.LOG_LEVEL_ERROR: + r.push(c.red(g.toUpperCase().toString())) + break + } + return r.push(c.green(w).toString()), r.push(c.gray(":")), r.join(" ") + }, + }) + } + /** + * 设置输出栈的深度，默认1 + * + * @param stackSize - 栈的深度 + */ + setStackSize(e) { + this.stackSize = e ?? 1 + } + /** + * 获取调用堆栈，若未获取到直接返回空数组 + * + * @author terwer + * @since 1.6.0 + */ + getCallStack() { + let e + try { + e = K() + } catch { + e = [] + } + return e + } +} +class X { + /** + * 默认日志级别 + * + * @param level - 可选，未设置默认INFO + * @param sign - 可选前缀，默认zhi + * @param env - 可选环境变量实例 + */ + constructor(e, t2, l) { + _$1(this, "logger") + this.logger = new Y(e, t2, l) + } + /** + * 获取日志记录器 + * + * @param loggerName - 日志记录器名称 + * @param stackSize - 打印栈的深度 + * @protected + */ + getLogger(e, t2) { + return this.logger.setStackSize(t2), this.logger.getLogger(e) + } +} +class N extends X { + constructor(e, t2, l) { + super(e, t2, l) + } + /** + * 获取默认的日志记录器 + * + * @param loggerName - 日志记录器名称 + * @param stackSize - 打印栈的深度 + */ + getLogger(e, t2) { + return super.getLogger(e, t2) + } +} +class M { + /** + * 默认日志记录器 + * + * @param stackSize - 栈的深度 + * @param env - 环境变量实例 + */ + static defaultLogger(e, t2) { + return M.customLogFactory(void 0, void 0, e).getLogger(void 0, t2) + } + /** + * 自定义日志工厂 + */ + static customLogFactory(e, t2, l) { + return new N(e, t2, l) + } + /** + * 自定义日志工厂，自定义前缀 + */ + static customSignLogFactory(e, t2) { + return new N(void 0, e, t2) + } +} +function insertBefore(positionEl, el) { + return positionEl.insertAdjacentElement("beforebegin", el) +} +function insertAfter(positionEl, el) { + return positionEl.insertAdjacentElement("afterend", el) +} +function addToolbarLeft(el) { + var _a2 + const title = (_a2 = document.getElementById("toolbar")) == null ? void 0 : _a2.getElementsByClassName("fn__ellipsis") + if (!title) { + return + } + insertBefore(title[0], el) +} +function addToolbarRight(el) { + var _a2 + const title = (_a2 = document.getElementById("toolbar")) == null ? void 0 : _a2.getElementsByClassName("fn__ellipsis") + if (!title) { + return + } + insertAfter(title[0], el) +} +const createLogger = (name2) => getLogger(name2) +const clientApi = /* @__PURE__ */ Object.freeze( + /* @__PURE__ */ Object.defineProperty( + { + __proto__: null, + addToolbarLeft, + addToolbarRight, + createLogger, + }, + Symbol.toStringTag, + { value: "Module" } + ) +) +class Menu { + constructor(id2) { + var _a2, _b + const menu = (_b = (_a2 = window.siyuan) == null ? void 0 : _a2.menus) == null ? void 0 : _b.menu + if (!menu) { + throw Error("Siyuan internal menu not found!") + } + this.menu = menu + if (!id2) { + throw Error("Menu must has an id, got empty or undefined!") + } + menu.remove() + menu.element.setAttribute("data-name", id2) + } + addItem(item) { + this.menu.append(item.element) + return this + } + addSeparator() { + this.addItem(new MenuItem({ type: "separator" })) + return this + } + showAtMouseEvent(event) { + this.menu.popup({ x: event.clientX, y: event.clientY }) + return this + } + showAtPosition(position) { + this.menu.popup({ x: position.x, y: position.y }) + return this + } + close() { + this.menu.remove() + } +} +class MenuItem { + constructor(options) { + this.element = document.createElement("button") + if (options.disabled) { + this.element.setAttribute("disabled", "disabled") + } + if (options.type === "separator") { + this.element.classList.add("b3-menu__separator") + return + } + this.element.classList.add("b3-menu__item") + if (options.current) { + this.element.classList.add("b3-menu__item--selected") + } + if (options.click) { + this.element.addEventListener("click", (event) => { + if (this.element.getAttribute("disabled")) { + return + } + options.click(this.element) + event.preventDefault() + event.stopImmediatePropagation() + event.stopPropagation() + window.siyuan.menus.menu.remove() + }) + } + let html = `${options.label}` + if (options.iconHTML) { + html = options.iconHTML + html + } else { + html = `${html}` + } + if (options.action) { + html += `` + } + if (options.id) { + this.element.setAttribute("data-id", options.id) + } + if (options.type === "readonly") { + this.element.classList.add("b3-menu__item--readonly") + } + this.element.innerHTML = html + if (options.bind) { + this.element.classList.add("b3-menu__item--custom") + options.bind(this.element) + } + if (options.submenu) { + const submenuElement = document.createElement("div") + submenuElement.classList.add("b3-menu__submenu") + options.submenu.forEach((item) => { + submenuElement.append(new MenuItem(item).element) + }) + this.element.insertAdjacentHTML( + "beforeend", + '' + ) + this.element.append(submenuElement) + } + } +} +class MenuSeparator {} +class Dialog { + constructor(options) { + this.disableClose = options.disableClose + this.id = genUUID() + window.siyuan.dialogs.push(this) + this.destroyCallback = options.destroyCallback + this.element = document.createElement("div") + this.element.innerHTML = `
+
+
+ +
${ + options.title || "" + }
+
${options.content}
+
` + this.element.querySelector(".b3-dialog__scrim").addEventListener("click", (event) => { + if (!this.disableClose) { + this.destroy() + } + event.preventDefault() + event.stopPropagation() + window.siyuan.menus.menu.remove() + }) + if (!this.disableClose) { + this.element.querySelector(".b3-dialog__close").addEventListener("click", (event) => { + this.destroy() + event.preventDefault() + event.stopPropagation() + }) + } + document.body.append(this.element) + if (options.disableAnimation) { + this.element.classList.add("b3-dialog--open") + } else { + setTimeout(() => { + this.element.classList.add("b3-dialog--open") + }) + } + window.siyuan.menus.menu.remove() + } + static destroyAll() { + window.siyuan.dialogs.forEach((p) => p.destroy()) + } + destroy() { + this.element.remove() + window.siyuan.menus.menu.remove() + if (this.destroyCallback) { + this.destroyCallback() + } + window.siyuan.dialogs.find((item, index) => { + if (item.id === this.id) { + window.siyuan.dialogs.splice(index, 1) + return true + } + }) + } + bindInput(inputElement, enterEvent) { + inputElement.focus() + inputElement.addEventListener("keydown", (event) => { + if (event.isComposing) { + event.preventDefault() + return + } + if (event.key === "Escape") { + this.destroy() + event.preventDefault() + event.stopPropagation() + return + } + if (event.key === "Enter" && enterEvent) { + enterEvent() + event.preventDefault() + } + }) + } +} +class Plugin { + onload() {} + onunload() {} + registerCommand(command) {} + registerSettingRender(settingRender) {} + async loadStorage(filename) { + return null + } + async writeStorage(filename, content) {} +} +const api = { + clientApi, + serverApi, + Plugin, + Menu, + MenuItem, + MenuSeparator, + Notification, + Dialog, +} +var reExports = {} +var re$3 = { + get exports() { + return reExports + }, + set exports(v) { + reExports = v + }, +} +const SEMVER_SPEC_VERSION = "2.0.0" +const MAX_LENGTH$2 = 256 +const MAX_SAFE_INTEGER$1 = Number.MAX_SAFE_INTEGER /* istanbul ignore next */ || 9007199254740991 +const MAX_SAFE_COMPONENT_LENGTH = 16 +var constants$1 = { + SEMVER_SPEC_VERSION, + MAX_LENGTH: MAX_LENGTH$2, + MAX_SAFE_INTEGER: MAX_SAFE_INTEGER$1, + MAX_SAFE_COMPONENT_LENGTH, +} +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 +;(function (module2, exports2) { + const { MAX_SAFE_COMPONENT_LENGTH: MAX_SAFE_COMPONENT_LENGTH2 } = constants$1 + const debug2 = debug_1 + exports2 = module2.exports = {} + const re2 = (exports2.re = []) + const src = (exports2.src = []) + const t2 = (exports2.t = {}) + let R2 = 0 + const createToken = (name2, value, isGlobal) => { + const index = R2++ + debug2(name2, index, value) + t2[name2] = index + src[index] = value + re2[index] = new RegExp(value, isGlobal ? "g" : void 0) + } + createToken("NUMERICIDENTIFIER", "0|[1-9]\\d*") + createToken("NUMERICIDENTIFIERLOOSE", "[0-9]+") + createToken("NONNUMERICIDENTIFIER", "\\d*[a-zA-Z-][a-zA-Z0-9-]*") + createToken( + "MAINVERSION", + `(${src[t2.NUMERICIDENTIFIER]})\\.(${src[t2.NUMERICIDENTIFIER]})\\.(${src[t2.NUMERICIDENTIFIER]})` + ) + createToken( + "MAINVERSIONLOOSE", + `(${src[t2.NUMERICIDENTIFIERLOOSE]})\\.(${src[t2.NUMERICIDENTIFIERLOOSE]})\\.(${src[t2.NUMERICIDENTIFIERLOOSE]})` + ) + createToken("PRERELEASEIDENTIFIER", `(?:${src[t2.NUMERICIDENTIFIER]}|${src[t2.NONNUMERICIDENTIFIER]})`) + createToken("PRERELEASEIDENTIFIERLOOSE", `(?:${src[t2.NUMERICIDENTIFIERLOOSE]}|${src[t2.NONNUMERICIDENTIFIER]})`) + createToken("PRERELEASE", `(?:-(${src[t2.PRERELEASEIDENTIFIER]}(?:\\.${src[t2.PRERELEASEIDENTIFIER]})*))`) + createToken( + "PRERELEASELOOSE", + `(?:-?(${src[t2.PRERELEASEIDENTIFIERLOOSE]}(?:\\.${src[t2.PRERELEASEIDENTIFIERLOOSE]})*))` + ) + createToken("BUILDIDENTIFIER", "[0-9A-Za-z-]+") + createToken("BUILD", `(?:\\+(${src[t2.BUILDIDENTIFIER]}(?:\\.${src[t2.BUILDIDENTIFIER]})*))`) + createToken("FULLPLAIN", `v?${src[t2.MAINVERSION]}${src[t2.PRERELEASE]}?${src[t2.BUILD]}?`) + createToken("FULL", `^${src[t2.FULLPLAIN]}$`) + createToken("LOOSEPLAIN", `[v=\\s]*${src[t2.MAINVERSIONLOOSE]}${src[t2.PRERELEASELOOSE]}?${src[t2.BUILD]}?`) + createToken("LOOSE", `^${src[t2.LOOSEPLAIN]}$`) + createToken("GTLT", "((?:<|>)?=?)") + createToken("XRANGEIDENTIFIERLOOSE", `${src[t2.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`) + createToken("XRANGEIDENTIFIER", `${src[t2.NUMERICIDENTIFIER]}|x|X|\\*`) + createToken( + "XRANGEPLAIN", + `[v=\\s]*(${src[t2.XRANGEIDENTIFIER]})(?:\\.(${src[t2.XRANGEIDENTIFIER]})(?:\\.(${src[t2.XRANGEIDENTIFIER]})(?:${ + src[t2.PRERELEASE] + })?${src[t2.BUILD]}?)?)?` + ) + createToken( + "XRANGEPLAINLOOSE", + `[v=\\s]*(${src[t2.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t2.XRANGEIDENTIFIERLOOSE]})(?:\\.(${ + src[t2.XRANGEIDENTIFIERLOOSE] + })(?:${src[t2.PRERELEASELOOSE]})?${src[t2.BUILD]}?)?)?` + ) + createToken("XRANGE", `^${src[t2.GTLT]}\\s*${src[t2.XRANGEPLAIN]}$`) + createToken("XRANGELOOSE", `^${src[t2.GTLT]}\\s*${src[t2.XRANGEPLAINLOOSE]}$`) + createToken( + "COERCE", + `${"(^|[^\\d])(\\d{1,"}${MAX_SAFE_COMPONENT_LENGTH2}})(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH2}}))?(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH2}}))?(?:$|[^\\d])` + ) + createToken("COERCERTL", src[t2.COERCE], true) + createToken("LONETILDE", "(?:~>?)") + createToken("TILDETRIM", `(\\s*)${src[t2.LONETILDE]}\\s+`, true) + exports2.tildeTrimReplace = "$1~" + createToken("TILDE", `^${src[t2.LONETILDE]}${src[t2.XRANGEPLAIN]}$`) + createToken("TILDELOOSE", `^${src[t2.LONETILDE]}${src[t2.XRANGEPLAINLOOSE]}$`) + createToken("LONECARET", "(?:\\^)") + createToken("CARETTRIM", `(\\s*)${src[t2.LONECARET]}\\s+`, true) + exports2.caretTrimReplace = "$1^" + createToken("CARET", `^${src[t2.LONECARET]}${src[t2.XRANGEPLAIN]}$`) + createToken("CARETLOOSE", `^${src[t2.LONECARET]}${src[t2.XRANGEPLAINLOOSE]}$`) + createToken("COMPARATORLOOSE", `^${src[t2.GTLT]}\\s*(${src[t2.LOOSEPLAIN]})$|^$`) + createToken("COMPARATOR", `^${src[t2.GTLT]}\\s*(${src[t2.FULLPLAIN]})$|^$`) + createToken("COMPARATORTRIM", `(\\s*)${src[t2.GTLT]}\\s*(${src[t2.LOOSEPLAIN]}|${src[t2.XRANGEPLAIN]})`, true) + exports2.comparatorTrimReplace = "$1$2$3" + createToken("HYPHENRANGE", `^\\s*(${src[t2.XRANGEPLAIN]})\\s+-\\s+(${src[t2.XRANGEPLAIN]})\\s*$`) + createToken("HYPHENRANGELOOSE", `^\\s*(${src[t2.XRANGEPLAINLOOSE]})\\s+-\\s+(${src[t2.XRANGEPLAINLOOSE]})\\s*$`) + createToken("STAR", "(<|>)?=?\\s*\\*") + createToken("GTE0", "^\\s*>=\\s*0\\.0\\.0\\s*$") + createToken("GTE0PRE", "^\\s*>=\\s*0\\.0\\.0-0\\s*$") +})(re$3, reExports) +const opts = ["includePrerelease", "loose", "rtl"] +const parseOptions$2 = (options) => + !options + ? {} + : typeof options !== "object" + ? { loose: true } + : opts + .filter((k2) => options[k2]) + .reduce((o, k2) => { + o[k2] = true + return o + }, {}) +var parseOptions_1 = parseOptions$2 +const numeric = /^[0-9]+$/ +const compareIdentifiers$1 = (a2, b2) => { + const anum = numeric.test(a2) + const bnum = numeric.test(b2) + if (anum && bnum) { + a2 = +a2 + b2 = +b2 + } + return a2 === b2 ? 0 : anum && !bnum ? -1 : bnum && !anum ? 1 : a2 < b2 ? -1 : 1 +} +const rcompareIdentifiers = (a2, b2) => compareIdentifiers$1(b2, a2) +var identifiers$1 = { + compareIdentifiers: compareIdentifiers$1, + rcompareIdentifiers, +} +const debug = debug_1 +const { MAX_LENGTH: MAX_LENGTH$1, MAX_SAFE_INTEGER } = constants$1 +const { re: re$2, t: t$2 } = reExports +const parseOptions$1 = parseOptions_1 +const { compareIdentifiers } = identifiers$1 +let SemVer$d = class SemVer2 { + constructor(version2, options) { + options = parseOptions$1(options) + if (version2 instanceof SemVer2) { + if (version2.loose === !!options.loose && version2.includePrerelease === !!options.includePrerelease) { + return version2 + } else { + version2 = version2.version + } + } else if (typeof version2 !== "string") { + throw new TypeError(`Invalid Version: ${version2}`) + } + if (version2.length > MAX_LENGTH$1) { + throw new TypeError(`version is longer than ${MAX_LENGTH$1} characters`) + } + debug("SemVer", version2, options) + this.options = options + this.loose = !!options.loose + this.includePrerelease = !!options.includePrerelease + const m = version2.trim().match(options.loose ? re$2[t$2.LOOSE] : re$2[t$2.FULL]) + if (!m) { + throw new TypeError(`Invalid Version: ${version2}`) + } + this.raw = version2 + this.major = +m[1] + this.minor = +m[2] + this.patch = +m[3] + if (this.major > MAX_SAFE_INTEGER || this.major < 0) { + throw new TypeError("Invalid major version") + } + if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) { + throw new TypeError("Invalid minor version") + } + if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) { + throw new TypeError("Invalid patch version") + } + if (!m[4]) { + this.prerelease = [] + } else { + this.prerelease = m[4].split(".").map((id2) => { + if (/^[0-9]+$/.test(id2)) { + const num = +id2 + if (num >= 0 && num < MAX_SAFE_INTEGER) { + return num + } + } + return id2 + }) + } + 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 SemVer2)) { + if (typeof other === "string" && other === this.version) { + return 0 + } + other = new SemVer2(other, this.options) + } + if (other.version === this.version) { + return 0 + } + return this.compareMain(other) || this.comparePre(other) + } + compareMain(other) { + if (!(other instanceof SemVer2)) { + other = new SemVer2(other, this.options) + } + return ( + compareIdentifiers(this.major, other.major) || + compareIdentifiers(this.minor, other.minor) || + compareIdentifiers(this.patch, other.patch) + ) + } + comparePre(other) { + if (!(other instanceof SemVer2)) { + other = new SemVer2(other, this.options) + } + if (this.prerelease.length && !other.prerelease.length) { + return -1 + } else if (!this.prerelease.length && other.prerelease.length) { + return 1 + } else if (!this.prerelease.length && !other.prerelease.length) { + return 0 + } + let i = 0 + do { + const a2 = this.prerelease[i] + const b2 = other.prerelease[i] + debug("prerelease compare", i, a2, b2) + if (a2 === void 0 && b2 === void 0) { + return 0 + } else if (b2 === void 0) { + return 1 + } else if (a2 === void 0) { + return -1 + } else if (a2 === b2) { + continue + } else { + return compareIdentifiers(a2, b2) + } + } while (++i) + } + compareBuild(other) { + if (!(other instanceof SemVer2)) { + other = new SemVer2(other, this.options) + } + let i = 0 + do { + const a2 = this.build[i] + const b2 = other.build[i] + debug("prerelease compare", i, a2, b2) + if (a2 === void 0 && b2 === void 0) { + return 0 + } else if (b2 === void 0) { + return 1 + } else if (a2 === void 0) { + return -1 + } else if (a2 === b2) { + continue + } else { + return compareIdentifiers(a2, b2) + } + } 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) { + switch (release) { + case "premajor": + this.prerelease.length = 0 + this.patch = 0 + this.minor = 0 + this.major++ + this.inc("pre", identifier) + break + case "preminor": + this.prerelease.length = 0 + this.patch = 0 + this.minor++ + this.inc("pre", identifier) + break + case "prepatch": + this.prerelease.length = 0 + this.inc("patch", identifier) + this.inc("pre", identifier) + break + case "prerelease": + if (this.prerelease.length === 0) { + this.inc("patch", identifier) + } + this.inc("pre", identifier) + break + case "major": + if (this.minor !== 0 || this.patch !== 0 || this.prerelease.length === 0) { + this.major++ + } + this.minor = 0 + this.patch = 0 + this.prerelease = [] + break + case "minor": + if (this.patch !== 0 || this.prerelease.length === 0) { + this.minor++ + } + this.patch = 0 + this.prerelease = [] + break + case "patch": + if (this.prerelease.length === 0) { + this.patch++ + } + this.prerelease = [] + break + case "pre": + if (this.prerelease.length === 0) { + this.prerelease = [0] + } else { + let i = this.prerelease.length + while (--i >= 0) { + if (typeof this.prerelease[i] === "number") { + this.prerelease[i]++ + i = -2 + } + } + if (i === -1) { + this.prerelease.push(0) + } + } + if (identifier) { + if (compareIdentifiers(this.prerelease[0], identifier) === 0) { + if (isNaN(this.prerelease[1])) { + this.prerelease = [identifier, 0] + } + } else { + this.prerelease = [identifier, 0] + } + } + break + default: + throw new Error(`invalid increment argument: ${release}`) + } + this.format() + this.raw = this.version + return this + } +} +var semver$1 = SemVer$d +const { MAX_LENGTH } = constants$1 +const { re: re$1, t: t$1 } = reExports +const SemVer$c = semver$1 +const parseOptions = parseOptions_1 +const parse$6 = (version2, options) => { + options = parseOptions(options) + if (version2 instanceof SemVer$c) { + return version2 + } + if (typeof version2 !== "string") { + return null + } + if (version2.length > MAX_LENGTH) { + return null + } + const r = options.loose ? re$1[t$1.LOOSE] : re$1[t$1.FULL] + if (!r.test(version2)) { + return null + } + try { + return new SemVer$c(version2, options) + } catch (er) { + return null + } +} +var parse_1 = parse$6 +const parse$5 = parse_1 +const valid$2 = (version2, options) => { + const v = parse$5(version2, options) + return v ? v.version : null +} +var valid_1 = valid$2 +const parse$4 = parse_1 +const clean$1 = (version2, options) => { + const s = parse$4(version2.trim().replace(/^[=v]+/, ""), options) + return s ? s.version : null +} +var clean_1 = clean$1 +const SemVer$b = semver$1 +const inc$1 = (version2, release, options, identifier) => { + if (typeof options === "string") { + identifier = options + options = void 0 + } + try { + return new SemVer$b(version2 instanceof SemVer$b ? version2.version : version2, options).inc(release, identifier) + .version + } catch (er) { + return null + } +} +var inc_1 = inc$1 +const SemVer$a = semver$1 +const compare$b = (a2, b2, loose) => new SemVer$a(a2, loose).compare(new SemVer$a(b2, loose)) +var compare_1 = compare$b +const compare$a = compare_1 +const eq$3 = (a2, b2, loose) => compare$a(a2, b2, loose) === 0 +var eq_1 = eq$3 +const parse$3 = parse_1 +const eq$2 = eq_1 +const diff$1 = (version1, version2) => { + if (eq$2(version1, version2)) { + return null + } else { + const v1 = parse$3(version1) + const v2 = parse$3(version2) + const hasPre = v1.prerelease.length || v2.prerelease.length + const prefix = hasPre ? "pre" : "" + const defaultResult = hasPre ? "prerelease" : "" + for (const key in v1) { + if (key === "major" || key === "minor" || key === "patch") { + if (v1[key] !== v2[key]) { + return prefix + key + } + } + } + return defaultResult + } +} +var diff_1 = diff$1 +const SemVer$9 = semver$1 +const major$1 = (a2, loose) => new SemVer$9(a2, loose).major +var major_1 = major$1 +const SemVer$8 = semver$1 +const minor$1 = (a2, loose) => new SemVer$8(a2, loose).minor +var minor_1 = minor$1 +const SemVer$7 = semver$1 +const patch$1 = (a2, loose) => new SemVer$7(a2, loose).patch +var patch_1 = patch$1 +const parse$2 = parse_1 +const prerelease$1 = (version2, options) => { + const parsed = parse$2(version2, options) + return parsed && parsed.prerelease.length ? parsed.prerelease : null +} +var prerelease_1 = prerelease$1 +const compare$9 = compare_1 +const rcompare$1 = (a2, b2, loose) => compare$9(b2, a2, loose) +var rcompare_1 = rcompare$1 +const compare$8 = compare_1 +const compareLoose$1 = (a2, b2) => compare$8(a2, b2, true) +var compareLoose_1 = compareLoose$1 +const SemVer$6 = semver$1 +const compareBuild$3 = (a2, b2, loose) => { + const versionA = new SemVer$6(a2, loose) + const versionB = new SemVer$6(b2, loose) + return versionA.compare(versionB) || versionA.compareBuild(versionB) +} +var compareBuild_1 = compareBuild$3 +const compareBuild$2 = compareBuild_1 +const sort$1 = (list, loose) => list.sort((a2, b2) => compareBuild$2(a2, b2, loose)) +var sort_1 = sort$1 +const compareBuild$1 = compareBuild_1 +const rsort$1 = (list, loose) => list.sort((a2, b2) => compareBuild$1(b2, a2, loose)) +var rsort_1 = rsort$1 +const compare$7 = compare_1 +const gt$4 = (a2, b2, loose) => compare$7(a2, b2, loose) > 0 +var gt_1 = gt$4 +const compare$6 = compare_1 +const lt$3 = (a2, b2, loose) => compare$6(a2, b2, loose) < 0 +var lt_1 = lt$3 +const compare$5 = compare_1 +const neq$2 = (a2, b2, loose) => compare$5(a2, b2, loose) !== 0 +var neq_1 = neq$2 +const compare$4 = compare_1 +const gte$3 = (a2, b2, loose) => compare$4(a2, b2, loose) >= 0 +var gte_1 = gte$3 +const compare$3 = compare_1 +const lte$3 = (a2, b2, loose) => compare$3(a2, b2, loose) <= 0 +var lte_1 = lte$3 +const eq$1 = eq_1 +const neq$1 = neq_1 +const gt$3 = gt_1 +const gte$2 = gte_1 +const lt$2 = lt_1 +const lte$2 = lte_1 +const cmp$1 = (a2, op, b2, loose) => { + switch (op) { + case "===": + if (typeof a2 === "object") { + a2 = a2.version + } + if (typeof b2 === "object") { + b2 = b2.version + } + return a2 === b2 + case "!==": + if (typeof a2 === "object") { + a2 = a2.version + } + if (typeof b2 === "object") { + b2 = b2.version + } + return a2 !== b2 + case "": + case "=": + case "==": + return eq$1(a2, b2, loose) + case "!=": + return neq$1(a2, b2, loose) + case ">": + return gt$3(a2, b2, loose) + case ">=": + return gte$2(a2, b2, loose) + case "<": + return lt$2(a2, b2, loose) + case "<=": + return lte$2(a2, b2, loose) + default: + throw new TypeError(`Invalid operator: ${op}`) + } +} +var cmp_1 = cmp$1 +const SemVer$5 = semver$1 +const parse$1 = parse_1 +const { re, t } = reExports +const coerce$1 = (version2, options) => { + if (version2 instanceof SemVer$5) { + return version2 + } + if (typeof version2 === "number") { + version2 = String(version2) + } + if (typeof version2 !== "string") { + return null + } + options = options || {} + let match = null + if (!options.rtl) { + match = version2.match(re[t.COERCE]) + } else { + let next + while ((next = re[t.COERCERTL].exec(version2)) && (!match || match.index + match[0].length !== version2.length)) { + if (!match || next.index + next[0].length !== match.index + match[0].length) { + match = next + } + re[t.COERCERTL].lastIndex = next.index + next[1].length + next[2].length + } + re[t.COERCERTL].lastIndex = -1 + } + if (match === null) { + return null + } + return parse$1(`${match[2]}.${match[3] || "0"}.${match[4] || "0"}`, options) +} +var coerce_1 = coerce$1 +var iterator +var hasRequiredIterator +function requireIterator() { + if (hasRequiredIterator) return iterator + hasRequiredIterator = 1 + iterator = function (Yallist) { + Yallist.prototype[Symbol.iterator] = function* () { + for (let walker = this.head; walker; walker = walker.next) { + yield walker.value + } + } + } + return iterator +} +var yallist +var hasRequiredYallist +function requireYallist() { + if (hasRequiredYallist) return yallist + hasRequiredYallist = 1 + yallist = Yallist + Yallist.Node = Node + Yallist.create = Yallist + function Yallist(list) { + var self2 = this + if (!(self2 instanceof Yallist)) { + self2 = new Yallist() + } + self2.tail = null + self2.head = null + self2.length = 0 + if (list && typeof list.forEach === "function") { + list.forEach(function (item) { + self2.push(item) + }) + } else if (arguments.length > 0) { + for (var i = 0, l = arguments.length; i < l; i++) { + self2.push(arguments[i]) + } + } + return self2 + } + Yallist.prototype.removeNode = function (node) { + if (node.list !== this) { + throw new Error("removing node which does not belong to this list") + } + var next = node.next + var prev = node.prev + if (next) { + next.prev = prev + } + if (prev) { + prev.next = next + } + if (node === this.head) { + this.head = next + } + if (node === this.tail) { + this.tail = prev + } + node.list.length-- + node.next = null + node.prev = null + node.list = null + return next + } + Yallist.prototype.unshiftNode = function (node) { + if (node === this.head) { + return + } + if (node.list) { + node.list.removeNode(node) + } + var head = this.head + node.list = this + node.next = head + if (head) { + head.prev = node + } + this.head = node + if (!this.tail) { + this.tail = node + } + this.length++ + } + Yallist.prototype.pushNode = function (node) { + if (node === this.tail) { + return + } + if (node.list) { + node.list.removeNode(node) + } + var tail = this.tail + node.list = this + node.prev = tail + if (tail) { + tail.next = node + } + this.tail = node + if (!this.head) { + this.head = node + } + this.length++ + } + Yallist.prototype.push = function () { + for (var i = 0, l = arguments.length; i < l; i++) { + push(this, arguments[i]) + } + return this.length + } + Yallist.prototype.unshift = function () { + for (var i = 0, l = arguments.length; i < l; i++) { + unshift(this, arguments[i]) + } + return this.length + } + Yallist.prototype.pop = function () { + if (!this.tail) { + return void 0 + } + var res = this.tail.value + this.tail = this.tail.prev + if (this.tail) { + this.tail.next = null + } else { + this.head = null + } + this.length-- + return res + } + Yallist.prototype.shift = function () { + if (!this.head) { + return void 0 + } + var res = this.head.value + this.head = this.head.next + if (this.head) { + this.head.prev = null + } else { + this.tail = null + } + this.length-- + return res + } + Yallist.prototype.forEach = function (fn, thisp) { + thisp = thisp || this + for (var walker = this.head, i = 0; walker !== null; i++) { + fn.call(thisp, walker.value, i, this) + walker = walker.next + } + } + Yallist.prototype.forEachReverse = function (fn, thisp) { + thisp = thisp || this + for (var walker = this.tail, i = this.length - 1; walker !== null; i--) { + fn.call(thisp, walker.value, i, this) + walker = walker.prev + } + } + Yallist.prototype.get = function (n) { + for (var i = 0, walker = this.head; walker !== null && i < n; i++) { + walker = walker.next + } + if (i === n && walker !== null) { + return walker.value + } + } + Yallist.prototype.getReverse = function (n) { + for (var i = 0, walker = this.tail; walker !== null && i < n; i++) { + walker = walker.prev + } + if (i === n && walker !== null) { + return walker.value + } + } + Yallist.prototype.map = function (fn, thisp) { + thisp = thisp || this + var res = new Yallist() + for (var walker = this.head; walker !== null; ) { + res.push(fn.call(thisp, walker.value, this)) + walker = walker.next + } + return res + } + Yallist.prototype.mapReverse = function (fn, thisp) { + thisp = thisp || this + var res = new Yallist() + for (var walker = this.tail; walker !== null; ) { + res.push(fn.call(thisp, walker.value, this)) + walker = walker.prev + } + return res + } + Yallist.prototype.reduce = function (fn, initial) { + var acc + var walker = this.head + if (arguments.length > 1) { + acc = initial + } else if (this.head) { + walker = this.head.next + acc = this.head.value + } else { + throw new TypeError("Reduce of empty list with no initial value") + } + for (var i = 0; walker !== null; i++) { + acc = fn(acc, walker.value, i) + walker = walker.next + } + return acc + } + Yallist.prototype.reduceReverse = function (fn, initial) { + var acc + var walker = this.tail + if (arguments.length > 1) { + acc = initial + } else if (this.tail) { + walker = this.tail.prev + acc = this.tail.value + } else { + throw new TypeError("Reduce of empty list with no initial value") + } + for (var i = this.length - 1; walker !== null; i--) { + acc = fn(acc, walker.value, i) + walker = walker.prev + } + return acc + } + Yallist.prototype.toArray = function () { + var arr = new Array(this.length) + for (var i = 0, walker = this.head; walker !== null; i++) { + arr[i] = walker.value + walker = walker.next + } + return arr + } + Yallist.prototype.toArrayReverse = function () { + var arr = new Array(this.length) + for (var i = 0, walker = this.tail; walker !== null; i++) { + arr[i] = walker.value + walker = walker.prev + } + return arr + } + Yallist.prototype.slice = function (from, to) { + to = to || this.length + if (to < 0) { + to += this.length + } + from = from || 0 + if (from < 0) { + from += this.length + } + var ret = new Yallist() + if (to < from || to < 0) { + return ret + } + if (from < 0) { + from = 0 + } + if (to > this.length) { + to = this.length + } + for (var i = 0, walker = this.head; walker !== null && i < from; i++) { + walker = walker.next + } + for (; walker !== null && i < to; i++, walker = walker.next) { + ret.push(walker.value) + } + return ret + } + Yallist.prototype.sliceReverse = function (from, to) { + to = to || this.length + if (to < 0) { + to += this.length + } + from = from || 0 + if (from < 0) { + from += this.length + } + var ret = new Yallist() + if (to < from || to < 0) { + return ret + } + if (from < 0) { + from = 0 + } + if (to > this.length) { + to = this.length + } + for (var i = this.length, walker = this.tail; walker !== null && i > to; i--) { + walker = walker.prev + } + for (; walker !== null && i > from; i--, walker = walker.prev) { + ret.push(walker.value) + } + return ret + } + Yallist.prototype.splice = function (start, deleteCount, ...nodes) { + if (start > this.length) { + start = this.length - 1 + } + if (start < 0) { + start = this.length + start + } + for (var i = 0, walker = this.head; walker !== null && i < start; i++) { + walker = walker.next + } + var ret = [] + for (var i = 0; walker && i < deleteCount; i++) { + ret.push(walker.value) + walker = this.removeNode(walker) + } + if (walker === null) { + walker = this.tail + } + if (walker !== this.head && walker !== this.tail) { + walker = walker.prev + } + for (var i = 0; i < nodes.length; i++) { + walker = insert2(this, walker, nodes[i]) + } + return ret + } + Yallist.prototype.reverse = function () { + var head = this.head + var tail = this.tail + for (var walker = head; walker !== null; walker = walker.prev) { + var p = walker.prev + walker.prev = walker.next + walker.next = p + } + this.head = tail + this.tail = head + return this + } + function insert2(self2, node, value) { + var inserted = node === self2.head ? new Node(value, null, node, self2) : new Node(value, node, node.next, self2) + if (inserted.next === null) { + self2.tail = inserted + } + if (inserted.prev === null) { + self2.head = inserted + } + self2.length++ + return inserted + } + function push(self2, item) { + self2.tail = new Node(item, self2.tail, null, self2) + if (!self2.head) { + self2.head = self2.tail + } + self2.length++ + } + function unshift(self2, item) { + self2.head = new Node(item, null, self2.head, self2) + if (!self2.tail) { + self2.tail = self2.head + } + self2.length++ + } + function Node(value, prev, next, list) { + if (!(this instanceof Node)) { + return new Node(value, prev, next, list) + } + this.list = list + this.value = value + if (prev) { + prev.next = this + this.prev = prev + } else { + this.prev = null + } + if (next) { + next.prev = this + this.next = next + } else { + this.next = null + } + } + try { + requireIterator()(Yallist) + } catch (er) {} + return yallist +} +var lruCache +var hasRequiredLruCache +function requireLruCache() { + if (hasRequiredLruCache) return lruCache + hasRequiredLruCache = 1 + const Yallist = requireYallist() + const MAX = Symbol("max") + const LENGTH = Symbol("length") + const LENGTH_CALCULATOR = Symbol("lengthCalculator") + const ALLOW_STALE = Symbol("allowStale") + const MAX_AGE = Symbol("maxAge") + const DISPOSE = Symbol("dispose") + const NO_DISPOSE_ON_SET = Symbol("noDisposeOnSet") + const LRU_LIST = Symbol("lruList") + const CACHE = Symbol("cache") + const UPDATE_AGE_ON_GET = Symbol("updateAgeOnGet") + const naiveLength = () => 1 + class LRUCache { + constructor(options) { + if (typeof options === "number") options = { max: options } + if (!options) options = {} + if (options.max && (typeof options.max !== "number" || options.max < 0)) + throw new TypeError("max must be a non-negative number") + this[MAX] = options.max || Infinity + const lc = options.length || naiveLength + this[LENGTH_CALCULATOR] = typeof lc !== "function" ? naiveLength : lc + this[ALLOW_STALE] = options.stale || false + if (options.maxAge && typeof options.maxAge !== "number") throw new TypeError("maxAge must be a number") + this[MAX_AGE] = options.maxAge || 0 + this[DISPOSE] = options.dispose + this[NO_DISPOSE_ON_SET] = options.noDisposeOnSet || false + this[UPDATE_AGE_ON_GET] = options.updateAgeOnGet || false + this.reset() + } + // resize the cache when the max changes. + set max(mL) { + if (typeof mL !== "number" || mL < 0) throw new TypeError("max must be a non-negative number") + this[MAX] = mL || Infinity + trim2(this) + } + get max() { + return this[MAX] + } + set allowStale(allowStale) { + this[ALLOW_STALE] = !!allowStale + } + get allowStale() { + return this[ALLOW_STALE] + } + set maxAge(mA) { + if (typeof mA !== "number") throw new TypeError("maxAge must be a non-negative number") + this[MAX_AGE] = mA + trim2(this) + } + get maxAge() { + return this[MAX_AGE] + } + // resize the cache when the lengthCalculator changes. + set lengthCalculator(lC) { + if (typeof lC !== "function") lC = naiveLength + if (lC !== this[LENGTH_CALCULATOR]) { + this[LENGTH_CALCULATOR] = lC + this[LENGTH] = 0 + this[LRU_LIST].forEach((hit) => { + hit.length = this[LENGTH_CALCULATOR](hit.value, hit.key) + this[LENGTH] += hit.length + }) + } + trim2(this) + } + get lengthCalculator() { + return this[LENGTH_CALCULATOR] + } + get length() { + return this[LENGTH] + } + get itemCount() { + return this[LRU_LIST].length + } + rforEach(fn, thisp) { + thisp = thisp || this + for (let walker = this[LRU_LIST].tail; walker !== null; ) { + const prev = walker.prev + forEachStep(this, fn, walker, thisp) + walker = prev + } + } + forEach(fn, thisp) { + thisp = thisp || this + for (let walker = this[LRU_LIST].head; walker !== null; ) { + const next = walker.next + forEachStep(this, fn, walker, thisp) + walker = next + } + } + keys() { + return this[LRU_LIST].toArray().map((k2) => k2.key) + } + values() { + return this[LRU_LIST].toArray().map((k2) => k2.value) + } + reset() { + if (this[DISPOSE] && this[LRU_LIST] && this[LRU_LIST].length) { + this[LRU_LIST].forEach((hit) => this[DISPOSE](hit.key, hit.value)) + } + this[CACHE] = /* @__PURE__ */ new Map() + this[LRU_LIST] = new Yallist() + this[LENGTH] = 0 + } + dump() { + return this[LRU_LIST].map((hit) => + isStale(this, hit) + ? false + : { + k: hit.key, + v: hit.value, + e: hit.now + (hit.maxAge || 0), + } + ) + .toArray() + .filter((h) => h) + } + dumpLru() { + return this[LRU_LIST] + } + set(key, value, maxAge) { + maxAge = maxAge || this[MAX_AGE] + if (maxAge && typeof maxAge !== "number") throw new TypeError("maxAge must be a number") + const now = maxAge ? Date.now() : 0 + const len = this[LENGTH_CALCULATOR](value, key) + if (this[CACHE].has(key)) { + if (len > this[MAX]) { + del(this, this[CACHE].get(key)) + return false + } + const node = this[CACHE].get(key) + const item = node.value + if (this[DISPOSE]) { + if (!this[NO_DISPOSE_ON_SET]) this[DISPOSE](key, item.value) + } + item.now = now + item.maxAge = maxAge + item.value = value + this[LENGTH] += len - item.length + item.length = len + this.get(key) + trim2(this) + return true + } + const hit = new Entry(key, value, len, now, maxAge) + if (hit.length > this[MAX]) { + if (this[DISPOSE]) this[DISPOSE](key, value) + return false + } + this[LENGTH] += hit.length + this[LRU_LIST].unshift(hit) + this[CACHE].set(key, this[LRU_LIST].head) + trim2(this) + return true + } + has(key) { + if (!this[CACHE].has(key)) return false + const hit = this[CACHE].get(key).value + return !isStale(this, hit) + } + get(key) { + return get(this, key, true) + } + peek(key) { + return get(this, key, false) + } + pop() { + const node = this[LRU_LIST].tail + if (!node) return null + del(this, node) + return node.value + } + del(key) { + del(this, this[CACHE].get(key)) + } + load(arr) { + this.reset() + const now = Date.now() + for (let l = arr.length - 1; l >= 0; l--) { + const hit = arr[l] + const expiresAt = hit.e || 0 + if (expiresAt === 0) this.set(hit.k, hit.v) + else { + const maxAge = expiresAt - now + if (maxAge > 0) { + this.set(hit.k, hit.v, maxAge) + } + } + } + } + prune() { + this[CACHE].forEach((value, key) => get(this, key, false)) + } + } + const get = (self2, key, doUse) => { + const node = self2[CACHE].get(key) + if (node) { + const hit = node.value + if (isStale(self2, hit)) { + del(self2, node) + if (!self2[ALLOW_STALE]) return void 0 + } else { + if (doUse) { + if (self2[UPDATE_AGE_ON_GET]) node.value.now = Date.now() + self2[LRU_LIST].unshiftNode(node) + } + } + return hit.value + } + } + const isStale = (self2, hit) => { + if (!hit || (!hit.maxAge && !self2[MAX_AGE])) return false + const diff2 = Date.now() - hit.now + return hit.maxAge ? diff2 > hit.maxAge : self2[MAX_AGE] && diff2 > self2[MAX_AGE] + } + const trim2 = (self2) => { + if (self2[LENGTH] > self2[MAX]) { + for (let walker = self2[LRU_LIST].tail; self2[LENGTH] > self2[MAX] && walker !== null; ) { + const prev = walker.prev + del(self2, walker) + walker = prev + } + } + } + const del = (self2, node) => { + if (node) { + const hit = node.value + if (self2[DISPOSE]) self2[DISPOSE](hit.key, hit.value) + self2[LENGTH] -= hit.length + self2[CACHE].delete(hit.key) + self2[LRU_LIST].removeNode(node) + } + } + class Entry { + constructor(key, value, length, now, maxAge) { + this.key = key + this.value = value + this.length = length + this.now = now + this.maxAge = maxAge || 0 + } + } + const forEachStep = (self2, fn, node, thisp) => { + let hit = node.value + if (isStale(self2, hit)) { + del(self2, node) + if (!self2[ALLOW_STALE]) hit = void 0 + } + if (hit) fn.call(thisp, hit.value, hit.key, self2) + } + lruCache = LRUCache + return lruCache +} +var range +var hasRequiredRange +function requireRange() { + if (hasRequiredRange) return range + hasRequiredRange = 1 + class Range2 { + constructor(range2, options) { + options = parseOptions2(options) + if (range2 instanceof Range2) { + if (range2.loose === !!options.loose && range2.includePrerelease === !!options.includePrerelease) { + return range2 + } else { + return new Range2(range2.raw, options) + } + } + if (range2 instanceof Comparator2) { + this.raw = range2.value + this.set = [[range2]] + this.format() + return this + } + this.options = options + this.loose = !!options.loose + this.includePrerelease = !!options.includePrerelease + this.raw = range2 + this.set = range2 + .split("||") + .map((r) => this.parseRange(r.trim())) + .filter((c) => c.length) + if (!this.set.length) { + throw new TypeError(`Invalid SemVer Range: ${range2}`) + } + if (this.set.length > 1) { + const first = this.set[0] + this.set = this.set.filter((c) => !isNullSet(c[0])) + if (this.set.length === 0) { + this.set = [first] + } else if (this.set.length > 1) { + for (const c of this.set) { + if (c.length === 1 && isAny(c[0])) { + this.set = [c] + break + } + } + } + } + this.format() + } + format() { + this.range = this.set + .map((comps) => { + return comps.join(" ").trim() + }) + .join("||") + .trim() + return this.range + } + toString() { + return this.range + } + parseRange(range2) { + range2 = range2.trim() + const memoOpts = Object.keys(this.options).join(",") + const memoKey = `parseRange:${memoOpts}:${range2}` + const cached = cache.get(memoKey) + if (cached) { + return cached + } + const loose = this.options.loose + const hr = loose ? re2[t2.HYPHENRANGELOOSE] : re2[t2.HYPHENRANGE] + range2 = range2.replace(hr, hyphenReplace(this.options.includePrerelease)) + debug2("hyphen replace", range2) + range2 = range2.replace(re2[t2.COMPARATORTRIM], comparatorTrimReplace) + debug2("comparator trim", range2) + range2 = range2.replace(re2[t2.TILDETRIM], tildeTrimReplace) + range2 = range2.replace(re2[t2.CARETTRIM], caretTrimReplace) + range2 = range2.split(/\s+/).join(" ") + let rangeList = range2 + .split(" ") + .map((comp) => parseComparator(comp, this.options)) + .join(" ") + .split(/\s+/) + .map((comp) => replaceGTE0(comp, this.options)) + if (loose) { + rangeList = rangeList.filter((comp) => { + debug2("loose invalid filter", comp, this.options) + return !!comp.match(re2[t2.COMPARATORLOOSE]) + }) + } + debug2("range list", rangeList) + const rangeMap = /* @__PURE__ */ new Map() + const comparators = rangeList.map((comp) => new Comparator2(comp, this.options)) + for (const comp of comparators) { + if (isNullSet(comp)) { + return [comp] + } + rangeMap.set(comp.value, comp) + } + if (rangeMap.size > 1 && rangeMap.has("")) { + rangeMap.delete("") + } + const result = [...rangeMap.values()] + cache.set(memoKey, result) + return result + } + intersects(range2, options) { + if (!(range2 instanceof Range2)) { + throw new TypeError("a Range is required") + } + return this.set.some((thisComparators) => { + return ( + isSatisfiable(thisComparators, options) && + range2.set.some((rangeComparators) => { + return ( + isSatisfiable(rangeComparators, options) && + thisComparators.every((thisComparator) => { + return rangeComparators.every((rangeComparator) => { + return thisComparator.intersects(rangeComparator, options) + }) + }) + ) + }) + ) + }) + } + // if ANY of the sets match ALL of its comparators, then pass + test(version2) { + if (!version2) { + return false + } + if (typeof version2 === "string") { + try { + version2 = new SemVer3(version2, this.options) + } catch (er) { + return false + } + } + for (let i = 0; i < this.set.length; i++) { + if (testSet(this.set[i], version2, this.options)) { + return true + } + } + return false + } + } + range = Range2 + const LRU = requireLruCache() + const cache = new LRU({ max: 1e3 }) + const parseOptions2 = parseOptions_1 + const Comparator2 = requireComparator() + const debug2 = debug_1 + const SemVer3 = semver$1 + const { re: re2, t: t2, comparatorTrimReplace, tildeTrimReplace, caretTrimReplace } = reExports + const isNullSet = (c) => c.value === "<0.0.0-0" + const isAny = (c) => c.value === "" + const isSatisfiable = (comparators, options) => { + let result = true + const remainingComparators = comparators.slice() + let testComparator = remainingComparators.pop() + while (result && remainingComparators.length) { + result = remainingComparators.every((otherComparator) => { + return testComparator.intersects(otherComparator, options) + }) + testComparator = remainingComparators.pop() + } + return result + } + const parseComparator = (comp, options) => { + debug2("comp", comp, options) + comp = replaceCarets(comp, options) + debug2("caret", comp) + comp = replaceTildes(comp, options) + debug2("tildes", comp) + comp = replaceXRanges(comp, options) + debug2("xrange", comp) + comp = replaceStars(comp, options) + debug2("stars", comp) + return comp + } + const isX = (id2) => !id2 || id2.toLowerCase() === "x" || id2 === "*" + const replaceTildes = (comp, options) => + comp + .trim() + .split(/\s+/) + .map((c) => { + return replaceTilde(c, options) + }) + .join(" ") + const replaceTilde = (comp, options) => { + const r = options.loose ? re2[t2.TILDELOOSE] : re2[t2.TILDE] + return comp.replace(r, (_2, M2, m, p, pr) => { + debug2("tilde", comp, _2, M2, m, p, pr) + let ret + if (isX(M2)) { + ret = "" + } else if (isX(m)) { + ret = `>=${M2}.0.0 <${+M2 + 1}.0.0-0` + } else if (isX(p)) { + ret = `>=${M2}.${m}.0 <${M2}.${+m + 1}.0-0` + } else if (pr) { + debug2("replaceTilde pr", pr) + ret = `>=${M2}.${m}.${p}-${pr} <${M2}.${+m + 1}.0-0` + } else { + ret = `>=${M2}.${m}.${p} <${M2}.${+m + 1}.0-0` + } + debug2("tilde return", ret) + return ret + }) + } + const replaceCarets = (comp, options) => + comp + .trim() + .split(/\s+/) + .map((c) => { + return replaceCaret(c, options) + }) + .join(" ") + const replaceCaret = (comp, options) => { + debug2("caret", comp, options) + const r = options.loose ? re2[t2.CARETLOOSE] : re2[t2.CARET] + const z2 = options.includePrerelease ? "-0" : "" + return comp.replace(r, (_2, M2, m, p, pr) => { + debug2("caret", comp, _2, M2, m, p, pr) + let ret + if (isX(M2)) { + ret = "" + } else if (isX(m)) { + ret = `>=${M2}.0.0${z2} <${+M2 + 1}.0.0-0` + } else if (isX(p)) { + if (M2 === "0") { + ret = `>=${M2}.${m}.0${z2} <${M2}.${+m + 1}.0-0` + } else { + ret = `>=${M2}.${m}.0${z2} <${+M2 + 1}.0.0-0` + } + } else if (pr) { + debug2("replaceCaret pr", pr) + if (M2 === "0") { + if (m === "0") { + ret = `>=${M2}.${m}.${p}-${pr} <${M2}.${m}.${+p + 1}-0` + } else { + ret = `>=${M2}.${m}.${p}-${pr} <${M2}.${+m + 1}.0-0` + } + } else { + ret = `>=${M2}.${m}.${p}-${pr} <${+M2 + 1}.0.0-0` + } + } else { + debug2("no pr") + if (M2 === "0") { + if (m === "0") { + ret = `>=${M2}.${m}.${p}${z2} <${M2}.${m}.${+p + 1}-0` + } else { + ret = `>=${M2}.${m}.${p}${z2} <${M2}.${+m + 1}.0-0` + } + } else { + ret = `>=${M2}.${m}.${p} <${+M2 + 1}.0.0-0` + } + } + debug2("caret return", ret) + return ret + }) + } + const replaceXRanges = (comp, options) => { + debug2("replaceXRanges", comp, options) + return comp + .split(/\s+/) + .map((c) => { + return replaceXRange(c, options) + }) + .join(" ") + } + const replaceXRange = (comp, options) => { + comp = comp.trim() + const r = options.loose ? re2[t2.XRANGELOOSE] : re2[t2.XRANGE] + return comp.replace(r, (ret, gtlt, M2, m, p, pr) => { + debug2("xRange", comp, ret, gtlt, M2, m, p, pr) + const xM = isX(M2) + const xm = xM || isX(m) + const xp = xm || isX(p) + const anyX = xp + if (gtlt === "=" && anyX) { + gtlt = "" + } + pr = options.includePrerelease ? "-0" : "" + if (xM) { + if (gtlt === ">" || gtlt === "<") { + ret = "<0.0.0-0" + } else { + ret = "*" + } + } else if (gtlt && anyX) { + if (xm) { + m = 0 + } + p = 0 + if (gtlt === ">") { + gtlt = ">=" + if (xm) { + M2 = +M2 + 1 + m = 0 + p = 0 + } else { + m = +m + 1 + p = 0 + } + } else if (gtlt === "<=") { + gtlt = "<" + if (xm) { + M2 = +M2 + 1 + } else { + m = +m + 1 + } + } + if (gtlt === "<") { + pr = "-0" + } + ret = `${gtlt + M2}.${m}.${p}${pr}` + } else if (xm) { + ret = `>=${M2}.0.0${pr} <${+M2 + 1}.0.0-0` + } else if (xp) { + ret = `>=${M2}.${m}.0${pr} <${M2}.${+m + 1}.0-0` + } + debug2("xRange return", ret) + return ret + }) + } + const replaceStars = (comp, options) => { + debug2("replaceStars", comp, options) + return comp.trim().replace(re2[t2.STAR], "") + } + const replaceGTE0 = (comp, options) => { + debug2("replaceGTE0", comp, options) + return comp.trim().replace(re2[options.includePrerelease ? t2.GTE0PRE : t2.GTE0], "") + } + const hyphenReplace = (incPr) => ($0, from, fM, fm, fp, fpr, fb, to, tM, tm, tp, tpr, tb) => { + if (isX(fM)) { + from = "" + } else if (isX(fm)) { + from = `>=${fM}.0.0${incPr ? "-0" : ""}` + } else if (isX(fp)) { + from = `>=${fM}.${fm}.0${incPr ? "-0" : ""}` + } else if (fpr) { + from = `>=${from}` + } else { + from = `>=${from}${incPr ? "-0" : ""}` + } + if (isX(tM)) { + to = "" + } else if (isX(tm)) { + to = `<${+tM + 1}.0.0-0` + } else if (isX(tp)) { + to = `<${tM}.${+tm + 1}.0-0` + } else if (tpr) { + to = `<=${tM}.${tm}.${tp}-${tpr}` + } else if (incPr) { + to = `<${tM}.${tm}.${+tp + 1}-0` + } else { + to = `<=${to}` + } + return `${from} ${to}`.trim() + } + const testSet = (set, version2, options) => { + for (let i = 0; i < set.length; i++) { + if (!set[i].test(version2)) { + return false + } + } + if (version2.prerelease.length && !options.includePrerelease) { + for (let i = 0; i < set.length; i++) { + debug2(set[i].semver) + if (set[i].semver === Comparator2.ANY) { + continue + } + if (set[i].semver.prerelease.length > 0) { + const allowed = set[i].semver + if ( + allowed.major === version2.major && + allowed.minor === version2.minor && + allowed.patch === version2.patch + ) { + return true + } + } + } + return false + } + return true + } + return range +} +var comparator +var hasRequiredComparator +function requireComparator() { + if (hasRequiredComparator) return comparator + hasRequiredComparator = 1 + const ANY2 = Symbol("SemVer ANY") + class Comparator2 { + static get ANY() { + return ANY2 + } + constructor(comp, options) { + options = parseOptions2(options) + if (comp instanceof Comparator2) { + if (comp.loose === !!options.loose) { + return comp + } else { + comp = comp.value + } + } + debug2("comparator", comp, options) + this.options = options + this.loose = !!options.loose + this.parse(comp) + if (this.semver === ANY2) { + this.value = "" + } else { + this.value = this.operator + this.semver.version + } + debug2("comp", this) + } + parse(comp) { + const r = this.options.loose ? re2[t2.COMPARATORLOOSE] : re2[t2.COMPARATOR] + const m = comp.match(r) + if (!m) { + throw new TypeError(`Invalid comparator: ${comp}`) + } + this.operator = m[1] !== void 0 ? m[1] : "" + if (this.operator === "=") { + this.operator = "" + } + if (!m[2]) { + this.semver = ANY2 + } else { + this.semver = new SemVer3(m[2], this.options.loose) + } + } + toString() { + return this.value + } + test(version2) { + debug2("Comparator.test", version2, this.options.loose) + if (this.semver === ANY2 || version2 === ANY2) { + return true + } + if (typeof version2 === "string") { + try { + version2 = new SemVer3(version2, this.options) + } catch (er) { + return false + } + } + return cmp2(version2, this.operator, this.semver, this.options) + } + intersects(comp, options) { + if (!(comp instanceof Comparator2)) { + throw new TypeError("a Comparator is required") + } + if (!options || typeof options !== "object") { + options = { + loose: !!options, + includePrerelease: false, + } + } + if (this.operator === "") { + if (this.value === "") { + return true + } + return new Range2(comp.value, options).test(this.value) + } else if (comp.operator === "") { + if (comp.value === "") { + return true + } + return new Range2(this.value, options).test(comp.semver) + } + const sameDirectionIncreasing = + (this.operator === ">=" || this.operator === ">") && (comp.operator === ">=" || comp.operator === ">") + const sameDirectionDecreasing = + (this.operator === "<=" || this.operator === "<") && (comp.operator === "<=" || comp.operator === "<") + const sameSemVer = this.semver.version === comp.semver.version + const differentDirectionsInclusive = + (this.operator === ">=" || this.operator === "<=") && (comp.operator === ">=" || comp.operator === "<=") + const oppositeDirectionsLessThan = + cmp2(this.semver, "<", comp.semver, options) && + (this.operator === ">=" || this.operator === ">") && + (comp.operator === "<=" || comp.operator === "<") + const oppositeDirectionsGreaterThan = + cmp2(this.semver, ">", comp.semver, options) && + (this.operator === "<=" || this.operator === "<") && + (comp.operator === ">=" || comp.operator === ">") + return ( + sameDirectionIncreasing || + sameDirectionDecreasing || + (sameSemVer && differentDirectionsInclusive) || + oppositeDirectionsLessThan || + oppositeDirectionsGreaterThan + ) + } + } + comparator = Comparator2 + const parseOptions2 = parseOptions_1 + const { re: re2, t: t2 } = reExports + const cmp2 = cmp_1 + const debug2 = debug_1 + const SemVer3 = semver$1 + const Range2 = requireRange() + return comparator +} +const Range$9 = requireRange() +const satisfies$4 = (version2, range2, options) => { + try { + range2 = new Range$9(range2, options) + } catch (er) { + return false + } + return range2.test(version2) +} +var satisfies_1 = satisfies$4 +const Range$8 = requireRange() +const toComparators$1 = (range2, options) => + new Range$8(range2, options).set.map((comp) => + comp + .map((c) => c.value) + .join(" ") + .trim() + .split(" ") + ) +var toComparators_1 = toComparators$1 +const SemVer$4 = semver$1 +const Range$7 = requireRange() +const maxSatisfying$1 = (versions, range2, options) => { + let max = null + let maxSV = null + let rangeObj = null + try { + rangeObj = new Range$7(range2, options) + } catch (er) { + return null + } + versions.forEach((v) => { + if (rangeObj.test(v)) { + if (!max || maxSV.compare(v) === -1) { + max = v + maxSV = new SemVer$4(max, options) + } + } + }) + return max +} +var maxSatisfying_1 = maxSatisfying$1 +const SemVer$3 = semver$1 +const Range$6 = requireRange() +const minSatisfying$1 = (versions, range2, options) => { + let min = null + let minSV = null + let rangeObj = null + try { + rangeObj = new Range$6(range2, options) + } catch (er) { + return null + } + versions.forEach((v) => { + if (rangeObj.test(v)) { + if (!min || minSV.compare(v) === 1) { + min = v + minSV = new SemVer$3(min, options) + } + } + }) + return min +} +var minSatisfying_1 = minSatisfying$1 +const SemVer$2 = semver$1 +const Range$5 = requireRange() +const gt$2 = gt_1 +const minVersion$1 = (range2, loose) => { + range2 = new Range$5(range2, loose) + let minver = new SemVer$2("0.0.0") + if (range2.test(minver)) { + return minver + } + minver = new SemVer$2("0.0.0-0") + if (range2.test(minver)) { + return minver + } + minver = null + for (let i = 0; i < range2.set.length; ++i) { + const comparators = range2.set[i] + let setMin = null + comparators.forEach((comparator2) => { + const compver = new SemVer$2(comparator2.semver.version) + switch (comparator2.operator) { + case ">": + if (compver.prerelease.length === 0) { + compver.patch++ + } else { + compver.prerelease.push(0) + } + compver.raw = compver.format() + case "": + case ">=": + if (!setMin || gt$2(compver, setMin)) { + setMin = compver + } + break + case "<": + case "<=": + break + default: + throw new Error(`Unexpected operation: ${comparator2.operator}`) + } + }) + if (setMin && (!minver || gt$2(minver, setMin))) { + minver = setMin + } + } + if (minver && range2.test(minver)) { + return minver + } + return null +} +var minVersion_1 = minVersion$1 +const Range$4 = requireRange() +const validRange$1 = (range2, options) => { + try { + return new Range$4(range2, options).range || "*" + } catch (er) { + return null + } +} +var valid$1 = validRange$1 +const SemVer$1 = semver$1 +const Comparator$2 = requireComparator() +const { ANY: ANY$1 } = Comparator$2 +const Range$3 = requireRange() +const satisfies$3 = satisfies_1 +const gt$1 = gt_1 +const lt$1 = lt_1 +const lte$1 = lte_1 +const gte$1 = gte_1 +const outside$3 = (version2, range2, hilo, options) => { + version2 = new SemVer$1(version2, options) + range2 = new Range$3(range2, options) + let gtfn, ltefn, ltfn, comp, ecomp + switch (hilo) { + case ">": + gtfn = gt$1 + ltefn = lte$1 + ltfn = lt$1 + comp = ">" + ecomp = ">=" + break + case "<": + gtfn = lt$1 + ltefn = gte$1 + ltfn = gt$1 + comp = "<" + ecomp = "<=" + break + default: + throw new TypeError('Must provide a hilo val of "<" or ">"') + } + if (satisfies$3(version2, range2, options)) { + return false + } + for (let i = 0; i < range2.set.length; ++i) { + const comparators = range2.set[i] + let high = null + let low = null + comparators.forEach((comparator2) => { + if (comparator2.semver === ANY$1) { + comparator2 = new Comparator$2(">=0.0.0") + } + high = high || comparator2 + low = low || comparator2 + if (gtfn(comparator2.semver, high.semver, options)) { + high = comparator2 + } else if (ltfn(comparator2.semver, low.semver, options)) { + low = comparator2 + } + }) + if (high.operator === comp || high.operator === ecomp) { + return false + } + if ((!low.operator || low.operator === comp) && ltefn(version2, low.semver)) { + return false + } else if (low.operator === ecomp && ltfn(version2, low.semver)) { + return false + } + } + return true +} +var outside_1 = outside$3 +const outside$2 = outside_1 +const gtr$1 = (version2, range2, options) => outside$2(version2, range2, ">", options) +var gtr_1 = gtr$1 +const outside$1 = outside_1 +const ltr$1 = (version2, range2, options) => outside$1(version2, range2, "<", options) +var ltr_1 = ltr$1 +const Range$2 = requireRange() +const intersects$1 = (r1, r2, options) => { + r1 = new Range$2(r1, options) + r2 = new Range$2(r2, options) + return r1.intersects(r2) +} +var intersects_1 = intersects$1 +const satisfies$2 = satisfies_1 +const compare$2 = compare_1 +var simplify = (versions, range2, options) => { + const set = [] + let first = null + let prev = null + const v = versions.sort((a2, b2) => compare$2(a2, b2, options)) + for (const version2 of v) { + const included = satisfies$2(version2, range2, options) + if (included) { + prev = version2 + if (!first) { + first = version2 + } + } else { + if (prev) { + set.push([first, prev]) + } + prev = null + first = null + } + } + if (first) { + set.push([first, null]) + } + const ranges = [] + for (const [min, max] of set) { + if (min === max) { + ranges.push(min) + } else if (!max && min === v[0]) { + ranges.push("*") + } else if (!max) { + ranges.push(`>=${min}`) + } else if (min === v[0]) { + ranges.push(`<=${max}`) + } else { + ranges.push(`${min} - ${max}`) + } + } + const simplified = ranges.join(" || ") + const original = typeof range2.raw === "string" ? range2.raw : String(range2) + return simplified.length < original.length ? simplified : range2 +} +const Range$1 = requireRange() +const Comparator$1 = requireComparator() +const { ANY } = Comparator$1 +const satisfies$1 = satisfies_1 +const compare$1 = compare_1 +const subset$1 = (sub, dom, options = {}) => { + if (sub === dom) { + return true + } + sub = new Range$1(sub, options) + dom = new Range$1(dom, options) + let sawNonNull = false + OUTER: for (const simpleSub of sub.set) { + for (const simpleDom of dom.set) { + const isSub = simpleSubset(simpleSub, simpleDom, options) + sawNonNull = sawNonNull || isSub !== null + if (isSub) { + continue OUTER + } + } + if (sawNonNull) { + return false + } + } + return true +} +const simpleSubset = (sub, dom, options) => { + if (sub === dom) { + return true + } + if (sub.length === 1 && sub[0].semver === ANY) { + if (dom.length === 1 && dom[0].semver === ANY) { + return true + } else if (options.includePrerelease) { + sub = [new Comparator$1(">=0.0.0-0")] + } else { + sub = [new Comparator$1(">=0.0.0")] + } + } + if (dom.length === 1 && dom[0].semver === ANY) { + if (options.includePrerelease) { + return true + } else { + dom = [new Comparator$1(">=0.0.0")] + } + } + const eqSet = /* @__PURE__ */ new Set() + let gt2, lt2 + for (const c of sub) { + if (c.operator === ">" || c.operator === ">=") { + gt2 = higherGT(gt2, c, options) + } else if (c.operator === "<" || c.operator === "<=") { + lt2 = lowerLT(lt2, c, options) + } else { + eqSet.add(c.semver) + } + } + if (eqSet.size > 1) { + return null + } + let gtltComp + if (gt2 && lt2) { + gtltComp = compare$1(gt2.semver, lt2.semver, options) + if (gtltComp > 0) { + return null + } else if (gtltComp === 0 && (gt2.operator !== ">=" || lt2.operator !== "<=")) { + return null + } + } + for (const eq2 of eqSet) { + if (gt2 && !satisfies$1(eq2, String(gt2), options)) { + return null + } + if (lt2 && !satisfies$1(eq2, String(lt2), options)) { + return null + } + for (const c of dom) { + if (!satisfies$1(eq2, String(c), options)) { + return false + } + } + return true + } + let higher, lower + let hasDomLT, hasDomGT + let needDomLTPre = lt2 && !options.includePrerelease && lt2.semver.prerelease.length ? lt2.semver : false + let needDomGTPre = gt2 && !options.includePrerelease && gt2.semver.prerelease.length ? gt2.semver : false + if ( + needDomLTPre && + needDomLTPre.prerelease.length === 1 && + lt2.operator === "<" && + needDomLTPre.prerelease[0] === 0 + ) { + needDomLTPre = false + } + for (const c of dom) { + hasDomGT = hasDomGT || c.operator === ">" || c.operator === ">=" + hasDomLT = hasDomLT || c.operator === "<" || c.operator === "<=" + if (gt2) { + if (needDomGTPre) { + if ( + c.semver.prerelease && + c.semver.prerelease.length && + c.semver.major === needDomGTPre.major && + c.semver.minor === needDomGTPre.minor && + c.semver.patch === needDomGTPre.patch + ) { + needDomGTPre = false + } + } + if (c.operator === ">" || c.operator === ">=") { + higher = higherGT(gt2, c, options) + if (higher === c && higher !== gt2) { + return false + } + } else if (gt2.operator === ">=" && !satisfies$1(gt2.semver, String(c), options)) { + return false + } + } + if (lt2) { + if (needDomLTPre) { + if ( + c.semver.prerelease && + c.semver.prerelease.length && + c.semver.major === needDomLTPre.major && + c.semver.minor === needDomLTPre.minor && + c.semver.patch === needDomLTPre.patch + ) { + needDomLTPre = false + } + } + if (c.operator === "<" || c.operator === "<=") { + lower = lowerLT(lt2, c, options) + if (lower === c && lower !== lt2) { + return false + } + } else if (lt2.operator === "<=" && !satisfies$1(lt2.semver, String(c), options)) { + return false + } + } + if (!c.operator && (lt2 || gt2) && gtltComp !== 0) { + return false + } + } + if (gt2 && hasDomLT && !lt2 && gtltComp !== 0) { + return false + } + if (lt2 && hasDomGT && !gt2 && gtltComp !== 0) { + return false + } + if (needDomGTPre || needDomLTPre) { + return false + } + return true +} +const higherGT = (a2, b2, options) => { + if (!a2) { + return b2 + } + const comp = compare$1(a2.semver, b2.semver, options) + return comp > 0 ? a2 : comp < 0 ? b2 : b2.operator === ">" && a2.operator === ">=" ? b2 : a2 +} +const lowerLT = (a2, b2, options) => { + if (!a2) { + return b2 + } + const comp = compare$1(a2.semver, b2.semver, options) + return comp < 0 ? a2 : comp > 0 ? b2 : b2.operator === "<" && a2.operator === "<=" ? b2 : a2 +} +var subset_1 = subset$1 +const internalRe = reExports +const constants = constants$1 +const SemVer = semver$1 +const identifiers = identifiers$1 +const parse = parse_1 +const valid = valid_1 +const clean = clean_1 +const inc = inc_1 +const diff = diff_1 +const major = major_1 +const minor = minor_1 +const patch = patch_1 +const prerelease = prerelease_1 +const compare = compare_1 +const rcompare = rcompare_1 +const compareLoose = compareLoose_1 +const compareBuild = compareBuild_1 +const sort = sort_1 +const rsort = rsort_1 +const gt = gt_1 +const lt = lt_1 +const eq = eq_1 +const neq = neq_1 +const gte = gte_1 +const lte = lte_1 +const cmp = cmp_1 +const coerce = coerce_1 +const Comparator = requireComparator() +const Range = requireRange() +const satisfies = satisfies_1 +const toComparators = toComparators_1 +const maxSatisfying = maxSatisfying_1 +const minSatisfying = minSatisfying_1 +const minVersion = minVersion_1 +const validRange = valid$1 +const outside = outside_1 +const gtr = gtr_1 +const ltr = ltr_1 +const intersects = intersects_1 +const simplifyRange = simplify +const subset = subset_1 +var semver = { + parse, + valid, + clean, + inc, + diff, + major, + minor, + patch, + prerelease, + compare, + rcompare, + compareLoose, + compareBuild, + sort, + rsort, + gt, + lt, + eq, + neq, + gte, + lte, + cmp, + coerce, + Comparator, + Range, + satisfies, + toComparators, + maxSatisfying, + minSatisfying, + minVersion, + validRange, + outside, + gtr, + ltr, + intersects, + simplifyRange, + subset, + SemVer, + re: internalRe.re, + src: internalRe.src, + tokens: internalRe.t, + SEMVER_SPEC_VERSION: constants.SEMVER_SPEC_VERSION, + compareIdentifiers: identifiers.compareIdentifiers, + rcompareIdentifiers: identifiers.rcompareIdentifiers, +} +class FileClient { + constructor() { + this.electronApi = { + readDir(p) { + const fs = window.require("fs") + const path = window.require("path") + const SIYUAN_WORKSPACE = path.join(window.siyuan.config.system.dataDir, "..") + return new Promise((resolve2) => { + fs.readdir(path.join(SIYUAN_WORKSPACE, p), (err, files) => { + if (err) { + resolve2([]) + return + } + const result = files.map((f) => ({ + isDir: fs.statSync(path.join(SIYUAN_WORKSPACE, p, f)).isDirectory(), + name: f, + })) + resolve2(result) + }) + }) + }, + getFile(f, type = "text") { + return new Promise((resolve2, reject) => { + const fs = window.require("fs") + const path = window.require("path") + const SIYUAN_WORKSPACE = path.join(window.siyuan.config.system.dataDir, "..") + fs.readFile(path.join(SIYUAN_WORKSPACE, f), (err, data) => { + if (err) { + return reject(err) + } + const text2 = data.toString("utf8") + if (type === "json") { + try { + return resolve2(JSON.parse(text2)) + } catch (e) { + reject(e) + return + } + } + return resolve2(text2) + }) + }) + }, + putFile, + removeFile(f) { + return new Promise((resolve2, reject) => { + const fs = window.require("fs") + const path = window.require("path") + const SIYUAN_WORKSPACE = path.join(window.siyuan.config.system.dataDir, "..") + const p = path.join(SIYUAN_WORKSPACE, f) + log("Remove files from", p) + fs.rm(p, { recursive: true, force: true }, (err) => { + if (err) { + return reject(err) + } + resolve2(null) + }) + }) + }, + } + this.serverApi = { + readDir, + getFile, + putFile, + removeFile, + } + const v = this.getVersion() + if (semver.compare(v, "2.8.1") < 0) { + this.fileApi = this.electronApi + } else { + this.fileApi = this.serverApi + } + } + getVersion() { + return window.siyuan.config.system.kernelVersion + } + static getInstanceApi() { + if (!this.fileClient) { + this.fileClient = new FileClient() + } + return this.fileClient + } +} +const author$1 = "作者" +const version$1 = "版本" +const description$1 = "描述" +const goBack$1 = "返回" +const url$1 = "地址" +const readme$1 = "README" +const loading$1 = "加载中" +const downloading$1 = "下载中" +const downloaded$1 = "已下载" +const download$1 = "下载" +const upgrade$1 = "升级" +const nodescription$1 = "无描述内容" +const safemode$1 = "安全模式" +const safemodetip$1 = "关闭安全模式允许第三方插件加载" +const autoupgrade$1 = "自动更新" +const autoupgradetip$1 = "从固定位置获取版本并更新本地存储的插件系统脚本" +const store_url$1 = "插件商店地址" +const store_url_tip$1 = "线上插件系统仓库地址, 默认为" +const menu_common$1 = "通用配置" +const menu_list$1 = "插件列表" +const menu_store$1 = "插件商店" +const plugin_system$1 = "插件系统" +const plugin_system_setting$1 = "插件系统设置" +const reload$1 = "重载" +const show_plugin_system_config$1 = "显示插件系统配置" +const reload_window$1 = "重载当前窗口" +const shortcut$1 = "快捷键" +const show_command_panel$1 = "显示控制面板" +const uninstall$1 = "卸载" +const new_version_widget$1 = "集市发现新版本的插件系统,请前往更新并重载" +const zh_CN = { + author: author$1, + version: version$1, + description: description$1, + goBack: goBack$1, + url: url$1, + readme: readme$1, + loading: loading$1, + downloading: downloading$1, + downloaded: downloaded$1, + download: download$1, + upgrade: upgrade$1, + nodescription: nodescription$1, + safemode: safemode$1, + safemodetip: safemodetip$1, + autoupgrade: autoupgrade$1, + autoupgradetip: autoupgradetip$1, + store_url: store_url$1, + store_url_tip: store_url_tip$1, + menu_common: menu_common$1, + menu_list: menu_list$1, + menu_store: menu_store$1, + plugin_system: plugin_system$1, + plugin_system_setting: plugin_system_setting$1, + reload: reload$1, + show_plugin_system_config: show_plugin_system_config$1, + reload_window: reload_window$1, + shortcut: shortcut$1, + show_command_panel: show_command_panel$1, + uninstall: uninstall$1, + new_version_widget: new_version_widget$1, +} +const author = "Author" +const version = "Version" +const description = "Description" +const goBack = "Go Back" +const url = "URL" +const readme = "README" +const loading = "Loading" +const downloading = "Downloading" +const downloaded = "Downloaded" +const download = "Download" +const upgrade = "Upgrade" +const nodescription = "No Description content" +const safemode = "Safe Mode" +const safemodetip = "Turn off safe mode to enable third party plugins." +const autoupgrade = "Auto Upgrade" +const autoupgradetip = "Auto upgrade plugin system online." +const store_url = "Plugin Store URL" +const store_url_tip = "Plugin Store URL, default is" +const menu_common = "Common Setting" +const menu_list = "Plugins" +const menu_store = "Store" +const plugin_system = "Plugin System" +const plugin_system_setting = "Plugin System Setting" +const reload = "Reload" +const show_plugin_system_config = "Show plugin system config" +const reload_window = "Reload current window" +const shortcut = "Shortcut" +const show_command_panel = "Show command panel" +const uninstall = "Uninstall" +const new_version_widget = "New version plugin system found in Bazzar, please upgrade and reload." +const en_US = { + author, + version, + description, + goBack, + url, + readme, + loading, + downloading, + downloaded, + download, + upgrade, + nodescription, + safemode, + safemodetip, + autoupgrade, + autoupgradetip, + store_url, + store_url_tip, + menu_common, + menu_list, + menu_store, + plugin_system, + plugin_system_setting, + reload, + show_plugin_system_config, + reload_window, + shortcut, + show_command_panel, + uninstall, + new_version_widget, +} +function bind(fn, thisArg) { + return function wrap() { + return fn.apply(thisArg, arguments) + } +} +const { toString } = Object.prototype +const { getPrototypeOf } = Object +const kindOf = ((cache) => (thing) => { + const str = toString.call(thing) + return cache[str] || (cache[str] = str.slice(8, -1).toLowerCase()) +})(/* @__PURE__ */ Object.create(null)) +const kindOfTest = (type) => { + type = type.toLowerCase() + return (thing) => kindOf(thing) === type +} +const typeOfTest = (type) => (thing) => typeof thing === type +const { isArray } = Array +const isUndefined = typeOfTest("undefined") +function isBuffer(val) { + return ( + val !== null && + !isUndefined(val) && + val.constructor !== null && + !isUndefined(val.constructor) && + isFunction(val.constructor.isBuffer) && + val.constructor.isBuffer(val) + ) +} +const isArrayBuffer = kindOfTest("ArrayBuffer") +function isArrayBufferView(val) { + let result + if (typeof ArrayBuffer !== "undefined" && ArrayBuffer.isView) { + result = ArrayBuffer.isView(val) + } else { + result = val && val.buffer && isArrayBuffer(val.buffer) + } + return result +} +const isString = typeOfTest("string") +const isFunction = typeOfTest("function") +const isNumber = typeOfTest("number") +const isObject = (thing) => thing !== null && typeof thing === "object" +const isBoolean = (thing) => thing === true || thing === false +const isPlainObject = (val) => { + if (kindOf(val) !== "object") { + return false + } + const prototype2 = getPrototypeOf(val) + return ( + (prototype2 === null || prototype2 === Object.prototype || Object.getPrototypeOf(prototype2) === null) && + !(Symbol.toStringTag in val) && + !(Symbol.iterator in val) + ) +} +const isDate = kindOfTest("Date") +const isFile = kindOfTest("File") +const isBlob = kindOfTest("Blob") +const isFileList = kindOfTest("FileList") +const isStream = (val) => isObject(val) && isFunction(val.pipe) +const isFormData = (thing) => { + const pattern = "[object FormData]" + return ( + thing && + ((typeof FormData === "function" && thing instanceof FormData) || + toString.call(thing) === pattern || + (isFunction(thing.toString) && thing.toString() === pattern)) + ) +} +const isURLSearchParams = kindOfTest("URLSearchParams") +const trim = (str) => (str.trim ? str.trim() : str.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, "")) +function forEach(obj, fn, { allOwnKeys = false } = {}) { + if (obj === null || typeof obj === "undefined") { + return + } + let i + let l + if (typeof obj !== "object") { + obj = [obj] + } + if (isArray(obj)) { + for (i = 0, l = obj.length; i < l; i++) { + fn.call(null, obj[i], i, obj) + } + } else { + const keys = allOwnKeys ? Object.getOwnPropertyNames(obj) : Object.keys(obj) + const len = keys.length + let key + for (i = 0; i < len; i++) { + key = keys[i] + fn.call(null, obj[key], key, obj) + } + } +} +function findKey(obj, key) { + key = key.toLowerCase() + const keys = Object.keys(obj) + let i = keys.length + let _key + while (i-- > 0) { + _key = keys[i] + if (key === _key.toLowerCase()) { + return _key + } + } + return null +} +const _global = (() => { + if (typeof globalThis !== "undefined") return globalThis + return typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : global +})() +const isContextDefined = (context) => !isUndefined(context) && context !== _global +function merge() { + const { caseless } = (isContextDefined(this) && this) || {} + const result = {} + const assignValue = (val, key) => { + const targetKey = (caseless && findKey(result, key)) || key + if (isPlainObject(result[targetKey]) && isPlainObject(val)) { + result[targetKey] = merge(result[targetKey], val) + } else if (isPlainObject(val)) { + result[targetKey] = merge({}, val) + } else if (isArray(val)) { + result[targetKey] = val.slice() + } else { + result[targetKey] = val + } + } + for (let i = 0, l = arguments.length; i < l; i++) { + arguments[i] && forEach(arguments[i], assignValue) + } + return result +} +const extend = (a2, b2, thisArg, { allOwnKeys } = {}) => { + forEach( + b2, + (val, key) => { + if (thisArg && isFunction(val)) { + a2[key] = bind(val, thisArg) + } else { + a2[key] = val + } + }, + { allOwnKeys } + ) + return a2 +} +const stripBOM = (content) => { + if (content.charCodeAt(0) === 65279) { + content = content.slice(1) + } + return content +} +const inherits = (constructor, superConstructor, props, descriptors2) => { + constructor.prototype = Object.create(superConstructor.prototype, descriptors2) + constructor.prototype.constructor = constructor + Object.defineProperty(constructor, "super", { + value: superConstructor.prototype, + }) + props && Object.assign(constructor.prototype, props) +} +const toFlatObject = (sourceObj, destObj, filter3, propFilter) => { + let props + let i + let prop + const merged = {} + destObj = destObj || {} + if (sourceObj == null) return destObj + do { + props = Object.getOwnPropertyNames(sourceObj) + i = props.length + while (i-- > 0) { + prop = props[i] + if ((!propFilter || propFilter(prop, sourceObj, destObj)) && !merged[prop]) { + destObj[prop] = sourceObj[prop] + merged[prop] = true + } + } + sourceObj = filter3 !== false && getPrototypeOf(sourceObj) + } while (sourceObj && (!filter3 || filter3(sourceObj, destObj)) && sourceObj !== Object.prototype) + return destObj +} +const endsWith = (str, searchString, position) => { + str = String(str) + if (position === void 0 || position > str.length) { + position = str.length + } + position -= searchString.length + const lastIndex = str.indexOf(searchString, position) + return lastIndex !== -1 && lastIndex === position +} +const toArray = (thing) => { + if (!thing) return null + if (isArray(thing)) return thing + let i = thing.length + if (!isNumber(i)) return null + const arr = new Array(i) + while (i-- > 0) { + arr[i] = thing[i] + } + return arr +} +const isTypedArray = ((TypedArray) => { + return (thing) => { + return TypedArray && thing instanceof TypedArray + } +})(typeof Uint8Array !== "undefined" && getPrototypeOf(Uint8Array)) +const forEachEntry = (obj, fn) => { + const generator = obj && obj[Symbol.iterator] + const iterator2 = generator.call(obj) + let result + while ((result = iterator2.next()) && !result.done) { + const pair = result.value + fn.call(obj, pair[0], pair[1]) + } +} +const matchAll = (regExp, str) => { + let matches + const arr = [] + while ((matches = regExp.exec(str)) !== null) { + arr.push(matches) + } + return arr +} +const isHTMLForm = kindOfTest("HTMLFormElement") +const toCamelCase = (str) => { + return str.toLowerCase().replace(/[-_\s]([a-z\d])(\w*)/g, function replacer(m, p1, p2) { + return p1.toUpperCase() + p2 + }) +} +const hasOwnProperty = ( + ({ hasOwnProperty: hasOwnProperty2 }) => + (obj, prop) => + hasOwnProperty2.call(obj, prop) +)(Object.prototype) +const isRegExp = kindOfTest("RegExp") +const reduceDescriptors = (obj, reducer) => { + const descriptors2 = Object.getOwnPropertyDescriptors(obj) + const reducedDescriptors = {} + forEach(descriptors2, (descriptor, name2) => { + if (reducer(descriptor, name2, obj) !== false) { + reducedDescriptors[name2] = descriptor + } + }) + Object.defineProperties(obj, reducedDescriptors) +} +const freezeMethods = (obj) => { + reduceDescriptors(obj, (descriptor, name2) => { + if (isFunction(obj) && ["arguments", "caller", "callee"].indexOf(name2) !== -1) { + return false + } + const value = obj[name2] + if (!isFunction(value)) return + descriptor.enumerable = false + if ("writable" in descriptor) { + descriptor.writable = false + return + } + if (!descriptor.set) { + descriptor.set = () => { + throw Error("Can not rewrite read-only method '" + name2 + "'") + } + } + }) +} +const toObjectSet = (arrayOrString, delimiter) => { + const obj = {} + const define = (arr) => { + arr.forEach((value) => { + obj[value] = true + }) + } + isArray(arrayOrString) ? define(arrayOrString) : define(String(arrayOrString).split(delimiter)) + return obj +} +const noop$1 = () => {} +const toFiniteNumber = (value, defaultValue) => { + value = +value + return Number.isFinite(value) ? value : defaultValue +} +const ALPHA = "abcdefghijklmnopqrstuvwxyz" +const DIGIT = "0123456789" +const ALPHABET = { + DIGIT, + ALPHA, + ALPHA_DIGIT: ALPHA + ALPHA.toUpperCase() + DIGIT, +} +const generateString = (size = 16, alphabet = ALPHABET.ALPHA_DIGIT) => { + let str = "" + const { length } = alphabet + while (size--) { + str += alphabet[(Math.random() * length) | 0] + } + return str +} +function isSpecCompliantForm(thing) { + return !!(thing && isFunction(thing.append) && thing[Symbol.toStringTag] === "FormData" && thing[Symbol.iterator]) +} +const toJSONObject = (obj) => { + const stack = new Array(10) + const visit = (source, i) => { + if (isObject(source)) { + if (stack.indexOf(source) >= 0) { + return + } + if (!("toJSON" in source)) { + stack[i] = source + const target = isArray(source) ? [] : {} + forEach(source, (value, key) => { + const reducedValue = visit(value, i + 1) + !isUndefined(reducedValue) && (target[key] = reducedValue) + }) + stack[i] = void 0 + return target + } + } + return source + } + return visit(obj, 0) +} +const utils = { + isArray, + isArrayBuffer, + isBuffer, + isFormData, + isArrayBufferView, + isString, + isNumber, + isBoolean, + isObject, + isPlainObject, + isUndefined, + isDate, + isFile, + isBlob, + isRegExp, + isFunction, + isStream, + isURLSearchParams, + isTypedArray, + isFileList, + forEach, + merge, + extend, + trim, + stripBOM, + inherits, + toFlatObject, + kindOf, + kindOfTest, + endsWith, + toArray, + forEachEntry, + matchAll, + isHTMLForm, + hasOwnProperty, + hasOwnProp: hasOwnProperty, + // an alias to avoid ESLint no-prototype-builtins detection + reduceDescriptors, + freezeMethods, + toObjectSet, + toCamelCase, + noop: noop$1, + toFiniteNumber, + findKey, + global: _global, + isContextDefined, + ALPHABET, + generateString, + isSpecCompliantForm, + toJSONObject, +} +function AxiosError(message, code3, config2, request2, response) { + Error.call(this) + if (Error.captureStackTrace) { + Error.captureStackTrace(this, this.constructor) + } else { + this.stack = new Error().stack + } + this.message = message + this.name = "AxiosError" + code3 && (this.code = code3) + config2 && (this.config = config2) + request2 && (this.request = request2) + response && (this.response = response) +} +utils.inherits(AxiosError, Error, { + toJSON: function toJSON() { + return { + // Standard + message: this.message, + name: this.name, + // Microsoft + description: this.description, + number: this.number, + // Mozilla + fileName: this.fileName, + lineNumber: this.lineNumber, + columnNumber: this.columnNumber, + stack: this.stack, + // Axios + config: utils.toJSONObject(this.config), + code: this.code, + status: this.response && this.response.status ? this.response.status : null, + } + }, +}) +const prototype$1 = AxiosError.prototype +const descriptors = {} +;[ + "ERR_BAD_OPTION_VALUE", + "ERR_BAD_OPTION", + "ECONNABORTED", + "ETIMEDOUT", + "ERR_NETWORK", + "ERR_FR_TOO_MANY_REDIRECTS", + "ERR_DEPRECATED", + "ERR_BAD_RESPONSE", + "ERR_BAD_REQUEST", + "ERR_CANCELED", + "ERR_NOT_SUPPORT", + "ERR_INVALID_URL", + // eslint-disable-next-line func-names +].forEach((code3) => { + descriptors[code3] = { value: code3 } +}) +Object.defineProperties(AxiosError, descriptors) +Object.defineProperty(prototype$1, "isAxiosError", { value: true }) +AxiosError.from = (error2, code3, config2, request2, response, customProps) => { + const axiosError = Object.create(prototype$1) + utils.toFlatObject( + error2, + axiosError, + function filter3(obj) { + return obj !== Error.prototype + }, + (prop) => { + return prop !== "isAxiosError" + } + ) + AxiosError.call(axiosError, error2.message, code3, config2, request2, response) + axiosError.cause = error2 + axiosError.name = error2.name + customProps && Object.assign(axiosError, customProps) + return axiosError +} +const httpAdapter = null +function isVisitable(thing) { + return utils.isPlainObject(thing) || utils.isArray(thing) +} +function removeBrackets(key) { + return utils.endsWith(key, "[]") ? key.slice(0, -2) : key +} +function renderKey(path, key, dots) { + if (!path) return key + return path + .concat(key) + .map(function each(token, i) { + token = removeBrackets(token) + return !dots && i ? "[" + token + "]" : token + }) + .join(dots ? "." : "") +} +function isFlatArray(arr) { + return utils.isArray(arr) && !arr.some(isVisitable) +} +const predicates = utils.toFlatObject(utils, {}, null, function filter2(prop) { + return /^is[A-Z]/.test(prop) +}) +function toFormData(obj, formData, options) { + if (!utils.isObject(obj)) { + throw new TypeError("target must be an object") + } + formData = formData || new FormData() + options = utils.toFlatObject( + options, + { + metaTokens: true, + dots: false, + indexes: false, + }, + false, + function defined(option, source) { + return !utils.isUndefined(source[option]) + } + ) + const metaTokens = options.metaTokens + const visitor = options.visitor || defaultVisitor + const dots = options.dots + const indexes = options.indexes + const _Blob = options.Blob || (typeof Blob !== "undefined" && Blob) + const useBlob = _Blob && utils.isSpecCompliantForm(formData) + if (!utils.isFunction(visitor)) { + throw new TypeError("visitor must be a function") + } + function convertValue(value) { + if (value === null) return "" + if (utils.isDate(value)) { + return value.toISOString() + } + if (!useBlob && utils.isBlob(value)) { + throw new AxiosError("Blob is not supported. Use a Buffer instead.") + } + if (utils.isArrayBuffer(value) || utils.isTypedArray(value)) { + return useBlob && typeof Blob === "function" ? new Blob([value]) : Buffer.from(value) + } + return value + } + function defaultVisitor(value, key, path) { + let arr = value + if (value && !path && typeof value === "object") { + if (utils.endsWith(key, "{}")) { + key = metaTokens ? key : key.slice(0, -2) + value = JSON.stringify(value) + } else if ( + (utils.isArray(value) && isFlatArray(value)) || + ((utils.isFileList(value) || utils.endsWith(key, "[]")) && (arr = utils.toArray(value))) + ) { + key = removeBrackets(key) + arr.forEach(function each(el, index) { + !(utils.isUndefined(el) || el === null) && + formData.append( + // eslint-disable-next-line no-nested-ternary + indexes === true ? renderKey([key], index, dots) : indexes === null ? key : key + "[]", + convertValue(el) + ) + }) + return false + } + } + if (isVisitable(value)) { + return true + } + formData.append(renderKey(path, key, dots), convertValue(value)) + return false + } + const stack = [] + const exposedHelpers = Object.assign(predicates, { + defaultVisitor, + convertValue, + isVisitable, + }) + function build(value, path) { + if (utils.isUndefined(value)) return + if (stack.indexOf(value) !== -1) { + throw Error("Circular reference detected in " + path.join(".")) + } + stack.push(value) + utils.forEach(value, function each(el, key) { + const result = + !(utils.isUndefined(el) || el === null) && + visitor.call(formData, el, utils.isString(key) ? key.trim() : key, path, exposedHelpers) + if (result === true) { + build(el, path ? path.concat(key) : [key]) + } + }) + stack.pop() + } + if (!utils.isObject(obj)) { + throw new TypeError("data must be an object") + } + build(obj) + return formData +} +function encode$1(str) { + const charMap = { + "!": "%21", + "'": "%27", + "(": "%28", + ")": "%29", + "~": "%7E", + "%20": "+", + "%00": "\0", + } + return encodeURIComponent(str).replace(/[!'()~]|%20|%00/g, function replacer(match) { + return charMap[match] + }) +} +function AxiosURLSearchParams(params, options) { + this._pairs = [] + params && toFormData(params, this, options) +} +const prototype = AxiosURLSearchParams.prototype +prototype.append = function append2(name2, value) { + this._pairs.push([name2, value]) +} +prototype.toString = function toString2(encoder) { + const _encode = encoder + ? function (value) { + return encoder.call(this, value, encode$1) + } + : encode$1 + return this._pairs + .map(function each(pair) { + return _encode(pair[0]) + "=" + _encode(pair[1]) + }, "") + .join("&") +} +function encode(val) { + return encodeURIComponent(val) + .replace(/%3A/gi, ":") + .replace(/%24/g, "$") + .replace(/%2C/gi, ",") + .replace(/%20/g, "+") + .replace(/%5B/gi, "[") + .replace(/%5D/gi, "]") +} +function buildURL(url2, params, options) { + if (!params) { + return url2 + } + const _encode = (options && options.encode) || encode + const serializeFn = options && options.serialize + let serializedParams + if (serializeFn) { + serializedParams = serializeFn(params, options) + } else { + serializedParams = utils.isURLSearchParams(params) + ? params.toString() + : new AxiosURLSearchParams(params, options).toString(_encode) + } + if (serializedParams) { + const hashmarkIndex = url2.indexOf("#") + if (hashmarkIndex !== -1) { + url2 = url2.slice(0, hashmarkIndex) + } + url2 += (url2.indexOf("?") === -1 ? "?" : "&") + serializedParams + } + return url2 +} +class InterceptorManager { + constructor() { + this.handlers = [] + } + /** + * Add a new interceptor to the stack + * + * @param {Function} fulfilled The function to handle `then` for a `Promise` + * @param {Function} rejected The function to handle `reject` for a `Promise` + * + * @return {Number} An ID used to remove interceptor later + */ + use(fulfilled, rejected, options) { + this.handlers.push({ + fulfilled, + rejected, + synchronous: options ? options.synchronous : false, + runWhen: options ? options.runWhen : null, + }) + return this.handlers.length - 1 + } + /** + * Remove an interceptor from the stack + * + * @param {Number} id The ID that was returned by `use` + * + * @returns {Boolean} `true` if the interceptor was removed, `false` otherwise + */ + eject(id2) { + if (this.handlers[id2]) { + this.handlers[id2] = null + } + } + /** + * Clear all interceptors from the stack + * + * @returns {void} + */ + clear() { + if (this.handlers) { + this.handlers = [] + } + } + /** + * Iterate over all the registered interceptors + * + * This method is particularly useful for skipping over any + * interceptors that may have become `null` calling `eject`. + * + * @param {Function} fn The function to call for each interceptor + * + * @returns {void} + */ + forEach(fn) { + utils.forEach(this.handlers, function forEachHandler(h) { + if (h !== null) { + fn(h) + } + }) + } +} +const InterceptorManager$1 = InterceptorManager +const transitionalDefaults = { + silentJSONParsing: true, + forcedJSONParsing: true, + clarifyTimeoutError: false, +} +const URLSearchParams$1 = typeof URLSearchParams !== "undefined" ? URLSearchParams : AxiosURLSearchParams +const FormData$1 = typeof FormData !== "undefined" ? FormData : null +const Blob$1 = typeof Blob !== "undefined" ? Blob : null +const isStandardBrowserEnv = (() => { + let product + if ( + typeof navigator !== "undefined" && + ((product = navigator.product) === "ReactNative" || product === "NativeScript" || product === "NS") + ) { + return false + } + return typeof window !== "undefined" && typeof document !== "undefined" +})() +const isStandardBrowserWebWorkerEnv = (() => { + return ( + typeof WorkerGlobalScope !== "undefined" && // eslint-disable-next-line no-undef + self instanceof WorkerGlobalScope && + typeof self.importScripts === "function" + ) +})() +const platform = { + isBrowser: true, + classes: { + URLSearchParams: URLSearchParams$1, + FormData: FormData$1, + Blob: Blob$1, + }, + isStandardBrowserEnv, + isStandardBrowserWebWorkerEnv, + protocols: ["http", "https", "file", "blob", "url", "data"], +} +function toURLEncodedForm(data, options) { + return toFormData( + data, + new platform.classes.URLSearchParams(), + Object.assign( + { + visitor: function (value, key, path, helpers) { + if (platform.isNode && utils.isBuffer(value)) { + this.append(key, value.toString("base64")) + return false + } + return helpers.defaultVisitor.apply(this, arguments) + }, + }, + options + ) + ) +} +function parsePropPath(name2) { + return utils.matchAll(/\w+|\[(\w*)]/g, name2).map((match) => { + return match[0] === "[]" ? "" : match[1] || match[0] + }) +} +function arrayToObject(arr) { + const obj = {} + const keys = Object.keys(arr) + let i + const len = keys.length + let key + for (i = 0; i < len; i++) { + key = keys[i] + obj[key] = arr[key] + } + return obj +} +function formDataToJSON(formData) { + function buildPath(path, value, target, index) { + let name2 = path[index++] + const isNumericKey = Number.isFinite(+name2) + const isLast = index >= path.length + name2 = !name2 && utils.isArray(target) ? target.length : name2 + if (isLast) { + if (utils.hasOwnProp(target, name2)) { + target[name2] = [target[name2], value] + } else { + target[name2] = value + } + return !isNumericKey + } + if (!target[name2] || !utils.isObject(target[name2])) { + target[name2] = [] + } + const result = buildPath(path, value, target[name2], index) + if (result && utils.isArray(target[name2])) { + target[name2] = arrayToObject(target[name2]) + } + return !isNumericKey + } + if (utils.isFormData(formData) && utils.isFunction(formData.entries)) { + const obj = {} + utils.forEachEntry(formData, (name2, value) => { + buildPath(parsePropPath(name2), value, obj, 0) + }) + return obj + } + return null +} +const DEFAULT_CONTENT_TYPE = { + "Content-Type": void 0, +} +function stringifySafely(rawValue, parser, encoder) { + if (utils.isString(rawValue)) { + try { + ;(parser || JSON.parse)(rawValue) + return utils.trim(rawValue) + } catch (e) { + if (e.name !== "SyntaxError") { + throw e + } + } + } + return (encoder || JSON.stringify)(rawValue) +} +const defaults = { + transitional: transitionalDefaults, + adapter: ["xhr", "http"], + transformRequest: [ + function transformRequest(data, headers) { + const contentType = headers.getContentType() || "" + const hasJSONContentType = contentType.indexOf("application/json") > -1 + const isObjectPayload = utils.isObject(data) + if (isObjectPayload && utils.isHTMLForm(data)) { + data = new FormData(data) + } + const isFormData2 = utils.isFormData(data) + if (isFormData2) { + if (!hasJSONContentType) { + return data + } + return hasJSONContentType ? JSON.stringify(formDataToJSON(data)) : data + } + if ( + utils.isArrayBuffer(data) || + utils.isBuffer(data) || + utils.isStream(data) || + utils.isFile(data) || + utils.isBlob(data) + ) { + return data + } + if (utils.isArrayBufferView(data)) { + return data.buffer + } + if (utils.isURLSearchParams(data)) { + headers.setContentType("application/x-www-form-urlencoded;charset=utf-8", false) + return data.toString() + } + let isFileList2 + if (isObjectPayload) { + if (contentType.indexOf("application/x-www-form-urlencoded") > -1) { + return toURLEncodedForm(data, this.formSerializer).toString() + } + if ((isFileList2 = utils.isFileList(data)) || contentType.indexOf("multipart/form-data") > -1) { + const _FormData = this.env && this.env.FormData + return toFormData(isFileList2 ? { "files[]": data } : data, _FormData && new _FormData(), this.formSerializer) + } + } + if (isObjectPayload || hasJSONContentType) { + headers.setContentType("application/json", false) + return stringifySafely(data) + } + return data + }, + ], + transformResponse: [ + function transformResponse(data) { + const transitional2 = this.transitional || defaults.transitional + const forcedJSONParsing = transitional2 && transitional2.forcedJSONParsing + const JSONRequested = this.responseType === "json" + if (data && utils.isString(data) && ((forcedJSONParsing && !this.responseType) || JSONRequested)) { + const silentJSONParsing = transitional2 && transitional2.silentJSONParsing + const strictJSONParsing = !silentJSONParsing && JSONRequested + try { + return JSON.parse(data) + } catch (e) { + if (strictJSONParsing) { + if (e.name === "SyntaxError") { + throw AxiosError.from(e, AxiosError.ERR_BAD_RESPONSE, this, null, this.response) + } + throw e + } + } + } + return data + }, + ], + /** + * A timeout in milliseconds to abort a request. If set to 0 (default) a + * timeout is not created. + */ + timeout: 0, + xsrfCookieName: "XSRF-TOKEN", + xsrfHeaderName: "X-XSRF-TOKEN", + maxContentLength: -1, + maxBodyLength: -1, + env: { + FormData: platform.classes.FormData, + Blob: platform.classes.Blob, + }, + validateStatus: function validateStatus(status) { + return status >= 200 && status < 300 + }, + headers: { + common: { + Accept: "application/json, text/plain, */*", + }, + }, +} +utils.forEach(["delete", "get", "head"], function forEachMethodNoData(method) { + defaults.headers[method] = {} +}) +utils.forEach(["post", "put", "patch"], function forEachMethodWithData(method) { + defaults.headers[method] = utils.merge(DEFAULT_CONTENT_TYPE) +}) +const defaults$1 = defaults +const ignoreDuplicateOf = utils.toObjectSet([ + "age", + "authorization", + "content-length", + "content-type", + "etag", + "expires", + "from", + "host", + "if-modified-since", + "if-unmodified-since", + "last-modified", + "location", + "max-forwards", + "proxy-authorization", + "referer", + "retry-after", + "user-agent", +]) +const parseHeaders = (rawHeaders) => { + const parsed = {} + let key + let val + let i + rawHeaders && + rawHeaders.split("\n").forEach(function parser(line) { + i = line.indexOf(":") + key = line.substring(0, i).trim().toLowerCase() + val = line.substring(i + 1).trim() + if (!key || (parsed[key] && ignoreDuplicateOf[key])) { + return + } + if (key === "set-cookie") { + if (parsed[key]) { + parsed[key].push(val) + } else { + parsed[key] = [val] + } + } else { + parsed[key] = parsed[key] ? parsed[key] + ", " + val : val + } + }) + return parsed +} +const $internals = Symbol("internals") +function normalizeHeader(header) { + return header && String(header).trim().toLowerCase() +} +function normalizeValue(value) { + if (value === false || value == null) { + return value + } + return utils.isArray(value) ? value.map(normalizeValue) : String(value) +} +function parseTokens(str) { + const tokens = /* @__PURE__ */ Object.create(null) + const tokensRE = /([^\s,;=]+)\s*(?:=\s*([^,;]+))?/g + let match + while ((match = tokensRE.exec(str))) { + tokens[match[1]] = match[2] + } + return tokens +} +function isValidHeaderName(str) { + return /^[-_a-zA-Z]+$/.test(str.trim()) +} +function matchHeaderValue(context, value, header, filter3, isHeaderNameFilter) { + if (utils.isFunction(filter3)) { + return filter3.call(this, value, header) + } + if (isHeaderNameFilter) { + value = header + } + if (!utils.isString(value)) return + if (utils.isString(filter3)) { + return value.indexOf(filter3) !== -1 + } + if (utils.isRegExp(filter3)) { + return filter3.test(value) + } +} +function formatHeader(header) { + return header + .trim() + .toLowerCase() + .replace(/([a-z\d])(\w*)/g, (w, char, str) => { + return char.toUpperCase() + str + }) +} +function buildAccessors(obj, header) { + const accessorName = utils.toCamelCase(" " + header) + ;["get", "set", "has"].forEach((methodName) => { + Object.defineProperty(obj, methodName + accessorName, { + value: function (arg1, arg2, arg3) { + return this[methodName].call(this, header, arg1, arg2, arg3) + }, + configurable: true, + }) + }) +} +class AxiosHeaders { + constructor(headers) { + headers && this.set(headers) + } + set(header, valueOrRewrite, rewrite) { + const self2 = this + function setHeader(_value, _header, _rewrite) { + const lHeader = normalizeHeader(_header) + if (!lHeader) { + throw new Error("header name must be a non-empty string") + } + const key = utils.findKey(self2, lHeader) + if (!key || self2[key] === void 0 || _rewrite === true || (_rewrite === void 0 && self2[key] !== false)) { + self2[key || _header] = normalizeValue(_value) + } + } + const setHeaders = (headers, _rewrite) => + utils.forEach(headers, (_value, _header) => setHeader(_value, _header, _rewrite)) + if (utils.isPlainObject(header) || header instanceof this.constructor) { + setHeaders(header, valueOrRewrite) + } else if (utils.isString(header) && (header = header.trim()) && !isValidHeaderName(header)) { + setHeaders(parseHeaders(header), valueOrRewrite) + } else { + header != null && setHeader(valueOrRewrite, header, rewrite) + } + return this + } + get(header, parser) { + header = normalizeHeader(header) + if (header) { + const key = utils.findKey(this, header) + if (key) { + const value = this[key] + if (!parser) { + return value + } + if (parser === true) { + return parseTokens(value) + } + if (utils.isFunction(parser)) { + return parser.call(this, value, key) + } + if (utils.isRegExp(parser)) { + return parser.exec(value) + } + throw new TypeError("parser must be boolean|regexp|function") + } + } + } + has(header, matcher) { + header = normalizeHeader(header) + if (header) { + const key = utils.findKey(this, header) + return !!(key && this[key] !== void 0 && (!matcher || matchHeaderValue(this, this[key], key, matcher))) + } + return false + } + delete(header, matcher) { + const self2 = this + let deleted = false + function deleteHeader(_header) { + _header = normalizeHeader(_header) + if (_header) { + const key = utils.findKey(self2, _header) + if (key && (!matcher || matchHeaderValue(self2, self2[key], key, matcher))) { + delete self2[key] + deleted = true + } + } + } + if (utils.isArray(header)) { + header.forEach(deleteHeader) + } else { + deleteHeader(header) + } + return deleted + } + clear(matcher) { + const keys = Object.keys(this) + let i = keys.length + let deleted = false + while (i--) { + const key = keys[i] + if (!matcher || matchHeaderValue(this, this[key], key, matcher, true)) { + delete this[key] + deleted = true + } + } + return deleted + } + normalize(format) { + const self2 = this + const headers = {} + utils.forEach(this, (value, header) => { + const key = utils.findKey(headers, header) + if (key) { + self2[key] = normalizeValue(value) + delete self2[header] + return + } + const normalized = format ? formatHeader(header) : String(header).trim() + if (normalized !== header) { + delete self2[header] + } + self2[normalized] = normalizeValue(value) + headers[normalized] = true + }) + return this + } + concat(...targets) { + return this.constructor.concat(this, ...targets) + } + toJSON(asStrings) { + const obj = /* @__PURE__ */ Object.create(null) + utils.forEach(this, (value, header) => { + value != null && value !== false && (obj[header] = asStrings && utils.isArray(value) ? value.join(", ") : value) + }) + return obj + } + [Symbol.iterator]() { + return Object.entries(this.toJSON())[Symbol.iterator]() + } + toString() { + return Object.entries(this.toJSON()) + .map(([header, value]) => header + ": " + value) + .join("\n") + } + get [Symbol.toStringTag]() { + return "AxiosHeaders" + } + static from(thing) { + return thing instanceof this ? thing : new this(thing) + } + static concat(first, ...targets) { + const computed = new this(first) + targets.forEach((target) => computed.set(target)) + return computed + } + static accessor(header) { + const internals = + (this[$internals] = + this[$internals] = + { + accessors: {}, + }) + const accessors = internals.accessors + const prototype2 = this.prototype + function defineAccessor(_header) { + const lHeader = normalizeHeader(_header) + if (!accessors[lHeader]) { + buildAccessors(prototype2, _header) + accessors[lHeader] = true + } + } + utils.isArray(header) ? header.forEach(defineAccessor) : defineAccessor(header) + return this + } +} +AxiosHeaders.accessor(["Content-Type", "Content-Length", "Accept", "Accept-Encoding", "User-Agent", "Authorization"]) +utils.freezeMethods(AxiosHeaders.prototype) +utils.freezeMethods(AxiosHeaders) +const AxiosHeaders$1 = AxiosHeaders +function transformData(fns, response) { + const config2 = this || defaults$1 + const context = response || config2 + const headers = AxiosHeaders$1.from(context.headers) + let data = context.data + utils.forEach(fns, function transform(fn) { + data = fn.call(config2, data, headers.normalize(), response ? response.status : void 0) + }) + headers.normalize() + return data +} +function isCancel(value) { + return !!(value && value.__CANCEL__) +} +function CanceledError(message, config2, request2) { + AxiosError.call(this, message == null ? "canceled" : message, AxiosError.ERR_CANCELED, config2, request2) + this.name = "CanceledError" +} +utils.inherits(CanceledError, AxiosError, { + __CANCEL__: true, +}) +function settle(resolve2, reject, response) { + const validateStatus2 = response.config.validateStatus + if (!response.status || !validateStatus2 || validateStatus2(response.status)) { + resolve2(response) + } else { + reject( + new AxiosError( + "Request failed with status code " + response.status, + [AxiosError.ERR_BAD_REQUEST, AxiosError.ERR_BAD_RESPONSE][Math.floor(response.status / 100) - 4], + response.config, + response.request, + response + ) + ) + } +} +const cookies = platform.isStandardBrowserEnv + ? // Standard browser envs support document.cookie + (function standardBrowserEnv() { + return { + write: function write(name2, value, expires, path, domain, secure) { + const cookie = [] + cookie.push(name2 + "=" + encodeURIComponent(value)) + if (utils.isNumber(expires)) { + cookie.push("expires=" + new Date(expires).toGMTString()) + } + if (utils.isString(path)) { + cookie.push("path=" + path) + } + if (utils.isString(domain)) { + cookie.push("domain=" + domain) + } + if (secure === true) { + cookie.push("secure") + } + document.cookie = cookie.join("; ") + }, + read: function read(name2) { + const match = document.cookie.match(new RegExp("(^|;\\s*)(" + name2 + ")=([^;]*)")) + return match ? decodeURIComponent(match[3]) : null + }, + remove: function remove(name2) { + this.write(name2, "", Date.now() - 864e5) + }, + } + })() + : // Non standard browser env (web workers, react-native) lack needed support. + (function nonStandardBrowserEnv() { + return { + write: function write() {}, + read: function read() { + return null + }, + remove: function remove() {}, + } + })() +function isAbsoluteURL(url2) { + return /^([a-z][a-z\d+\-.]*:)?\/\//i.test(url2) +} +function combineURLs(baseURL, relativeURL) { + return relativeURL ? baseURL.replace(/\/+$/, "") + "/" + relativeURL.replace(/^\/+/, "") : baseURL +} +function buildFullPath(baseURL, requestedURL) { + if (baseURL && !isAbsoluteURL(requestedURL)) { + return combineURLs(baseURL, requestedURL) + } + return requestedURL +} +const isURLSameOrigin = platform.isStandardBrowserEnv + ? // Standard browser envs have full support of the APIs needed to test + // whether the request URL is of the same origin as current location. + (function standardBrowserEnv2() { + const msie = /(msie|trident)/i.test(navigator.userAgent) + const urlParsingNode = document.createElement("a") + let originURL + function resolveURL(url2) { + let href = url2 + if (msie) { + urlParsingNode.setAttribute("href", href) + href = urlParsingNode.href + } + urlParsingNode.setAttribute("href", href) + return { + href: urlParsingNode.href, + protocol: urlParsingNode.protocol ? urlParsingNode.protocol.replace(/:$/, "") : "", + host: urlParsingNode.host, + search: urlParsingNode.search ? urlParsingNode.search.replace(/^\?/, "") : "", + hash: urlParsingNode.hash ? urlParsingNode.hash.replace(/^#/, "") : "", + hostname: urlParsingNode.hostname, + port: urlParsingNode.port, + pathname: urlParsingNode.pathname.charAt(0) === "/" ? urlParsingNode.pathname : "/" + urlParsingNode.pathname, + } + } + originURL = resolveURL(window.location.href) + return function isURLSameOrigin2(requestURL) { + const parsed = utils.isString(requestURL) ? resolveURL(requestURL) : requestURL + return parsed.protocol === originURL.protocol && parsed.host === originURL.host + } + })() + : // Non standard browser envs (web workers, react-native) lack needed support. + (function nonStandardBrowserEnv2() { + return function isURLSameOrigin2() { + return true + } + })() +function parseProtocol(url2) { + const match = /^([-+\w]{1,25})(:?\/\/|:)/.exec(url2) + return (match && match[1]) || "" +} +function speedometer(samplesCount, min) { + samplesCount = samplesCount || 10 + const bytes = new Array(samplesCount) + const timestamps = new Array(samplesCount) + let head = 0 + let tail = 0 + let firstSampleTS + min = min !== void 0 ? min : 1e3 + return function push(chunkLength) { + const now = Date.now() + const startedAt = timestamps[tail] + if (!firstSampleTS) { + firstSampleTS = now + } + bytes[head] = chunkLength + timestamps[head] = now + let i = tail + let bytesCount = 0 + while (i !== head) { + bytesCount += bytes[i++] + i = i % samplesCount + } + head = (head + 1) % samplesCount + if (head === tail) { + tail = (tail + 1) % samplesCount + } + if (now - firstSampleTS < min) { + return + } + const passed = startedAt && now - startedAt + return passed ? Math.round((bytesCount * 1e3) / passed) : void 0 + } +} +function progressEventReducer(listener, isDownloadStream) { + let bytesNotified = 0 + const _speedometer = speedometer(50, 250) + return (e) => { + const loaded = e.loaded + const total = e.lengthComputable ? e.total : void 0 + const progressBytes = loaded - bytesNotified + const rate = _speedometer(progressBytes) + const inRange = loaded <= total + bytesNotified = loaded + const data = { + loaded, + total, + progress: total ? loaded / total : void 0, + bytes: progressBytes, + rate: rate ? rate : void 0, + estimated: rate && total && inRange ? (total - loaded) / rate : void 0, + event: e, + } + data[isDownloadStream ? "download" : "upload"] = true + listener(data) + } +} +const isXHRAdapterSupported = typeof XMLHttpRequest !== "undefined" +const xhrAdapter = + isXHRAdapterSupported && + function (config2) { + return new Promise(function dispatchXhrRequest(resolve2, reject) { + let requestData = config2.data + const requestHeaders = AxiosHeaders$1.from(config2.headers).normalize() + const responseType = config2.responseType + let onCanceled + function done() { + if (config2.cancelToken) { + config2.cancelToken.unsubscribe(onCanceled) + } + if (config2.signal) { + config2.signal.removeEventListener("abort", onCanceled) + } + } + if (utils.isFormData(requestData) && (platform.isStandardBrowserEnv || platform.isStandardBrowserWebWorkerEnv)) { + requestHeaders.setContentType(false) + } + let request2 = new XMLHttpRequest() + if (config2.auth) { + const username = config2.auth.username || "" + const password = config2.auth.password ? unescape(encodeURIComponent(config2.auth.password)) : "" + requestHeaders.set("Authorization", "Basic " + btoa(username + ":" + password)) + } + const fullPath = buildFullPath(config2.baseURL, config2.url) + request2.open(config2.method.toUpperCase(), buildURL(fullPath, config2.params, config2.paramsSerializer), true) + request2.timeout = config2.timeout + function onloadend() { + if (!request2) { + return + } + const responseHeaders = AxiosHeaders$1.from( + "getAllResponseHeaders" in request2 && request2.getAllResponseHeaders() + ) + const responseData = + !responseType || responseType === "text" || responseType === "json" + ? request2.responseText + : request2.response + const response = { + data: responseData, + status: request2.status, + statusText: request2.statusText, + headers: responseHeaders, + config: config2, + request: request2, + } + settle( + function _resolve(value) { + resolve2(value) + done() + }, + function _reject(err) { + reject(err) + done() + }, + response + ) + request2 = null + } + if ("onloadend" in request2) { + request2.onloadend = onloadend + } else { + request2.onreadystatechange = function handleLoad() { + if (!request2 || request2.readyState !== 4) { + return + } + if (request2.status === 0 && !(request2.responseURL && request2.responseURL.indexOf("file:") === 0)) { + return + } + setTimeout(onloadend) + } + } + request2.onabort = function handleAbort() { + if (!request2) { + return + } + reject(new AxiosError("Request aborted", AxiosError.ECONNABORTED, config2, request2)) + request2 = null + } + request2.onerror = function handleError() { + reject(new AxiosError("Network Error", AxiosError.ERR_NETWORK, config2, request2)) + request2 = null + } + request2.ontimeout = function handleTimeout() { + let timeoutErrorMessage = config2.timeout ? "timeout of " + config2.timeout + "ms exceeded" : "timeout exceeded" + const transitional2 = config2.transitional || transitionalDefaults + if (config2.timeoutErrorMessage) { + timeoutErrorMessage = config2.timeoutErrorMessage + } + reject( + new AxiosError( + timeoutErrorMessage, + transitional2.clarifyTimeoutError ? AxiosError.ETIMEDOUT : AxiosError.ECONNABORTED, + config2, + request2 + ) + ) + request2 = null + } + if (platform.isStandardBrowserEnv) { + const xsrfValue = + (config2.withCredentials || isURLSameOrigin(fullPath)) && + config2.xsrfCookieName && + cookies.read(config2.xsrfCookieName) + if (xsrfValue) { + requestHeaders.set(config2.xsrfHeaderName, xsrfValue) + } + } + requestData === void 0 && requestHeaders.setContentType(null) + if ("setRequestHeader" in request2) { + utils.forEach(requestHeaders.toJSON(), function setRequestHeader(val, key) { + request2.setRequestHeader(key, val) + }) + } + if (!utils.isUndefined(config2.withCredentials)) { + request2.withCredentials = !!config2.withCredentials + } + if (responseType && responseType !== "json") { + request2.responseType = config2.responseType + } + if (typeof config2.onDownloadProgress === "function") { + request2.addEventListener("progress", progressEventReducer(config2.onDownloadProgress, true)) + } + if (typeof config2.onUploadProgress === "function" && request2.upload) { + request2.upload.addEventListener("progress", progressEventReducer(config2.onUploadProgress)) + } + if (config2.cancelToken || config2.signal) { + onCanceled = (cancel) => { + if (!request2) { + return + } + reject(!cancel || cancel.type ? new CanceledError(null, config2, request2) : cancel) + request2.abort() + request2 = null + } + config2.cancelToken && config2.cancelToken.subscribe(onCanceled) + if (config2.signal) { + config2.signal.aborted ? onCanceled() : config2.signal.addEventListener("abort", onCanceled) + } + } + const protocol = parseProtocol(fullPath) + if (protocol && platform.protocols.indexOf(protocol) === -1) { + reject(new AxiosError("Unsupported protocol " + protocol + ":", AxiosError.ERR_BAD_REQUEST, config2)) + return + } + request2.send(requestData || null) + }) + } +const knownAdapters = { + http: httpAdapter, + xhr: xhrAdapter, +} +utils.forEach(knownAdapters, (fn, value) => { + if (fn) { + try { + Object.defineProperty(fn, "name", { value }) + } catch (e) {} + Object.defineProperty(fn, "adapterName", { value }) + } +}) +const adapters = { + getAdapter: (adapters2) => { + adapters2 = utils.isArray(adapters2) ? adapters2 : [adapters2] + const { length } = adapters2 + let nameOrAdapter + let adapter + for (let i = 0; i < length; i++) { + nameOrAdapter = adapters2[i] + if ((adapter = utils.isString(nameOrAdapter) ? knownAdapters[nameOrAdapter.toLowerCase()] : nameOrAdapter)) { + break + } + } + if (!adapter) { + if (adapter === false) { + throw new AxiosError(`Adapter ${nameOrAdapter} is not supported by the environment`, "ERR_NOT_SUPPORT") + } + throw new Error( + utils.hasOwnProp(knownAdapters, nameOrAdapter) + ? `Adapter '${nameOrAdapter}' is not available in the build` + : `Unknown adapter '${nameOrAdapter}'` + ) + } + if (!utils.isFunction(adapter)) { + throw new TypeError("adapter is not a function") + } + return adapter + }, + adapters: knownAdapters, +} +function throwIfCancellationRequested(config2) { + if (config2.cancelToken) { + config2.cancelToken.throwIfRequested() + } + if (config2.signal && config2.signal.aborted) { + throw new CanceledError(null, config2) + } +} +function dispatchRequest(config2) { + throwIfCancellationRequested(config2) + config2.headers = AxiosHeaders$1.from(config2.headers) + config2.data = transformData.call(config2, config2.transformRequest) + if (["post", "put", "patch"].indexOf(config2.method) !== -1) { + config2.headers.setContentType("application/x-www-form-urlencoded", false) + } + const adapter = adapters.getAdapter(config2.adapter || defaults$1.adapter) + return adapter(config2).then( + function onAdapterResolution(response) { + throwIfCancellationRequested(config2) + response.data = transformData.call(config2, config2.transformResponse, response) + response.headers = AxiosHeaders$1.from(response.headers) + return response + }, + function onAdapterRejection(reason) { + if (!isCancel(reason)) { + throwIfCancellationRequested(config2) + if (reason && reason.response) { + reason.response.data = transformData.call(config2, config2.transformResponse, reason.response) + reason.response.headers = AxiosHeaders$1.from(reason.response.headers) + } + } + return Promise.reject(reason) + } + ) +} +const headersToObject = (thing) => (thing instanceof AxiosHeaders$1 ? thing.toJSON() : thing) +function mergeConfig(config1, config2) { + config2 = config2 || {} + const config3 = {} + function getMergedValue(target, source, caseless) { + if (utils.isPlainObject(target) && utils.isPlainObject(source)) { + return utils.merge.call({ caseless }, target, source) + } else if (utils.isPlainObject(source)) { + return utils.merge({}, source) + } else if (utils.isArray(source)) { + return source.slice() + } + return source + } + function mergeDeepProperties(a2, b2, caseless) { + if (!utils.isUndefined(b2)) { + return getMergedValue(a2, b2, caseless) + } else if (!utils.isUndefined(a2)) { + return getMergedValue(void 0, a2, caseless) + } + } + function valueFromConfig2(a2, b2) { + if (!utils.isUndefined(b2)) { + return getMergedValue(void 0, b2) + } + } + function defaultToConfig2(a2, b2) { + if (!utils.isUndefined(b2)) { + return getMergedValue(void 0, b2) + } else if (!utils.isUndefined(a2)) { + return getMergedValue(void 0, a2) + } + } + function mergeDirectKeys(a2, b2, prop) { + if (prop in config2) { + return getMergedValue(a2, b2) + } else if (prop in config1) { + return getMergedValue(void 0, a2) + } + } + const mergeMap = { + url: valueFromConfig2, + method: valueFromConfig2, + data: valueFromConfig2, + baseURL: defaultToConfig2, + transformRequest: defaultToConfig2, + transformResponse: defaultToConfig2, + paramsSerializer: defaultToConfig2, + timeout: defaultToConfig2, + timeoutMessage: defaultToConfig2, + withCredentials: defaultToConfig2, + adapter: defaultToConfig2, + responseType: defaultToConfig2, + xsrfCookieName: defaultToConfig2, + xsrfHeaderName: defaultToConfig2, + onUploadProgress: defaultToConfig2, + onDownloadProgress: defaultToConfig2, + decompress: defaultToConfig2, + maxContentLength: defaultToConfig2, + maxBodyLength: defaultToConfig2, + beforeRedirect: defaultToConfig2, + transport: defaultToConfig2, + httpAgent: defaultToConfig2, + httpsAgent: defaultToConfig2, + cancelToken: defaultToConfig2, + socketPath: defaultToConfig2, + responseEncoding: defaultToConfig2, + validateStatus: mergeDirectKeys, + headers: (a2, b2) => mergeDeepProperties(headersToObject(a2), headersToObject(b2), true), + } + utils.forEach(Object.keys(config1).concat(Object.keys(config2)), function computeConfigValue(prop) { + const merge2 = mergeMap[prop] || mergeDeepProperties + const configValue = merge2(config1[prop], config2[prop], prop) + ;(utils.isUndefined(configValue) && merge2 !== mergeDirectKeys) || (config3[prop] = configValue) + }) + return config3 +} +const VERSION = "1.3.4" +const validators$1 = {} +;["object", "boolean", "number", "function", "string", "symbol"].forEach((type, i) => { + validators$1[type] = function validator2(thing) { + return typeof thing === type || "a" + (i < 1 ? "n " : " ") + type + } +}) +const deprecatedWarnings = {} +validators$1.transitional = function transitional(validator2, version2, message) { + function formatMessage(opt, desc) { + return "[Axios v" + VERSION + "] Transitional option '" + opt + "'" + desc + (message ? ". " + message : "") + } + return (value, opt, opts2) => { + if (validator2 === false) { + throw new AxiosError( + formatMessage(opt, " has been removed" + (version2 ? " in " + version2 : "")), + AxiosError.ERR_DEPRECATED + ) + } + if (version2 && !deprecatedWarnings[opt]) { + deprecatedWarnings[opt] = true + console.warn( + formatMessage(opt, " has been deprecated since v" + version2 + " and will be removed in the near future") + ) + } + return validator2 ? validator2(value, opt, opts2) : true + } +} +function assertOptions(options, schema, allowUnknown) { + if (typeof options !== "object") { + throw new AxiosError("options must be an object", AxiosError.ERR_BAD_OPTION_VALUE) + } + const keys = Object.keys(options) + let i = keys.length + while (i-- > 0) { + const opt = keys[i] + const validator2 = schema[opt] + if (validator2) { + const value = options[opt] + const result = value === void 0 || validator2(value, opt, options) + if (result !== true) { + throw new AxiosError("option " + opt + " must be " + result, AxiosError.ERR_BAD_OPTION_VALUE) + } + continue + } + if (allowUnknown !== true) { + throw new AxiosError("Unknown option " + opt, AxiosError.ERR_BAD_OPTION) + } + } +} +const validator = { + assertOptions, + validators: validators$1, +} +const validators = validator.validators +class Axios { + constructor(instanceConfig) { + this.defaults = instanceConfig + this.interceptors = { + request: new InterceptorManager$1(), + response: new InterceptorManager$1(), + } + } + /** + * Dispatch a request + * + * @param {String|Object} configOrUrl The config specific for this request (merged with this.defaults) + * @param {?Object} config + * + * @returns {Promise} The Promise to be fulfilled + */ + request(configOrUrl, config2) { + if (typeof configOrUrl === "string") { + config2 = config2 || {} + config2.url = configOrUrl + } else { + config2 = configOrUrl || {} + } + config2 = mergeConfig(this.defaults, config2) + const { transitional: transitional2, paramsSerializer, headers } = config2 + if (transitional2 !== void 0) { + validator.assertOptions( + transitional2, + { + silentJSONParsing: validators.transitional(validators.boolean), + forcedJSONParsing: validators.transitional(validators.boolean), + clarifyTimeoutError: validators.transitional(validators.boolean), + }, + false + ) + } + if (paramsSerializer !== void 0) { + validator.assertOptions( + paramsSerializer, + { + encode: validators.function, + serialize: validators.function, + }, + true + ) + } + config2.method = (config2.method || this.defaults.method || "get").toLowerCase() + let contextHeaders + contextHeaders = headers && utils.merge(headers.common, headers[config2.method]) + contextHeaders && + utils.forEach(["delete", "get", "head", "post", "put", "patch", "common"], (method) => { + delete headers[method] + }) + config2.headers = AxiosHeaders$1.concat(contextHeaders, headers) + const requestInterceptorChain = [] + let synchronousRequestInterceptors = true + this.interceptors.request.forEach(function unshiftRequestInterceptors(interceptor) { + if (typeof interceptor.runWhen === "function" && interceptor.runWhen(config2) === false) { + return + } + synchronousRequestInterceptors = synchronousRequestInterceptors && interceptor.synchronous + requestInterceptorChain.unshift(interceptor.fulfilled, interceptor.rejected) + }) + const responseInterceptorChain = [] + this.interceptors.response.forEach(function pushResponseInterceptors(interceptor) { + responseInterceptorChain.push(interceptor.fulfilled, interceptor.rejected) + }) + let promise + let i = 0 + let len + if (!synchronousRequestInterceptors) { + const chain = [dispatchRequest.bind(this), void 0] + chain.unshift.apply(chain, requestInterceptorChain) + chain.push.apply(chain, responseInterceptorChain) + len = chain.length + promise = Promise.resolve(config2) + while (i < len) { + promise = promise.then(chain[i++], chain[i++]) + } + return promise + } + len = requestInterceptorChain.length + let newConfig = config2 + i = 0 + while (i < len) { + const onFulfilled = requestInterceptorChain[i++] + const onRejected = requestInterceptorChain[i++] + try { + newConfig = onFulfilled(newConfig) + } catch (error2) { + onRejected.call(this, error2) + break + } + } + try { + promise = dispatchRequest.call(this, newConfig) + } catch (error2) { + return Promise.reject(error2) + } + i = 0 + len = responseInterceptorChain.length + while (i < len) { + promise = promise.then(responseInterceptorChain[i++], responseInterceptorChain[i++]) + } + return promise + } + getUri(config2) { + config2 = mergeConfig(this.defaults, config2) + const fullPath = buildFullPath(config2.baseURL, config2.url) + return buildURL(fullPath, config2.params, config2.paramsSerializer) + } +} +utils.forEach(["delete", "get", "head", "options"], function forEachMethodNoData2(method) { + Axios.prototype[method] = function (url2, config2) { + return this.request( + mergeConfig(config2 || {}, { + method, + url: url2, + data: (config2 || {}).data, + }) + ) + } +}) +utils.forEach(["post", "put", "patch"], function forEachMethodWithData2(method) { + function generateHTTPMethod(isForm) { + return function httpMethod(url2, data, config2) { + return this.request( + mergeConfig(config2 || {}, { + method, + headers: isForm + ? { + "Content-Type": "multipart/form-data", + } + : {}, + url: url2, + data, + }) + ) + } + } + Axios.prototype[method] = generateHTTPMethod() + Axios.prototype[method + "Form"] = generateHTTPMethod(true) +}) +const Axios$1 = Axios +class CancelToken { + constructor(executor) { + if (typeof executor !== "function") { + throw new TypeError("executor must be a function.") + } + let resolvePromise + this.promise = new Promise(function promiseExecutor(resolve2) { + resolvePromise = resolve2 + }) + const token = this + this.promise.then((cancel) => { + if (!token._listeners) return + let i = token._listeners.length + while (i-- > 0) { + token._listeners[i](cancel) + } + token._listeners = null + }) + this.promise.then = (onfulfilled) => { + let _resolve + const promise = new Promise((resolve2) => { + token.subscribe(resolve2) + _resolve = resolve2 + }).then(onfulfilled) + promise.cancel = function reject() { + token.unsubscribe(_resolve) + } + return promise + } + executor(function cancel(message, config2, request2) { + if (token.reason) { + return + } + token.reason = new CanceledError(message, config2, request2) + resolvePromise(token.reason) + }) + } + /** + * Throws a `CanceledError` if cancellation has been requested. + */ + throwIfRequested() { + if (this.reason) { + throw this.reason + } + } + /** + * Subscribe to the cancel signal + */ + subscribe(listener) { + if (this.reason) { + listener(this.reason) + return + } + if (this._listeners) { + this._listeners.push(listener) + } else { + this._listeners = [listener] + } + } + /** + * Unsubscribe from the cancel signal + */ + unsubscribe(listener) { + if (!this._listeners) { + return + } + const index = this._listeners.indexOf(listener) + if (index !== -1) { + this._listeners.splice(index, 1) + } + } + /** + * Returns an object that contains a new `CancelToken` and a function that, when called, + * cancels the `CancelToken`. + */ + static source() { + let cancel + const token = new CancelToken(function executor(c) { + cancel = c + }) + return { + token, + cancel, + } + } +} +const CancelToken$1 = CancelToken +function spread(callback) { + return function wrap(arr) { + return callback.apply(null, arr) + } +} +function isAxiosError(payload) { + return utils.isObject(payload) && payload.isAxiosError === true +} +const HttpStatusCode = { + Continue: 100, + SwitchingProtocols: 101, + Processing: 102, + EarlyHints: 103, + Ok: 200, + Created: 201, + Accepted: 202, + NonAuthoritativeInformation: 203, + NoContent: 204, + ResetContent: 205, + PartialContent: 206, + MultiStatus: 207, + AlreadyReported: 208, + ImUsed: 226, + MultipleChoices: 300, + MovedPermanently: 301, + Found: 302, + SeeOther: 303, + NotModified: 304, + UseProxy: 305, + Unused: 306, + TemporaryRedirect: 307, + PermanentRedirect: 308, + BadRequest: 400, + Unauthorized: 401, + PaymentRequired: 402, + Forbidden: 403, + NotFound: 404, + MethodNotAllowed: 405, + NotAcceptable: 406, + ProxyAuthenticationRequired: 407, + RequestTimeout: 408, + Conflict: 409, + Gone: 410, + LengthRequired: 411, + PreconditionFailed: 412, + PayloadTooLarge: 413, + UriTooLong: 414, + UnsupportedMediaType: 415, + RangeNotSatisfiable: 416, + ExpectationFailed: 417, + ImATeapot: 418, + MisdirectedRequest: 421, + UnprocessableEntity: 422, + Locked: 423, + FailedDependency: 424, + TooEarly: 425, + UpgradeRequired: 426, + PreconditionRequired: 428, + TooManyRequests: 429, + RequestHeaderFieldsTooLarge: 431, + UnavailableForLegalReasons: 451, + InternalServerError: 500, + NotImplemented: 501, + BadGateway: 502, + ServiceUnavailable: 503, + GatewayTimeout: 504, + HttpVersionNotSupported: 505, + VariantAlsoNegotiates: 506, + InsufficientStorage: 507, + LoopDetected: 508, + NotExtended: 510, + NetworkAuthenticationRequired: 511, +} +Object.entries(HttpStatusCode).forEach(([key, value]) => { + HttpStatusCode[value] = key +}) +const HttpStatusCode$1 = HttpStatusCode +function createInstance(defaultConfig2) { + const context = new Axios$1(defaultConfig2) + const instance2 = bind(Axios$1.prototype.request, context) + utils.extend(instance2, Axios$1.prototype, context, { allOwnKeys: true }) + utils.extend(instance2, context, null, { allOwnKeys: true }) + instance2.create = function create(instanceConfig) { + return createInstance(mergeConfig(defaultConfig2, instanceConfig)) + } + return instance2 +} +const axios = createInstance(defaults$1) +axios.Axios = Axios$1 +axios.CanceledError = CanceledError +axios.CancelToken = CancelToken$1 +axios.isCancel = isCancel +axios.VERSION = VERSION +axios.toFormData = toFormData +axios.AxiosError = AxiosError +axios.Cancel = axios.CanceledError +axios.all = function all(promises) { + return Promise.all(promises) +} +axios.spread = spread +axios.isAxiosError = isAxiosError +axios.mergeConfig = mergeConfig +axios.AxiosHeaders = AxiosHeaders$1 +axios.formToJSON = (thing) => formDataToJSON(utils.isHTMLForm(thing) ? new FormData(thing) : thing) +axios.HttpStatusCode = HttpStatusCode$1 +axios.default = axios +const axios$1 = axios +const factory = M.customLogFactory(S.LOG_LEVEL_INFO, "PluginSystem") +const pluginSystemLogger = factory.getLogger("plugin system") +const log = (...p) => { + pluginSystemLogger.info(...p) +} +const request = axios$1.create({ + withCredentials: false, + headers: { + "Cache-Control": "no-cache", + Pragma: "no-cache", + Expires: "0", + }, +}) +const sleep = async (t2) => { + return new Promise((resolve2) => { + setTimeout(() => resolve2(null), t2) + }) +} +const error = (...p) => pluginSystemLogger.error(...p) +const reloadWindow = () => window.location.reload() +const genUUID = () => + ([1e7].toString() + -1e3 + -4e3 + -8e3 + -1e11).replace(/[018]/g, (c) => + (parseInt(c, 10) ^ (window.crypto.getRandomValues(new Uint32Array(1))[0] & (15 >> (parseInt(c, 10) / 4)))).toString( + 16 + ) + ) +async function isExists(p) { + try { + const res = await FileClient.getInstanceApi().fileApi.getFile(p) + return res !== null + } catch { + return false + } +} +let Error$1 = class Error2 { + constructor(message) { + this.message = message + } +} +class Warning { + constructor(message) { + this.message = message + } +} +const showInfoMessage = (message, timeout) => new Notification({ type: "info", message, timeout }).show() +const showErrorMessage = (message, timeout) => new Notification({ type: "error", message, timeout }).show() +const getLogger = (name2) => factory.getLogger(name2) +const langs = { + zh_CN, + en_US, +} +const _ = (v) => { + return langs[window.siyuan.config.lang][v] || "not defined" +} +var NAMED_TAG = "named" +var NAME_TAG = "name" +var UNMANAGED_TAG = "unmanaged" +var OPTIONAL_TAG = "optional" +var INJECT_TAG = "inject" +var MULTI_INJECT_TAG = "multi_inject" +var TAGGED = "inversify:tagged" +var TAGGED_PROP = "inversify:tagged_props" +var PARAM_TYPES = "inversify:paramtypes" +var DESIGN_PARAM_TYPES = "design:paramtypes" +var POST_CONSTRUCT = "post_construct" +var PRE_DESTROY = "pre_destroy" +function getNonCustomTagKeys() { + return [INJECT_TAG, MULTI_INJECT_TAG, NAME_TAG, UNMANAGED_TAG, NAMED_TAG, OPTIONAL_TAG] +} +var NON_CUSTOM_TAG_KEYS = getNonCustomTagKeys() +var BindingScopeEnum = { + Request: "Request", + Singleton: "Singleton", + Transient: "Transient", +} +var BindingTypeEnum = { + ConstantValue: "ConstantValue", + Constructor: "Constructor", + DynamicValue: "DynamicValue", + Factory: "Factory", + Function: "Function", + Instance: "Instance", + Invalid: "Invalid", + Provider: "Provider", +} +var TargetTypeEnum = { + ClassProperty: "ClassProperty", + ConstructorArgument: "ConstructorArgument", + Variable: "Variable", +} +var idCounter = 0 +function id() { + return idCounter++ +} +var Binding = (function () { + function Binding2(serviceIdentifier, scope) { + this.id = id() + this.activated = false + this.serviceIdentifier = serviceIdentifier + this.scope = scope + this.type = BindingTypeEnum.Invalid + this.constraint = function (request2) { + return true + } + this.implementationType = null + this.cache = null + this.factory = null + this.provider = null + this.onActivation = null + this.onDeactivation = null + this.dynamicValue = null + } + Binding2.prototype.clone = function () { + var clone = new Binding2(this.serviceIdentifier, this.scope) + clone.activated = clone.scope === BindingScopeEnum.Singleton ? this.activated : false + clone.implementationType = this.implementationType + clone.dynamicValue = this.dynamicValue + clone.scope = this.scope + clone.type = this.type + clone.factory = this.factory + clone.provider = this.provider + clone.constraint = this.constraint + clone.onActivation = this.onActivation + clone.onDeactivation = this.onDeactivation + clone.cache = this.cache + return clone + } + return Binding2 +})() +var DUPLICATED_INJECTABLE_DECORATOR = "Cannot apply @injectable decorator multiple times." +var DUPLICATED_METADATA = "Metadata key was used more than once in a parameter:" +var NULL_ARGUMENT = "NULL argument" +var KEY_NOT_FOUND = "Key Not Found" +var AMBIGUOUS_MATCH = "Ambiguous match found for serviceIdentifier:" +var CANNOT_UNBIND = "Could not unbind serviceIdentifier:" +var NOT_REGISTERED = "No matching bindings found for serviceIdentifier:" +var MISSING_INJECTABLE_ANNOTATION = "Missing required @injectable annotation in:" +var MISSING_INJECT_ANNOTATION = "Missing required @inject or @multiInject annotation in:" +var UNDEFINED_INJECT_ANNOTATION = function (name2) { + return ( + "@inject called with undefined this could mean that the class " + + name2 + + " has a circular dependency problem. You can use a LazyServiceIdentifer to overcome this limitation." + ) +} +var CIRCULAR_DEPENDENCY = "Circular dependency found:" +var INVALID_BINDING_TYPE = "Invalid binding type:" +var NO_MORE_SNAPSHOTS_AVAILABLE = "No snapshot available to restore." +var INVALID_MIDDLEWARE_RETURN = "Invalid return type in middleware. Middleware must return!" +var INVALID_FUNCTION_BINDING = "Value provided to function binding must be a function!" +var LAZY_IN_SYNC = function (key) { + return "You are attempting to construct '" + key + "' in a synchronous way\n but it has asynchronous dependencies." +} +var INVALID_TO_SELF_VALUE = "The toSelf function can only be applied when a constructor is used as service identifier" +var INVALID_DECORATOR_OPERATION = + "The @inject @multiInject @tagged and @named decorators must be applied to the parameters of a class constructor or a class property." +var ARGUMENTS_LENGTH_MISMATCH = function () { + var values = [] + for (var _i = 0; _i < arguments.length; _i++) { + values[_i] = arguments[_i] + } + return ( + "The number of constructor arguments in the derived class " + + (values[0] + " must be >= than the number of constructor arguments of its base class.") + ) +} +var CONTAINER_OPTIONS_MUST_BE_AN_OBJECT = "Invalid Container constructor argument. Container options must be an object." +var CONTAINER_OPTIONS_INVALID_DEFAULT_SCOPE = + "Invalid Container option. Default scope must be a string ('singleton' or 'transient')." +var CONTAINER_OPTIONS_INVALID_AUTO_BIND_INJECTABLE = "Invalid Container option. Auto bind injectable must be a boolean" +var CONTAINER_OPTIONS_INVALID_SKIP_BASE_CHECK = "Invalid Container option. Skip base check must be a boolean" +var ASYNC_UNBIND_REQUIRED = + "Attempting to unbind dependency with asynchronous destruction (@preDestroy or onDeactivation)" +var POST_CONSTRUCT_ERROR = function (clazz, errorMessage) { + return "@postConstruct error in class " + clazz + ": " + errorMessage +} +var PRE_DESTROY_ERROR = function (clazz, errorMessage) { + return "@preDestroy error in class " + clazz + ": " + errorMessage +} +var ON_DEACTIVATION_ERROR = function (clazz, errorMessage) { + return "onDeactivation() error in class " + clazz + ": " + errorMessage +} +var CIRCULAR_DEPENDENCY_IN_FACTORY = function (factoryType, serviceIdentifier) { + return ( + "It looks like there is a circular dependency in one of the '" + + factoryType + + "' bindings. Please investigate bindings with" + + ("service identifier '" + serviceIdentifier + "'.") + ) +} +var STACK_OVERFLOW = "Maximum call stack size exceeded" +var MetadataReader = (function () { + function MetadataReader2() {} + MetadataReader2.prototype.getConstructorMetadata = function (constructorFunc) { + var compilerGeneratedMetadata = Reflect.getMetadata(PARAM_TYPES, constructorFunc) + var userGeneratedMetadata = Reflect.getMetadata(TAGGED, constructorFunc) + return { + compilerGeneratedMetadata, + userGeneratedMetadata: userGeneratedMetadata || {}, + } + } + MetadataReader2.prototype.getPropertiesMetadata = function (constructorFunc) { + var userGeneratedMetadata = Reflect.getMetadata(TAGGED_PROP, constructorFunc) || [] + return userGeneratedMetadata + } + return MetadataReader2 +})() +var BindingCount = { + MultipleBindingsAvailable: 2, + NoBindingsAvailable: 0, + OnlyOneBindingAvailable: 1, +} +function isStackOverflowExeption(error2) { + return error2 instanceof RangeError || error2.message === STACK_OVERFLOW +} +var tryAndThrowErrorIfStackOverflow = function (fn, errorCallback) { + try { + return fn() + } catch (error2) { + if (isStackOverflowExeption(error2)) { + error2 = errorCallback() + } + throw error2 + } +} +function getServiceIdentifierAsString(serviceIdentifier) { + if (typeof serviceIdentifier === "function") { + var _serviceIdentifier = serviceIdentifier + return _serviceIdentifier.name + } else if (typeof serviceIdentifier === "symbol") { + return serviceIdentifier.toString() + } else { + var _serviceIdentifier = serviceIdentifier + return _serviceIdentifier + } +} +function listRegisteredBindingsForServiceIdentifier(container2, serviceIdentifier, getBindings2) { + var registeredBindingsList = "" + var registeredBindings = getBindings2(container2, serviceIdentifier) + if (registeredBindings.length !== 0) { + registeredBindingsList = "\nRegistered bindings:" + registeredBindings.forEach(function (binding) { + var name2 = "Object" + if (binding.implementationType !== null) { + name2 = getFunctionName(binding.implementationType) + } + registeredBindingsList = registeredBindingsList + "\n " + name2 + if (binding.constraint.metaData) { + registeredBindingsList = registeredBindingsList + " - " + binding.constraint.metaData + } + }) + } + return registeredBindingsList +} +function alreadyDependencyChain(request2, serviceIdentifier) { + if (request2.parentRequest === null) { + return false + } else if (request2.parentRequest.serviceIdentifier === serviceIdentifier) { + return true + } else { + return alreadyDependencyChain(request2.parentRequest, serviceIdentifier) + } +} +function dependencyChainToString(request2) { + function _createStringArr(req, result) { + if (result === void 0) { + result = [] + } + var serviceIdentifier = getServiceIdentifierAsString(req.serviceIdentifier) + result.push(serviceIdentifier) + if (req.parentRequest !== null) { + return _createStringArr(req.parentRequest, result) + } + return result + } + var stringArr = _createStringArr(request2) + return stringArr.reverse().join(" --> ") +} +function circularDependencyToException(request2) { + request2.childRequests.forEach(function (childRequest) { + if (alreadyDependencyChain(childRequest, childRequest.serviceIdentifier)) { + var services = dependencyChainToString(childRequest) + throw new Error(CIRCULAR_DEPENDENCY + " " + services) + } else { + circularDependencyToException(childRequest) + } + }) +} +function listMetadataForTarget(serviceIdentifierString, target) { + if (target.isTagged() || target.isNamed()) { + var m_1 = "" + var namedTag = target.getNamedTag() + var otherTags = target.getCustomTags() + if (namedTag !== null) { + m_1 += namedTag.toString() + "\n" + } + if (otherTags !== null) { + otherTags.forEach(function (tag) { + m_1 += tag.toString() + "\n" + }) + } + return " " + serviceIdentifierString + "\n " + serviceIdentifierString + " - " + m_1 + } else { + return " " + serviceIdentifierString + } +} +function getFunctionName(func) { + if (func.name) { + return func.name + } else { + var name_1 = func.toString() + var match = name_1.match(/^function\s*([^\s(]+)/) + return match ? match[1] : "Anonymous function: " + name_1 + } +} +function getSymbolDescription(symbol) { + return symbol.toString().slice(7, -1) +} +var Context = (function () { + function Context2(container2) { + this.id = id() + this.container = container2 + } + Context2.prototype.addPlan = function (plan2) { + this.plan = plan2 + } + Context2.prototype.setCurrentRequest = function (currentRequest) { + this.currentRequest = currentRequest + } + return Context2 +})() +var Metadata = (function () { + function Metadata2(key, value) { + this.key = key + this.value = value + } + Metadata2.prototype.toString = function () { + if (this.key === NAMED_TAG) { + return "named: " + String(this.value).toString() + " " + } else { + return "tagged: { key:" + this.key.toString() + ", value: " + String(this.value) + " }" + } + } + return Metadata2 +})() +var Plan = (function () { + function Plan2(parentContext, rootRequest) { + this.parentContext = parentContext + this.rootRequest = rootRequest + } + return Plan2 +})() +var LazyServiceIdentifer = (function () { + function LazyServiceIdentifer2(cb) { + this._cb = cb + } + LazyServiceIdentifer2.prototype.unwrap = function () { + return this._cb() + } + return LazyServiceIdentifer2 +})() +var QueryableString = (function () { + function QueryableString2(str) { + this.str = str + } + QueryableString2.prototype.startsWith = function (searchString) { + return this.str.indexOf(searchString) === 0 + } + QueryableString2.prototype.endsWith = function (searchString) { + var reverseString = "" + var reverseSearchString = searchString.split("").reverse().join("") + reverseString = this.str.split("").reverse().join("") + return this.startsWith.call({ str: reverseString }, reverseSearchString) + } + QueryableString2.prototype.contains = function (searchString) { + return this.str.indexOf(searchString) !== -1 + } + QueryableString2.prototype.equals = function (compareString) { + return this.str === compareString + } + QueryableString2.prototype.value = function () { + return this.str + } + return QueryableString2 +})() +var Target = (function () { + function Target2(type, identifier, serviceIdentifier, namedOrTagged) { + this.id = id() + this.type = type + this.serviceIdentifier = serviceIdentifier + var queryableName = typeof identifier === "symbol" ? getSymbolDescription(identifier) : identifier + this.name = new QueryableString(queryableName || "") + this.identifier = identifier + this.metadata = [] + var metadataItem = null + if (typeof namedOrTagged === "string") { + metadataItem = new Metadata(NAMED_TAG, namedOrTagged) + } else if (namedOrTagged instanceof Metadata) { + metadataItem = namedOrTagged + } + if (metadataItem !== null) { + this.metadata.push(metadataItem) + } + } + Target2.prototype.hasTag = function (key) { + for (var _i = 0, _a2 = this.metadata; _i < _a2.length; _i++) { + var m = _a2[_i] + if (m.key === key) { + return true + } + } + return false + } + Target2.prototype.isArray = function () { + return this.hasTag(MULTI_INJECT_TAG) + } + Target2.prototype.matchesArray = function (name2) { + return this.matchesTag(MULTI_INJECT_TAG)(name2) + } + Target2.prototype.isNamed = function () { + return this.hasTag(NAMED_TAG) + } + Target2.prototype.isTagged = function () { + return this.metadata.some(function (metadata) { + return NON_CUSTOM_TAG_KEYS.every(function (key) { + return metadata.key !== key + }) + }) + } + Target2.prototype.isOptional = function () { + return this.matchesTag(OPTIONAL_TAG)(true) + } + Target2.prototype.getNamedTag = function () { + if (this.isNamed()) { + return this.metadata.filter(function (m) { + return m.key === NAMED_TAG + })[0] + } + return null + } + Target2.prototype.getCustomTags = function () { + if (this.isTagged()) { + return this.metadata.filter(function (metadata) { + return NON_CUSTOM_TAG_KEYS.every(function (key) { + return metadata.key !== key + }) + }) + } else { + return null + } + } + Target2.prototype.matchesNamedTag = function (name2) { + return this.matchesTag(NAMED_TAG)(name2) + } + Target2.prototype.matchesTag = function (key) { + var _this = this + return function (value) { + for (var _i = 0, _a2 = _this.metadata; _i < _a2.length; _i++) { + var m = _a2[_i] + if (m.key === key && m.value === value) { + return true + } + } + return false + } + } + return Target2 +})() +var __spreadArray$2 = + (globalThis && globalThis.__spreadArray) || + function (to, from, pack) { + if (pack || arguments.length === 2) + for (var i = 0, l = from.length, ar; i < l; i++) { + if (ar || !(i in from)) { + if (!ar) ar = Array.prototype.slice.call(from, 0, i) + ar[i] = from[i] + } + } + return to.concat(ar || Array.prototype.slice.call(from)) + } +function getDependencies(metadataReader, func) { + var constructorName = getFunctionName(func) + return getTargets(metadataReader, constructorName, func, false) +} +function getTargets(metadataReader, constructorName, func, isBaseClass) { + var metadata = metadataReader.getConstructorMetadata(func) + var serviceIdentifiers = metadata.compilerGeneratedMetadata + if (serviceIdentifiers === void 0) { + var msg = MISSING_INJECTABLE_ANNOTATION + " " + constructorName + "." + throw new Error(msg) + } + var constructorArgsMetadata = metadata.userGeneratedMetadata + var keys = Object.keys(constructorArgsMetadata) + var hasUserDeclaredUnknownInjections = func.length === 0 && keys.length > 0 + var hasOptionalParameters = keys.length > func.length + var iterations = hasUserDeclaredUnknownInjections || hasOptionalParameters ? keys.length : func.length + var constructorTargets = getConstructorArgsAsTargets( + isBaseClass, + constructorName, + serviceIdentifiers, + constructorArgsMetadata, + iterations + ) + var propertyTargets = getClassPropsAsTargets(metadataReader, func, constructorName) + var targets = __spreadArray$2(__spreadArray$2([], constructorTargets, true), propertyTargets, true) + return targets +} +function getConstructorArgsAsTarget(index, isBaseClass, constructorName, serviceIdentifiers, constructorArgsMetadata) { + var targetMetadata = constructorArgsMetadata[index.toString()] || [] + var metadata = formatTargetMetadata(targetMetadata) + var isManaged = metadata.unmanaged !== true + var serviceIdentifier = serviceIdentifiers[index] + var injectIdentifier = metadata.inject || metadata.multiInject + serviceIdentifier = injectIdentifier ? injectIdentifier : serviceIdentifier + if (serviceIdentifier instanceof LazyServiceIdentifer) { + serviceIdentifier = serviceIdentifier.unwrap() + } + if (isManaged) { + var isObject2 = serviceIdentifier === Object + var isFunction2 = serviceIdentifier === Function + var isUndefined2 = serviceIdentifier === void 0 + var isUnknownType = isObject2 || isFunction2 || isUndefined2 + if (!isBaseClass && isUnknownType) { + var msg = MISSING_INJECT_ANNOTATION + " argument " + index + " in class " + constructorName + "." + throw new Error(msg) + } + var target = new Target(TargetTypeEnum.ConstructorArgument, metadata.targetName, serviceIdentifier) + target.metadata = targetMetadata + return target + } + return null +} +function getConstructorArgsAsTargets( + isBaseClass, + constructorName, + serviceIdentifiers, + constructorArgsMetadata, + iterations +) { + var targets = [] + for (var i = 0; i < iterations; i++) { + var index = i + var target = getConstructorArgsAsTarget( + index, + isBaseClass, + constructorName, + serviceIdentifiers, + constructorArgsMetadata + ) + if (target !== null) { + targets.push(target) + } + } + return targets +} +function _getServiceIdentifierForProperty(inject2, multiInject, propertyName, className) { + var serviceIdentifier = inject2 || multiInject + if (serviceIdentifier === void 0) { + var msg = MISSING_INJECTABLE_ANNOTATION + " for property " + String(propertyName) + " in class " + className + "." + throw new Error(msg) + } + return serviceIdentifier +} +function getClassPropsAsTargets(metadataReader, constructorFunc, constructorName) { + var classPropsMetadata = metadataReader.getPropertiesMetadata(constructorFunc) + var targets = [] + var symbolKeys = Object.getOwnPropertySymbols(classPropsMetadata) + var stringKeys = Object.keys(classPropsMetadata) + var keys = stringKeys.concat(symbolKeys) + for (var _i = 0, keys_1 = keys; _i < keys_1.length; _i++) { + var key = keys_1[_i] + var targetMetadata = classPropsMetadata[key] + var metadata = formatTargetMetadata(targetMetadata) + var identifier = metadata.targetName || key + var serviceIdentifier = _getServiceIdentifierForProperty( + metadata.inject, + metadata.multiInject, + key, + constructorName + ) + var target = new Target(TargetTypeEnum.ClassProperty, identifier, serviceIdentifier) + target.metadata = targetMetadata + targets.push(target) + } + var baseConstructor = Object.getPrototypeOf(constructorFunc.prototype).constructor + if (baseConstructor !== Object) { + var baseTargets = getClassPropsAsTargets(metadataReader, baseConstructor, constructorName) + targets = __spreadArray$2(__spreadArray$2([], targets, true), baseTargets, true) + } + return targets +} +function getBaseClassDependencyCount(metadataReader, func) { + var baseConstructor = Object.getPrototypeOf(func.prototype).constructor + if (baseConstructor !== Object) { + var baseConstructorName = getFunctionName(baseConstructor) + var targets = getTargets(metadataReader, baseConstructorName, baseConstructor, true) + var metadata = targets.map(function (t2) { + return t2.metadata.filter(function (m) { + return m.key === UNMANAGED_TAG + }) + }) + var unmanagedCount = [].concat.apply([], metadata).length + var dependencyCount = targets.length - unmanagedCount + if (dependencyCount > 0) { + return dependencyCount + } else { + return getBaseClassDependencyCount(metadataReader, baseConstructor) + } + } else { + return 0 + } +} +function formatTargetMetadata(targetMetadata) { + var targetMetadataMap = {} + targetMetadata.forEach(function (m) { + targetMetadataMap[m.key.toString()] = m.value + }) + return { + inject: targetMetadataMap[INJECT_TAG], + multiInject: targetMetadataMap[MULTI_INJECT_TAG], + targetName: targetMetadataMap[NAME_TAG], + unmanaged: targetMetadataMap[UNMANAGED_TAG], + } +} +var Request = (function () { + function Request2(serviceIdentifier, parentContext, parentRequest, bindings, target) { + this.id = id() + this.serviceIdentifier = serviceIdentifier + this.parentContext = parentContext + this.parentRequest = parentRequest + this.target = target + this.childRequests = [] + this.bindings = Array.isArray(bindings) ? bindings : [bindings] + this.requestScope = parentRequest === null ? /* @__PURE__ */ new Map() : null + } + Request2.prototype.addChildRequest = function (serviceIdentifier, bindings, target) { + var child = new Request2(serviceIdentifier, this.parentContext, this, bindings, target) + this.childRequests.push(child) + return child + } + return Request2 +})() +function getBindingDictionary(cntnr) { + return cntnr._bindingDictionary +} +function _createTarget(isMultiInject, targetType, serviceIdentifier, name2, key, value) { + var metadataKey = isMultiInject ? MULTI_INJECT_TAG : INJECT_TAG + var injectMetadata = new Metadata(metadataKey, serviceIdentifier) + var target = new Target(targetType, name2, serviceIdentifier, injectMetadata) + if (key !== void 0) { + var tagMetadata = new Metadata(key, value) + target.metadata.push(tagMetadata) + } + return target +} +function _getActiveBindings(metadataReader, avoidConstraints, context, parentRequest, target) { + var bindings = getBindings(context.container, target.serviceIdentifier) + var activeBindings = [] + if ( + bindings.length === BindingCount.NoBindingsAvailable && + context.container.options.autoBindInjectable && + typeof target.serviceIdentifier === "function" && + metadataReader.getConstructorMetadata(target.serviceIdentifier).compilerGeneratedMetadata + ) { + context.container.bind(target.serviceIdentifier).toSelf() + bindings = getBindings(context.container, target.serviceIdentifier) + } + if (!avoidConstraints) { + activeBindings = bindings.filter(function (binding) { + var request2 = new Request(binding.serviceIdentifier, context, parentRequest, binding, target) + return binding.constraint(request2) + }) + } else { + activeBindings = bindings + } + _validateActiveBindingCount(target.serviceIdentifier, activeBindings, target, context.container) + return activeBindings +} +function _validateActiveBindingCount(serviceIdentifier, bindings, target, container2) { + switch (bindings.length) { + case BindingCount.NoBindingsAvailable: + if (target.isOptional()) { + return bindings + } else { + var serviceIdentifierString = getServiceIdentifierAsString(serviceIdentifier) + var msg = NOT_REGISTERED + msg += listMetadataForTarget(serviceIdentifierString, target) + msg += listRegisteredBindingsForServiceIdentifier(container2, serviceIdentifierString, getBindings) + throw new Error(msg) + } + case BindingCount.OnlyOneBindingAvailable: + return bindings + case BindingCount.MultipleBindingsAvailable: + default: + if (!target.isArray()) { + var serviceIdentifierString = getServiceIdentifierAsString(serviceIdentifier) + var msg = AMBIGUOUS_MATCH + " " + serviceIdentifierString + msg += listRegisteredBindingsForServiceIdentifier(container2, serviceIdentifierString, getBindings) + throw new Error(msg) + } else { + return bindings + } + } +} +function _createSubRequests(metadataReader, avoidConstraints, serviceIdentifier, context, parentRequest, target) { + var activeBindings + var childRequest + if (parentRequest === null) { + activeBindings = _getActiveBindings(metadataReader, avoidConstraints, context, null, target) + childRequest = new Request(serviceIdentifier, context, null, activeBindings, target) + var thePlan = new Plan(context, childRequest) + context.addPlan(thePlan) + } else { + activeBindings = _getActiveBindings(metadataReader, avoidConstraints, context, parentRequest, target) + childRequest = parentRequest.addChildRequest(target.serviceIdentifier, activeBindings, target) + } + activeBindings.forEach(function (binding) { + var subChildRequest = null + if (target.isArray()) { + subChildRequest = childRequest.addChildRequest(binding.serviceIdentifier, binding, target) + } else { + if (binding.cache) { + return + } + subChildRequest = childRequest + } + if (binding.type === BindingTypeEnum.Instance && binding.implementationType !== null) { + var dependencies = getDependencies(metadataReader, binding.implementationType) + if (!context.container.options.skipBaseClassChecks) { + var baseClassDependencyCount = getBaseClassDependencyCount(metadataReader, binding.implementationType) + if (dependencies.length < baseClassDependencyCount) { + var error2 = ARGUMENTS_LENGTH_MISMATCH(getFunctionName(binding.implementationType)) + throw new Error(error2) + } + } + dependencies.forEach(function (dependency) { + _createSubRequests(metadataReader, false, dependency.serviceIdentifier, context, subChildRequest, dependency) + }) + } + }) +} +function getBindings(container2, serviceIdentifier) { + var bindings = [] + var bindingDictionary = getBindingDictionary(container2) + if (bindingDictionary.hasKey(serviceIdentifier)) { + bindings = bindingDictionary.get(serviceIdentifier) + } else if (container2.parent !== null) { + bindings = getBindings(container2.parent, serviceIdentifier) + } + return bindings +} +function plan(metadataReader, container2, isMultiInject, targetType, serviceIdentifier, key, value, avoidConstraints) { + if (avoidConstraints === void 0) { + avoidConstraints = false + } + var context = new Context(container2) + var target = _createTarget(isMultiInject, targetType, serviceIdentifier, "", key, value) + try { + _createSubRequests(metadataReader, avoidConstraints, serviceIdentifier, context, null, target) + return context + } catch (error2) { + if (isStackOverflowExeption(error2)) { + circularDependencyToException(context.plan.rootRequest) + } + throw error2 + } +} +function createMockRequest(container2, serviceIdentifier, key, value) { + var target = new Target(TargetTypeEnum.Variable, "", serviceIdentifier, new Metadata(key, value)) + var context = new Context(container2) + var request2 = new Request(serviceIdentifier, context, null, [], target) + return request2 +} +function isPromise(object) { + var isObjectOrFunction = (typeof object === "object" && object !== null) || typeof object === "function" + return isObjectOrFunction && typeof object.then === "function" +} +function isPromiseOrContainsPromise(object) { + if (isPromise(object)) { + return true + } + return Array.isArray(object) && object.some(isPromise) +} +var __awaiter$3 = + (globalThis && globalThis.__awaiter) || + function (thisArg, _arguments, P2, generator) { + function adopt(value) { + return value instanceof P2 + ? value + : new P2(function (resolve2) { + resolve2(value) + }) + } + return new (P2 || (P2 = Promise))(function (resolve2, reject) { + function fulfilled(value) { + try { + step(generator.next(value)) + } catch (e) { + reject(e) + } + } + function rejected(value) { + try { + step(generator["throw"](value)) + } catch (e) { + reject(e) + } + } + function step(result) { + result.done ? resolve2(result.value) : adopt(result.value).then(fulfilled, rejected) + } + step((generator = generator.apply(thisArg, _arguments || [])).next()) + }) + } +var __generator$3 = + (globalThis && globalThis.__generator) || + function (thisArg, body) { + var _2 = { + label: 0, + sent: function () { + if (t2[0] & 1) throw t2[1] + return t2[1] + }, + trys: [], + ops: [], + }, + f, + y, + t2, + g + return ( + (g = { next: verb(0), throw: verb(1), return: verb(2) }), + typeof Symbol === "function" && + (g[Symbol.iterator] = function () { + return this + }), + g + ) + function verb(n) { + return function (v) { + return step([n, v]) + } + } + function step(op) { + if (f) throw new TypeError("Generator is already executing.") + while (_2) + try { + if ( + ((f = 1), + y && + (t2 = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t2 = y["return"]) && t2.call(y), 0) : y.next) && + !(t2 = t2.call(y, op[1])).done) + ) + return t2 + if (((y = 0), t2)) op = [op[0] & 2, t2.value] + switch (op[0]) { + case 0: + case 1: + t2 = op + break + case 4: + _2.label++ + return { value: op[1], done: false } + case 5: + _2.label++ + y = op[1] + op = [0] + continue + case 7: + op = _2.ops.pop() + _2.trys.pop() + continue + default: + if (!((t2 = _2.trys), (t2 = t2.length > 0 && t2[t2.length - 1])) && (op[0] === 6 || op[0] === 2)) { + _2 = 0 + continue + } + if (op[0] === 3 && (!t2 || (op[1] > t2[0] && op[1] < t2[3]))) { + _2.label = op[1] + break + } + if (op[0] === 6 && _2.label < t2[1]) { + _2.label = t2[1] + t2 = op + break + } + if (t2 && _2.label < t2[2]) { + _2.label = t2[2] + _2.ops.push(op) + break + } + if (t2[2]) _2.ops.pop() + _2.trys.pop() + continue + } + op = body.call(thisArg, _2) + } catch (e) { + op = [6, e] + y = 0 + } finally { + f = t2 = 0 + } + if (op[0] & 5) throw op[1] + return { value: op[0] ? op[1] : void 0, done: true } + } + } +var tryGetFromScope = function (requestScope, binding) { + if (binding.scope === BindingScopeEnum.Singleton && binding.activated) { + return binding.cache + } + if (binding.scope === BindingScopeEnum.Request && requestScope.has(binding.id)) { + return requestScope.get(binding.id) + } + return null +} +var saveToScope = function (requestScope, binding, result) { + if (binding.scope === BindingScopeEnum.Singleton) { + _saveToSingletonScope(binding, result) + } + if (binding.scope === BindingScopeEnum.Request) { + _saveToRequestScope(requestScope, binding, result) + } +} +var _saveToRequestScope = function (requestScope, binding, result) { + if (!requestScope.has(binding.id)) { + requestScope.set(binding.id, result) + } +} +var _saveToSingletonScope = function (binding, result) { + binding.cache = result + binding.activated = true + if (isPromise(result)) { + void _saveAsyncResultToSingletonScope(binding, result) + } +} +var _saveAsyncResultToSingletonScope = function (binding, asyncResult) { + return __awaiter$3(void 0, void 0, void 0, function () { + var result, ex_1 + return __generator$3(this, function (_a2) { + switch (_a2.label) { + case 0: + _a2.trys.push([0, 2, , 3]) + return [4, asyncResult] + case 1: + result = _a2.sent() + binding.cache = result + return [3, 3] + case 2: + ex_1 = _a2.sent() + binding.cache = null + binding.activated = false + throw ex_1 + case 3: + return [2] + } + }) + }) +} +var FactoryType +;(function (FactoryType2) { + FactoryType2["DynamicValue"] = "toDynamicValue" + FactoryType2["Factory"] = "toFactory" + FactoryType2["Provider"] = "toProvider" +})(FactoryType || (FactoryType = {})) +var ensureFullyBound = function (binding) { + var boundValue = null + switch (binding.type) { + case BindingTypeEnum.ConstantValue: + case BindingTypeEnum.Function: + boundValue = binding.cache + break + case BindingTypeEnum.Constructor: + case BindingTypeEnum.Instance: + boundValue = binding.implementationType + break + case BindingTypeEnum.DynamicValue: + boundValue = binding.dynamicValue + break + case BindingTypeEnum.Provider: + boundValue = binding.provider + break + case BindingTypeEnum.Factory: + boundValue = binding.factory + break + } + if (boundValue === null) { + var serviceIdentifierAsString = getServiceIdentifierAsString(binding.serviceIdentifier) + throw new Error(INVALID_BINDING_TYPE + " " + serviceIdentifierAsString) + } +} +var getFactoryDetails = function (binding) { + switch (binding.type) { + case BindingTypeEnum.Factory: + return { factory: binding.factory, factoryType: FactoryType.Factory } + case BindingTypeEnum.Provider: + return { factory: binding.provider, factoryType: FactoryType.Provider } + case BindingTypeEnum.DynamicValue: + return { factory: binding.dynamicValue, factoryType: FactoryType.DynamicValue } + default: + throw new Error("Unexpected factory type " + binding.type) + } +} +var __assign$1 = + (globalThis && globalThis.__assign) || + function () { + __assign$1 = + Object.assign || + function (t2) { + for (var s, i = 1, n = arguments.length; i < n; i++) { + s = arguments[i] + for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t2[p] = s[p] + } + return t2 + } + return __assign$1.apply(this, arguments) + } +var __awaiter$2 = + (globalThis && globalThis.__awaiter) || + function (thisArg, _arguments, P2, generator) { + function adopt(value) { + return value instanceof P2 + ? value + : new P2(function (resolve2) { + resolve2(value) + }) + } + return new (P2 || (P2 = Promise))(function (resolve2, reject) { + function fulfilled(value) { + try { + step(generator.next(value)) + } catch (e) { + reject(e) + } + } + function rejected(value) { + try { + step(generator["throw"](value)) + } catch (e) { + reject(e) + } + } + function step(result) { + result.done ? resolve2(result.value) : adopt(result.value).then(fulfilled, rejected) + } + step((generator = generator.apply(thisArg, _arguments || [])).next()) + }) + } +var __generator$2 = + (globalThis && globalThis.__generator) || + function (thisArg, body) { + var _2 = { + label: 0, + sent: function () { + if (t2[0] & 1) throw t2[1] + return t2[1] + }, + trys: [], + ops: [], + }, + f, + y, + t2, + g + return ( + (g = { next: verb(0), throw: verb(1), return: verb(2) }), + typeof Symbol === "function" && + (g[Symbol.iterator] = function () { + return this + }), + g + ) + function verb(n) { + return function (v) { + return step([n, v]) + } + } + function step(op) { + if (f) throw new TypeError("Generator is already executing.") + while (_2) + try { + if ( + ((f = 1), + y && + (t2 = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t2 = y["return"]) && t2.call(y), 0) : y.next) && + !(t2 = t2.call(y, op[1])).done) + ) + return t2 + if (((y = 0), t2)) op = [op[0] & 2, t2.value] + switch (op[0]) { + case 0: + case 1: + t2 = op + break + case 4: + _2.label++ + return { value: op[1], done: false } + case 5: + _2.label++ + y = op[1] + op = [0] + continue + case 7: + op = _2.ops.pop() + _2.trys.pop() + continue + default: + if (!((t2 = _2.trys), (t2 = t2.length > 0 && t2[t2.length - 1])) && (op[0] === 6 || op[0] === 2)) { + _2 = 0 + continue + } + if (op[0] === 3 && (!t2 || (op[1] > t2[0] && op[1] < t2[3]))) { + _2.label = op[1] + break + } + if (op[0] === 6 && _2.label < t2[1]) { + _2.label = t2[1] + t2 = op + break + } + if (t2 && _2.label < t2[2]) { + _2.label = t2[2] + _2.ops.push(op) + break + } + if (t2[2]) _2.ops.pop() + _2.trys.pop() + continue + } + op = body.call(thisArg, _2) + } catch (e) { + op = [6, e] + y = 0 + } finally { + f = t2 = 0 + } + if (op[0] & 5) throw op[1] + return { value: op[0] ? op[1] : void 0, done: true } + } + } +var __spreadArray$1 = + (globalThis && globalThis.__spreadArray) || + function (to, from, pack) { + if (pack || arguments.length === 2) + for (var i = 0, l = from.length, ar; i < l; i++) { + if (ar || !(i in from)) { + if (!ar) ar = Array.prototype.slice.call(from, 0, i) + ar[i] = from[i] + } + } + return to.concat(ar || Array.prototype.slice.call(from)) + } +function _resolveRequests(childRequests, resolveRequest) { + return childRequests.reduce( + function (resolvedRequests, childRequest) { + var injection = resolveRequest(childRequest) + var targetType = childRequest.target.type + if (targetType === TargetTypeEnum.ConstructorArgument) { + resolvedRequests.constructorInjections.push(injection) + } else { + resolvedRequests.propertyRequests.push(childRequest) + resolvedRequests.propertyInjections.push(injection) + } + if (!resolvedRequests.isAsync) { + resolvedRequests.isAsync = isPromiseOrContainsPromise(injection) + } + return resolvedRequests + }, + { constructorInjections: [], propertyInjections: [], propertyRequests: [], isAsync: false } + ) +} +function _createInstance(constr, childRequests, resolveRequest) { + var result + if (childRequests.length > 0) { + var resolved = _resolveRequests(childRequests, resolveRequest) + var createInstanceWithInjectionsArg = __assign$1(__assign$1({}, resolved), { constr }) + if (resolved.isAsync) { + result = createInstanceWithInjectionsAsync(createInstanceWithInjectionsArg) + } else { + result = createInstanceWithInjections(createInstanceWithInjectionsArg) + } + } else { + result = new constr() + } + return result +} +function createInstanceWithInjections(args) { + var _a2 + var instance2 = new ((_a2 = args.constr).bind.apply( + _a2, + __spreadArray$1([void 0], args.constructorInjections, false) + ))() + args.propertyRequests.forEach(function (r, index) { + var property = r.target.identifier + var injection = args.propertyInjections[index] + instance2[property] = injection + }) + return instance2 +} +function createInstanceWithInjectionsAsync(args) { + return __awaiter$2(this, void 0, void 0, function () { + var constructorInjections, propertyInjections + return __generator$2(this, function (_a2) { + switch (_a2.label) { + case 0: + return [4, possiblyWaitInjections(args.constructorInjections)] + case 1: + constructorInjections = _a2.sent() + return [4, possiblyWaitInjections(args.propertyInjections)] + case 2: + propertyInjections = _a2.sent() + return [ + 2, + createInstanceWithInjections( + __assign$1(__assign$1({}, args), { constructorInjections, propertyInjections }) + ), + ] + } + }) + }) +} +function possiblyWaitInjections(possiblePromiseinjections) { + return __awaiter$2(this, void 0, void 0, function () { + var injections, _i, possiblePromiseinjections_1, injection + return __generator$2(this, function (_a2) { + injections = [] + for ( + _i = 0, possiblePromiseinjections_1 = possiblePromiseinjections; + _i < possiblePromiseinjections_1.length; + _i++ + ) { + injection = possiblePromiseinjections_1[_i] + if (Array.isArray(injection)) { + injections.push(Promise.all(injection)) + } else { + injections.push(injection) + } + } + return [2, Promise.all(injections)] + }) + }) +} +function _getInstanceAfterPostConstruct(constr, result) { + var postConstructResult = _postConstruct(constr, result) + if (isPromise(postConstructResult)) { + return postConstructResult.then(function () { + return result + }) + } else { + return result + } +} +function _postConstruct(constr, instance2) { + var _a2, _b + if (Reflect.hasMetadata(POST_CONSTRUCT, constr)) { + var data = Reflect.getMetadata(POST_CONSTRUCT, constr) + try { + return (_b = (_a2 = instance2)[data.value]) === null || _b === void 0 ? void 0 : _b.call(_a2) + } catch (e) { + throw new Error(POST_CONSTRUCT_ERROR(constr.name, e.message)) + } + } +} +function _validateInstanceResolution(binding, constr) { + if (binding.scope !== BindingScopeEnum.Singleton) { + _throwIfHandlingDeactivation(binding, constr) + } +} +function _throwIfHandlingDeactivation(binding, constr) { + var scopeErrorMessage = + "Class cannot be instantiated in " + + (binding.scope === BindingScopeEnum.Request ? "request" : "transient") + + " scope." + if (typeof binding.onDeactivation === "function") { + throw new Error(ON_DEACTIVATION_ERROR(constr.name, scopeErrorMessage)) + } + if (Reflect.hasMetadata(PRE_DESTROY, constr)) { + throw new Error(PRE_DESTROY_ERROR(constr.name, scopeErrorMessage)) + } +} +function resolveInstance(binding, constr, childRequests, resolveRequest) { + _validateInstanceResolution(binding, constr) + var result = _createInstance(constr, childRequests, resolveRequest) + if (isPromise(result)) { + return result.then(function (resolvedResult) { + return _getInstanceAfterPostConstruct(constr, resolvedResult) + }) + } else { + return _getInstanceAfterPostConstruct(constr, result) + } +} +var __awaiter$1 = + (globalThis && globalThis.__awaiter) || + function (thisArg, _arguments, P2, generator) { + function adopt(value) { + return value instanceof P2 + ? value + : new P2(function (resolve2) { + resolve2(value) + }) + } + return new (P2 || (P2 = Promise))(function (resolve2, reject) { + function fulfilled(value) { + try { + step(generator.next(value)) + } catch (e) { + reject(e) + } + } + function rejected(value) { + try { + step(generator["throw"](value)) + } catch (e) { + reject(e) + } + } + function step(result) { + result.done ? resolve2(result.value) : adopt(result.value).then(fulfilled, rejected) + } + step((generator = generator.apply(thisArg, _arguments || [])).next()) + }) + } +var __generator$1 = + (globalThis && globalThis.__generator) || + function (thisArg, body) { + var _2 = { + label: 0, + sent: function () { + if (t2[0] & 1) throw t2[1] + return t2[1] + }, + trys: [], + ops: [], + }, + f, + y, + t2, + g + return ( + (g = { next: verb(0), throw: verb(1), return: verb(2) }), + typeof Symbol === "function" && + (g[Symbol.iterator] = function () { + return this + }), + g + ) + function verb(n) { + return function (v) { + return step([n, v]) + } + } + function step(op) { + if (f) throw new TypeError("Generator is already executing.") + while (_2) + try { + if ( + ((f = 1), + y && + (t2 = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t2 = y["return"]) && t2.call(y), 0) : y.next) && + !(t2 = t2.call(y, op[1])).done) + ) + return t2 + if (((y = 0), t2)) op = [op[0] & 2, t2.value] + switch (op[0]) { + case 0: + case 1: + t2 = op + break + case 4: + _2.label++ + return { value: op[1], done: false } + case 5: + _2.label++ + y = op[1] + op = [0] + continue + case 7: + op = _2.ops.pop() + _2.trys.pop() + continue + default: + if (!((t2 = _2.trys), (t2 = t2.length > 0 && t2[t2.length - 1])) && (op[0] === 6 || op[0] === 2)) { + _2 = 0 + continue + } + if (op[0] === 3 && (!t2 || (op[1] > t2[0] && op[1] < t2[3]))) { + _2.label = op[1] + break + } + if (op[0] === 6 && _2.label < t2[1]) { + _2.label = t2[1] + t2 = op + break + } + if (t2 && _2.label < t2[2]) { + _2.label = t2[2] + _2.ops.push(op) + break + } + if (t2[2]) _2.ops.pop() + _2.trys.pop() + continue + } + op = body.call(thisArg, _2) + } catch (e) { + op = [6, e] + y = 0 + } finally { + f = t2 = 0 + } + if (op[0] & 5) throw op[1] + return { value: op[0] ? op[1] : void 0, done: true } + } + } +var _resolveRequest = function (requestScope) { + return function (request2) { + request2.parentContext.setCurrentRequest(request2) + var bindings = request2.bindings + var childRequests = request2.childRequests + var targetIsAnArray = request2.target && request2.target.isArray() + var targetParentIsNotAnArray = + !request2.parentRequest || + !request2.parentRequest.target || + !request2.target || + !request2.parentRequest.target.matchesArray(request2.target.serviceIdentifier) + if (targetIsAnArray && targetParentIsNotAnArray) { + return childRequests.map(function (childRequest) { + var _f = _resolveRequest(requestScope) + return _f(childRequest) + }) + } else { + if (request2.target.isOptional() && bindings.length === 0) { + return void 0 + } + var binding = bindings[0] + return _resolveBinding(requestScope, request2, binding) + } + } +} +var _resolveFactoryFromBinding = function (binding, context) { + var factoryDetails = getFactoryDetails(binding) + return tryAndThrowErrorIfStackOverflow( + function () { + return factoryDetails.factory.bind(binding)(context) + }, + function () { + return new Error( + CIRCULAR_DEPENDENCY_IN_FACTORY(factoryDetails.factoryType, context.currentRequest.serviceIdentifier.toString()) + ) + } + ) +} +var _getResolvedFromBinding = function (requestScope, request2, binding) { + var result + var childRequests = request2.childRequests + ensureFullyBound(binding) + switch (binding.type) { + case BindingTypeEnum.ConstantValue: + case BindingTypeEnum.Function: + result = binding.cache + break + case BindingTypeEnum.Constructor: + result = binding.implementationType + break + case BindingTypeEnum.Instance: + result = resolveInstance(binding, binding.implementationType, childRequests, _resolveRequest(requestScope)) + break + default: + result = _resolveFactoryFromBinding(binding, request2.parentContext) + } + return result +} +var _resolveInScope = function (requestScope, binding, resolveFromBinding) { + var result = tryGetFromScope(requestScope, binding) + if (result !== null) { + return result + } + result = resolveFromBinding() + saveToScope(requestScope, binding, result) + return result +} +var _resolveBinding = function (requestScope, request2, binding) { + return _resolveInScope(requestScope, binding, function () { + var result = _getResolvedFromBinding(requestScope, request2, binding) + if (isPromise(result)) { + result = result.then(function (resolved) { + return _onActivation(request2, binding, resolved) + }) + } else { + result = _onActivation(request2, binding, result) + } + return result + }) +} +function _onActivation(request2, binding, resolved) { + var result = _bindingActivation(request2.parentContext, binding, resolved) + var containersIterator = _getContainersIterator(request2.parentContext.container) + var container2 + var containersIteratorResult = containersIterator.next() + do { + container2 = containersIteratorResult.value + var context_1 = request2.parentContext + var serviceIdentifier = request2.serviceIdentifier + var activationsIterator = _getContainerActivationsForService(container2, serviceIdentifier) + if (isPromise(result)) { + result = _activateContainerAsync(activationsIterator, context_1, result) + } else { + result = _activateContainer(activationsIterator, context_1, result) + } + containersIteratorResult = containersIterator.next() + } while ( + containersIteratorResult.done !== true && + !getBindingDictionary(container2).hasKey(request2.serviceIdentifier) + ) + return result +} +var _bindingActivation = function (context, binding, previousResult) { + var result + if (typeof binding.onActivation === "function") { + result = binding.onActivation(context, previousResult) + } else { + result = previousResult + } + return result +} +var _activateContainer = function (activationsIterator, context, result) { + var activation = activationsIterator.next() + while (!activation.done) { + result = activation.value(context, result) + if (isPromise(result)) { + return _activateContainerAsync(activationsIterator, context, result) + } + activation = activationsIterator.next() + } + return result +} +var _activateContainerAsync = function (activationsIterator, context, resultPromise) { + return __awaiter$1(void 0, void 0, void 0, function () { + var result, activation + return __generator$1(this, function (_a2) { + switch (_a2.label) { + case 0: + return [4, resultPromise] + case 1: + result = _a2.sent() + activation = activationsIterator.next() + _a2.label = 2 + case 2: + if (activation.done) return [3, 4] + return [4, activation.value(context, result)] + case 3: + result = _a2.sent() + activation = activationsIterator.next() + return [3, 2] + case 4: + return [2, result] + } + }) + }) +} +var _getContainerActivationsForService = function (container2, serviceIdentifier) { + var activations = container2._activations + return activations.hasKey(serviceIdentifier) ? activations.get(serviceIdentifier).values() : [].values() +} +var _getContainersIterator = function (container2) { + var containersStack = [container2] + var parent = container2.parent + while (parent !== null) { + containersStack.push(parent) + parent = parent.parent + } + var getNextContainer = function () { + var nextContainer = containersStack.pop() + if (nextContainer !== void 0) { + return { done: false, value: nextContainer } + } else { + return { done: true, value: void 0 } + } + } + var containersIterator = { + next: getNextContainer, + } + return containersIterator +} +function resolve(context) { + var _f = _resolveRequest(context.plan.rootRequest.requestScope) + return _f(context.plan.rootRequest) +} +var traverseAncerstors = function (request2, constraint) { + var parent = request2.parentRequest + if (parent !== null) { + return constraint(parent) ? true : traverseAncerstors(parent, constraint) + } else { + return false + } +} +var taggedConstraint = function (key) { + return function (value) { + var constraint = function (request2) { + return request2 !== null && request2.target !== null && request2.target.matchesTag(key)(value) + } + constraint.metaData = new Metadata(key, value) + return constraint + } +} +var namedConstraint = taggedConstraint(NAMED_TAG) +var typeConstraint = function (type) { + return function (request2) { + var binding = null + if (request2 !== null) { + binding = request2.bindings[0] + if (typeof type === "string") { + var serviceIdentifier = binding.serviceIdentifier + return serviceIdentifier === type + } else { + var constructor = request2.bindings[0].implementationType + return type === constructor + } + } + return false + } +} +var BindingWhenSyntax = (function () { + function BindingWhenSyntax2(binding) { + this._binding = binding + } + BindingWhenSyntax2.prototype.when = function (constraint) { + this._binding.constraint = constraint + return new BindingOnSyntax(this._binding) + } + BindingWhenSyntax2.prototype.whenTargetNamed = function (name2) { + this._binding.constraint = namedConstraint(name2) + return new BindingOnSyntax(this._binding) + } + BindingWhenSyntax2.prototype.whenTargetIsDefault = function () { + this._binding.constraint = function (request2) { + if (request2 === null) { + return false + } + var targetIsDefault = request2.target !== null && !request2.target.isNamed() && !request2.target.isTagged() + return targetIsDefault + } + return new BindingOnSyntax(this._binding) + } + BindingWhenSyntax2.prototype.whenTargetTagged = function (tag, value) { + this._binding.constraint = taggedConstraint(tag)(value) + return new BindingOnSyntax(this._binding) + } + BindingWhenSyntax2.prototype.whenInjectedInto = function (parent) { + this._binding.constraint = function (request2) { + return request2 !== null && typeConstraint(parent)(request2.parentRequest) + } + return new BindingOnSyntax(this._binding) + } + BindingWhenSyntax2.prototype.whenParentNamed = function (name2) { + this._binding.constraint = function (request2) { + return request2 !== null && namedConstraint(name2)(request2.parentRequest) + } + return new BindingOnSyntax(this._binding) + } + BindingWhenSyntax2.prototype.whenParentTagged = function (tag, value) { + this._binding.constraint = function (request2) { + return request2 !== null && taggedConstraint(tag)(value)(request2.parentRequest) + } + return new BindingOnSyntax(this._binding) + } + BindingWhenSyntax2.prototype.whenAnyAncestorIs = function (ancestor) { + this._binding.constraint = function (request2) { + return request2 !== null && traverseAncerstors(request2, typeConstraint(ancestor)) + } + return new BindingOnSyntax(this._binding) + } + BindingWhenSyntax2.prototype.whenNoAncestorIs = function (ancestor) { + this._binding.constraint = function (request2) { + return request2 !== null && !traverseAncerstors(request2, typeConstraint(ancestor)) + } + return new BindingOnSyntax(this._binding) + } + BindingWhenSyntax2.prototype.whenAnyAncestorNamed = function (name2) { + this._binding.constraint = function (request2) { + return request2 !== null && traverseAncerstors(request2, namedConstraint(name2)) + } + return new BindingOnSyntax(this._binding) + } + BindingWhenSyntax2.prototype.whenNoAncestorNamed = function (name2) { + this._binding.constraint = function (request2) { + return request2 !== null && !traverseAncerstors(request2, namedConstraint(name2)) + } + return new BindingOnSyntax(this._binding) + } + BindingWhenSyntax2.prototype.whenAnyAncestorTagged = function (tag, value) { + this._binding.constraint = function (request2) { + return request2 !== null && traverseAncerstors(request2, taggedConstraint(tag)(value)) + } + return new BindingOnSyntax(this._binding) + } + BindingWhenSyntax2.prototype.whenNoAncestorTagged = function (tag, value) { + this._binding.constraint = function (request2) { + return request2 !== null && !traverseAncerstors(request2, taggedConstraint(tag)(value)) + } + return new BindingOnSyntax(this._binding) + } + BindingWhenSyntax2.prototype.whenAnyAncestorMatches = function (constraint) { + this._binding.constraint = function (request2) { + return request2 !== null && traverseAncerstors(request2, constraint) + } + return new BindingOnSyntax(this._binding) + } + BindingWhenSyntax2.prototype.whenNoAncestorMatches = function (constraint) { + this._binding.constraint = function (request2) { + return request2 !== null && !traverseAncerstors(request2, constraint) + } + return new BindingOnSyntax(this._binding) + } + return BindingWhenSyntax2 +})() +var BindingOnSyntax = (function () { + function BindingOnSyntax2(binding) { + this._binding = binding + } + BindingOnSyntax2.prototype.onActivation = function (handler) { + this._binding.onActivation = handler + return new BindingWhenSyntax(this._binding) + } + BindingOnSyntax2.prototype.onDeactivation = function (handler) { + this._binding.onDeactivation = handler + return new BindingWhenSyntax(this._binding) + } + return BindingOnSyntax2 +})() +var BindingWhenOnSyntax = (function () { + function BindingWhenOnSyntax2(binding) { + this._binding = binding + this._bindingWhenSyntax = new BindingWhenSyntax(this._binding) + this._bindingOnSyntax = new BindingOnSyntax(this._binding) + } + BindingWhenOnSyntax2.prototype.when = function (constraint) { + return this._bindingWhenSyntax.when(constraint) + } + BindingWhenOnSyntax2.prototype.whenTargetNamed = function (name2) { + return this._bindingWhenSyntax.whenTargetNamed(name2) + } + BindingWhenOnSyntax2.prototype.whenTargetIsDefault = function () { + return this._bindingWhenSyntax.whenTargetIsDefault() + } + BindingWhenOnSyntax2.prototype.whenTargetTagged = function (tag, value) { + return this._bindingWhenSyntax.whenTargetTagged(tag, value) + } + BindingWhenOnSyntax2.prototype.whenInjectedInto = function (parent) { + return this._bindingWhenSyntax.whenInjectedInto(parent) + } + BindingWhenOnSyntax2.prototype.whenParentNamed = function (name2) { + return this._bindingWhenSyntax.whenParentNamed(name2) + } + BindingWhenOnSyntax2.prototype.whenParentTagged = function (tag, value) { + return this._bindingWhenSyntax.whenParentTagged(tag, value) + } + BindingWhenOnSyntax2.prototype.whenAnyAncestorIs = function (ancestor) { + return this._bindingWhenSyntax.whenAnyAncestorIs(ancestor) + } + BindingWhenOnSyntax2.prototype.whenNoAncestorIs = function (ancestor) { + return this._bindingWhenSyntax.whenNoAncestorIs(ancestor) + } + BindingWhenOnSyntax2.prototype.whenAnyAncestorNamed = function (name2) { + return this._bindingWhenSyntax.whenAnyAncestorNamed(name2) + } + BindingWhenOnSyntax2.prototype.whenAnyAncestorTagged = function (tag, value) { + return this._bindingWhenSyntax.whenAnyAncestorTagged(tag, value) + } + BindingWhenOnSyntax2.prototype.whenNoAncestorNamed = function (name2) { + return this._bindingWhenSyntax.whenNoAncestorNamed(name2) + } + BindingWhenOnSyntax2.prototype.whenNoAncestorTagged = function (tag, value) { + return this._bindingWhenSyntax.whenNoAncestorTagged(tag, value) + } + BindingWhenOnSyntax2.prototype.whenAnyAncestorMatches = function (constraint) { + return this._bindingWhenSyntax.whenAnyAncestorMatches(constraint) + } + BindingWhenOnSyntax2.prototype.whenNoAncestorMatches = function (constraint) { + return this._bindingWhenSyntax.whenNoAncestorMatches(constraint) + } + BindingWhenOnSyntax2.prototype.onActivation = function (handler) { + return this._bindingOnSyntax.onActivation(handler) + } + BindingWhenOnSyntax2.prototype.onDeactivation = function (handler) { + return this._bindingOnSyntax.onDeactivation(handler) + } + return BindingWhenOnSyntax2 +})() +var BindingInSyntax = (function () { + function BindingInSyntax2(binding) { + this._binding = binding + } + BindingInSyntax2.prototype.inRequestScope = function () { + this._binding.scope = BindingScopeEnum.Request + return new BindingWhenOnSyntax(this._binding) + } + BindingInSyntax2.prototype.inSingletonScope = function () { + this._binding.scope = BindingScopeEnum.Singleton + return new BindingWhenOnSyntax(this._binding) + } + BindingInSyntax2.prototype.inTransientScope = function () { + this._binding.scope = BindingScopeEnum.Transient + return new BindingWhenOnSyntax(this._binding) + } + return BindingInSyntax2 +})() +var BindingInWhenOnSyntax = (function () { + function BindingInWhenOnSyntax2(binding) { + this._binding = binding + this._bindingWhenSyntax = new BindingWhenSyntax(this._binding) + this._bindingOnSyntax = new BindingOnSyntax(this._binding) + this._bindingInSyntax = new BindingInSyntax(binding) + } + BindingInWhenOnSyntax2.prototype.inRequestScope = function () { + return this._bindingInSyntax.inRequestScope() + } + BindingInWhenOnSyntax2.prototype.inSingletonScope = function () { + return this._bindingInSyntax.inSingletonScope() + } + BindingInWhenOnSyntax2.prototype.inTransientScope = function () { + return this._bindingInSyntax.inTransientScope() + } + BindingInWhenOnSyntax2.prototype.when = function (constraint) { + return this._bindingWhenSyntax.when(constraint) + } + BindingInWhenOnSyntax2.prototype.whenTargetNamed = function (name2) { + return this._bindingWhenSyntax.whenTargetNamed(name2) + } + BindingInWhenOnSyntax2.prototype.whenTargetIsDefault = function () { + return this._bindingWhenSyntax.whenTargetIsDefault() + } + BindingInWhenOnSyntax2.prototype.whenTargetTagged = function (tag, value) { + return this._bindingWhenSyntax.whenTargetTagged(tag, value) + } + BindingInWhenOnSyntax2.prototype.whenInjectedInto = function (parent) { + return this._bindingWhenSyntax.whenInjectedInto(parent) + } + BindingInWhenOnSyntax2.prototype.whenParentNamed = function (name2) { + return this._bindingWhenSyntax.whenParentNamed(name2) + } + BindingInWhenOnSyntax2.prototype.whenParentTagged = function (tag, value) { + return this._bindingWhenSyntax.whenParentTagged(tag, value) + } + BindingInWhenOnSyntax2.prototype.whenAnyAncestorIs = function (ancestor) { + return this._bindingWhenSyntax.whenAnyAncestorIs(ancestor) + } + BindingInWhenOnSyntax2.prototype.whenNoAncestorIs = function (ancestor) { + return this._bindingWhenSyntax.whenNoAncestorIs(ancestor) + } + BindingInWhenOnSyntax2.prototype.whenAnyAncestorNamed = function (name2) { + return this._bindingWhenSyntax.whenAnyAncestorNamed(name2) + } + BindingInWhenOnSyntax2.prototype.whenAnyAncestorTagged = function (tag, value) { + return this._bindingWhenSyntax.whenAnyAncestorTagged(tag, value) + } + BindingInWhenOnSyntax2.prototype.whenNoAncestorNamed = function (name2) { + return this._bindingWhenSyntax.whenNoAncestorNamed(name2) + } + BindingInWhenOnSyntax2.prototype.whenNoAncestorTagged = function (tag, value) { + return this._bindingWhenSyntax.whenNoAncestorTagged(tag, value) + } + BindingInWhenOnSyntax2.prototype.whenAnyAncestorMatches = function (constraint) { + return this._bindingWhenSyntax.whenAnyAncestorMatches(constraint) + } + BindingInWhenOnSyntax2.prototype.whenNoAncestorMatches = function (constraint) { + return this._bindingWhenSyntax.whenNoAncestorMatches(constraint) + } + BindingInWhenOnSyntax2.prototype.onActivation = function (handler) { + return this._bindingOnSyntax.onActivation(handler) + } + BindingInWhenOnSyntax2.prototype.onDeactivation = function (handler) { + return this._bindingOnSyntax.onDeactivation(handler) + } + return BindingInWhenOnSyntax2 +})() +var BindingToSyntax = (function () { + function BindingToSyntax2(binding) { + this._binding = binding + } + BindingToSyntax2.prototype.to = function (constructor) { + this._binding.type = BindingTypeEnum.Instance + this._binding.implementationType = constructor + return new BindingInWhenOnSyntax(this._binding) + } + BindingToSyntax2.prototype.toSelf = function () { + if (typeof this._binding.serviceIdentifier !== "function") { + throw new Error("" + INVALID_TO_SELF_VALUE) + } + var self2 = this._binding.serviceIdentifier + return this.to(self2) + } + BindingToSyntax2.prototype.toConstantValue = function (value) { + this._binding.type = BindingTypeEnum.ConstantValue + this._binding.cache = value + this._binding.dynamicValue = null + this._binding.implementationType = null + this._binding.scope = BindingScopeEnum.Singleton + return new BindingWhenOnSyntax(this._binding) + } + BindingToSyntax2.prototype.toDynamicValue = function (func) { + this._binding.type = BindingTypeEnum.DynamicValue + this._binding.cache = null + this._binding.dynamicValue = func + this._binding.implementationType = null + return new BindingInWhenOnSyntax(this._binding) + } + BindingToSyntax2.prototype.toConstructor = function (constructor) { + this._binding.type = BindingTypeEnum.Constructor + this._binding.implementationType = constructor + this._binding.scope = BindingScopeEnum.Singleton + return new BindingWhenOnSyntax(this._binding) + } + BindingToSyntax2.prototype.toFactory = function (factory2) { + this._binding.type = BindingTypeEnum.Factory + this._binding.factory = factory2 + this._binding.scope = BindingScopeEnum.Singleton + return new BindingWhenOnSyntax(this._binding) + } + BindingToSyntax2.prototype.toFunction = function (func) { + if (typeof func !== "function") { + throw new Error(INVALID_FUNCTION_BINDING) + } + var bindingWhenOnSyntax = this.toConstantValue(func) + this._binding.type = BindingTypeEnum.Function + this._binding.scope = BindingScopeEnum.Singleton + return bindingWhenOnSyntax + } + BindingToSyntax2.prototype.toAutoFactory = function (serviceIdentifier) { + this._binding.type = BindingTypeEnum.Factory + this._binding.factory = function (context) { + var autofactory = function () { + return context.container.get(serviceIdentifier) + } + return autofactory + } + this._binding.scope = BindingScopeEnum.Singleton + return new BindingWhenOnSyntax(this._binding) + } + BindingToSyntax2.prototype.toAutoNamedFactory = function (serviceIdentifier) { + this._binding.type = BindingTypeEnum.Factory + this._binding.factory = function (context) { + return function (named) { + return context.container.getNamed(serviceIdentifier, named) + } + } + return new BindingWhenOnSyntax(this._binding) + } + BindingToSyntax2.prototype.toProvider = function (provider) { + this._binding.type = BindingTypeEnum.Provider + this._binding.provider = provider + this._binding.scope = BindingScopeEnum.Singleton + return new BindingWhenOnSyntax(this._binding) + } + BindingToSyntax2.prototype.toService = function (service) { + this.toDynamicValue(function (context) { + return context.container.get(service) + }) + } + return BindingToSyntax2 +})() +var ContainerSnapshot = (function () { + function ContainerSnapshot2() {} + ContainerSnapshot2.of = function (bindings, middleware, activations, deactivations, moduleActivationStore) { + var snapshot = new ContainerSnapshot2() + snapshot.bindings = bindings + snapshot.middleware = middleware + snapshot.deactivations = deactivations + snapshot.activations = activations + snapshot.moduleActivationStore = moduleActivationStore + return snapshot + } + return ContainerSnapshot2 +})() +function isClonable(obj) { + return typeof obj === "object" && obj !== null && "clone" in obj && typeof obj.clone === "function" +} +var Lookup = (function () { + function Lookup2() { + this._map = /* @__PURE__ */ new Map() + } + Lookup2.prototype.getMap = function () { + return this._map + } + Lookup2.prototype.add = function (serviceIdentifier, value) { + if (serviceIdentifier === null || serviceIdentifier === void 0) { + throw new Error(NULL_ARGUMENT) + } + if (value === null || value === void 0) { + throw new Error(NULL_ARGUMENT) + } + var entry = this._map.get(serviceIdentifier) + if (entry !== void 0) { + entry.push(value) + } else { + this._map.set(serviceIdentifier, [value]) + } + } + Lookup2.prototype.get = function (serviceIdentifier) { + if (serviceIdentifier === null || serviceIdentifier === void 0) { + throw new Error(NULL_ARGUMENT) + } + var entry = this._map.get(serviceIdentifier) + if (entry !== void 0) { + return entry + } else { + throw new Error(KEY_NOT_FOUND) + } + } + Lookup2.prototype.remove = function (serviceIdentifier) { + if (serviceIdentifier === null || serviceIdentifier === void 0) { + throw new Error(NULL_ARGUMENT) + } + if (!this._map.delete(serviceIdentifier)) { + throw new Error(KEY_NOT_FOUND) + } + } + Lookup2.prototype.removeIntersection = function (lookup) { + var _this = this + this.traverse(function (serviceIdentifier, value) { + var lookupActivations = lookup.hasKey(serviceIdentifier) ? lookup.get(serviceIdentifier) : void 0 + if (lookupActivations !== void 0) { + var filteredValues = value.filter(function (lookupValue) { + return !lookupActivations.some(function (moduleActivation) { + return lookupValue === moduleActivation + }) + }) + _this._setValue(serviceIdentifier, filteredValues) + } + }) + } + Lookup2.prototype.removeByCondition = function (condition) { + var _this = this + var removals = [] + this._map.forEach(function (entries, key) { + var updatedEntries = [] + for (var _i = 0, entries_1 = entries; _i < entries_1.length; _i++) { + var entry = entries_1[_i] + var remove = condition(entry) + if (remove) { + removals.push(entry) + } else { + updatedEntries.push(entry) + } + } + _this._setValue(key, updatedEntries) + }) + return removals + } + Lookup2.prototype.hasKey = function (serviceIdentifier) { + if (serviceIdentifier === null || serviceIdentifier === void 0) { + throw new Error(NULL_ARGUMENT) + } + return this._map.has(serviceIdentifier) + } + Lookup2.prototype.clone = function () { + var copy = new Lookup2() + this._map.forEach(function (value, key) { + value.forEach(function (b2) { + return copy.add(key, isClonable(b2) ? b2.clone() : b2) + }) + }) + return copy + } + Lookup2.prototype.traverse = function (func) { + this._map.forEach(function (value, key) { + func(key, value) + }) + } + Lookup2.prototype._setValue = function (serviceIdentifier, value) { + if (value.length > 0) { + this._map.set(serviceIdentifier, value) + } else { + this._map.delete(serviceIdentifier) + } + } + return Lookup2 +})() +var ModuleActivationStore = (function () { + function ModuleActivationStore2() { + this._map = /* @__PURE__ */ new Map() + } + ModuleActivationStore2.prototype.remove = function (moduleId) { + if (this._map.has(moduleId)) { + var handlers = this._map.get(moduleId) + this._map.delete(moduleId) + return handlers + } + return this._getEmptyHandlersStore() + } + ModuleActivationStore2.prototype.addDeactivation = function (moduleId, serviceIdentifier, onDeactivation) { + this._getModuleActivationHandlers(moduleId).onDeactivations.add(serviceIdentifier, onDeactivation) + } + ModuleActivationStore2.prototype.addActivation = function (moduleId, serviceIdentifier, onActivation) { + this._getModuleActivationHandlers(moduleId).onActivations.add(serviceIdentifier, onActivation) + } + ModuleActivationStore2.prototype.clone = function () { + var clone = new ModuleActivationStore2() + this._map.forEach(function (handlersStore, moduleId) { + clone._map.set(moduleId, { + onActivations: handlersStore.onActivations.clone(), + onDeactivations: handlersStore.onDeactivations.clone(), + }) + }) + return clone + } + ModuleActivationStore2.prototype._getModuleActivationHandlers = function (moduleId) { + var moduleActivationHandlers = this._map.get(moduleId) + if (moduleActivationHandlers === void 0) { + moduleActivationHandlers = this._getEmptyHandlersStore() + this._map.set(moduleId, moduleActivationHandlers) + } + return moduleActivationHandlers + } + ModuleActivationStore2.prototype._getEmptyHandlersStore = function () { + var handlersStore = { + onActivations: new Lookup(), + onDeactivations: new Lookup(), + } + return handlersStore + } + return ModuleActivationStore2 +})() +var __assign = + (globalThis && globalThis.__assign) || + function () { + __assign = + Object.assign || + function (t2) { + for (var s, i = 1, n = arguments.length; i < n; i++) { + s = arguments[i] + for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t2[p] = s[p] + } + return t2 + } + return __assign.apply(this, arguments) + } +var __awaiter = + (globalThis && globalThis.__awaiter) || + function (thisArg, _arguments, P2, generator) { + function adopt(value) { + return value instanceof P2 + ? value + : new P2(function (resolve2) { + resolve2(value) + }) + } + return new (P2 || (P2 = Promise))(function (resolve2, reject) { + function fulfilled(value) { + try { + step(generator.next(value)) + } catch (e) { + reject(e) + } + } + function rejected(value) { + try { + step(generator["throw"](value)) + } catch (e) { + reject(e) + } + } + function step(result) { + result.done ? resolve2(result.value) : adopt(result.value).then(fulfilled, rejected) + } + step((generator = generator.apply(thisArg, _arguments || [])).next()) + }) + } +var __generator = + (globalThis && globalThis.__generator) || + function (thisArg, body) { + var _2 = { + label: 0, + sent: function () { + if (t2[0] & 1) throw t2[1] + return t2[1] + }, + trys: [], + ops: [], + }, + f, + y, + t2, + g + return ( + (g = { next: verb(0), throw: verb(1), return: verb(2) }), + typeof Symbol === "function" && + (g[Symbol.iterator] = function () { + return this + }), + g + ) + function verb(n) { + return function (v) { + return step([n, v]) + } + } + function step(op) { + if (f) throw new TypeError("Generator is already executing.") + while (_2) + try { + if ( + ((f = 1), + y && + (t2 = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t2 = y["return"]) && t2.call(y), 0) : y.next) && + !(t2 = t2.call(y, op[1])).done) + ) + return t2 + if (((y = 0), t2)) op = [op[0] & 2, t2.value] + switch (op[0]) { + case 0: + case 1: + t2 = op + break + case 4: + _2.label++ + return { value: op[1], done: false } + case 5: + _2.label++ + y = op[1] + op = [0] + continue + case 7: + op = _2.ops.pop() + _2.trys.pop() + continue + default: + if (!((t2 = _2.trys), (t2 = t2.length > 0 && t2[t2.length - 1])) && (op[0] === 6 || op[0] === 2)) { + _2 = 0 + continue + } + if (op[0] === 3 && (!t2 || (op[1] > t2[0] && op[1] < t2[3]))) { + _2.label = op[1] + break + } + if (op[0] === 6 && _2.label < t2[1]) { + _2.label = t2[1] + t2 = op + break + } + if (t2 && _2.label < t2[2]) { + _2.label = t2[2] + _2.ops.push(op) + break + } + if (t2[2]) _2.ops.pop() + _2.trys.pop() + continue + } + op = body.call(thisArg, _2) + } catch (e) { + op = [6, e] + y = 0 + } finally { + f = t2 = 0 + } + if (op[0] & 5) throw op[1] + return { value: op[0] ? op[1] : void 0, done: true } + } + } +var __spreadArray = + (globalThis && globalThis.__spreadArray) || + function (to, from, pack) { + if (pack || arguments.length === 2) + for (var i = 0, l = from.length, ar; i < l; i++) { + if (ar || !(i in from)) { + if (!ar) ar = Array.prototype.slice.call(from, 0, i) + ar[i] = from[i] + } + } + return to.concat(ar || Array.prototype.slice.call(from)) + } +var Container = (function () { + function Container2(containerOptions) { + var options = containerOptions || {} + if (typeof options !== "object") { + throw new Error("" + CONTAINER_OPTIONS_MUST_BE_AN_OBJECT) + } + if (options.defaultScope === void 0) { + options.defaultScope = BindingScopeEnum.Transient + } else if ( + options.defaultScope !== BindingScopeEnum.Singleton && + options.defaultScope !== BindingScopeEnum.Transient && + options.defaultScope !== BindingScopeEnum.Request + ) { + throw new Error("" + CONTAINER_OPTIONS_INVALID_DEFAULT_SCOPE) + } + if (options.autoBindInjectable === void 0) { + options.autoBindInjectable = false + } else if (typeof options.autoBindInjectable !== "boolean") { + throw new Error("" + CONTAINER_OPTIONS_INVALID_AUTO_BIND_INJECTABLE) + } + if (options.skipBaseClassChecks === void 0) { + options.skipBaseClassChecks = false + } else if (typeof options.skipBaseClassChecks !== "boolean") { + throw new Error("" + CONTAINER_OPTIONS_INVALID_SKIP_BASE_CHECK) + } + this.options = { + autoBindInjectable: options.autoBindInjectable, + defaultScope: options.defaultScope, + skipBaseClassChecks: options.skipBaseClassChecks, + } + this.id = id() + this._bindingDictionary = new Lookup() + this._snapshots = [] + this._middleware = null + this._activations = new Lookup() + this._deactivations = new Lookup() + this.parent = null + this._metadataReader = new MetadataReader() + this._moduleActivationStore = new ModuleActivationStore() + } + Container2.merge = function (container1, container2) { + var containers = [] + for (var _i = 2; _i < arguments.length; _i++) { + containers[_i - 2] = arguments[_i] + } + var container3 = new Container2() + var targetContainers = __spreadArray([container1, container2], containers, true).map(function (targetContainer) { + return getBindingDictionary(targetContainer) + }) + var bindingDictionary = getBindingDictionary(container3) + function copyDictionary(origin, destination) { + origin.traverse(function (_key, value) { + value.forEach(function (binding) { + destination.add(binding.serviceIdentifier, binding.clone()) + }) + }) + } + targetContainers.forEach(function (targetBindingDictionary) { + copyDictionary(targetBindingDictionary, bindingDictionary) + }) + return container3 + } + Container2.prototype.load = function () { + var modules = [] + for (var _i = 0; _i < arguments.length; _i++) { + modules[_i] = arguments[_i] + } + var getHelpers = this._getContainerModuleHelpersFactory() + for (var _a2 = 0, modules_1 = modules; _a2 < modules_1.length; _a2++) { + var currentModule = modules_1[_a2] + var containerModuleHelpers = getHelpers(currentModule.id) + currentModule.registry( + containerModuleHelpers.bindFunction, + containerModuleHelpers.unbindFunction, + containerModuleHelpers.isboundFunction, + containerModuleHelpers.rebindFunction, + containerModuleHelpers.unbindAsyncFunction, + containerModuleHelpers.onActivationFunction, + containerModuleHelpers.onDeactivationFunction + ) + } + } + Container2.prototype.loadAsync = function () { + var modules = [] + for (var _i = 0; _i < arguments.length; _i++) { + modules[_i] = arguments[_i] + } + return __awaiter(this, void 0, void 0, function () { + var getHelpers, _a2, modules_2, currentModule, containerModuleHelpers + return __generator(this, function (_b) { + switch (_b.label) { + case 0: + getHelpers = this._getContainerModuleHelpersFactory() + ;(_a2 = 0), (modules_2 = modules) + _b.label = 1 + case 1: + if (!(_a2 < modules_2.length)) return [3, 4] + currentModule = modules_2[_a2] + containerModuleHelpers = getHelpers(currentModule.id) + return [ + 4, + currentModule.registry( + containerModuleHelpers.bindFunction, + containerModuleHelpers.unbindFunction, + containerModuleHelpers.isboundFunction, + containerModuleHelpers.rebindFunction, + containerModuleHelpers.unbindAsyncFunction, + containerModuleHelpers.onActivationFunction, + containerModuleHelpers.onDeactivationFunction + ), + ] + case 2: + _b.sent() + _b.label = 3 + case 3: + _a2++ + return [3, 1] + case 4: + return [2] + } + }) + }) + } + Container2.prototype.unload = function () { + var _this = this + var modules = [] + for (var _i = 0; _i < arguments.length; _i++) { + modules[_i] = arguments[_i] + } + modules.forEach(function (module2) { + var deactivations = _this._removeModuleBindings(module2.id) + _this._deactivateSingletons(deactivations) + _this._removeModuleHandlers(module2.id) + }) + } + Container2.prototype.unloadAsync = function () { + var modules = [] + for (var _i = 0; _i < arguments.length; _i++) { + modules[_i] = arguments[_i] + } + return __awaiter(this, void 0, void 0, function () { + var _a2, modules_3, module_1, deactivations + return __generator(this, function (_b) { + switch (_b.label) { + case 0: + ;(_a2 = 0), (modules_3 = modules) + _b.label = 1 + case 1: + if (!(_a2 < modules_3.length)) return [3, 4] + module_1 = modules_3[_a2] + deactivations = this._removeModuleBindings(module_1.id) + return [4, this._deactivateSingletonsAsync(deactivations)] + case 2: + _b.sent() + this._removeModuleHandlers(module_1.id) + _b.label = 3 + case 3: + _a2++ + return [3, 1] + case 4: + return [2] + } + }) + }) + } + Container2.prototype.bind = function (serviceIdentifier) { + var scope = this.options.defaultScope || BindingScopeEnum.Transient + var binding = new Binding(serviceIdentifier, scope) + this._bindingDictionary.add(serviceIdentifier, binding) + return new BindingToSyntax(binding) + } + Container2.prototype.rebind = function (serviceIdentifier) { + this.unbind(serviceIdentifier) + return this.bind(serviceIdentifier) + } + Container2.prototype.rebindAsync = function (serviceIdentifier) { + return __awaiter(this, void 0, void 0, function () { + return __generator(this, function (_a2) { + switch (_a2.label) { + case 0: + return [4, this.unbindAsync(serviceIdentifier)] + case 1: + _a2.sent() + return [2, this.bind(serviceIdentifier)] + } + }) + }) + } + Container2.prototype.unbind = function (serviceIdentifier) { + if (this._bindingDictionary.hasKey(serviceIdentifier)) { + var bindings = this._bindingDictionary.get(serviceIdentifier) + this._deactivateSingletons(bindings) + } + this._removeServiceFromDictionary(serviceIdentifier) + } + Container2.prototype.unbindAsync = function (serviceIdentifier) { + return __awaiter(this, void 0, void 0, function () { + var bindings + return __generator(this, function (_a2) { + switch (_a2.label) { + case 0: + if (!this._bindingDictionary.hasKey(serviceIdentifier)) return [3, 2] + bindings = this._bindingDictionary.get(serviceIdentifier) + return [4, this._deactivateSingletonsAsync(bindings)] + case 1: + _a2.sent() + _a2.label = 2 + case 2: + this._removeServiceFromDictionary(serviceIdentifier) + return [2] + } + }) + }) + } + Container2.prototype.unbindAll = function () { + var _this = this + this._bindingDictionary.traverse(function (_key, value) { + _this._deactivateSingletons(value) + }) + this._bindingDictionary = new Lookup() + } + Container2.prototype.unbindAllAsync = function () { + return __awaiter(this, void 0, void 0, function () { + var promises + var _this = this + return __generator(this, function (_a2) { + switch (_a2.label) { + case 0: + promises = [] + this._bindingDictionary.traverse(function (_key, value) { + promises.push(_this._deactivateSingletonsAsync(value)) + }) + return [4, Promise.all(promises)] + case 1: + _a2.sent() + this._bindingDictionary = new Lookup() + return [2] + } + }) + }) + } + Container2.prototype.onActivation = function (serviceIdentifier, onActivation) { + this._activations.add(serviceIdentifier, onActivation) + } + Container2.prototype.onDeactivation = function (serviceIdentifier, onDeactivation) { + this._deactivations.add(serviceIdentifier, onDeactivation) + } + Container2.prototype.isBound = function (serviceIdentifier) { + var bound = this._bindingDictionary.hasKey(serviceIdentifier) + if (!bound && this.parent) { + bound = this.parent.isBound(serviceIdentifier) + } + return bound + } + Container2.prototype.isCurrentBound = function (serviceIdentifier) { + return this._bindingDictionary.hasKey(serviceIdentifier) + } + Container2.prototype.isBoundNamed = function (serviceIdentifier, named) { + return this.isBoundTagged(serviceIdentifier, NAMED_TAG, named) + } + Container2.prototype.isBoundTagged = function (serviceIdentifier, key, value) { + var bound = false + if (this._bindingDictionary.hasKey(serviceIdentifier)) { + var bindings = this._bindingDictionary.get(serviceIdentifier) + var request_1 = createMockRequest(this, serviceIdentifier, key, value) + bound = bindings.some(function (b2) { + return b2.constraint(request_1) + }) + } + if (!bound && this.parent) { + bound = this.parent.isBoundTagged(serviceIdentifier, key, value) + } + return bound + } + Container2.prototype.snapshot = function () { + this._snapshots.push( + ContainerSnapshot.of( + this._bindingDictionary.clone(), + this._middleware, + this._activations.clone(), + this._deactivations.clone(), + this._moduleActivationStore.clone() + ) + ) + } + Container2.prototype.restore = function () { + var snapshot = this._snapshots.pop() + if (snapshot === void 0) { + throw new Error(NO_MORE_SNAPSHOTS_AVAILABLE) + } + this._bindingDictionary = snapshot.bindings + this._activations = snapshot.activations + this._deactivations = snapshot.deactivations + this._middleware = snapshot.middleware + this._moduleActivationStore = snapshot.moduleActivationStore + } + Container2.prototype.createChild = function (containerOptions) { + var child = new Container2(containerOptions || this.options) + child.parent = this + return child + } + Container2.prototype.applyMiddleware = function () { + var middlewares = [] + for (var _i = 0; _i < arguments.length; _i++) { + middlewares[_i] = arguments[_i] + } + var initial = this._middleware ? this._middleware : this._planAndResolve() + this._middleware = middlewares.reduce(function (prev, curr) { + return curr(prev) + }, initial) + } + Container2.prototype.applyCustomMetadataReader = function (metadataReader) { + this._metadataReader = metadataReader + } + Container2.prototype.get = function (serviceIdentifier) { + var getArgs = this._getNotAllArgs(serviceIdentifier, false) + return this._getButThrowIfAsync(getArgs) + } + Container2.prototype.getAsync = function (serviceIdentifier) { + return __awaiter(this, void 0, void 0, function () { + var getArgs + return __generator(this, function (_a2) { + getArgs = this._getNotAllArgs(serviceIdentifier, false) + return [2, this._get(getArgs)] + }) + }) + } + Container2.prototype.getTagged = function (serviceIdentifier, key, value) { + var getArgs = this._getNotAllArgs(serviceIdentifier, false, key, value) + return this._getButThrowIfAsync(getArgs) + } + Container2.prototype.getTaggedAsync = function (serviceIdentifier, key, value) { + return __awaiter(this, void 0, void 0, function () { + var getArgs + return __generator(this, function (_a2) { + getArgs = this._getNotAllArgs(serviceIdentifier, false, key, value) + return [2, this._get(getArgs)] + }) + }) + } + Container2.prototype.getNamed = function (serviceIdentifier, named) { + return this.getTagged(serviceIdentifier, NAMED_TAG, named) + } + Container2.prototype.getNamedAsync = function (serviceIdentifier, named) { + return this.getTaggedAsync(serviceIdentifier, NAMED_TAG, named) + } + Container2.prototype.getAll = function (serviceIdentifier) { + var getArgs = this._getAllArgs(serviceIdentifier) + return this._getButThrowIfAsync(getArgs) + } + Container2.prototype.getAllAsync = function (serviceIdentifier) { + var getArgs = this._getAllArgs(serviceIdentifier) + return this._getAll(getArgs) + } + Container2.prototype.getAllTagged = function (serviceIdentifier, key, value) { + var getArgs = this._getNotAllArgs(serviceIdentifier, true, key, value) + return this._getButThrowIfAsync(getArgs) + } + Container2.prototype.getAllTaggedAsync = function (serviceIdentifier, key, value) { + var getArgs = this._getNotAllArgs(serviceIdentifier, true, key, value) + return this._getAll(getArgs) + } + Container2.prototype.getAllNamed = function (serviceIdentifier, named) { + return this.getAllTagged(serviceIdentifier, NAMED_TAG, named) + } + Container2.prototype.getAllNamedAsync = function (serviceIdentifier, named) { + return this.getAllTaggedAsync(serviceIdentifier, NAMED_TAG, named) + } + Container2.prototype.resolve = function (constructorFunction) { + var isBound = this.isBound(constructorFunction) + if (!isBound) { + this.bind(constructorFunction).toSelf() + } + var resolved = this.get(constructorFunction) + if (!isBound) { + this.unbind(constructorFunction) + } + return resolved + } + Container2.prototype._preDestroy = function (constructor, instance2) { + if (Reflect.hasMetadata(PRE_DESTROY, constructor)) { + var data = Reflect.getMetadata(PRE_DESTROY, constructor) + return instance2[data.value]() + } + } + Container2.prototype._removeModuleHandlers = function (moduleId) { + var moduleActivationsHandlers = this._moduleActivationStore.remove(moduleId) + this._activations.removeIntersection(moduleActivationsHandlers.onActivations) + this._deactivations.removeIntersection(moduleActivationsHandlers.onDeactivations) + } + Container2.prototype._removeModuleBindings = function (moduleId) { + return this._bindingDictionary.removeByCondition(function (binding) { + return binding.moduleId === moduleId + }) + } + Container2.prototype._deactivate = function (binding, instance2) { + var _this = this + var constructor = Object.getPrototypeOf(instance2).constructor + try { + if (this._deactivations.hasKey(binding.serviceIdentifier)) { + var result = this._deactivateContainer(instance2, this._deactivations.get(binding.serviceIdentifier).values()) + if (isPromise(result)) { + return this._handleDeactivationError( + result.then(function () { + return _this._propagateContainerDeactivationThenBindingAndPreDestroyAsync(binding, instance2, constructor) + }), + constructor + ) + } + } + var propagateDeactivationResult = this._propagateContainerDeactivationThenBindingAndPreDestroy( + binding, + instance2, + constructor + ) + if (isPromise(propagateDeactivationResult)) { + return this._handleDeactivationError(propagateDeactivationResult, constructor) + } + } catch (ex) { + throw new Error(ON_DEACTIVATION_ERROR(constructor.name, ex.message)) + } + } + Container2.prototype._handleDeactivationError = function (asyncResult, constructor) { + return __awaiter(this, void 0, void 0, function () { + var ex_1 + return __generator(this, function (_a2) { + switch (_a2.label) { + case 0: + _a2.trys.push([0, 2, , 3]) + return [4, asyncResult] + case 1: + _a2.sent() + return [3, 3] + case 2: + ex_1 = _a2.sent() + throw new Error(ON_DEACTIVATION_ERROR(constructor.name, ex_1.message)) + case 3: + return [2] + } + }) + }) + } + Container2.prototype._deactivateContainer = function (instance2, deactivationsIterator) { + var _this = this + var deactivation = deactivationsIterator.next() + while (deactivation.value) { + var result = deactivation.value(instance2) + if (isPromise(result)) { + return result.then(function () { + return _this._deactivateContainerAsync(instance2, deactivationsIterator) + }) + } + deactivation = deactivationsIterator.next() + } + } + Container2.prototype._deactivateContainerAsync = function (instance2, deactivationsIterator) { + return __awaiter(this, void 0, void 0, function () { + var deactivation + return __generator(this, function (_a2) { + switch (_a2.label) { + case 0: + deactivation = deactivationsIterator.next() + _a2.label = 1 + case 1: + if (!deactivation.value) return [3, 3] + return [4, deactivation.value(instance2)] + case 2: + _a2.sent() + deactivation = deactivationsIterator.next() + return [3, 1] + case 3: + return [2] + } + }) + }) + } + Container2.prototype._getContainerModuleHelpersFactory = function () { + var _this = this + var setModuleId = function (bindingToSyntax, moduleId) { + bindingToSyntax._binding.moduleId = moduleId + } + var getBindFunction = function (moduleId) { + return function (serviceIdentifier) { + var bindingToSyntax = _this.bind(serviceIdentifier) + setModuleId(bindingToSyntax, moduleId) + return bindingToSyntax + } + } + var getUnbindFunction = function () { + return function (serviceIdentifier) { + return _this.unbind(serviceIdentifier) + } + } + var getUnbindAsyncFunction = function () { + return function (serviceIdentifier) { + return _this.unbindAsync(serviceIdentifier) + } + } + var getIsboundFunction = function () { + return function (serviceIdentifier) { + return _this.isBound(serviceIdentifier) + } + } + var getRebindFunction = function (moduleId) { + return function (serviceIdentifier) { + var bindingToSyntax = _this.rebind(serviceIdentifier) + setModuleId(bindingToSyntax, moduleId) + return bindingToSyntax + } + } + var getOnActivationFunction = function (moduleId) { + return function (serviceIdentifier, onActivation) { + _this._moduleActivationStore.addActivation(moduleId, serviceIdentifier, onActivation) + _this.onActivation(serviceIdentifier, onActivation) + } + } + var getOnDeactivationFunction = function (moduleId) { + return function (serviceIdentifier, onDeactivation) { + _this._moduleActivationStore.addDeactivation(moduleId, serviceIdentifier, onDeactivation) + _this.onDeactivation(serviceIdentifier, onDeactivation) + } + } + return function (mId) { + return { + bindFunction: getBindFunction(mId), + isboundFunction: getIsboundFunction(), + onActivationFunction: getOnActivationFunction(mId), + onDeactivationFunction: getOnDeactivationFunction(mId), + rebindFunction: getRebindFunction(mId), + unbindFunction: getUnbindFunction(), + unbindAsyncFunction: getUnbindAsyncFunction(), + } + } + } + Container2.prototype._getAll = function (getArgs) { + return Promise.all(this._get(getArgs)) + } + Container2.prototype._get = function (getArgs) { + var planAndResolveArgs = __assign(__assign({}, getArgs), { + contextInterceptor: function (context) { + return context + }, + targetType: TargetTypeEnum.Variable, + }) + if (this._middleware) { + var middlewareResult = this._middleware(planAndResolveArgs) + if (middlewareResult === void 0 || middlewareResult === null) { + throw new Error(INVALID_MIDDLEWARE_RETURN) + } + return middlewareResult + } + return this._planAndResolve()(planAndResolveArgs) + } + Container2.prototype._getButThrowIfAsync = function (getArgs) { + var result = this._get(getArgs) + if (isPromiseOrContainsPromise(result)) { + throw new Error(LAZY_IN_SYNC(getArgs.serviceIdentifier)) + } + return result + } + Container2.prototype._getAllArgs = function (serviceIdentifier) { + var getAllArgs = { + avoidConstraints: true, + isMultiInject: true, + serviceIdentifier, + } + return getAllArgs + } + Container2.prototype._getNotAllArgs = function (serviceIdentifier, isMultiInject, key, value) { + var getNotAllArgs = { + avoidConstraints: false, + isMultiInject, + serviceIdentifier, + key, + value, + } + return getNotAllArgs + } + Container2.prototype._planAndResolve = function () { + var _this = this + return function (args) { + var context = plan( + _this._metadataReader, + _this, + args.isMultiInject, + args.targetType, + args.serviceIdentifier, + args.key, + args.value, + args.avoidConstraints + ) + context = args.contextInterceptor(context) + var result = resolve(context) + return result + } + } + Container2.prototype._deactivateIfSingleton = function (binding) { + var _this = this + if (!binding.activated) { + return + } + if (isPromise(binding.cache)) { + return binding.cache.then(function (resolved) { + return _this._deactivate(binding, resolved) + }) + } + return this._deactivate(binding, binding.cache) + } + Container2.prototype._deactivateSingletons = function (bindings) { + for (var _i = 0, bindings_1 = bindings; _i < bindings_1.length; _i++) { + var binding = bindings_1[_i] + var result = this._deactivateIfSingleton(binding) + if (isPromise(result)) { + throw new Error(ASYNC_UNBIND_REQUIRED) + } + } + } + Container2.prototype._deactivateSingletonsAsync = function (bindings) { + return __awaiter(this, void 0, void 0, function () { + var _this = this + return __generator(this, function (_a2) { + switch (_a2.label) { + case 0: + return [ + 4, + Promise.all( + bindings.map(function (b2) { + return _this._deactivateIfSingleton(b2) + }) + ), + ] + case 1: + _a2.sent() + return [2] + } + }) + }) + } + Container2.prototype._propagateContainerDeactivationThenBindingAndPreDestroy = function ( + binding, + instance2, + constructor + ) { + if (this.parent) { + return this._deactivate.bind(this.parent)(binding, instance2) + } else { + return this._bindingDeactivationAndPreDestroy(binding, instance2, constructor) + } + } + Container2.prototype._propagateContainerDeactivationThenBindingAndPreDestroyAsync = function ( + binding, + instance2, + constructor + ) { + return __awaiter(this, void 0, void 0, function () { + return __generator(this, function (_a2) { + switch (_a2.label) { + case 0: + if (!this.parent) return [3, 2] + return [4, this._deactivate.bind(this.parent)(binding, instance2)] + case 1: + _a2.sent() + return [3, 4] + case 2: + return [4, this._bindingDeactivationAndPreDestroyAsync(binding, instance2, constructor)] + case 3: + _a2.sent() + _a2.label = 4 + case 4: + return [2] + } + }) + }) + } + Container2.prototype._removeServiceFromDictionary = function (serviceIdentifier) { + try { + this._bindingDictionary.remove(serviceIdentifier) + } catch (e) { + throw new Error(CANNOT_UNBIND + " " + getServiceIdentifierAsString(serviceIdentifier)) + } + } + Container2.prototype._bindingDeactivationAndPreDestroy = function (binding, instance2, constructor) { + var _this = this + if (typeof binding.onDeactivation === "function") { + var result = binding.onDeactivation(instance2) + if (isPromise(result)) { + return result.then(function () { + return _this._preDestroy(constructor, instance2) + }) + } + } + return this._preDestroy(constructor, instance2) + } + Container2.prototype._bindingDeactivationAndPreDestroyAsync = function (binding, instance2, constructor) { + return __awaiter(this, void 0, void 0, function () { + return __generator(this, function (_a2) { + switch (_a2.label) { + case 0: + if (!(typeof binding.onDeactivation === "function")) return [3, 2] + return [4, binding.onDeactivation(instance2)] + case 1: + _a2.sent() + _a2.label = 2 + case 2: + return [4, this._preDestroy(constructor, instance2)] + case 3: + _a2.sent() + return [2] + } + }) + }) + } + return Container2 +})() +function getFirstArrayDuplicate(array) { + var seenValues = /* @__PURE__ */ new Set() + for (var _i = 0, array_1 = array; _i < array_1.length; _i++) { + var entry = array_1[_i] + if (seenValues.has(entry)) { + return entry + } else { + seenValues.add(entry) + } + } + return void 0 +} +function targetIsConstructorFunction(target) { + return target.prototype !== void 0 +} +function _throwIfMethodParameter(parameterName) { + if (parameterName !== void 0) { + throw new Error(INVALID_DECORATOR_OPERATION) + } +} +function tagParameter(annotationTarget, parameterName, parameterIndex, metadata) { + _throwIfMethodParameter(parameterName) + _tagParameterOrProperty(TAGGED, annotationTarget, parameterIndex.toString(), metadata) +} +function tagProperty(annotationTarget, propertyName, metadata) { + if (targetIsConstructorFunction(annotationTarget)) { + throw new Error(INVALID_DECORATOR_OPERATION) + } + _tagParameterOrProperty(TAGGED_PROP, annotationTarget.constructor, propertyName, metadata) +} +function _ensureNoMetadataKeyDuplicates(metadata) { + var metadatas = [] + if (Array.isArray(metadata)) { + metadatas = metadata + var duplicate = getFirstArrayDuplicate( + metadatas.map(function (md) { + return md.key + }) + ) + if (duplicate !== void 0) { + throw new Error(DUPLICATED_METADATA + " " + duplicate.toString()) + } + } else { + metadatas = [metadata] + } + return metadatas +} +function _tagParameterOrProperty(metadataKey, annotationTarget, key, metadata) { + var metadatas = _ensureNoMetadataKeyDuplicates(metadata) + var paramsOrPropertiesMetadata = {} + if (Reflect.hasOwnMetadata(metadataKey, annotationTarget)) { + paramsOrPropertiesMetadata = Reflect.getMetadata(metadataKey, annotationTarget) + } + var paramOrPropertyMetadata = paramsOrPropertiesMetadata[key] + if (paramOrPropertyMetadata === void 0) { + paramOrPropertyMetadata = [] + } else { + var _loop_1 = function (m2) { + if ( + metadatas.some(function (md) { + return md.key === m2.key + }) + ) { + throw new Error(DUPLICATED_METADATA + " " + m2.key.toString()) + } + } + for (var _i = 0, paramOrPropertyMetadata_1 = paramOrPropertyMetadata; _i < paramOrPropertyMetadata_1.length; _i++) { + var m = paramOrPropertyMetadata_1[_i] + _loop_1(m) + } + } + paramOrPropertyMetadata.push.apply(paramOrPropertyMetadata, metadatas) + paramsOrPropertiesMetadata[key] = paramOrPropertyMetadata + Reflect.defineMetadata(metadataKey, paramsOrPropertiesMetadata, annotationTarget) +} +function createTaggedDecorator(metadata) { + return function (target, targetKey, indexOrPropertyDescriptor) { + if (typeof indexOrPropertyDescriptor === "number") { + tagParameter(target, targetKey, indexOrPropertyDescriptor, metadata) + } else { + tagProperty(target, targetKey, metadata) + } + } +} +function injectable() { + return function (target) { + if (Reflect.hasOwnMetadata(PARAM_TYPES, target)) { + throw new Error(DUPLICATED_INJECTABLE_DECORATOR) + } + var types = Reflect.getMetadata(DESIGN_PARAM_TYPES, target) || [] + Reflect.defineMetadata(PARAM_TYPES, types, target) + return target + } +} +function injectBase(metadataKey) { + return function (serviceIdentifier) { + return function (target, targetKey, indexOrPropertyDescriptor) { + if (serviceIdentifier === void 0) { + var className = typeof target === "function" ? target.name : target.constructor.name + throw new Error(UNDEFINED_INJECT_ANNOTATION(className)) + } + return createTaggedDecorator(new Metadata(metadataKey, serviceIdentifier))( + target, + targetKey, + indexOrPropertyDescriptor + ) + } + } +} +var inject = injectBase(INJECT_TAG) +const PLUGIN_SYSTEM_AUTO_UPDATE = "PLUGIN_SYSTEM_AUTO_UPDATE" +const PLUGIN_SYSTEM_PLUGIN = "PLUGIN_SYSTEM_PLUGIN" +const PLUGIN_SYSTEM_THIRD_PARTY_PLUGIN = "PLUGIN_SYSTEM_THIRD_PARTY_PLUGIN" +const PLUGIN_SYSTEM_SAFE_MODE_ENABLED = "PLUGIN_SYSTEM_SAFE_MODE_ENABLED" +const PLUGIN_STORE_URL = "PLUGIN_STORE_URL" +const defaultConfig = { + [PLUGIN_SYSTEM_SAFE_MODE_ENABLED]: true, + [PLUGIN_SYSTEM_AUTO_UPDATE]: true, + [PLUGIN_SYSTEM_PLUGIN]: [{ key: "setting", enabled: true }], + [PLUGIN_SYSTEM_THIRD_PARTY_PLUGIN]: [], + [PLUGIN_STORE_URL]: "https://bitbucket.org/siyuan-plugin/siyuan-plugins/raw/main/", +} +function noop() {} +function assign(tar, src) { + for (const k2 in src) tar[k2] = src[k2] + return tar +} +function run(fn) { + return fn() +} +function blank_object() { + return /* @__PURE__ */ Object.create(null) +} +function run_all(fns) { + fns.forEach(run) +} +function is_function(thing) { + return typeof thing === "function" +} +function safe_not_equal(a2, b2) { + return a2 != a2 ? b2 == b2 : a2 !== b2 || (a2 && typeof a2 === "object") || typeof a2 === "function" +} +function is_empty(obj) { + return Object.keys(obj).length === 0 +} +function create_slot(definition, ctx, $$scope, fn) { + if (definition) { + const slot_ctx = get_slot_context(definition, ctx, $$scope, fn) + return definition[0](slot_ctx) + } +} +function get_slot_context(definition, ctx, $$scope, fn) { + return definition[1] && fn ? assign($$scope.ctx.slice(), definition[1](fn(ctx))) : $$scope.ctx +} +function get_slot_changes(definition, $$scope, dirty, fn) { + if (definition[2] && fn) { + const lets = definition[2](fn(dirty)) + if ($$scope.dirty === void 0) { + return lets + } + if (typeof lets === "object") { + const merged = [] + const len = Math.max($$scope.dirty.length, lets.length) + for (let i = 0; i < len; i += 1) { + merged[i] = $$scope.dirty[i] | lets[i] + } + return merged + } + return $$scope.dirty | lets + } + return $$scope.dirty +} +function update_slot_base(slot, slot_definition, ctx, $$scope, slot_changes, get_slot_context_fn) { + if (slot_changes) { + const slot_context = get_slot_context(slot_definition, ctx, $$scope, get_slot_context_fn) + slot.p(slot_context, slot_changes) + } +} +function get_all_dirty_from_scope($$scope) { + if ($$scope.ctx.length > 32) { + const dirty = [] + const length = $$scope.ctx.length / 32 + for (let i = 0; i < length; i++) { + dirty[i] = -1 + } + return dirty + } + return -1 +} +function null_to_empty(value) { + return value == null ? "" : value +} +function append(target, node) { + target.appendChild(node) +} +function insert(target, node, anchor) { + target.insertBefore(node, anchor || null) +} +function detach(node) { + if (node.parentNode) { + node.parentNode.removeChild(node) + } +} +function destroy_each(iterations, detaching) { + for (let i = 0; i < iterations.length; i += 1) { + if (iterations[i]) iterations[i].d(detaching) + } +} +function element(name2) { + return document.createElement(name2) +} +function svg_element(name2) { + return document.createElementNS("http://www.w3.org/2000/svg", name2) +} +function text(data) { + return document.createTextNode(data) +} +function space() { + return text(" ") +} +function empty() { + return text("") +} +function listen(node, event, handler, options) { + node.addEventListener(event, handler, options) + return () => node.removeEventListener(event, handler, options) +} +function attr(node, attribute, value) { + if (value == null) node.removeAttribute(attribute) + else if (node.getAttribute(attribute) !== value) node.setAttribute(attribute, value) +} +function xlink_attr(node, attribute, value) { + node.setAttributeNS("http://www.w3.org/1999/xlink", attribute, value) +} +function children(element2) { + return Array.from(element2.childNodes) +} +function set_data(text2, data) { + data = "" + data + if (text2.wholeText !== data) text2.data = data +} +function set_input_value(input, value) { + input.value = value == null ? "" : value +} +function set_style(node, key, value, important) { + if (value === null) { + node.style.removeProperty(key) + } else { + node.style.setProperty(key, value, important ? "important" : "") + } +} +function custom_event(type, detail, { bubbles = false, cancelable = false } = {}) { + const e = document.createEvent("CustomEvent") + e.initCustomEvent(type, bubbles, cancelable, detail) + return e +} +class HtmlTag { + constructor(is_svg = false) { + this.is_svg = false + this.is_svg = is_svg + this.e = this.n = null + } + c(html) { + this.h(html) + } + m(html, target, anchor = null) { + if (!this.e) { + if (this.is_svg) this.e = svg_element(target.nodeName) + else this.e = element(target.nodeName) + this.t = target + this.c(html) + } + this.i(anchor) + } + h(html) { + this.e.innerHTML = html + this.n = Array.from(this.e.childNodes) + } + i(anchor) { + for (let i = 0; i < this.n.length; i += 1) { + insert(this.t, this.n[i], anchor) + } + } + p(html) { + this.d() + this.h(html) + this.i(this.a) + } + d() { + this.n.forEach(detach) + } +} +function construct_svelte_component(component, props) { + return new component(props) +} +let current_component +function set_current_component(component) { + current_component = component +} +function get_current_component() { + if (!current_component) throw new Error("Function called outside component initialization") + return current_component +} +function onMount(fn) { + get_current_component().$$.on_mount.push(fn) +} +function createEventDispatcher() { + const component = get_current_component() + return (type, detail, { cancelable = false } = {}) => { + const callbacks = component.$$.callbacks[type] + if (callbacks) { + const event = custom_event(type, detail, { cancelable }) + callbacks.slice().forEach((fn) => { + fn.call(component, event) + }) + return !event.defaultPrevented + } + return true + } +} +const dirty_components = [] +const binding_callbacks = [] +const render_callbacks = [] +const flush_callbacks = [] +const resolved_promise = Promise.resolve() +let update_scheduled = false +function schedule_update() { + if (!update_scheduled) { + update_scheduled = true + resolved_promise.then(flush) + } +} +function add_render_callback(fn) { + render_callbacks.push(fn) +} +const seen_callbacks = /* @__PURE__ */ new Set() +let flushidx = 0 +function flush() { + if (flushidx !== 0) { + return + } + const saved_component = current_component + do { + try { + while (flushidx < dirty_components.length) { + const component = dirty_components[flushidx] + flushidx++ + set_current_component(component) + update(component.$$) + } + } catch (e) { + dirty_components.length = 0 + flushidx = 0 + throw e + } + set_current_component(null) + dirty_components.length = 0 + flushidx = 0 + while (binding_callbacks.length) binding_callbacks.pop()() + for (let i = 0; i < render_callbacks.length; i += 1) { + const callback = render_callbacks[i] + if (!seen_callbacks.has(callback)) { + seen_callbacks.add(callback) + callback() + } + } + render_callbacks.length = 0 + } while (dirty_components.length) + while (flush_callbacks.length) { + flush_callbacks.pop()() + } + update_scheduled = false + seen_callbacks.clear() + set_current_component(saved_component) +} +function update($$) { + if ($$.fragment !== null) { + $$.update() + run_all($$.before_update) + const dirty = $$.dirty + $$.dirty = [-1] + $$.fragment && $$.fragment.p($$.ctx, dirty) + $$.after_update.forEach(add_render_callback) + } +} +const outroing = /* @__PURE__ */ new Set() +let outros +function group_outros() { + outros = { + r: 0, + c: [], + p: outros, + // parent group + } +} +function check_outros() { + if (!outros.r) { + run_all(outros.c) + } + outros = outros.p +} +function transition_in(block, local) { + if (block && block.i) { + outroing.delete(block) + block.i(local) + } +} +function transition_out(block, local, detach2, callback) { + if (block && block.o) { + if (outroing.has(block)) return + outroing.add(block) + outros.c.push(() => { + outroing.delete(block) + if (callback) { + if (detach2) block.d(1) + callback() + } + }) + block.o(local) + } else if (callback) { + callback() + } +} +function create_component(block) { + block && block.c() +} +function mount_component(component, target, anchor, customElement) { + const { fragment, after_update } = component.$$ + fragment && fragment.m(target, anchor) + if (!customElement) { + add_render_callback(() => { + const new_on_destroy = component.$$.on_mount.map(run).filter(is_function) + if (component.$$.on_destroy) { + component.$$.on_destroy.push(...new_on_destroy) + } else { + run_all(new_on_destroy) + } + component.$$.on_mount = [] + }) + } + after_update.forEach(add_render_callback) +} +function destroy_component(component, detaching) { + const $$ = component.$$ + if ($$.fragment !== null) { + run_all($$.on_destroy) + $$.fragment && $$.fragment.d(detaching) + $$.on_destroy = $$.fragment = null + $$.ctx = [] + } +} +function make_dirty(component, i) { + if (component.$$.dirty[0] === -1) { + dirty_components.push(component) + schedule_update() + component.$$.dirty.fill(0) + } + component.$$.dirty[(i / 31) | 0] |= 1 << i % 31 +} +function init(component, options, instance2, create_fragment2, not_equal, props, append_styles, dirty = [-1]) { + const parent_component = current_component + set_current_component(component) + const $$ = (component.$$ = { + fragment: null, + ctx: [], + // state + props, + update: noop, + not_equal, + bound: blank_object(), + // lifecycle + on_mount: [], + on_destroy: [], + on_disconnect: [], + before_update: [], + after_update: [], + context: new Map(options.context || (parent_component ? parent_component.$$.context : [])), + // everything else + callbacks: blank_object(), + dirty, + skip_bound: false, + root: options.target || parent_component.$$.root, + }) + append_styles && append_styles($$.root) + let ready = false + $$.ctx = instance2 + ? instance2(component, options.props || {}, (i, ret, ...rest) => { + const value = rest.length ? rest[0] : ret + if ($$.ctx && not_equal($$.ctx[i], ($$.ctx[i] = value))) { + if (!$$.skip_bound && $$.bound[i]) $$.bound[i](value) + if (ready) make_dirty(component, i) + } + return ret + }) + : [] + $$.update() + ready = true + run_all($$.before_update) + $$.fragment = create_fragment2 ? create_fragment2($$.ctx) : false + if (options.target) { + if (options.hydrate) { + const nodes = children(options.target) + $$.fragment && $$.fragment.l(nodes) + nodes.forEach(detach) + } else { + $$.fragment && $$.fragment.c() + } + if (options.intro) transition_in(component.$$.fragment) + mount_component(component, options.target, options.anchor, options.customElement) + flush() + } + set_current_component(parent_component) +} +class SvelteComponent { + $destroy() { + destroy_component(this, 1) + this.$destroy = noop + } + $on(type, callback) { + if (!is_function(callback)) { + return noop + } + const callbacks = this.$$.callbacks[type] || (this.$$.callbacks[type] = []) + callbacks.push(callback) + return () => { + const index = callbacks.indexOf(callback) + if (index !== -1) callbacks.splice(index, 1) + } + } + $set($$props) { + if (this.$$set && !is_empty($$props)) { + this.$$.skip_bound = true + this.$$set($$props) + this.$$.skip_bound = false + } + } +} +const commandPanel_svelte_svelte_type_style_lang = "" +function get_each_context$4(ctx, list, i) { + const child_ctx = ctx.slice() + child_ctx[11] = list[i] + child_ctx[13] = i + return child_ctx +} +function create_if_block$5(ctx) { + let each_1_anchor + let each_value = + /*result*/ + ctx[2] + let each_blocks = [] + for (let i = 0; i < each_value.length; i += 1) { + each_blocks[i] = create_each_block$4(get_each_context$4(ctx, each_value, i)) + } + return { + c() { + for (let i = 0; i < each_blocks.length; i += 1) { + each_blocks[i].c() + } + each_1_anchor = empty() + }, + m(target, anchor) { + for (let i = 0; i < each_blocks.length; i += 1) { + each_blocks[i].m(target, anchor) + } + insert(target, each_1_anchor, anchor) + }, + p(ctx2, dirty) { + if (dirty /*currentIndex, onClick, result, _*/ & 22) { + each_value = /*result*/ ctx2[2] + let i + for (i = 0; i < each_value.length; i += 1) { + const child_ctx = get_each_context$4(ctx2, each_value, i) + if (each_blocks[i]) { + each_blocks[i].p(child_ctx, dirty) + } else { + each_blocks[i] = create_each_block$4(child_ctx) + each_blocks[i].c() + each_blocks[i].m(each_1_anchor.parentNode, each_1_anchor) + } + } + for (; i < each_blocks.length; i += 1) { + each_blocks[i].d(1) + } + each_blocks.length = each_value.length + } + }, + d(detaching) { + destroy_each(each_blocks, detaching) + if (detaching) detach(each_1_anchor) + }, + } +} +function create_if_block_1$4(ctx) { + let div + let t0_value = _("shortcut") + "" + let t0 + let t1 + let t2_value = + /*com*/ + ctx[11].shortcut + "" + let t2 + return { + c() { + div = element("div") + t0 = text(t0_value) + t1 = text(": ") + t2 = text(t2_value) + attr(div, "class", "command-shortcut svelte-1bq7axd") + }, + m(target, anchor) { + insert(target, div, anchor) + append(div, t0) + append(div, t1) + append(div, t2) + }, + p(ctx2, dirty) { + if (dirty /*result*/ & 4 && t2_value !== (t2_value = /*com*/ ctx2[11].shortcut + "")) set_data(t2, t2_value) + }, + d(detaching) { + if (detaching) detach(div) + }, + } +} +function create_each_block$4(ctx) { + let div + let span0 + let t0_value = + /*com*/ + ctx[11].pluginName + "" + let t0 + let t1 + let t2_value = ":" + let t2 + let t3 + let span1 + let t4_value = + /*com*/ + ctx[11].command + "" + let t4 + let t5 + let t6_value = + /*com*/ + (ctx[11].description || "") + "" + let t6 + let t7 + let t8 + let div_class_value + let mounted + let dispose + let if_block = + /*com*/ + ctx[11].shortcut && create_if_block_1$4(ctx) + function click_handler() { + return ( + /*click_handler*/ + ctx[7]( + /*i*/ + ctx[13] + ) + ) + } + return { + c() { + div = element("div") + span0 = element("span") + t0 = text(t0_value) + t1 = space() + t2 = text(t2_value) + t3 = space() + span1 = element("span") + t4 = text(t4_value) + t5 = space() + t6 = text(t6_value) + t7 = space() + if (if_block) if_block.c() + t8 = space() + attr(span0, "class", "command-plugin svelte-1bq7axd") + attr(span1, "class", "command-description") + attr( + div, + "class", + (div_class_value = + null_to_empty( + /*i*/ + ctx[13] /*currentIndex*/ === ctx[1] ? "command-selected command" : "command" + ) + " svelte-1bq7axd") + ) + }, + m(target, anchor) { + insert(target, div, anchor) + append(div, span0) + append(span0, t0) + append(span0, t1) + append(span0, t2) + append(div, t3) + append(div, span1) + append(span1, t4) + append(span1, t5) + append(span1, t6) + append(div, t7) + if (if_block) if_block.m(div, null) + append(div, t8) + if (!mounted) { + dispose = listen(div, "click", click_handler) + mounted = true + } + }, + p(new_ctx, dirty) { + ctx = new_ctx + if (dirty /*result*/ & 4 && t0_value !== (t0_value = /*com*/ ctx[11].pluginName + "")) set_data(t0, t0_value) + if (dirty /*result*/ & 4 && t4_value !== (t4_value = /*com*/ ctx[11].command + "")) set_data(t4, t4_value) + if (dirty /*result*/ & 4 && t6_value !== (t6_value = /*com*/ (ctx[11].description || "") + "")) + set_data(t6, t6_value) + if ( + /*com*/ + ctx[11].shortcut + ) { + if (if_block) { + if_block.p(ctx, dirty) + } else { + if_block = create_if_block_1$4(ctx) + if_block.c() + if_block.m(div, t8) + } + } else if (if_block) { + if_block.d(1) + if_block = null + } + if ( + dirty /*currentIndex*/ & 2 && + div_class_value !== + (div_class_value = + null_to_empty( + /*i*/ + ctx[13] /*currentIndex*/ === ctx[1] ? "command-selected command" : "command" + ) + " svelte-1bq7axd") + ) { + attr(div, "class", div_class_value) + } + }, + d(detaching) { + if (detaching) detach(div) + if (if_block) if_block.d() + mounted = false + dispose() + }, + } +} +function create_fragment$7(ctx) { + let div1 + let div0 + let svg + let path + let t0 + let input + let t1 + let mounted + let dispose + let if_block = + /*result*/ + ctx[2] && create_if_block$5(ctx) + return { + c() { + div1 = element("div") + div0 = element("div") + svg = svg_element("svg") + path = svg_element("path") + t0 = space() + input = element("input") + t1 = space() + if (if_block) if_block.c() + attr( + path, + "d", + "M64 112v800h896V112H64z m846 750H114V162h796v700zM234.6 688.8L411.3 512 234.6 335.2l35.4-35.4L482.1 512 269.9 724.1l-35.3-35.3z m554.8-10.2h-300v-50h300v50z" + ) + set_style(svg, "left", "14px") + attr(svg, "class", "b3-form__icon-icon") + attr(svg, "viewBox", "0 0 1024 1024") + attr(svg, "version", "1.1") + attr(svg, "xmlns", "http://www.w3.org/2000/svg") + attr(svg, "width", "200") + attr(svg, "height", "200") + attr(input, "id", "commandPanelInput") + attr(input, "class", "b3-text-field b3-text-field--text fn__block b3-form__icon-input") + attr(div0, "class", "b3-form__icon search__header") + attr(div1, "class", "fn__flex-column") + set_style(div1, "border-radius", "4px") + set_style(div1, "overflow", "hidden") + set_style(div1, "position", "relative") + set_style(div1, "width", "max(80vw, 1000px)") + }, + m(target, anchor) { + insert(target, div1, anchor) + append(div1, div0) + append(div0, svg) + append(svg, path) + append(div0, t0) + append(div0, input) + set_input_value( + input, + /*command*/ + ctx[0] + ) + append(div1, t1) + if (if_block) if_block.m(div1, null) + if (!mounted) { + dispose = [ + listen( + input, + "input", + /*input_input_handler*/ + ctx[6] + ), + listen( + input, + "keydown", + /*onkeypress*/ + ctx[3] + ), + ] + mounted = true + } + }, + p(ctx2, [dirty]) { + if (dirty /*command*/ & 1 && input.value /*command*/ !== ctx2[0]) { + set_input_value( + input, + /*command*/ + ctx2[0] + ) + } + if ( + /*result*/ + ctx2[2] + ) { + if (if_block) { + if_block.p(ctx2, dirty) + } else { + if_block = create_if_block$5(ctx2) + if_block.c() + if_block.m(div1, null) + } + } else if (if_block) { + if_block.d(1) + if_block = null + } + }, + i: noop, + o: noop, + d(detaching) { + if (detaching) detach(div1) + if (if_block) if_block.d() + mounted = false + run_all(dispose) + }, + } +} +function instance$7($$self, $$props, $$invalidate) { + const commandManager = container.get("CommandManager") + let commands = [] + let command = "" + let currentIndex = 0 + let result = [] + const onkeypress = (e) => { + if (e.keyCode === 13) { + onEnter() + return + } + if (e.keyCode === 38) { + e.preventDefault() + if (currentIndex === 0) { + return + } + $$invalidate(1, currentIndex--, currentIndex) + return + } + if (e.keyCode === 40) { + const len = result.length + e.preventDefault() + if (currentIndex >= len - 1) { + return + } + $$invalidate(1, currentIndex++, currentIndex) + } + } + const onEnter = () => { + const com = result[currentIndex] + Dialog.destroyAll() + com.callback() + } + const onClick = (i) => { + $$invalidate(1, (currentIndex = i)) + onEnter() + } + const hasContent = (v, c) => v && v.toLowerCase().indexOf(c.toLowerCase()) >= 0 + onMount(() => { + $$invalidate(5, (commands = commandManager.getCommands())) + const el = document.getElementById("commandPanelInput") + el.focus() + }) + function input_input_handler() { + command = this.value + $$invalidate(0, command) + } + const click_handler = (i) => onClick(i) + $$self.$$.update = () => { + if ($$self.$$.dirty /*command, commands*/ & 33) { + { + $$invalidate(1, (currentIndex = 0)) + if (!command) { + $$invalidate(2, (result = commands)) + } else { + $$invalidate( + 2, + (result = commands.filter((c) => { + return ( + hasContent(c.plugin, command) || + hasContent(c.pluginName, command) || + hasContent(c.command, command) || + hasContent(c.description, command) + ) + })) + ) + } + } + } + } + return [command, currentIndex, result, onkeypress, onClick, commands, input_input_handler, click_handler] +} +class Command_panel extends SvelteComponent { + constructor(options) { + super() + init(this, options, instance$7, create_fragment$7, safe_not_equal, {}) + } +} +class CommandPanelPlugin extends Plugin { + onload() { + this.registerCommand({ + command: "Show command panel", + description: _("show_command_panel"), + shortcut: "ctrl+shift+o,command+shift+o", + callback: () => { + this.showPanel() + }, + }) + } + showPanel() { + Dialog.destroyAll() + new Dialog({ content: '
' }) + setImmediate(() => { + new Command_panel({ + target: document.getElementById("command-panel"), + }) + }) + } +} +function get_each_context$3(ctx, list, i) { + const child_ctx = ctx.slice() + child_ctx[5] = list[i] + child_ctx[6] = list + child_ctx[7] = i + return child_ctx +} +function create_if_block_1$3(ctx) { + let input + let mounted + let dispose + function input_input_handler() { + ctx[2].call( + input, + /*each_value*/ + ctx[6], + /*config_index*/ + ctx[7] + ) + } + return { + c() { + input = element("input") + attr(input, "class", "b3-text-field fn__flex-center fn__size200") + attr(input, "type", "input") + }, + m(target, anchor) { + insert(target, input, anchor) + set_input_value( + input, + /*config*/ + ctx[5].value + ) + if (!mounted) { + dispose = [ + listen(input, "input", input_input_handler), + listen(input, "change", function () { + if ( + is_function( + /*config*/ + ctx[5].onChange + ) + ) + ctx[5].onChange.apply(this, arguments) + }), + ] + mounted = true + } + }, + p(new_ctx, dirty) { + ctx = new_ctx + if (dirty /*configs*/ & 1) { + set_input_value( + input, + /*config*/ + ctx[5].value + ) + } + }, + d(detaching) { + if (detaching) detach(input) + mounted = false + run_all(dispose) + }, + } +} +function create_if_block$4(ctx) { + let input + let mounted + let dispose + function input_change_handler() { + ctx[1].call( + input, + /*each_value*/ + ctx[6], + /*config_index*/ + ctx[7] + ) + } + return { + c() { + input = element("input") + attr(input, "class", "b3-switch fn__flex-center") + attr(input, "type", "checkbox") + }, + m(target, anchor) { + insert(target, input, anchor) + input.checked = /*config*/ ctx[5].checked + if (!mounted) { + dispose = [ + listen(input, "change", input_change_handler), + listen(input, "change", function () { + if ( + is_function( + /*config*/ + ctx[5].onChange + ) + ) + ctx[5].onChange.apply(this, arguments) + }), + ] + mounted = true + } + }, + p(new_ctx, dirty) { + ctx = new_ctx + if (dirty /*configs*/ & 1) { + input.checked = /*config*/ ctx[5].checked + } + }, + d(detaching) { + if (detaching) detach(input) + mounted = false + run_all(dispose) + }, + } +} +function create_each_block$3(ctx) { + let label + let div1 + let t0_value = + /*config*/ + ctx[5].label + "" + let t0 + let t1 + let div0 + let t2_value = + /*config*/ + ctx[5].tip + "" + let t2 + let t3 + let span + let t4 + let t5 + function select_block_type(ctx2, dirty) { + if ( + /*config*/ + ctx2[5].type === "checkbox" + ) + return create_if_block$4 + if ( + /*config*/ + ctx2[5].type === "input" + ) + return create_if_block_1$3 + } + let current_block_type = select_block_type(ctx) + let if_block = current_block_type && current_block_type(ctx) + return { + c() { + label = element("label") + div1 = element("div") + t0 = text(t0_value) + t1 = space() + div0 = element("div") + t2 = text(t2_value) + t3 = space() + span = element("span") + t4 = space() + if (if_block) if_block.c() + t5 = space() + attr(div0, "class", "b3-label__text") + attr(div1, "class", "fn__flex-1") + attr(span, "class", "fn__space") + attr(label, "class", "fn__flex b3-label config__item") + }, + m(target, anchor) { + insert(target, label, anchor) + append(label, div1) + append(div1, t0) + append(div1, t1) + append(div1, div0) + append(div0, t2) + append(label, t3) + append(label, span) + append(label, t4) + if (if_block) if_block.m(label, null) + append(label, t5) + }, + p(ctx2, dirty) { + if (dirty /*configs*/ & 1 && t0_value !== (t0_value = /*config*/ ctx2[5].label + "")) set_data(t0, t0_value) + if (dirty /*configs*/ & 1 && t2_value !== (t2_value = /*config*/ ctx2[5].tip + "")) set_data(t2, t2_value) + if (current_block_type === (current_block_type = select_block_type(ctx2)) && if_block) { + if_block.p(ctx2, dirty) + } else { + if (if_block) if_block.d(1) + if_block = current_block_type && current_block_type(ctx2) + if (if_block) { + if_block.c() + if_block.m(label, t5) + } + } + }, + d(detaching) { + if (detaching) detach(label) + if (if_block) { + if_block.d() + } + }, + } +} +function create_fragment$6(ctx) { + let each_1_anchor + let each_value = + /*configs*/ + ctx[0] + let each_blocks = [] + for (let i = 0; i < each_value.length; i += 1) { + each_blocks[i] = create_each_block$3(get_each_context$3(ctx, each_value, i)) + } + return { + c() { + for (let i = 0; i < each_blocks.length; i += 1) { + each_blocks[i].c() + } + each_1_anchor = empty() + }, + m(target, anchor) { + for (let i = 0; i < each_blocks.length; i += 1) { + each_blocks[i].m(target, anchor) + } + insert(target, each_1_anchor, anchor) + }, + p(ctx2, [dirty]) { + if (dirty /*configs*/ & 1) { + each_value = /*configs*/ ctx2[0] + let i + for (i = 0; i < each_value.length; i += 1) { + const child_ctx = get_each_context$3(ctx2, each_value, i) + if (each_blocks[i]) { + each_blocks[i].p(child_ctx, dirty) + } else { + each_blocks[i] = create_each_block$3(child_ctx) + each_blocks[i].c() + each_blocks[i].m(each_1_anchor.parentNode, each_1_anchor) + } + } + for (; i < each_blocks.length; i += 1) { + each_blocks[i].d(1) + } + each_blocks.length = each_value.length + } + }, + i: noop, + o: noop, + d(detaching) { + destroy_each(each_blocks, detaching) + if (detaching) detach(each_1_anchor) + }, + } +} +function instance$6($$self, $$props, $$invalidate) { + const storageManager = container.get(TYPES.StorageManager) + const pluginSystem = container.get(TYPES.PluginSystem) + let configs = [ + { + label: _("safemode"), + tip: _("safemodetip"), + checked: true, + type: "checkbox", + onChange: (event) => { + const checked = event.target.checked + if (checked) { + pluginSystem.turnOnSafeMode() + } else { + pluginSystem.turnOffSafeMode() + } + }, + }, + // { + // label: _('autoupgrade'), + // tip: _('autoupgradetip'), + // checked: true, + // type: 'checkbox', + // onChange: (event) => { + // storageManager.set(PLUGIN_SYSTEM_AUTO_UPDATE, event.target.checked); + // }, + // }, + { + label: _("store_url"), + tip: `${_("store_url_tip")} ${defaultConfig.PLUGIN_STORE_URL}`, + type: "input", + value: storageManager.get(PLUGIN_STORE_URL), + onChange: (event) => { + storageManager.set(PLUGIN_STORE_URL, event.target.value) + }, + }, + ] + onMount(() => { + const securityMode = storageManager.get(PLUGIN_SYSTEM_SAFE_MODE_ENABLED) + $$invalidate(0, (configs[0].checked = securityMode), configs) + const autoUpdate = storageManager.get(PLUGIN_SYSTEM_AUTO_UPDATE) + $$invalidate(0, (configs[1].checked = autoUpdate), configs) + }) + function input_change_handler(each_value, config_index) { + each_value[config_index].checked = this.checked + $$invalidate(0, configs) + } + function input_input_handler(each_value, config_index) { + each_value[config_index].value = this.value + $$invalidate(0, configs) + } + return [configs, input_change_handler, input_input_handler] +} +class Setting_common extends SvelteComponent { + constructor(options) { + super() + init(this, options, instance$6, create_fragment$6, safe_not_equal, {}) + } +} +const settingList_svelte_svelte_type_style_lang = "" +function get_each_context$2(ctx, list, i) { + const child_ctx = ctx.slice() + child_ctx[10] = list[i] + child_ctx[11] = list + child_ctx[12] = i + return child_ctx +} +function create_if_block$3(ctx) { + let label + let div1 + let t0_value = + /*plugin*/ + ctx[10].name + "" + let t0 + let t1 + let t2_value = + /*plugin*/ + ctx[10].version + "" + let t2 + let t3 + let span0 + let t5 + let div0 + let t6_value = + /*plugin*/ + (ctx[10].description || _("nodescription")) + "" + let t6 + let t7 + let span1 + let t8 + let input + let t9 + let mounted + let dispose + function click_handler(...args) { + return ( + /*click_handler*/ + ctx[4]( + /*plugin*/ + ctx[10], + ...args + ) + ) + } + function input_change_handler() { + ctx[5].call( + input, + /*each_value*/ + ctx[11], + /*plugin_index*/ + ctx[12] + ) + } + return { + c() { + label = element("label") + div1 = element("div") + t0 = text(t0_value) + t1 = space() + t2 = text(t2_value) + t3 = space() + span0 = element("span") + span0.textContent = `${_("uninstall")}` + t5 = space() + div0 = element("div") + t6 = text(t6_value) + t7 = space() + span1 = element("span") + t8 = space() + input = element("input") + t9 = space() + attr(span0, "class", "remove svelte-bwhxpp") + attr(div0, "class", "b3-label__text") + attr(div1, "class", "plugin fn__flex-1 svelte-bwhxpp") + attr(span1, "class", "fn__space") + attr(input, "class", "b3-switch fn__flex-center") + attr(input, "id", "fullWidth") + attr(input, "type", "checkbox") + attr(label, "class", "fn__flex b3-label") + }, + m(target, anchor) { + insert(target, label, anchor) + append(label, div1) + append(div1, t0) + append(div1, t1) + append(div1, t2) + append(div1, t3) + append(div1, span0) + append(div1, t5) + append(div1, div0) + append(div0, t6) + append(label, t7) + append(label, span1) + append(label, t8) + append(label, input) + input.checked = /*plugin*/ ctx[10].enabled + append(label, t9) + if (!mounted) { + dispose = [ + listen(span0, "click", click_handler), + listen(input, "change", input_change_handler), + listen(input, "change", function () { + if ( + is_function( + /*onPluginEnabledChange*/ + ctx[1]( + /*plugin*/ + ctx[10].key + ) + ) + ) + ctx[1]( + /*plugin*/ + ctx[10].key + ).apply(this, arguments) + }), + ] + mounted = true + } + }, + p(new_ctx, dirty) { + ctx = new_ctx + if (dirty /*outsidePlugins*/ & 1 && t0_value !== (t0_value = /*plugin*/ ctx[10].name + "")) set_data(t0, t0_value) + if (dirty /*outsidePlugins*/ & 1 && t2_value !== (t2_value = /*plugin*/ ctx[10].version + "")) + set_data(t2, t2_value) + if ( + dirty /*outsidePlugins*/ & 1 && + t6_value !== (t6_value = /*plugin*/ (ctx[10].description || _("nodescription")) + "") + ) + set_data(t6, t6_value) + if (dirty /*outsidePlugins*/ & 1) { + input.checked = /*plugin*/ ctx[10].enabled + } + }, + d(detaching) { + if (detaching) detach(label) + mounted = false + run_all(dispose) + }, + } +} +function create_each_block$2(ctx) { + let if_block_anchor + let if_block = !(/*plugin*/ ctx[10].hidden) && create_if_block$3(ctx) + return { + c() { + if (if_block) if_block.c() + if_block_anchor = empty() + }, + m(target, anchor) { + if (if_block) if_block.m(target, anchor) + insert(target, if_block_anchor, anchor) + }, + p(ctx2, dirty) { + if (!(/*plugin*/ ctx2[10].hidden)) { + if (if_block) { + if_block.p(ctx2, dirty) + } else { + if_block = create_if_block$3(ctx2) + if_block.c() + if_block.m(if_block_anchor.parentNode, if_block_anchor) + } + } else if (if_block) { + if_block.d(1) + if_block = null + } + }, + d(detaching) { + if (if_block) if_block.d(detaching) + if (detaching) detach(if_block_anchor) + }, + } +} +function create_fragment$5(ctx) { + let label + let div + let each_value = + /*outsidePlugins*/ + ctx[0] + let each_blocks = [] + for (let i = 0; i < each_value.length; i += 1) { + each_blocks[i] = create_each_block$2(get_each_context$2(ctx, each_value, i)) + } + return { + c() { + label = element("label") + div = element("div") + for (let i = 0; i < each_blocks.length; i += 1) { + each_blocks[i].c() + } + attr(div, "class", "fn__flex-1") + attr(label, "class", "b3-label fn__flex") + }, + m(target, anchor) { + insert(target, label, anchor) + append(label, div) + for (let i = 0; i < each_blocks.length; i += 1) { + each_blocks[i].m(div, null) + } + }, + p(ctx2, [dirty]) { + if (dirty /*outsidePlugins, onPluginEnabledChange, _, uninstall*/ & 7) { + each_value = /*outsidePlugins*/ ctx2[0] + let i + for (i = 0; i < each_value.length; i += 1) { + const child_ctx = get_each_context$2(ctx2, each_value, i) + if (each_blocks[i]) { + each_blocks[i].p(child_ctx, dirty) + } else { + each_blocks[i] = create_each_block$2(child_ctx) + each_blocks[i].c() + each_blocks[i].m(div, null) + } + } + for (; i < each_blocks.length; i += 1) { + each_blocks[i].d(1) + } + each_blocks.length = each_value.length + } + }, + i: noop, + o: noop, + d(detaching) { + if (detaching) detach(label) + destroy_each(each_blocks, detaching) + }, + } +} +function instance$5($$self, $$props, $$invalidate) { + let outsidePlugins + const storageManager = container.get(TYPES.StorageManager) + const pluginSystem = container.get(TYPES.PluginSystem) + let plugins = [] + const loadPlugins = () => { + $$invalidate(3, (plugins = storageManager.getPlugins())) + } + const dispatcher = createEventDispatcher() + const onPluginEnabledChange = (key) => async (event) => { + const safeMode = storageManager.get(PLUGIN_SYSTEM_SAFE_MODE_ENABLED) + const checked = event.target.checked + await storageManager.setPluginEnabled(key, checked) + if (safeMode) { + return + } + if (checked) { + pluginSystem.loadPlugin(key) + } else { + pluginSystem.unloadPlugin(key) + } + dispatcher("update") + } + const uninstall2 = async (key, event) => { + event.preventDefault() + event.stopPropagation() + await pluginSystem.unloadPlugin(key) + await storageManager.uninstallPlugin(key) + await storageManager.initStorage() + loadPlugins() + } + onMount(async () => { + await storageManager.initStorage() + loadPlugins() + }) + const click_handler = (plugin2, event) => uninstall2(plugin2.key, event) + function input_change_handler(each_value, plugin_index) { + each_value[plugin_index].enabled = this.checked + $$invalidate(0, outsidePlugins), $$invalidate(3, plugins) + } + $$self.$$.update = () => { + if ($$self.$$.dirty /*plugins*/ & 8) { + $$invalidate(0, (outsidePlugins = plugins.filter((p) => p.script))) + } + } + return [outsidePlugins, onPluginEnabledChange, uninstall2, plugins, click_handler, input_change_handler] +} +class Setting_list extends SvelteComponent { + constructor(options) { + super() + init(this, options, instance$5, create_fragment$5, safe_not_equal, {}) + } +} +var __defProp$9 = Object.defineProperty +var __getOwnPropDesc$9 = Object.getOwnPropertyDescriptor +var __decorateClass$9 = (decorators, target, key, kind) => { + var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$9(target, key) : target + for (var i = decorators.length - 1, decorator; i >= 0; i--) + if ((decorator = decorators[i])) result = (kind ? decorator(target, key, result) : decorator(result)) || result + if (kind && result) __defProp$9(target, key, result) + return result +} +var __decorateParam$6 = (index, decorator) => (target, key) => decorator(target, key, index) +let Store = class { + constructor(storageManager) { + this.storageManager = storageManager + this.plugins = [] + this.pluginStatus = [] + } + async init() { + this.plugins = [] + this.pluginStatus = [] + await Promise.all([this.loadPluginsFromUrl(), this.storageManager.initStorage()]) + const plugins = this.storageManager.getPlugins() + const storePlugins = [] + for (const plugin2 of this.plugins) { + const p = { ...plugin2, isExist: false, needUpgrade: false } + const oldPlugin = plugins.find((p2) => p2.key === plugin2.key) + if (oldPlugin) { + p.isExist = true + const pV = new semver.SemVer(p.version) + const oldPluginV = new semver.SemVer(oldPlugin.version) + if (pV.compare(oldPluginV) === 1) { + p.needUpgrade = true + } + } + storePlugins.push(p) + } + this.pluginStatus = storePlugins + } + getStoreUrl() { + return this.storageManager.get(PLUGIN_STORE_URL) + } + getPlugins() { + return this.plugins + } + async loadPlugins() { + await this.init() + return this.getPluginsWithStatus() + } + getPluginsWithStatus() { + return this.pluginStatus + } + async loadPluginsFromUrl() { + var _a2, _b + const storeUrl = this.getStoreUrl() + if (!storeUrl) { + return + } + let res + try { + res = await request.get(storeUrl + "/plugins.json", { + headers: { + "Cache-Control": "no-cache", + }, + }) + } catch (e) { + console.error(e) + return + } + const req = [] + if (Array.isArray((_a2 = res.data) == null ? void 0 : _a2.plugins)) { + for (const pluginKey of ((_b = res.data) == null ? void 0 : _b.plugins) || {}) { + const plugin2 = this.getPluginManifest(`${storeUrl}/${pluginKey}`) + req.push(plugin2) + } + } + this.plugins = await Promise.all(req) + } + async getPluginByUrl(url2) { + return Promise.all([this.getPluginManifest(url2), this.getPluginMainJs(url2)]).then((value) => { + return { + manifest: value[0], + mainJs: value[1], + } + }) + } + async getPluginManifest(url2) { + try { + const manifest = await request.get(`${url2}/manifest.json`, { + headers: { + "Content-Type": "application/json", + "Cache-Control": "no-cache", + }, + }) + return manifest.data + } catch (e) { + console.error(e) + return null + } + } + async getPluginMainJs(url2) { + try { + const res = await request.get(`${url2}/main.js`, { + headers: { + "Content-Type": "text/plain", + "Cache-Control": "no-cache", + }, + }) + return res.data + } catch (e) { + console.error(e) + return null + } + } + async getPluginReadme(key) { + const url2 = `${this.getStoreUrl()}/${key}` + try { + const res = await request.get(`${url2}/README.md`, { + headers: { + "Content-Type": "text/plain", + "Cache-Control": "no-cache", + }, + }) + return res.data + } catch (e) { + console.error(e) + return null + } + } + async downloadPlugin(key) { + await sleep(500) + const files = await this.getPluginByUrl(`${this.getStoreUrl()}/${key}`) + const manifestJson = files.manifest + const mainJs = files.mainJs + return await Promise.all([ + FileClient.getInstanceApi().fileApi.putFile(`/data/plugins/${key}`, null, true), + FileClient.getInstanceApi().fileApi.putFile( + `/data/plugins/${key}/manifest.json`, + JSON.stringify(manifestJson), + false + ), + FileClient.getInstanceApi().fileApi.putFile(`/data/plugins/${key}/main.js`, mainJs, false), + ]) + } +} +Store = __decorateClass$9([injectable(), __decorateParam$6(0, inject(TYPES.StorageManager))], Store) +function create_fragment$4(ctx) { + let button + let current + let mounted + let dispose + const default_slot_template = + /*#slots*/ + ctx[3].default + const default_slot = create_slot( + default_slot_template, + ctx, + /*$$scope*/ + ctx[2], + null + ) + return { + c() { + button = element("button") + if (default_slot) default_slot.c() + button.disabled = /*disabled*/ ctx[1] + attr(button, "class", "b3-button") + }, + m(target, anchor) { + insert(target, button, anchor) + if (default_slot) { + default_slot.m(button, null) + } + current = true + if (!mounted) { + dispose = listen(button, "click", function () { + if ( + is_function( + /*onClick*/ + ctx[0] + ) + ) + ctx[0].apply(this, arguments) + }) + mounted = true + } + }, + p(new_ctx, [dirty]) { + ctx = new_ctx + if (default_slot) { + if (default_slot.p && (!current || dirty /*$$scope*/ & 4)) { + update_slot_base( + default_slot, + default_slot_template, + ctx, + /*$$scope*/ + ctx[2], + !current + ? get_all_dirty_from_scope( + /*$$scope*/ + ctx[2] + ) + : get_slot_changes( + default_slot_template, + /*$$scope*/ + ctx[2], + dirty, + null + ), + null + ) + } + } + if (!current || dirty /*disabled*/ & 2) { + button.disabled = /*disabled*/ ctx[1] + } + }, + i(local) { + if (current) return + transition_in(default_slot, local) + current = true + }, + o(local) { + transition_out(default_slot, local) + current = false + }, + d(detaching) { + if (detaching) detach(button) + if (default_slot) default_slot.d(detaching) + mounted = false + dispose() + }, + } +} +function instance$4($$self, $$props, $$invalidate) { + let { $$slots: slots = {}, $$scope } = $$props + let { onClick = null } = $$props + let { disabled = false } = $$props + $$self.$$set = ($$props2) => { + if ("onClick" in $$props2) $$invalidate(0, (onClick = $$props2.onClick)) + if ("disabled" in $$props2) $$invalidate(1, (disabled = $$props2.disabled)) + if ("$$scope" in $$props2) $$invalidate(2, ($$scope = $$props2.$$scope)) + } + return [onClick, disabled, $$scope, slots] +} +class Button extends SvelteComponent { + constructor(options) { + super() + init(this, options, instance$4, create_fragment$4, safe_not_equal, { onClick: 0, disabled: 1 }) + } +} +const settingPreview_svelte_svelte_type_style_lang = "" +function create_if_block_4$1(ctx) { + let div + let t0_value = _("url") + "" + let t0 + let t1 + let a2 + let t2_value = + /*plugin*/ + ctx[0].url + "" + let t2 + let a_href_value + return { + c() { + div = element("div") + t0 = text(t0_value) + t1 = text(": ") + a2 = element("a") + t2 = text(t2_value) + attr(a2, "href", (a_href_value = /*plugin*/ ctx[0].url)) + attr(a2, "target", "_blank") + attr(a2, "rel", "noreferrer") + attr(div, "class", "plugin-item") + }, + m(target, anchor) { + insert(target, div, anchor) + append(div, t0) + append(div, t1) + append(div, a2) + append(a2, t2) + }, + p(ctx2, dirty) { + if (dirty /*plugin*/ & 1 && t2_value !== (t2_value = /*plugin*/ ctx2[0].url + "")) set_data(t2, t2_value) + if (dirty /*plugin*/ & 1 && a_href_value !== (a_href_value = /*plugin*/ ctx2[0].url)) { + attr(a2, "href", a_href_value) + } + }, + d(detaching) { + if (detaching) detach(div) + }, + } +} +function create_if_block_3$1(ctx) { + let div + let t0_value = _("author") + "" + let t0 + let t1 + let t2_value = + /*plugin*/ + ctx[0].author + "" + let t2 + return { + c() { + div = element("div") + t0 = text(t0_value) + t1 = text(": ") + t2 = text(t2_value) + attr(div, "class", "plugin-item") + }, + m(target, anchor) { + insert(target, div, anchor) + append(div, t0) + append(div, t1) + append(div, t2) + }, + p(ctx2, dirty) { + if (dirty /*plugin*/ & 1 && t2_value !== (t2_value = /*plugin*/ ctx2[0].author + "")) set_data(t2, t2_value) + }, + d(detaching) { + if (detaching) detach(div) + }, + } +} +function create_if_block_2$1(ctx) { + let div + let t0_value = _("version") + "" + let t0 + let t1 + let t2_value = + /*plugin*/ + ctx[0].version + "" + let t2 + return { + c() { + div = element("div") + t0 = text(t0_value) + t1 = text(": ") + t2 = text(t2_value) + attr(div, "class", "plugin-item") + }, + m(target, anchor) { + insert(target, div, anchor) + append(div, t0) + append(div, t1) + append(div, t2) + }, + p(ctx2, dirty) { + if (dirty /*plugin*/ & 1 && t2_value !== (t2_value = /*plugin*/ ctx2[0].version + "")) set_data(t2, t2_value) + }, + d(detaching) { + if (detaching) detach(div) + }, + } +} +function create_if_block_1$2(ctx) { + let div + let t0_value = _("description") + "" + let t0 + let t1 + let t2_value = + /*plugin*/ + ctx[0].description + "" + let t2 + return { + c() { + div = element("div") + t0 = text(t0_value) + t1 = text(": ") + t2 = text(t2_value) + attr(div, "class", "plugin-item") + }, + m(target, anchor) { + insert(target, div, anchor) + append(div, t0) + append(div, t1) + append(div, t2) + }, + p(ctx2, dirty) { + if (dirty /*plugin*/ & 1 && t2_value !== (t2_value = /*plugin*/ ctx2[0].description + "")) set_data(t2, t2_value) + }, + d(detaching) { + if (detaching) detach(div) + }, + } +} +function create_else_block$2(ctx) { + let html_tag + let raw_value = + /*previewHTML*/ + ctx[2]() + "" + let html_anchor + return { + c() { + html_tag = new HtmlTag(false) + html_anchor = empty() + html_tag.a = html_anchor + }, + m(target, anchor) { + html_tag.m(raw_value, target, anchor) + insert(target, html_anchor, anchor) + }, + p(ctx2, dirty) { + if (dirty /*previewHTML*/ & 4 && raw_value !== (raw_value = /*previewHTML*/ ctx2[2]() + "")) html_tag.p(raw_value) + }, + d(detaching) { + if (detaching) detach(html_anchor) + if (detaching) html_tag.d() + }, + } +} +function create_if_block$2(ctx) { + let span + return { + c() { + span = element("span") + span.textContent = `${_("readme")}` + }, + m(target, anchor) { + insert(target, span, anchor) + }, + p: noop, + d(detaching) { + if (detaching) detach(span) + }, + } +} +function create_fragment$3(ctx) { + let div6 + let div4 + let div2 + let div0 + let t0_value = + /*plugin*/ + ctx[0].name + "" + let t0 + let t1 + let div1 + let t2 + let t3_value = + /*plugin*/ + ctx[0].key + "" + let t3 + let t4 + let t5 + let button + let svg + let use + let t6_value = _("goBack") + "" + let t6 + let t7 + let div3 + let t8 + let t9 + let t10 + let t11 + let hr + let t12 + let div5 + let mounted + let dispose + let if_block0 = + /*plugin*/ + ctx[0].url && create_if_block_4$1(ctx) + let if_block1 = + /*plugin*/ + ctx[0].author && create_if_block_3$1(ctx) + let if_block2 = + /*plugin*/ + ctx[0].version && create_if_block_2$1(ctx) + let if_block3 = + /*plugin*/ + ctx[0].description && create_if_block_1$2(ctx) + function select_block_type(ctx2, dirty) { + if ( + /*loading*/ + ctx2[1] + ) + return create_if_block$2 + return create_else_block$2 + } + let current_block_type = select_block_type(ctx) + let if_block4 = current_block_type(ctx) + return { + c() { + div6 = element("div") + div4 = element("div") + div2 = element("div") + div0 = element("div") + t0 = text(t0_value) + t1 = space() + div1 = element("div") + t2 = text("(") + t3 = text(t3_value) + t4 = text(")") + t5 = space() + button = element("button") + svg = svg_element("svg") + use = svg_element("use") + t6 = text(t6_value) + t7 = space() + div3 = element("div") + if (if_block0) if_block0.c() + t8 = space() + if (if_block1) if_block1.c() + t9 = space() + if (if_block2) if_block2.c() + t10 = space() + if (if_block3) if_block3.c() + t11 = space() + hr = element("hr") + t12 = space() + div5 = element("div") + if_block4.c() + attr(div0, "class", "plugin-name svelte-bj9chc") + attr(div1, "class", "plugin-key svelte-bj9chc") + xlink_attr(use, "xlink:href", "#iconBack") + attr(svg, "class", "go-back-icon svelte-bj9chc") + attr(button, "class", "go-back b3-button svelte-bj9chc") + attr(div2, "class", "plugin-info svelte-bj9chc") + attr(div3, "class", "plugin-manifest svelte-bj9chc") + attr(div4, "class", "plugin-basic") + attr(div5, "class", "plugin-readme b3-typography svelte-bj9chc") + attr(div6, "class", "plugin-detail svelte-bj9chc") + }, + m(target, anchor) { + insert(target, div6, anchor) + append(div6, div4) + append(div4, div2) + append(div2, div0) + append(div0, t0) + append(div2, t1) + append(div2, div1) + append(div1, t2) + append(div1, t3) + append(div1, t4) + append(div2, t5) + append(div2, button) + append(button, svg) + append(svg, use) + append(button, t6) + append(div4, t7) + append(div4, div3) + if (if_block0) if_block0.m(div3, null) + append(div3, t8) + if (if_block1) if_block1.m(div3, null) + append(div3, t9) + if (if_block2) if_block2.m(div3, null) + append(div3, t10) + if (if_block3) if_block3.m(div3, null) + append(div6, t11) + append(div6, hr) + append(div6, t12) + append(div6, div5) + if_block4.m(div5, null) + if (!mounted) { + dispose = listen( + button, + "click", + /*click_handler*/ + ctx[5] + ) + mounted = true + } + }, + p(ctx2, [dirty]) { + if (dirty /*plugin*/ & 1 && t0_value !== (t0_value = /*plugin*/ ctx2[0].name + "")) set_data(t0, t0_value) + if (dirty /*plugin*/ & 1 && t3_value !== (t3_value = /*plugin*/ ctx2[0].key + "")) set_data(t3, t3_value) + if ( + /*plugin*/ + ctx2[0].url + ) { + if (if_block0) { + if_block0.p(ctx2, dirty) + } else { + if_block0 = create_if_block_4$1(ctx2) + if_block0.c() + if_block0.m(div3, t8) + } + } else if (if_block0) { + if_block0.d(1) + if_block0 = null + } + if ( + /*plugin*/ + ctx2[0].author + ) { + if (if_block1) { + if_block1.p(ctx2, dirty) + } else { + if_block1 = create_if_block_3$1(ctx2) + if_block1.c() + if_block1.m(div3, t9) + } + } else if (if_block1) { + if_block1.d(1) + if_block1 = null + } + if ( + /*plugin*/ + ctx2[0].version + ) { + if (if_block2) { + if_block2.p(ctx2, dirty) + } else { + if_block2 = create_if_block_2$1(ctx2) + if_block2.c() + if_block2.m(div3, t10) + } + } else if (if_block2) { + if_block2.d(1) + if_block2 = null + } + if ( + /*plugin*/ + ctx2[0].description + ) { + if (if_block3) { + if_block3.p(ctx2, dirty) + } else { + if_block3 = create_if_block_1$2(ctx2) + if_block3.c() + if_block3.m(div3, null) + } + } else if (if_block3) { + if_block3.d(1) + if_block3 = null + } + if (current_block_type === (current_block_type = select_block_type(ctx2)) && if_block4) { + if_block4.p(ctx2, dirty) + } else { + if_block4.d(1) + if_block4 = current_block_type(ctx2) + if (if_block4) { + if_block4.c() + if_block4.m(div5, null) + } + } + }, + i: noop, + o: noop, + d(detaching) { + if (detaching) detach(div6) + if (if_block0) if_block0.d() + if (if_block1) if_block1.d() + if (if_block2) if_block2.d() + if (if_block3) if_block3.d() + if_block4.d() + mounted = false + dispose() + }, + } +} +function instance$3($$self, $$props, $$invalidate) { + let previewHTML + const dispatch2 = createEventDispatcher() + let loading2 = true + let { plugin: plugin2 } = $$props + const getPluginReadme = async () => { + $$invalidate(4, (readme2 = await container.get("Store").getPluginReadme(plugin2.key))) + $$invalidate(1, (loading2 = false)) + } + let readme2 + const LuteMdConverter = window.Lute.New() + onMount(() => { + getPluginReadme() + }) + const goBack2 = () => { + dispatch2("goback") + } + const click_handler = () => goBack2() + $$self.$$set = ($$props2) => { + if ("plugin" in $$props2) $$invalidate(0, (plugin2 = $$props2.plugin)) + } + $$self.$$.update = () => { + if ($$self.$$.dirty /*readme*/ & 16) { + $$invalidate( + 2, + (previewHTML = () => { + return readme2 ? LuteMdConverter.Md2HTML(readme2) : "" + }) + ) + } + } + return [plugin2, loading2, previewHTML, goBack2, readme2, click_handler] +} +class Setting_preview extends SvelteComponent { + constructor(options) { + super() + init(this, options, instance$3, create_fragment$3, safe_not_equal, { plugin: 0 }) + } +} +function get_each_context$1(ctx, list, i) { + const child_ctx = ctx.slice() + child_ctx[11] = list[i] + return child_ctx +} +function create_else_block_2(ctx) { + let settingpreview + let current + settingpreview = new Setting_preview({ + props: { + plugin: + /*selectedPlugin*/ + ctx[3], + }, + }) + settingpreview.$on( + "goback", + /*goback_handler*/ + ctx[9] + ) + return { + c() { + create_component(settingpreview.$$.fragment) + }, + m(target, anchor) { + mount_component(settingpreview, target, anchor) + current = true + }, + p(ctx2, dirty) { + const settingpreview_changes = {} + if (dirty /*selectedPlugin*/ & 8) settingpreview_changes.plugin = /*selectedPlugin*/ ctx2[3] + settingpreview.$set(settingpreview_changes) + }, + i(local) { + if (current) return + transition_in(settingpreview.$$.fragment, local) + current = true + }, + o(local) { + transition_out(settingpreview.$$.fragment, local) + current = false + }, + d(detaching) { + destroy_component(settingpreview, detaching) + }, + } +} +function create_if_block_1$1(ctx) { + let div + let current + let each_value = + /*plugins*/ + ctx[0] + let each_blocks = [] + for (let i = 0; i < each_value.length; i += 1) { + each_blocks[i] = create_each_block$1(get_each_context$1(ctx, each_value, i)) + } + const out = (i) => + transition_out(each_blocks[i], 1, 1, () => { + each_blocks[i] = null + }) + return { + c() { + div = element("div") + for (let i = 0; i < each_blocks.length; i += 1) { + each_blocks[i].c() + } + attr(div, "class", "fn__flex-1") + }, + m(target, anchor) { + insert(target, div, anchor) + for (let i = 0; i < each_blocks.length; i += 1) { + each_blocks[i].m(div, null) + } + current = true + }, + p(ctx2, dirty) { + if (dirty /*_, loadingMap, plugins, downloadPlugin, previewPlugin*/ & 53) { + each_value = /*plugins*/ ctx2[0] + let i + for (i = 0; i < each_value.length; i += 1) { + const child_ctx = get_each_context$1(ctx2, each_value, i) + if (each_blocks[i]) { + each_blocks[i].p(child_ctx, dirty) + transition_in(each_blocks[i], 1) + } else { + each_blocks[i] = create_each_block$1(child_ctx) + each_blocks[i].c() + transition_in(each_blocks[i], 1) + each_blocks[i].m(div, null) + } + } + group_outros() + for (i = each_value.length; i < each_blocks.length; i += 1) { + out(i) + } + check_outros() + } + }, + i(local) { + if (current) return + for (let i = 0; i < each_value.length; i += 1) { + transition_in(each_blocks[i]) + } + current = true + }, + o(local) { + each_blocks = each_blocks.filter(Boolean) + for (let i = 0; i < each_blocks.length; i += 1) { + transition_out(each_blocks[i]) + } + current = false + }, + d(detaching) { + if (detaching) detach(div) + destroy_each(each_blocks, detaching) + }, + } +} +function create_if_block$1(ctx) { + let div + return { + c() { + div = element("div") + div.textContent = `${_("loading")}` + }, + m(target, anchor) { + insert(target, div, anchor) + }, + p: noop, + i: noop, + o: noop, + d(detaching) { + if (detaching) detach(div) + }, + } +} +function create_else_block_1(ctx) { + let button + let current + function func_1() { + return ( + /*func_1*/ + ctx[8]( + /*plugin*/ + ctx[11] + ) + ) + } + button = new Button({ + props: { + onClick: func_1, + $$slots: { default: [create_default_slot_3] }, + $$scope: { ctx }, + }, + }) + return { + c() { + create_component(button.$$.fragment) + }, + m(target, anchor) { + mount_component(button, target, anchor) + current = true + }, + p(new_ctx, dirty) { + ctx = new_ctx + const button_changes = {} + if (dirty /*plugins*/ & 1) button_changes.onClick = func_1 + if (dirty /*$$scope*/ & 16384) { + button_changes.$$scope = { dirty, ctx } + } + button.$set(button_changes) + }, + i(local) { + if (current) return + transition_in(button.$$.fragment, local) + current = true + }, + o(local) { + transition_out(button.$$.fragment, local) + current = false + }, + d(detaching) { + destroy_component(button, detaching) + }, + } +} +function create_if_block_3(ctx) { + let current_block_type_index + let if_block + let if_block_anchor + let current + const if_block_creators = [create_if_block_4, create_else_block$1] + const if_blocks = [] + function select_block_type_2(ctx2, dirty) { + if ( + /*plugin*/ + ctx2[11].needUpgrade + ) + return 0 + return 1 + } + current_block_type_index = select_block_type_2(ctx) + if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx) + return { + c() { + if_block.c() + if_block_anchor = empty() + }, + m(target, anchor) { + if_blocks[current_block_type_index].m(target, anchor) + insert(target, if_block_anchor, anchor) + current = true + }, + p(ctx2, dirty) { + let previous_block_index = current_block_type_index + current_block_type_index = select_block_type_2(ctx2) + if (current_block_type_index === previous_block_index) { + if_blocks[current_block_type_index].p(ctx2, dirty) + } else { + group_outros() + transition_out(if_blocks[previous_block_index], 1, 1, () => { + if_blocks[previous_block_index] = null + }) + check_outros() + if_block = if_blocks[current_block_type_index] + if (!if_block) { + if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2) + if_block.c() + } else { + if_block.p(ctx2, dirty) + } + transition_in(if_block, 1) + if_block.m(if_block_anchor.parentNode, if_block_anchor) + } + }, + i(local) { + if (current) return + transition_in(if_block) + current = true + }, + o(local) { + transition_out(if_block) + current = false + }, + d(detaching) { + if_blocks[current_block_type_index].d(detaching) + if (detaching) detach(if_block_anchor) + }, + } +} +function create_if_block_2(ctx) { + let button + let current + button = new Button({ + props: { + disabled: true, + $$slots: { default: [create_default_slot] }, + $$scope: { ctx }, + }, + }) + return { + c() { + create_component(button.$$.fragment) + }, + m(target, anchor) { + mount_component(button, target, anchor) + current = true + }, + p(ctx2, dirty) { + const button_changes = {} + if (dirty /*$$scope*/ & 16384) { + button_changes.$$scope = { dirty, ctx: ctx2 } + } + button.$set(button_changes) + }, + i(local) { + if (current) return + transition_in(button.$$.fragment, local) + current = true + }, + o(local) { + transition_out(button.$$.fragment, local) + current = false + }, + d(detaching) { + destroy_component(button, detaching) + }, + } +} +function create_default_slot_3(ctx) { + let t_value = _("download") + "" + let t2 + return { + c() { + t2 = text(t_value) + }, + m(target, anchor) { + insert(target, t2, anchor) + }, + p: noop, + d(detaching) { + if (detaching) detach(t2) + }, + } +} +function create_else_block$1(ctx) { + let button + let current + button = new Button({ + props: { + disabled: true, + $$slots: { default: [create_default_slot_2] }, + $$scope: { ctx }, + }, + }) + return { + c() { + create_component(button.$$.fragment) + }, + m(target, anchor) { + mount_component(button, target, anchor) + current = true + }, + p(ctx2, dirty) { + const button_changes = {} + if (dirty /*$$scope*/ & 16384) { + button_changes.$$scope = { dirty, ctx: ctx2 } + } + button.$set(button_changes) + }, + i(local) { + if (current) return + transition_in(button.$$.fragment, local) + current = true + }, + o(local) { + transition_out(button.$$.fragment, local) + current = false + }, + d(detaching) { + destroy_component(button, detaching) + }, + } +} +function create_if_block_4(ctx) { + let button + let current + function func() { + return ( + /*func*/ + ctx[7]( + /*plugin*/ + ctx[11] + ) + ) + } + button = new Button({ + props: { + onClick: func, + $$slots: { default: [create_default_slot_1] }, + $$scope: { ctx }, + }, + }) + return { + c() { + create_component(button.$$.fragment) + }, + m(target, anchor) { + mount_component(button, target, anchor) + current = true + }, + p(new_ctx, dirty) { + ctx = new_ctx + const button_changes = {} + if (dirty /*plugins*/ & 1) button_changes.onClick = func + if (dirty /*$$scope*/ & 16384) { + button_changes.$$scope = { dirty, ctx } + } + button.$set(button_changes) + }, + i(local) { + if (current) return + transition_in(button.$$.fragment, local) + current = true + }, + o(local) { + transition_out(button.$$.fragment, local) + current = false + }, + d(detaching) { + destroy_component(button, detaching) + }, + } +} +function create_default_slot_2(ctx) { + let t_value = _("downloaded") + "" + let t2 + return { + c() { + t2 = text(t_value) + }, + m(target, anchor) { + insert(target, t2, anchor) + }, + p: noop, + d(detaching) { + if (detaching) detach(t2) + }, + } +} +function create_default_slot_1(ctx) { + let t_value = _("upgrade") + "" + let t2 + return { + c() { + t2 = text(t_value) + }, + m(target, anchor) { + insert(target, t2, anchor) + }, + p: noop, + d(detaching) { + if (detaching) detach(t2) + }, + } +} +function create_default_slot(ctx) { + let t_value = _("downloading") + "" + let t2 + return { + c() { + t2 = text(t_value) + }, + m(target, anchor) { + insert(target, t2, anchor) + }, + p: noop, + d(detaching) { + if (detaching) detach(t2) + }, + } +} +function create_each_block$1(ctx) { + let label + let div1 + let a2 + let t0_value = + /*plugin*/ + ctx[11].name + "" + let t0 + let t1 + let t2_value = + /*plugin*/ + ctx[11].version + "" + let t2 + let t3 + let div0 + let t4_value = + /*plugin*/ + (ctx[11].description || "") + "" + let t4 + let t5 + let span + let t6 + let current_block_type_index + let if_block + let t7 + let current + let mounted + let dispose + function click_handler(...args) { + return ( + /*click_handler*/ + ctx[6]( + /*plugin*/ + ctx[11], + ...args + ) + ) + } + const if_block_creators = [create_if_block_2, create_if_block_3, create_else_block_1] + const if_blocks = [] + function select_block_type_1(ctx2, dirty) { + if ( + /*loadingMap*/ + ctx2[2][ + /*plugin*/ + ctx2[11].key + ] + ) + return 0 + if ( + /*plugin*/ + ctx2[11].isExist + ) + return 1 + return 2 + } + current_block_type_index = select_block_type_1(ctx) + if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx) + return { + c() { + label = element("label") + div1 = element("div") + a2 = element("a") + t0 = text(t0_value) + t1 = space() + t2 = text(t2_value) + t3 = space() + div0 = element("div") + t4 = text(t4_value) + t5 = space() + span = element("span") + t6 = space() + if_block.c() + t7 = space() + attr(a2, "href", "javascript:void(0)") + attr(a2, "class", "") + attr(div0, "class", "b3-label__text") + attr(div1, "class", "fn__flex-1") + attr(span, "class", "fn__space") + attr(label, "class", "fn__flex b3-label") + }, + m(target, anchor) { + insert(target, label, anchor) + append(label, div1) + append(div1, a2) + append(a2, t0) + append(div1, t1) + append(div1, t2) + append(div1, t3) + append(div1, div0) + append(div0, t4) + append(label, t5) + append(label, span) + append(label, t6) + if_blocks[current_block_type_index].m(label, null) + append(label, t7) + current = true + if (!mounted) { + dispose = listen(a2, "click", click_handler) + mounted = true + } + }, + p(new_ctx, dirty) { + ctx = new_ctx + if ((!current || dirty /*plugins*/ & 1) && t0_value !== (t0_value = /*plugin*/ ctx[11].name + "")) + set_data(t0, t0_value) + if ((!current || dirty /*plugins*/ & 1) && t2_value !== (t2_value = /*plugin*/ ctx[11].version + "")) + set_data(t2, t2_value) + if ((!current || dirty /*plugins*/ & 1) && t4_value !== (t4_value = /*plugin*/ (ctx[11].description || "") + "")) + set_data(t4, t4_value) + let previous_block_index = current_block_type_index + current_block_type_index = select_block_type_1(ctx) + if (current_block_type_index === previous_block_index) { + if_blocks[current_block_type_index].p(ctx, dirty) + } else { + group_outros() + transition_out(if_blocks[previous_block_index], 1, 1, () => { + if_blocks[previous_block_index] = null + }) + check_outros() + if_block = if_blocks[current_block_type_index] + if (!if_block) { + if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx) + if_block.c() + } else { + if_block.p(ctx, dirty) + } + transition_in(if_block, 1) + if_block.m(label, t7) + } + }, + i(local) { + if (current) return + transition_in(if_block) + current = true + }, + o(local) { + transition_out(if_block) + current = false + }, + d(detaching) { + if (detaching) detach(label) + if_blocks[current_block_type_index].d() + mounted = false + dispose() + }, + } +} +function create_fragment$2(ctx) { + let div + let current_block_type_index + let if_block + let current + const if_block_creators = [create_if_block$1, create_if_block_1$1, create_else_block_2] + const if_blocks = [] + function select_block_type(ctx2, dirty) { + if ( + /*loading*/ + ctx2[1] + ) + return 0 + if (!(/*selectedPlugin*/ ctx2[3])) return 1 + return 2 + } + current_block_type_index = select_block_type(ctx) + if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx) + return { + c() { + div = element("div") + if_block.c() + attr(div, "class", "b3-label fn__flex") + }, + m(target, anchor) { + insert(target, div, anchor) + if_blocks[current_block_type_index].m(div, null) + current = true + }, + p(ctx2, [dirty]) { + let previous_block_index = current_block_type_index + current_block_type_index = select_block_type(ctx2) + if (current_block_type_index === previous_block_index) { + if_blocks[current_block_type_index].p(ctx2, dirty) + } else { + group_outros() + transition_out(if_blocks[previous_block_index], 1, 1, () => { + if_blocks[previous_block_index] = null + }) + check_outros() + if_block = if_blocks[current_block_type_index] + if (!if_block) { + if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2) + if_block.c() + } else { + if_block.p(ctx2, dirty) + } + transition_in(if_block, 1) + if_block.m(div, null) + } + }, + i(local) { + if (current) return + transition_in(if_block) + current = true + }, + o(local) { + transition_out(if_block) + current = false + }, + d(detaching) { + if (detaching) detach(div) + if_blocks[current_block_type_index].d() + }, + } +} +function instance$2($$self, $$props, $$invalidate) { + const store = container.get(TYPES.Store) + let plugins = [] + let loading2 = true + const loadingMap = {} + onMount(async () => { + $$invalidate(0, (plugins = await store.loadPlugins())) + $$invalidate(1, (loading2 = false)) + }) + const downloadPlugin = async (key) => { + if (loadingMap[key]) { + return + } + try { + $$invalidate(2, (loadingMap[key] = true), loadingMap) + await store.downloadPlugin(key) + const p = plugins.find((k2) => k2.key === key) + if (p) { + p.isExist = true + p.needUpgrade = false + } + } finally { + $$invalidate(2, (loadingMap[key] = false), loadingMap) + } + } + let selectedPlugin = null + const previewPlugin = (event, plugin2) => { + $$invalidate(3, (selectedPlugin = plugin2)) + event.stopPropagation() + event.preventDefault() + } + const click_handler = (plugin2, event) => previewPlugin(event, plugin2) + const func = (plugin2) => downloadPlugin(plugin2.key) + const func_1 = (plugin2) => downloadPlugin(plugin2.key) + const goback_handler = () => $$invalidate(3, (selectedPlugin = null)) + return [ + plugins, + loading2, + loadingMap, + selectedPlugin, + downloadPlugin, + previewPlugin, + click_handler, + func, + func_1, + goback_handler, + ] +} +class Setting_store extends SvelteComponent { + constructor(options) { + super() + init(this, options, instance$2, create_fragment$2, safe_not_equal, {}) + } +} +function create_fragment$1(ctx) { + let div + return { + c() { + div = element("div") + attr(div, "id", "setting-custom-render") + }, + m(target, anchor) { + insert(target, div, anchor) + }, + p: noop, + i: noop, + o: noop, + d(detaching) { + if (detaching) detach(div) + }, + } +} +function instance$1($$self, $$props, $$invalidate) { + let root + let { render: render2 } = $$props + onMount(() => { + $$invalidate(1, (root = document.createElement("div"))) + document.getElementById("setting-custom-render").appendChild(root) + render2(root) + }) + $$self.$$set = ($$props2) => { + if ("render" in $$props2) $$invalidate(0, (render2 = $$props2.render)) + } + $$self.$$.update = () => { + if ($$self.$$.dirty /*root, render*/ & 3) { + { + const el = document.getElementById("setting-custom-render") + if (el) { + if (root) { + root.remove() + } + $$invalidate(1, (root = document.createElement("div"))) + document.getElementById("setting-custom-render").appendChild(root) + render2(root) + } + } + } + } + return [render2, root] +} +class Setting_custom extends SvelteComponent { + constructor(options) { + super() + init(this, options, instance$1, create_fragment$1, safe_not_equal, { render: 0 }) + } +} +function get_each_context(ctx, list, i) { + const child_ctx = ctx.slice() + child_ctx[13] = list[i] + return child_ctx +} +function get_each_context_1(ctx, list, i) { + const child_ctx = ctx.slice() + child_ctx[13] = list[i] + return child_ctx +} +function create_each_block_1(ctx) { + let li + let span + let t_value = + /*menu*/ + ctx[13].name + "" + let t2 + let li_class_value + let mounted + let dispose + function click_handler() { + return ( + /*click_handler*/ + ctx[6]( + /*menu*/ + ctx[13] + ) + ) + } + return { + c() { + li = element("li") + span = element("span") + t2 = text(t_value) + attr(span, "class", "b3-list-item__text") + attr( + li, + "data-name", + /*menu*/ + ctx[13].key + ) + attr( + li, + "class", + (li_class_value = + /*currentSelection*/ + ctx[0].key /*menu*/ === ctx[13].key + ? "b3-list-item--focus b3-list-item b3-list-item--big" + : "b3-list-item b3-list-item--big") + ) + }, + m(target, anchor) { + insert(target, li, anchor) + append(li, span) + append(span, t2) + if (!mounted) { + dispose = listen(li, "click", click_handler) + mounted = true + } + }, + p(new_ctx, dirty) { + ctx = new_ctx + if ( + dirty /*currentSelection*/ & 1 && + li_class_value !== + (li_class_value = + /*currentSelection*/ + ctx[0].key /*menu*/ === ctx[13].key + ? "b3-list-item--focus b3-list-item b3-list-item--big" + : "b3-list-item b3-list-item--big") + ) { + attr(li, "class", li_class_value) + } + }, + d(detaching) { + if (detaching) detach(li) + mounted = false + dispose() + }, + } +} +function create_if_block_1(ctx) { + let hr + return { + c() { + hr = element("hr") + set_style(hr, "margin", "12px") + }, + m(target, anchor) { + insert(target, hr, anchor) + }, + d(detaching) { + if (detaching) detach(hr) + }, + } +} +function create_each_block(ctx) { + let li + let span + let t0_value = + /*menu*/ + ctx[13].name + "" + let t0 + let t1 + let li_data_name_value + let li_class_value + let mounted + let dispose + function click_handler_1() { + return ( + /*click_handler_1*/ + ctx[7]( + /*menu*/ + ctx[13] + ) + ) + } + return { + c() { + li = element("li") + span = element("span") + t0 = text(t0_value) + t1 = space() + attr(span, "class", "b3-list-item__text") + attr(li, "data-name", (li_data_name_value = /*menu*/ ctx[13].key)) + attr( + li, + "class", + (li_class_value = + /*currentSelection*/ + ctx[0].key /*menu*/ === ctx[13].key + ? "b3-list-item--focus b3-list-item b3-list-item--big" + : "b3-list-item b3-list-item--big") + ) + }, + m(target, anchor) { + insert(target, li, anchor) + append(li, span) + append(span, t0) + append(li, t1) + if (!mounted) { + dispose = listen(li, "click", click_handler_1) + mounted = true + } + }, + p(new_ctx, dirty) { + ctx = new_ctx + if (dirty /*thirdMenus*/ & 2 && t0_value !== (t0_value = /*menu*/ ctx[13].name + "")) set_data(t0, t0_value) + if (dirty /*thirdMenus*/ & 2 && li_data_name_value !== (li_data_name_value = /*menu*/ ctx[13].key)) { + attr(li, "data-name", li_data_name_value) + } + if ( + dirty /*currentSelection, thirdMenus*/ & 3 && + li_class_value !== + (li_class_value = + /*currentSelection*/ + ctx[0].key /*menu*/ === ctx[13].key + ? "b3-list-item--focus b3-list-item b3-list-item--big" + : "b3-list-item b3-list-item--big") + ) { + attr(li, "class", li_class_value) + } + }, + d(detaching) { + if (detaching) detach(li) + mounted = false + dispose() + }, + } +} +function create_else_block(ctx) { + let settingcustom + let current + settingcustom = new Setting_custom({ + props: { + render: + /*currentSelection*/ + ctx[0].render, + }, + }) + return { + c() { + create_component(settingcustom.$$.fragment) + }, + m(target, anchor) { + mount_component(settingcustom, target, anchor) + current = true + }, + p(ctx2, dirty) { + const settingcustom_changes = {} + if (dirty /*currentSelection*/ & 1) settingcustom_changes.render = /*currentSelection*/ ctx2[0].render + settingcustom.$set(settingcustom_changes) + }, + i(local) { + if (current) return + transition_in(settingcustom.$$.fragment, local) + current = true + }, + o(local) { + transition_out(settingcustom.$$.fragment, local) + current = false + }, + d(detaching) { + destroy_component(settingcustom, detaching) + }, + } +} +function create_if_block(ctx) { + let switch_instance + let switch_instance_anchor + let current + var switch_value = + /*currentSelection*/ + ctx[0].component + function switch_props(ctx2) { + return {} + } + if (switch_value) { + switch_instance = construct_svelte_component(switch_value, switch_props()) + switch_instance.$on( + "update", + /*update_handler*/ + ctx[8] + ) + } + return { + c() { + if (switch_instance) create_component(switch_instance.$$.fragment) + switch_instance_anchor = empty() + }, + m(target, anchor) { + if (switch_instance) mount_component(switch_instance, target, anchor) + insert(target, switch_instance_anchor, anchor) + current = true + }, + p(ctx2, dirty) { + if (switch_value !== (switch_value = /*currentSelection*/ ctx2[0].component)) { + if (switch_instance) { + group_outros() + const old_component = switch_instance + transition_out(old_component.$$.fragment, 1, 0, () => { + destroy_component(old_component, 1) + }) + check_outros() + } + if (switch_value) { + switch_instance = construct_svelte_component(switch_value, switch_props()) + switch_instance.$on( + "update", + /*update_handler*/ + ctx2[8] + ) + create_component(switch_instance.$$.fragment) + transition_in(switch_instance.$$.fragment, 1) + mount_component(switch_instance, switch_instance_anchor.parentNode, switch_instance_anchor) + } else { + switch_instance = null + } + } + }, + i(local) { + if (current) return + if (switch_instance) transition_in(switch_instance.$$.fragment, local) + current = true + }, + o(local) { + if (switch_instance) transition_out(switch_instance.$$.fragment, local) + current = false + }, + d(detaching) { + if (detaching) detach(switch_instance_anchor) + if (switch_instance) destroy_component(switch_instance, detaching) + }, + } +} +function create_fragment(ctx) { + let div2 + let div1 + let ul + let t0 + let t1 + let t2 + let div0 + let current_block_type_index + let if_block1 + let div0_data_name_value + let current + let each_value_1 = + /*menus*/ + ctx[2] + let each_blocks_1 = [] + for (let i = 0; i < each_value_1.length; i += 1) { + each_blocks_1[i] = create_each_block_1(get_each_context_1(ctx, each_value_1, i)) + } + let if_block0 = + /*thirdMenus*/ + ctx[1].length > 0 && create_if_block_1() + let each_value = + /*thirdMenus*/ + ctx[1] + let each_blocks = [] + for (let i = 0; i < each_value.length; i += 1) { + each_blocks[i] = create_each_block(get_each_context(ctx, each_value, i)) + } + const if_block_creators = [create_if_block, create_else_block] + const if_blocks = [] + function select_block_type(ctx2, dirty) { + if ( + /*currentSelection*/ + ctx2[0].type === "internal" + ) + return 0 + return 1 + } + current_block_type_index = select_block_type(ctx) + if_block1 = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx) + return { + c() { + div2 = element("div") + div1 = element("div") + ul = element("ul") + for (let i = 0; i < each_blocks_1.length; i += 1) { + each_blocks_1[i].c() + } + t0 = space() + if (if_block0) if_block0.c() + t1 = space() + for (let i = 0; i < each_blocks.length; i += 1) { + each_blocks[i].c() + } + t2 = space() + div0 = element("div") + if_block1.c() + attr(ul, "class", "b3-tab-bar b3-list b3-list--background") + set_style(ul, "height", "unset", 1) + attr(div0, "class", "config__tab-container") + set_style(div0, "height", "unset", 1) + attr(div0, "data-name", (div0_data_name_value = /*currentSelection*/ ctx[0].key)) + attr(div1, "class", "fn__flex-1 fn__flex config__panel") + attr(div2, "class", "fn__flex-column") + set_style(div2, "border-radius", "4px") + set_style(div2, "overflow", "auto") + set_style(div2, "position", "relative") + set_style(div2, "height", "80vh") + }, + m(target, anchor) { + insert(target, div2, anchor) + append(div2, div1) + append(div1, ul) + for (let i = 0; i < each_blocks_1.length; i += 1) { + each_blocks_1[i].m(ul, null) + } + append(ul, t0) + if (if_block0) if_block0.m(ul, null) + append(ul, t1) + for (let i = 0; i < each_blocks.length; i += 1) { + each_blocks[i].m(ul, null) + } + append(div1, t2) + append(div1, div0) + if_blocks[current_block_type_index].m(div0, null) + current = true + }, + p(ctx2, [dirty]) { + if (dirty /*menus, currentSelection, setCurrentSelection*/ & 13) { + each_value_1 = /*menus*/ ctx2[2] + let i + for (i = 0; i < each_value_1.length; i += 1) { + const child_ctx = get_each_context_1(ctx2, each_value_1, i) + if (each_blocks_1[i]) { + each_blocks_1[i].p(child_ctx, dirty) + } else { + each_blocks_1[i] = create_each_block_1(child_ctx) + each_blocks_1[i].c() + each_blocks_1[i].m(ul, t0) + } + } + for (; i < each_blocks_1.length; i += 1) { + each_blocks_1[i].d(1) + } + each_blocks_1.length = each_value_1.length + } + if ( + /*thirdMenus*/ + ctx2[1].length > 0 + ) { + if (if_block0); + else { + if_block0 = create_if_block_1() + if_block0.c() + if_block0.m(ul, t1) + } + } else if (if_block0) { + if_block0.d(1) + if_block0 = null + } + if (dirty /*thirdMenus, currentSelection, setCurrentSelection*/ & 11) { + each_value = /*thirdMenus*/ ctx2[1] + let i + for (i = 0; i < each_value.length; i += 1) { + const child_ctx = get_each_context(ctx2, each_value, i) + if (each_blocks[i]) { + each_blocks[i].p(child_ctx, dirty) + } else { + each_blocks[i] = create_each_block(child_ctx) + each_blocks[i].c() + each_blocks[i].m(ul, null) + } + } + for (; i < each_blocks.length; i += 1) { + each_blocks[i].d(1) + } + each_blocks.length = each_value.length + } + let previous_block_index = current_block_type_index + current_block_type_index = select_block_type(ctx2) + if (current_block_type_index === previous_block_index) { + if_blocks[current_block_type_index].p(ctx2, dirty) + } else { + group_outros() + transition_out(if_blocks[previous_block_index], 1, 1, () => { + if_blocks[previous_block_index] = null + }) + check_outros() + if_block1 = if_blocks[current_block_type_index] + if (!if_block1) { + if_block1 = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2) + if_block1.c() + } else { + if_block1.p(ctx2, dirty) + } + transition_in(if_block1, 1) + if_block1.m(div0, null) + } + if ( + !current || + (dirty /*currentSelection*/ & 1 && + div0_data_name_value !== (div0_data_name_value = /*currentSelection*/ ctx2[0].key)) + ) { + attr(div0, "data-name", div0_data_name_value) + } + }, + i(local) { + if (current) return + transition_in(if_block1) + current = true + }, + o(local) { + transition_out(if_block1) + current = false + }, + d(detaching) { + if (detaching) detach(div2) + destroy_each(each_blocks_1, detaching) + if (if_block0) if_block0.d() + destroy_each(each_blocks, detaching) + if_blocks[current_block_type_index].d() + }, + } +} +function instance($$self, $$props, $$invalidate) { + let thirdMenus + const menus = [ + { + key: "common", + name: _("menu_common"), + type: "internal", + component: Setting_common, + }, + { + key: "list", + name: _("menu_list"), + type: "internal", + component: Setting_list, + }, + { + key: "store", + name: _("menu_store"), + type: "internal", + component: Setting_store, + }, + ] + const sm = container.get(TYPES.SettingManager) + const sm1 = container.get(TYPES.StorageManager) + const plugins = sm1.getThirdPartyPlugins() + let settingRenders = sm.getSettingRenders() + const getName = (key) => { + var _a2 + return (_a2 = plugins.find((p) => p.key === key)) == null ? void 0 : _a2.name + } + const setCurrentSelection = (menu) => $$invalidate(0, (currentSelection = menu)) + const updateMenus = () => { + $$invalidate(5, (settingRenders = [...sm.getSettingRenders()])) + } + let currentSelection = menus[0] + const click_handler = (menu) => setCurrentSelection(menu) + const click_handler_1 = (menu) => setCurrentSelection(menu) + const update_handler = () => updateMenus() + $$self.$$.update = () => { + if ($$self.$$.dirty /*settingRenders*/ & 32) { + $$invalidate( + 1, + (thirdMenus = settingRenders.map((s) => { + return { + key: s.key, + name: getName(s.key), + component: Setting_common, + type: "custom", + render: s.value, + } + })) + ) + } + } + return [ + currentSelection, + thirdMenus, + menus, + setCurrentSelection, + updateMenus, + settingRenders, + click_handler, + click_handler_1, + update_handler, + ] +} +class Setting extends SvelteComponent { + constructor(options) { + super() + init(this, options, instance, create_fragment, safe_not_equal, {}) + } +} +class InternalSettingPlugin extends Plugin { + constructor() { + super() + this.svg = + '' + } + onload() { + const internalSettingButton = document.createElement("button") + internalSettingButton.setAttribute("aria-label", _("plugin_system")) + internalSettingButton.classList.add("toolbar__item", "b3-tooltips", "b3-tooltips__sw") + internalSettingButton.insertAdjacentHTML("beforeend", this.svg) + internalSettingButton.addEventListener("click", (event) => { + new Menu("internalSettingButton") + .addItem( + new MenuItem({ + label: _("plugin_system_setting"), + icon: "iconEdit", + click: () => showSettingDialog(), + }) + ) + .addSeparator() + .addItem( + new MenuItem({ + label: _("reload"), + icon: "iconRefresh", + click: () => window.location.reload(), + }) + ) + .showAtMouseEvent(event) + event.stopPropagation() + }) + addToolbarRight(internalSettingButton) + this.registerCommand({ + command: "Show plugin system conifg", + description: _("show_plugin_system_config"), + shortcut: "command+option+p", + callback: () => showSettingDialog(), + }) + this.registerCommand({ + command: "Reload Window", + description: _("reload_window"), + callback: () => window.location.reload(), + }) + } +} +function showSettingDialog() { + new Dialog({ + title: _("plugin_system_setting"), + content: '
', + width: "90vw", + height: "80vh", + }) + setTimeout(() => { + new Setting({ + target: document.getElementById("plugin-settings"), + }) + }) +} +const internalPlugins = [ + { key: "setting", name: "setting", plugin: InternalSettingPlugin, enabled: true, hidden: true, version: "1.0.0" }, + { + key: "commandPanel", + name: "commandPanel", + plugin: CommandPanelPlugin, + enabled: true, + hidden: true, + version: "1.0.0", + }, +] +function isHighSurrogate$1(codePoint) { + return codePoint >= 55296 && codePoint <= 56319 +} +function isLowSurrogate$1(codePoint) { + return codePoint >= 56320 && codePoint <= 57343 +} +var truncate$2 = function truncate2(getLength2, string, byteLength) { + if (typeof string !== "string") { + throw new Error("Input must be string") + } + var charLength = string.length + var curByteLength = 0 + var codePoint + var segment + for (var i = 0; i < charLength; i += 1) { + codePoint = string.charCodeAt(i) + segment = string[i] + if (isHighSurrogate$1(codePoint) && isLowSurrogate$1(string.charCodeAt(i + 1))) { + i += 1 + segment += string[i] + } + curByteLength += getLength2(segment) + if (curByteLength === byteLength) { + return string.slice(0, i + 1) + } else if (curByteLength > byteLength) { + return string.slice(0, i - segment.length + 1) + } + } + return string +} +function isHighSurrogate(codePoint) { + return codePoint >= 55296 && codePoint <= 56319 +} +function isLowSurrogate(codePoint) { + return codePoint >= 56320 && codePoint <= 57343 +} +var browser$1 = function getByteLength(string) { + if (typeof string !== "string") { + throw new Error("Input must be string") + } + var charLength = string.length + var byteLength = 0 + var codePoint = null + var prevCodePoint = null + for (var i = 0; i < charLength; i++) { + codePoint = string.charCodeAt(i) + if (isLowSurrogate(codePoint)) { + if (prevCodePoint != null && isHighSurrogate(prevCodePoint)) { + byteLength += 1 + } else { + byteLength += 3 + } + } else if (codePoint <= 127) { + byteLength += 1 + } else if (codePoint >= 128 && codePoint <= 2047) { + byteLength += 2 + } else if (codePoint >= 2048 && codePoint <= 65535) { + byteLength += 3 + } + prevCodePoint = codePoint + } + return byteLength +} +var truncate$1 = truncate$2 +var getLength = browser$1 +var browser = truncate$1.bind(null, getLength) +var truncate = browser +var illegalRe = /[\/\?<>\\:\*\|"]/g +var controlRe = /[\x00-\x1f\x80-\x9f]/g +var reservedRe = /^\.+$/ +var windowsReservedRe = /^(con|prn|aux|nul|com[0-9]|lpt[0-9])(\..*)?$/i +var windowsTrailingRe = /[\. ]+$/ +function sanitize(input, replacement) { + if (typeof input !== "string") { + throw new Error("Input must be string") + } + var sanitized = input + .replace(illegalRe, replacement) + .replace(controlRe, replacement) + .replace(reservedRe, replacement) + .replace(windowsReservedRe, replacement) + .replace(windowsTrailingRe, replacement) + return truncate(sanitized, 255) +} +var sanitizeFilename = function (input, options) { + var replacement = (options && options.replacement) || "" + var output = sanitize(input, replacement) + if (replacement === "") { + return output + } + return sanitize(output, "") +} +var __defProp$8 = Object.defineProperty +var __getOwnPropDesc$8 = Object.getOwnPropertyDescriptor +var __decorateClass$8 = (decorators, target, key, kind) => { + var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$8(target, key) : target + for (var i = decorators.length - 1, decorator; i >= 0; i--) + if ((decorator = decorators[i])) result = (kind ? decorator(target, key, result) : decorator(result)) || result + if (kind && result) __defProp$8(target, key, result) + return result +} +var __decorateParam$5 = (index, decorator) => (target, key) => decorator(target, key, index) +let StorageManager = class { + constructor(pluginFileManager) { + this.config = Object.assign({}, defaultConfig) + this.pluginFileManager = pluginFileManager + } + get(key) { + return this.config[key] + } + async set(key, val) { + this.config[key] = val + return setStorageVal(key, val) + } + async initStorage() { + const all2 = await getLocalStorage() + const configKeys = Object.keys(defaultConfig) + for (const key of configKeys) { + if (all2[key] !== void 0) { + this.config[key] = all2[key] + } else { + await setStorageVal(key, defaultConfig[key]) + } + } + this.thirdPartyPlugins = await this.pluginFileManager.getAllPlugins() + this.internalPlugins = [...internalPlugins] + this.init3rdPartyEnabled() + this.initInternalEnabled() + await this.savePluginsEnabled() + return this + } + init3rdPartyEnabled() { + const enabledPlugins = this.get(PLUGIN_SYSTEM_THIRD_PARTY_PLUGIN) + for (const ep of enabledPlugins) { + for (const p of this.thirdPartyPlugins) { + if (p.key === ep.key) { + p.enabled = ep.enabled || false + break + } + } + } + } + initInternalEnabled() { + const enabledPlugins = this.get(PLUGIN_SYSTEM_PLUGIN) + for (const ep of enabledPlugins) { + for (const p of this.internalPlugins) { + if (p.key === ep.key) { + p.enabled = ep.enabled || false + break + } + } + } + } + getPlugins() { + return [...this.internalPlugins, ...this.thirdPartyPlugins] + } + getInternalPlugins() { + return this.internalPlugins + } + getThirdPartyPlugins() { + return this.thirdPartyPlugins + } + getPluginByKey(key) { + return this.getPlugins().find((p) => p.key === key) + } + async setPluginEnabled(key, enabled) { + for (const p of [...this.internalPlugins, ...this.thirdPartyPlugins]) { + if (p.key === key) { + p.enabled = enabled + break + } + } + await this.savePluginsEnabled() + } + async setSafeModeEnabled(enabled) { + return this.set(PLUGIN_SYSTEM_SAFE_MODE_ENABLED, enabled) + } + async savePluginsEnabled() { + await this.set( + PLUGIN_SYSTEM_PLUGIN, + this.internalPlugins.map((p) => ({ key: p.key, enabled: p.enabled })) + ) + return this.set( + PLUGIN_SYSTEM_THIRD_PARTY_PLUGIN, + this.thirdPartyPlugins.map((p) => ({ key: p.key, enabled: p.enabled })) + ) + } + async setPluginStorage(pluginKey, filename, content) { + try { + if (this.isFileNameIllegal(filename)) { + showErrorMessage(`插件${pluginKey}存储文件名不合法`) + return + } + await this.addPluginStorageFolderIfNotExist(pluginKey) + await FileClient.getInstanceApi().fileApi.putFile(`/data/plugins/.storage/${pluginKey}/${filename}`, content) + } catch (e) { + showErrorMessage(`插件${pluginKey}存储保存失败`, 2e3) + } + } + async getPluginStorage(pluginKey, filename) { + try { + return await FileClient.getInstanceApi().fileApi.getFile(`/data/plugins/.storage/${pluginKey}/${filename}`) + } catch (e) { + showErrorMessage(`插件${pluginKey}存储保存失败`, 2e3) + return null + } + } + async uninstallPlugin(pluginKey) { + await FileClient.getInstanceApi().fileApi.removeFile(`/data/plugins/${pluginKey}`) + await FileClient.getInstanceApi().fileApi.removeFile(`/data/plugins//.storage/${pluginKey}`) + } + async addPluginStorageFolderIfNotExist(pluginKey) { + const folder = `/data/plugins/.storage/${pluginKey}` + await FileClient.getInstanceApi().fileApi.putFile(folder, null, true) + } + isFileNameIllegal(filename) { + return filename !== sanitizeFilename(filename) + } +} +StorageManager = __decorateClass$8( + [injectable(), __decorateParam$5(0, inject(TYPES.PluginFileManager))], + StorageManager +) +var __defProp$7 = Object.defineProperty +var __getOwnPropDesc$7 = Object.getOwnPropertyDescriptor +var __decorateClass$7 = (decorators, target, key, kind) => { + var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$7(target, key) : target + for (var i = decorators.length - 1, decorator; i >= 0; i--) + if ((decorator = decorators[i])) result = (kind ? decorator(target, key, result) : decorator(result)) || result + if (kind && result) __defProp$7(target, key, result) + return result +} +var __decorateParam$4 = (index, decorator) => (target, key) => decorator(target, key, index) +let PluginSystem = class { + constructor(pluginLoader, pslm, storageManager, commandManager, store) { + this.pluginLoader = pluginLoader + this.pslm = pslm + this.storageManager = storageManager + this.commandManager = commandManager + this.store = store + this.version = VERSION$1 + } + async init() { + await this.storageManager.initStorage() + const internalPlugins2 = this.storageManager.getInternalPlugins() + this.pluginLoader.loadEnabledPlugins(internalPlugins2) + log(`Loading internal enabled plugins: ${internalPlugins2.map((p) => p.key).join(",")}`) + const securityModeEnabled = this.storageManager.get(PLUGIN_SYSTEM_SAFE_MODE_ENABLED) + if (!securityModeEnabled) { + const plugins = this.storageManager.getThirdPartyPlugins() + log(`Loading 3rd party enabled plugins: ${plugins.map((p) => p.key).join(",")}`) + this.pluginLoader.loadEnabledPlugins(plugins) + } + this.pslm.localCacheInit() + return this + } + async loadPlugin(key) { + this.storageManager.setPluginEnabled(key, true) + const plugin2 = this.storageManager.getPluginByKey(key) + this.pluginLoader.loadPlugin(plugin2) + } + async unloadPlugin(key) { + this.storageManager.setPluginEnabled(key, false) + this.pluginLoader.unloadPlugin(key) + } + async turnOffSafeMode() { + this.storageManager.setSafeModeEnabled(false) + const plugins = this.storageManager.getThirdPartyPlugins() + return this.pluginLoader.loadEnabledPlugins(plugins) + } + async turnOnSafeMode() { + this.storageManager.setSafeModeEnabled(true) + const plugins = this.storageManager.getThirdPartyPlugins() + return this.pluginLoader.unloadThirdPartyPlugins(plugins) + } +} +PluginSystem = __decorateClass$7( + [ + injectable(), + __decorateParam$4(0, inject(TYPES.PluginLoader)), + __decorateParam$4(1, inject(TYPES.SystemManager)), + __decorateParam$4(2, inject(TYPES.StorageManager)), + __decorateParam$4(3, inject(TYPES.CommandManager)), + __decorateParam$4(4, inject(TYPES.Store)), + ], + PluginSystem +) +const migrate = async () => { + const SNIPPET_NAME = "plugin-system-bazzar" + const content = `(async () => { + window.pluginSystemSource = 'bazzar'; + const response = await fetch('/api/file/getFile', { + method: 'POST', + mode: 'cors', + cache: 'no-cache', + credentials: 'same-origin', + headers: { + 'Content-Type': 'application/json', + }, + redirect: 'follow', + referrerPolicy: 'no-referrer', + body: JSON.stringify({ path: '/data/widgets/插件系统/plugin.js' }), + }); + const js = await response.text(); + eval(js); + })()` + const request2 = async (url2, body) => { + const response = await fetch(url2, { + method: "POST", + mode: "cors", + cache: "no-cache", + credentials: "same-origin", + headers: { + "Content-Type": "application/json", + }, + redirect: "follow", + referrerPolicy: "no-referrer", + body: JSON.stringify(body), + }) + return response.json() + } + const res = await request2("/api/snippet/getSnippet", { enabled: 2, type: "all" }) + const snippets = res.data.snippets + for (const snippet of snippets) { + if (snippet.type !== "js") { + continue + } + if (snippet.content.indexOf("https://gitee.com/zuoez02/siyuan-plugin-system/raw/main/main.js") !== -1) { + snippet.enabled = false + } + if (snippet.name === SNIPPET_NAME) { + snippet.enabled = true + snippet.content = content + await request2("/api/snippet/setSnippet", { snippets }) + return + } + } + snippets.splice(0, 0, { + id: "20230324100959-plugind", + name: SNIPPET_NAME, + type: "js", + enabled: true, + content, + }) + await request2("/api/snippet/setSnippet", { snippets }) + setTimeout(() => window.parent.location.reload(), 1e3) +} +var __defProp$6 = Object.defineProperty +var __getOwnPropDesc$6 = Object.getOwnPropertyDescriptor +var __decorateClass$6 = (decorators, target, key, kind) => { + var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$6(target, key) : target + for (var i = decorators.length - 1, decorator; i >= 0; i--) + if ((decorator = decorators[i])) result = (kind ? decorator(target, key, result) : decorator(result)) || result + if (kind && result) __defProp$6(target, key, result) + return result +} +var __decorateParam$3 = (index, decorator) => (target, key) => decorator(target, key, index) +const pluginScriptPosition = PLUGIN_SYS_ABS_PATH +let SystemManager = class { + constructor(storageManager) { + this.storageMangager = storageManager + } + async saveToLocal(p, content) { + FileClient.getInstanceApi().fileApi.putFile(p, content) + } + async localCacheInit() { + try { + const plugin2 = FileClient.getInstanceApi().fileApi.getFile(pluginScriptPosition) + if (plugin2 !== null) { + this.delayAutoUpgrade() + } + return + } catch (e) { + log("Plugin system not found") + } + const script2 = window.siyuanPluginScript + if (!script2) { + return + } + await this.saveToLocal(pluginScriptPosition, script2) + this.delayAutoUpgrade() + } + delayAutoUpgrade() { + return false + } + async tryUpgrade() { + log("Plugin bundled with zhi theme, upgrade skip") + return + if (window.pluginSystemSource === "bazzar") { + log("Plugin installed from bazzar version, upgrade skip") + this.compareWidgetVersion() + return + } + log("Try getting online version") + const onlineVersion = await this.getOnlineVersion() + if (onlineVersion !== VERSION$1) { + showInfoMessage(`插件系统获取到最新版本 ${onlineVersion}，即将自动更新`) + log("Online Version: " + onlineVersion + ", local version: " + VERSION$1) + log("Downloading new version of Plugin System") + this.upgrade() + } else { + log("Version is " + VERSION$1 + ", OK") + } + } + async getOnlineVersion() { + return fetch(VERSION_URL, { cache: "no-cache" }).then((res) => res.text()) + } + async upgrade() { + const script2 = await fetch(SCRIPT_URL, { cache: "no-cache" }).then((res) => res.text()) + if (!script2) { + return + } + migrate() + showInfoMessage("插件系统升级中，即将自动重载...") + await this.saveToLocal(pluginScriptPosition, script2) + log("Plugin system upgraded, reloading...") + setTimeout(() => reloadWindow(), 3e3) + } + async compareWidgetVersion() { + const res = await getBazzarWidget() + const packages = res.packages + const ps = packages.find((p) => p.name === "插件系统") + if (!ps) { + return + } + const latestVersion = ps.version + const result = new semver.SemVer(VERSION$1).compare(latestVersion) + if (result < 0) { + new Notification({ message: _("new_version_widget"), type: "info" }).show() + } + } +} +SystemManager = __decorateClass$6([injectable(), __decorateParam$3(0, inject(TYPES.StorageManager))], SystemManager) +var __defProp$5 = Object.defineProperty +var __getOwnPropDesc$5 = Object.getOwnPropertyDescriptor +var __decorateClass$5 = (decorators, target, key, kind) => { + var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$5(target, key) : target + for (var i = decorators.length - 1, decorator; i >= 0; i--) + if ((decorator = decorators[i])) result = (kind ? decorator(target, key, result) : decorator(result)) || result + if (kind && result) __defProp$5(target, key, result) + return result +} +var __decorateParam$2 = (index, decorator) => (target, key) => decorator(target, key, index) +let components +let PluginLoader = class { + constructor(pluginFileManager) { + this.pluginFileManager = pluginFileManager + this.loadedPlugins = /* @__PURE__ */ new Map() + } + async loadEnabledPlugins(plugins) { + if (!plugins || !plugins.length) { + return + } + for (const p of plugins) { + if (!p.enabled) { + continue + } + await this.loadPlugin(p) + } + } + async loadAllInternalPlugins() { + internalPlugins.forEach(async (p) => { + const plug2 = new p.plugin() + if (!(plug2 instanceof Plugin)) { + throw new Error(`Failed to load plugin ${p.name}`) + } + log(`Load internal plugin: ${p.key}(${p.name})`) + this.addAdditionalMethod(plug2, p.key, p.name) + await plug2.onload() + this.loadedPlugins.set(p.key, plug2) + }) + } + async loadAllLocalPlugins() { + const plugins = await this.pluginFileManager.getAllPlugins() + if (!plugins) { + return + } + for (const p of plugins) { + await this.loadPlugin(p) + } + } + async loadPlugin(plugin) { + if (!components) { + this.generateRequiredModules() + } + if (!plugin.enabled || (!plugin.plugin && !plugin.script)) { + return + } + if (plugin.plugin) { + const plug2 = new plugin.plugin() + if (!(plug2 instanceof Plugin)) { + throw new Error(`Failed to load plugin ${plugin.name}`) + } + log(`Load internal plugin: ${plugin.key}(${plugin.name})`) + this.addAdditionalMethod(plug2, plugin.key, plugin.name) + await plug2.onload() + this.loadedPlugins.set(plugin.key, plug2) + return + } + const exports = {} + const module = { exports } + function run(script, name) { + return eval( + "(function anonymous(require,module,exports){".concat(script, "\n})\n//# sourceURL=").concat(name, "\n") + ) + } + const __require = (name2) => { + if (components[name2]) { + return components[name2] + } + throw new Error(`module ${name2} not found`) + } + const pluginName = plugin.key + try { + run(plugin.script, plugin.key)(__require, module, exports) + } catch (e) { + error("Error plugin:" + plugin.key + " ->", e) + return + } + let pluginConstructor + if (!(pluginConstructor = (module.exports || exports).default || module.exports)) { + throw new Error(`Failed to load plugin ${pluginName}. No exports detected.`) + } + const plug = new pluginConstructor() + if (!(plug instanceof Plugin)) { + throw new Error(`Failed to load plugin ${pluginName}`) + } + this.addAdditionalMethod(plug, plugin.key, pluginName) + try { + await plug.onload() + this.loadedPlugins.set(plugin.key, plug) + } catch (e) { + error("Error plugin:" + plugin.key + " ->", e) + } + } + async unloadPlugin(key) { + const plugin2 = this.loadedPlugins.get(key) + if (!plugin2) { + return + } + plugin2.onunload() + container.get(TYPES.CommandManager).unregisterCommandByPlugin(key) + container.get(TYPES.SettingManager).unregisterSetting(key) + this.loadedPlugins.delete(key) + } + async unloadThirdPartyPlugins(plugins) { + const keys = plugins.filter((p) => p.enabled).map((p) => p.key) + for (const k2 of keys) { + log(`unload third party plugin: ${k2}`) + await this.unloadPlugin(k2) + } + } + async loadThirdPartyEnabledPlugins(plugins) { + return this.loadEnabledPlugins(plugins) + } + generateRequiredModules() { + components = { + siyuan: api, + axios: axios$1, + } + } + addAdditionalMethod(plugin2, pluginKey, pluginName2) { + plugin2.registerCommand = (command) => { + const cm = container.get(TYPES.CommandManager) + cm.registerCommand({ + ...command, + plugin: pluginKey, + pluginName: pluginName2, + }) + } + const sm = container.get(TYPES.StorageManager) + plugin2.writeStorage = async (filename, content) => { + return await sm.setPluginStorage(pluginKey, filename, content) + } + plugin2.loadStorage = async (filename) => { + return await sm.getPluginStorage(pluginKey, filename) + } + plugin2.registerSettingRender = (settingRender) => { + const cm = container.get(TYPES.SettingManager) + cm.registerSetting(pluginKey, settingRender) + } + } +} +PluginLoader = __decorateClass$5([injectable(), __decorateParam$2(0, inject(TYPES.PluginFileManager))], PluginLoader) +var __defProp$4 = Object.defineProperty +var __getOwnPropDesc$4 = Object.getOwnPropertyDescriptor +var __decorateClass$4 = (decorators, target, key, kind) => { + var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$4(target, key) : target + for (var i = decorators.length - 1, decorator; i >= 0; i--) + if ((decorator = decorators[i])) result = (kind ? decorator(target, key, result) : decorator(result)) || result + if (kind && result) __defProp$4(target, key, result) + return result +} +let PluginFileManager = class { + async scanPlugins(pluginFolder) { + const res = await FileClient.getInstanceApi().fileApi.readDir(pluginFolder) + if (!res) { + return [] + } + const files = res + const result = [] + for (const f of files) { + if (f.name.startsWith(".")) { + continue + } + if ( + f.isDir && + (await isExists(`/data/plugins/${f.name}/manifest.json`)) && + (await isExists(`/data/plugins/${f.name}/main.js`)) + ) { + result.push(`/data/plugins/${f.name}`) + } + } + return result + } + async getFileContent(f) { + const res = await FileClient.getInstanceApi().fileApi.getFile(f) + return res || "" + } + async getManifest(manifest) { + const content = await this.getFileContent(manifest) + try { + return JSON.parse(content) + } catch (e) { + error("loading manifest: " + manifest, e) + return null + } + } + async getScript(script2) { + return await this.getFileContent(script2) + } + async getAllPlugins() { + const plugins = await this.scanPlugins("/data/plugins") + if (!plugins || !plugins.length) { + log("No plugin found in /data/plugins") + return [] + } + const req = [] + for (const p of plugins) { + log("Reading plugin from filesystem: " + p) + const key = this.getFolderName(p) + const f = async () => { + const [manifest, script2] = await Promise.all([ + this.getManifest(`${p}/manifest.json`), + this.getScript(`${p}/main.js`), + ]) + return { ...manifest, script: script2, enabled: false, key } + } + req.push(f()) + } + const result = await Promise.all(req) + return result || [] + } + getFolderName(p) { + const f = p.split("/") + for (let i = f.length - 1; i >= 0; i--) { + if (f[i]) { + return f[i] + } + } + return "" + } +} +PluginFileManager = __decorateClass$4([injectable()], PluginFileManager) +var __defProp$3 = Object.defineProperty +var __getOwnPropDesc$3 = Object.getOwnPropertyDescriptor +var __decorateClass$3 = (decorators, target, key, kind) => { + var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$3(target, key) : target + for (var i = decorators.length - 1, decorator; i >= 0; i--) + if ((decorator = decorators[i])) result = (kind ? decorator(target, key, result) : decorator(result)) || result + if (kind && result) __defProp$3(target, key, result) + return result +} +let EventBus = class { + constructor() { + this.eventListeners = {} + } + destroy() { + delete this.eventListeners + } + on(eventName, callback) { + if (!this.eventListeners[eventName]) { + this.eventListeners[eventName] = [] + } + this.eventListeners[eventName].push(callback) + return () => this.off(eventName, callback) + } + off(eventName, callback) { + if (!callback) { + delete this.eventListeners[eventName] + return + } + for (let i = 0; i < this.eventListeners[eventName].length; i++) { + if (this.eventListeners[eventName][i] === callback) { + this.eventListeners[eventName].splice(i, 1) + return + } + } + } + emit(eventName, ...args) { + if (this.eventListeners[eventName]) { + this.eventListeners[eventName].forEach((cb) => { + cb(...args) + }) + } + } +} +EventBus = __decorateClass$3([injectable()], EventBus) +var __defProp$2 = Object.defineProperty +var __getOwnPropDesc$2 = Object.getOwnPropertyDescriptor +var __decorateClass$2 = (decorators, target, key, kind) => { + var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$2(target, key) : target + for (var i = decorators.length - 1, decorator; i >= 0; i--) + if ((decorator = decorators[i])) result = (kind ? decorator(target, key, result) : decorator(result)) || result + if (kind && result) __defProp$2(target, key, result) + return result +} +var __decorateParam$1 = (index, decorator) => (target, key) => decorator(target, key, index) +let CommandManager = class { + constructor(shortcut2) { + this.commandList = [] + this.shortcut = shortcut2 + } + registerCommand(command) { + if ( + this.commandList.some((com) => { + com.plugin === command.plugin && com.command === command.command + }) + ) { + return new Error$1("Command is already registered, do not register command repeatly") + } + if ( + command.shortcut && + this.commandList.some((com) => { + com.shortcut === command.shortcut + }) + ) { + return new Warning("shortcut has already registered") + } + this.commandList.push(command) + this.shortcut.registerKeyboardEventFromPlugin(command) + log(`Register plugin: ${command.plugin} command: ${command.command}`) + } + unregisterCommandByPlugin(plugin2) { + for (let i = 0; i < this.commandList.length; i++) { + if (plugin2 === this.commandList[i].plugin) { + const com = this.commandList[i] + log(`Unregister plugin: ${plugin2} command: ${com.command}`) + this.commandList.splice(i, 1) + if (com.shortcut) { + this.shortcut.unregisterKeyboardEvent(com.shortcut) + } + } + } + } + unregisterCommand(command) { + for (let i = 0; i < this.commandList.length; i++) { + if (command.command === this.commandList[i].command && command.plugin === this.commandList[i].plugin) { + this.commandList.splice(i, 1) + break + } + } + this.shortcut.registerKeyboardEventFromPlugin(command) + } + getCommands() { + return this.commandList + } +} +CommandManager = __decorateClass$2([injectable(), __decorateParam$1(0, inject(TYPES.Shortcut))], CommandManager) +var isff = typeof navigator !== "undefined" ? navigator.userAgent.toLowerCase().indexOf("firefox") > 0 : false +function addEvent(object, event, method, useCapture) { + if (object.addEventListener) { + object.addEventListener(event, method, useCapture) + } else if (object.attachEvent) { + object.attachEvent("on".concat(event), function () { + method(window.event) + }) + } +} +function getMods(modifier, key) { + var mods = key.slice(0, key.length - 1) + for (var i = 0; i < mods.length; i++) { + mods[i] = modifier[mods[i].toLowerCase()] + } + return mods +} +function getKeys(key) { + if (typeof key !== "string") key = "" + key = key.replace(/\s/g, "") + var keys = key.split(",") + var index = keys.lastIndexOf("") + for (; index >= 0; ) { + keys[index - 1] += "," + keys.splice(index, 1) + index = keys.lastIndexOf("") + } + return keys +} +function compareArray(a1, a2) { + var arr1 = a1.length >= a2.length ? a1 : a2 + var arr2 = a1.length >= a2.length ? a2 : a1 + var isIndex = true + for (var i = 0; i < arr1.length; i++) { + if (arr2.indexOf(arr1[i]) === -1) isIndex = false + } + return isIndex +} +var _keyMap = { + backspace: 8, + "⌫": 8, + tab: 9, + clear: 12, + enter: 13, + "↩": 13, + return: 13, + esc: 27, + escape: 27, + space: 32, + left: 37, + up: 38, + right: 39, + down: 40, + del: 46, + delete: 46, + ins: 45, + insert: 45, + home: 36, + end: 35, + pageup: 33, + pagedown: 34, + capslock: 20, + num_0: 96, + num_1: 97, + num_2: 98, + num_3: 99, + num_4: 100, + num_5: 101, + num_6: 102, + num_7: 103, + num_8: 104, + num_9: 105, + num_multiply: 106, + num_add: 107, + num_enter: 108, + num_subtract: 109, + num_decimal: 110, + num_divide: 111, + "⇪": 20, + ",": 188, + ".": 190, + "/": 191, + "`": 192, + "-": isff ? 173 : 189, + "=": isff ? 61 : 187, + ";": isff ? 59 : 186, + "'": 222, + "[": 219, + "]": 221, + "\\": 220, +} +var _modifier = { + // shiftKey + "⇧": 16, + shift: 16, + // altKey + "⌥": 18, + alt: 18, + option: 18, + // ctrlKey + "⌃": 17, + ctrl: 17, + control: 17, + // metaKey + "⌘": 91, + cmd: 91, + command: 91, +} +var modifierMap = { + 16: "shiftKey", + 18: "altKey", + 17: "ctrlKey", + 91: "metaKey", + shiftKey: 16, + ctrlKey: 17, + altKey: 18, + metaKey: 91, +} +var _mods = { + 16: false, + 18: false, + 17: false, + 91: false, +} +var _handlers = {} +for (var k = 1; k < 20; k++) { + _keyMap["f".concat(k)] = 111 + k +} +var _downKeys = [] +var winListendFocus = false +var _scope = "all" +var elementHasBindEvent = [] +var code = function code2(x) { + return _keyMap[x.toLowerCase()] || _modifier[x.toLowerCase()] || x.toUpperCase().charCodeAt(0) +} +var getKey = function getKey2(x) { + return Object.keys(_keyMap).find(function (k2) { + return _keyMap[k2] === x + }) +} +var getModifier = function getModifier2(x) { + return Object.keys(_modifier).find(function (k2) { + return _modifier[k2] === x + }) +} +function setScope(scope) { + _scope = scope || "all" +} +function getScope() { + return _scope || "all" +} +function getPressedKeyCodes() { + return _downKeys.slice(0) +} +function getPressedKeyString() { + return _downKeys.map(function (c) { + return getKey(c) || getModifier(c) || String.fromCharCode(c) + }) +} +function filter(event) { + var target = event.target || event.srcElement + var tagName = target.tagName + var flag = true + if ( + target.isContentEditable || + ((tagName === "INPUT" || tagName === "TEXTAREA" || tagName === "SELECT") && !target.readOnly) + ) { + flag = false + } + return flag +} +function isPressed(keyCode) { + if (typeof keyCode === "string") { + keyCode = code(keyCode) + } + return _downKeys.indexOf(keyCode) !== -1 +} +function deleteScope(scope, newScope) { + var handlers + var i + if (!scope) scope = getScope() + for (var key in _handlers) { + if (Object.prototype.hasOwnProperty.call(_handlers, key)) { + handlers = _handlers[key] + for (i = 0; i < handlers.length; ) { + if (handlers[i].scope === scope) handlers.splice(i, 1) + else i++ + } + } + } + if (getScope() === scope) setScope(newScope || "all") +} +function clearModifier(event) { + var key = event.keyCode || event.which || event.charCode + var i = _downKeys.indexOf(key) + if (i >= 0) { + _downKeys.splice(i, 1) + } + if (event.key && event.key.toLowerCase() === "meta") { + _downKeys.splice(0, _downKeys.length) + } + if (key === 93 || key === 224) key = 91 + if (key in _mods) { + _mods[key] = false + for (var k2 in _modifier) { + if (_modifier[k2] === key) hotkeys[k2] = false + } + } +} +function unbind(keysInfo) { + if (typeof keysInfo === "undefined") { + Object.keys(_handlers).forEach(function (key) { + return delete _handlers[key] + }) + } else if (Array.isArray(keysInfo)) { + keysInfo.forEach(function (info) { + if (info.key) eachUnbind(info) + }) + } else if (typeof keysInfo === "object") { + if (keysInfo.key) eachUnbind(keysInfo) + } else if (typeof keysInfo === "string") { + for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { + args[_key - 1] = arguments[_key] + } + var scope = args[0], + method = args[1] + if (typeof scope === "function") { + method = scope + scope = "" + } + eachUnbind({ + key: keysInfo, + scope, + method, + splitKey: "+", + }) + } +} +var eachUnbind = function eachUnbind2(_ref) { + var key = _ref.key, + scope = _ref.scope, + method = _ref.method, + _ref$splitKey = _ref.splitKey, + splitKey = _ref$splitKey === void 0 ? "+" : _ref$splitKey + var multipleKeys = getKeys(key) + multipleKeys.forEach(function (originKey) { + var unbindKeys = originKey.split(splitKey) + var len = unbindKeys.length + var lastKey = unbindKeys[len - 1] + var keyCode = lastKey === "*" ? "*" : code(lastKey) + if (!_handlers[keyCode]) return + if (!scope) scope = getScope() + var mods = len > 1 ? getMods(_modifier, unbindKeys) : [] + _handlers[keyCode] = _handlers[keyCode].filter(function (record) { + var isMatchingMethod = method ? record.method === method : true + return !(isMatchingMethod && record.scope === scope && compareArray(record.mods, mods)) + }) + }) +} +function eventHandler(event, handler, scope, element2) { + if (handler.element !== element2) { + return + } + var modifiersMatch + if (handler.scope === scope || handler.scope === "all") { + modifiersMatch = handler.mods.length > 0 + for (var y in _mods) { + if (Object.prototype.hasOwnProperty.call(_mods, y)) { + if ((!_mods[y] && handler.mods.indexOf(+y) > -1) || (_mods[y] && handler.mods.indexOf(+y) === -1)) { + modifiersMatch = false + } + } + } + if ( + (handler.mods.length === 0 && !_mods[16] && !_mods[18] && !_mods[17] && !_mods[91]) || + modifiersMatch || + handler.shortcut === "*" + ) { + if (handler.method(event, handler) === false) { + if (event.preventDefault) event.preventDefault() + else event.returnValue = false + if (event.stopPropagation) event.stopPropagation() + if (event.cancelBubble) event.cancelBubble = true + } + } + } +} +function dispatch(event, element2) { + var asterisk = _handlers["*"] + var key = event.keyCode || event.which || event.charCode + if (!hotkeys.filter.call(this, event)) return + if (key === 93 || key === 224) key = 91 + if (_downKeys.indexOf(key) === -1 && key !== 229) _downKeys.push(key) + ;["ctrlKey", "altKey", "shiftKey", "metaKey"].forEach(function (keyName) { + var keyNum = modifierMap[keyName] + if (event[keyName] && _downKeys.indexOf(keyNum) === -1) { + _downKeys.push(keyNum) + } else if (!event[keyName] && _downKeys.indexOf(keyNum) > -1) { + _downKeys.splice(_downKeys.indexOf(keyNum), 1) + } else if (keyName === "metaKey" && event[keyName] && _downKeys.length === 3) { + if (!(event.ctrlKey || event.shiftKey || event.altKey)) { + _downKeys = _downKeys.slice(_downKeys.indexOf(keyNum)) + } + } + }) + if (key in _mods) { + _mods[key] = true + for (var k2 in _modifier) { + if (_modifier[k2] === key) hotkeys[k2] = true + } + if (!asterisk) return + } + for (var e in _mods) { + if (Object.prototype.hasOwnProperty.call(_mods, e)) { + _mods[e] = event[modifierMap[e]] + } + } + if (event.getModifierState && !(event.altKey && !event.ctrlKey) && event.getModifierState("AltGraph")) { + if (_downKeys.indexOf(17) === -1) { + _downKeys.push(17) + } + if (_downKeys.indexOf(18) === -1) { + _downKeys.push(18) + } + _mods[17] = true + _mods[18] = true + } + var scope = getScope() + if (asterisk) { + for (var i = 0; i < asterisk.length; i++) { + if ( + asterisk[i].scope === scope && + ((event.type === "keydown" && asterisk[i].keydown) || (event.type === "keyup" && asterisk[i].keyup)) + ) { + eventHandler(event, asterisk[i], scope, element2) + } + } + } + if (!(key in _handlers)) return + for (var _i = 0; _i < _handlers[key].length; _i++) { + if ( + (event.type === "keydown" && _handlers[key][_i].keydown) || + (event.type === "keyup" && _handlers[key][_i].keyup) + ) { + if (_handlers[key][_i].key) { + var record = _handlers[key][_i] + var splitKey = record.splitKey + var keyShortcut = record.key.split(splitKey) + var _downKeysCurrent = [] + for (var a2 = 0; a2 < keyShortcut.length; a2++) { + _downKeysCurrent.push(code(keyShortcut[a2])) + } + if (_downKeysCurrent.sort().join("") === _downKeys.sort().join("")) { + eventHandler(event, record, scope, element2) + } + } + } + } +} +function isElementBind(element2) { + return elementHasBindEvent.indexOf(element2) > -1 +} +function hotkeys(key, option, method) { + _downKeys = [] + var keys = getKeys(key) + var mods = [] + var scope = "all" + var element2 = document + var i = 0 + var keyup = false + var keydown = true + var splitKey = "+" + var capture = false + if (method === void 0 && typeof option === "function") { + method = option + } + if (Object.prototype.toString.call(option) === "[object Object]") { + if (option.scope) scope = option.scope + if (option.element) element2 = option.element + if (option.keyup) keyup = option.keyup + if (option.keydown !== void 0) keydown = option.keydown + if (option.capture !== void 0) capture = option.capture + if (typeof option.splitKey === "string") splitKey = option.splitKey + } + if (typeof option === "string") scope = option + for (; i < keys.length; i++) { + key = keys[i].split(splitKey) + mods = [] + if (key.length > 1) mods = getMods(_modifier, key) + key = key[key.length - 1] + key = key === "*" ? "*" : code(key) + if (!(key in _handlers)) _handlers[key] = [] + _handlers[key].push({ + keyup, + keydown, + scope, + mods, + shortcut: keys[i], + method, + key: keys[i], + splitKey, + element: element2, + }) + } + if (typeof element2 !== "undefined" && !isElementBind(element2) && window) { + elementHasBindEvent.push(element2) + addEvent( + element2, + "keydown", + function (e) { + dispatch(e, element2) + }, + capture + ) + if (!winListendFocus) { + winListendFocus = true + addEvent( + window, + "focus", + function () { + _downKeys = [] + }, + capture + ) + } + addEvent( + element2, + "keyup", + function (e) { + dispatch(e, element2) + clearModifier(e) + }, + capture + ) + } +} +function trigger(shortcut2) { + var scope = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "all" + Object.keys(_handlers).forEach(function (key) { + var dataList = _handlers[key].filter(function (item) { + return item.scope === scope && item.shortcut === shortcut2 + }) + dataList.forEach(function (data) { + if (data && data.method) { + data.method() + } + }) + }) +} +var _api = { + getPressedKeyString, + setScope, + getScope, + deleteScope, + getPressedKeyCodes, + isPressed, + filter, + trigger, + unbind, + keyMap: _keyMap, + modifier: _modifier, + modifierMap, +} +for (var a in _api) { + if (Object.prototype.hasOwnProperty.call(_api, a)) { + hotkeys[a] = _api[a] + } +} +if (typeof window !== "undefined") { + var _hotkeys = window.hotkeys + hotkeys.noConflict = function (deep) { + if (deep && window.hotkeys === hotkeys) { + window.hotkeys = _hotkeys + } + return hotkeys + } + window.hotkeys = hotkeys +} +var __defProp$1 = Object.defineProperty +var __getOwnPropDesc$1 = Object.getOwnPropertyDescriptor +var __decorateClass$1 = (decorators, target, key, kind) => { + var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$1(target, key) : target + for (var i = decorators.length - 1, decorator; i >= 0; i--) + if ((decorator = decorators[i])) result = (kind ? decorator(target, key, result) : decorator(result)) || result + if (kind && result) __defProp$1(target, key, result) + return result +} +var __decorateParam = (index, decorator) => (target, key) => decorator(target, key, index) +hotkeys.filter = function () { + return true +} +let Shortcut = class { + constructor(eventBus) { + this.option = { + capture: true, + } + log("Initialize shortcut subsystem") + this.eventBus = eventBus + } + registerKeyboardEvent(shortcut2, callback) { + hotkeys(shortcut2, this.option, callback) + this.eventBus.on(shortcut2.toString(), callback) + } + unregisterKeyboardEvent(shortcut2) { + hotkeys.unbind(shortcut2) + this.eventBus.off(shortcut2.toString()) + } + registerKeyboardEventFromPlugin(command) { + if (command.shortcut && command.callback) { + this.registerKeyboardEvent(command.shortcut, command.callback) + } + } + unregisterKeyboardEventFromPlugin(command) { + if (command.shortcut && command.callback) { + this.unregisterKeyboardEvent(command.shortcut) + } + } +} +Shortcut = __decorateClass$1([injectable(), __decorateParam(0, inject(TYPES.EventBus))], Shortcut) +var __defProp = Object.defineProperty +var __getOwnPropDesc = Object.getOwnPropertyDescriptor +var __decorateClass = (decorators, target, key, kind) => { + var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target + for (var i = decorators.length - 1, decorator; i >= 0; i--) + if ((decorator = decorators[i])) result = (kind ? decorator(target, key, result) : decorator(result)) || result + if (kind && result) __defProp(target, key, result) + return result +} +let SettingManager = class { + constructor() { + this.settingRenders = /* @__PURE__ */ new Map() + } + registerSetting(pluginKey, settingRender) { + this.settingRenders.set(pluginKey, settingRender) + } + unregisterSetting(key) { + this.settingRenders.delete(key) + } + getSettingRenders() { + const result = [] + this.settingRenders.forEach((value, key) => { + result.push({ key, value }) + }) + return result + } +} +SettingManager = __decorateClass([injectable()], SettingManager) +const container = new Container() +container.bind(TYPES.StorageManager).to(StorageManager).inSingletonScope() +container.bind(TYPES.SystemManager).to(SystemManager).inSingletonScope() +container.bind(TYPES.PluginSystem).to(PluginSystem).inSingletonScope() +container.bind(TYPES.PluginLoader).to(PluginLoader).inSingletonScope() +container.bind(TYPES.PluginFileManager).to(PluginFileManager).inSingletonScope() +container.bind(TYPES.EventBus).to(EventBus) +container.bind(TYPES.Shortcut).to(Shortcut).inSingletonScope() +container.bind(TYPES.CommandManager).to(CommandManager).inSingletonScope() +container.bind(TYPES.Store).to(Store).inSingletonScope() +container.bind(TYPES.SettingManager).to(SettingManager).inSingletonScope() +function initPluginSystem() { + if (!window.pluginSystem) { + log("Siyuan Plugin System loading...") + window.pluginSystemVersion = VERSION$1 + window.pluginSystem = container.get(TYPES.PluginSystem).init() + window.pluginSystemIocContainer = container + } +} +export { initPluginSystem as default, initPluginSystem } +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"main.esm.js","sources":["node_modules/.pnpm/reflect-metadata@0.1.13/node_modules/reflect-metadata/Reflect.js","src/config.ts","src/api/server-api.ts","src/internal/classes/notification.ts","node_modules/.pnpm/zhi-log@1.6.1/node_modules/zhi-log/lib/index.js","src/api/client-api.ts","src/internal/classes/menu.ts","src/internal/classes/dialog.ts","src/api/plugin.ts","src/api.ts","node_modules/.pnpm/semver@7.3.8/node_modules/semver/internal/constants.js","node_modules/.pnpm/semver@7.3.8/node_modules/semver/internal/debug.js","node_modules/.pnpm/semver@7.3.8/node_modules/semver/internal/re.js","node_modules/.pnpm/semver@7.3.8/node_modules/semver/internal/parse-options.js","node_modules/.pnpm/semver@7.3.8/node_modules/semver/internal/identifiers.js","node_modules/.pnpm/semver@7.3.8/node_modules/semver/classes/semver.js","node_modules/.pnpm/semver@7.3.8/node_modules/semver/functions/parse.js","node_modules/.pnpm/semver@7.3.8/node_modules/semver/functions/valid.js","node_modules/.pnpm/semver@7.3.8/node_modules/semver/functions/clean.js","node_modules/.pnpm/semver@7.3.8/node_modules/semver/functions/inc.js","node_modules/.pnpm/semver@7.3.8/node_modules/semver/functions/compare.js","node_modules/.pnpm/semver@7.3.8/node_modules/semver/functions/eq.js","node_modules/.pnpm/semver@7.3.8/node_modules/semver/functions/diff.js","node_modules/.pnpm/semver@7.3.8/node_modules/semver/functions/major.js","node_modules/.pnpm/semver@7.3.8/node_modules/semver/functions/minor.js","node_modules/.pnpm/semver@7.3.8/node_modules/semver/functions/patch.js","node_modules/.pnpm/semver@7.3.8/node_modules/semver/functions/prerelease.js","node_modules/.pnpm/semver@7.3.8/node_modules/semver/functions/rcompare.js","node_modules/.pnpm/semver@7.3.8/node_modules/semver/functions/compare-loose.js","node_modules/.pnpm/semver@7.3.8/node_modules/semver/functions/compare-build.js","node_modules/.pnpm/semver@7.3.8/node_modules/semver/functions/sort.js","node_modules/.pnpm/semver@7.3.8/node_modules/semver/functions/rsort.js","node_modules/.pnpm/semver@7.3.8/node_modules/semver/functions/gt.js","node_modules/.pnpm/semver@7.3.8/node_modules/semver/functions/lt.js","node_modules/.pnpm/semver@7.3.8/node_modules/semver/functions/neq.js","node_modules/.pnpm/semver@7.3.8/node_modules/semver/functions/gte.js","node_modules/.pnpm/semver@7.3.8/node_modules/semver/functions/lte.js","node_modules/.pnpm/semver@7.3.8/node_modules/semver/functions/cmp.js","node_modules/.pnpm/semver@7.3.8/node_modules/semver/functions/coerce.js","node_modules/.pnpm/yallist@4.0.0/node_modules/yallist/iterator.js","node_modules/.pnpm/yallist@4.0.0/node_modules/yallist/yallist.js","node_modules/.pnpm/lru-cache@6.0.0/node_modules/lru-cache/index.js","node_modules/.pnpm/semver@7.3.8/node_modules/semver/classes/range.js","node_modules/.pnpm/semver@7.3.8/node_modules/semver/classes/comparator.js","node_modules/.pnpm/semver@7.3.8/node_modules/semver/functions/satisfies.js","node_modules/.pnpm/semver@7.3.8/node_modules/semver/ranges/to-comparators.js","node_modules/.pnpm/semver@7.3.8/node_modules/semver/ranges/max-satisfying.js","node_modules/.pnpm/semver@7.3.8/node_modules/semver/ranges/min-satisfying.js","node_modules/.pnpm/semver@7.3.8/node_modules/semver/ranges/min-version.js","node_modules/.pnpm/semver@7.3.8/node_modules/semver/ranges/valid.js","node_modules/.pnpm/semver@7.3.8/node_modules/semver/ranges/outside.js","node_modules/.pnpm/semver@7.3.8/node_modules/semver/ranges/gtr.js","node_modules/.pnpm/semver@7.3.8/node_modules/semver/ranges/ltr.js","node_modules/.pnpm/semver@7.3.8/node_modules/semver/ranges/intersects.js","node_modules/.pnpm/semver@7.3.8/node_modules/semver/ranges/simplify.js","node_modules/.pnpm/semver@7.3.8/node_modules/semver/ranges/subset.js","node_modules/.pnpm/semver@7.3.8/node_modules/semver/index.js","src/api/file-api.ts","node_modules/.pnpm/axios@1.3.4/node_modules/axios/lib/helpers/bind.js","node_modules/.pnpm/axios@1.3.4/node_modules/axios/lib/utils.js","node_modules/.pnpm/axios@1.3.4/node_modules/axios/lib/core/AxiosError.js","node_modules/.pnpm/axios@1.3.4/node_modules/axios/lib/helpers/null.js","node_modules/.pnpm/axios@1.3.4/node_modules/axios/lib/helpers/toFormData.js","node_modules/.pnpm/axios@1.3.4/node_modules/axios/lib/helpers/AxiosURLSearchParams.js","node_modules/.pnpm/axios@1.3.4/node_modules/axios/lib/helpers/buildURL.js","node_modules/.pnpm/axios@1.3.4/node_modules/axios/lib/core/InterceptorManager.js","node_modules/.pnpm/axios@1.3.4/node_modules/axios/lib/defaults/transitional.js","node_modules/.pnpm/axios@1.3.4/node_modules/axios/lib/platform/browser/classes/URLSearchParams.js","node_modules/.pnpm/axios@1.3.4/node_modules/axios/lib/platform/browser/classes/FormData.js","node_modules/.pnpm/axios@1.3.4/node_modules/axios/lib/platform/browser/classes/Blob.js","node_modules/.pnpm/axios@1.3.4/node_modules/axios/lib/platform/browser/index.js","node_modules/.pnpm/axios@1.3.4/node_modules/axios/lib/helpers/toURLEncodedForm.js","node_modules/.pnpm/axios@1.3.4/node_modules/axios/lib/helpers/formDataToJSON.js","node_modules/.pnpm/axios@1.3.4/node_modules/axios/lib/defaults/index.js","node_modules/.pnpm/axios@1.3.4/node_modules/axios/lib/helpers/parseHeaders.js","node_modules/.pnpm/axios@1.3.4/node_modules/axios/lib/core/AxiosHeaders.js","node_modules/.pnpm/axios@1.3.4/node_modules/axios/lib/core/transformData.js","node_modules/.pnpm/axios@1.3.4/node_modules/axios/lib/cancel/isCancel.js","node_modules/.pnpm/axios@1.3.4/node_modules/axios/lib/cancel/CanceledError.js","node_modules/.pnpm/axios@1.3.4/node_modules/axios/lib/core/settle.js","node_modules/.pnpm/axios@1.3.4/node_modules/axios/lib/helpers/cookies.js","node_modules/.pnpm/axios@1.3.4/node_modules/axios/lib/helpers/isAbsoluteURL.js","node_modules/.pnpm/axios@1.3.4/node_modules/axios/lib/helpers/combineURLs.js","node_modules/.pnpm/axios@1.3.4/node_modules/axios/lib/core/buildFullPath.js","node_modules/.pnpm/axios@1.3.4/node_modules/axios/lib/helpers/isURLSameOrigin.js","node_modules/.pnpm/axios@1.3.4/node_modules/axios/lib/helpers/parseProtocol.js","node_modules/.pnpm/axios@1.3.4/node_modules/axios/lib/helpers/speedometer.js","node_modules/.pnpm/axios@1.3.4/node_modules/axios/lib/adapters/xhr.js","node_modules/.pnpm/axios@1.3.4/node_modules/axios/lib/adapters/adapters.js","node_modules/.pnpm/axios@1.3.4/node_modules/axios/lib/core/dispatchRequest.js","node_modules/.pnpm/axios@1.3.4/node_modules/axios/lib/core/mergeConfig.js","node_modules/.pnpm/axios@1.3.4/node_modules/axios/lib/env/data.js","node_modules/.pnpm/axios@1.3.4/node_modules/axios/lib/helpers/validator.js","node_modules/.pnpm/axios@1.3.4/node_modules/axios/lib/core/Axios.js","node_modules/.pnpm/axios@1.3.4/node_modules/axios/lib/cancel/CancelToken.js","node_modules/.pnpm/axios@1.3.4/node_modules/axios/lib/helpers/spread.js","node_modules/.pnpm/axios@1.3.4/node_modules/axios/lib/helpers/isAxiosError.js","node_modules/.pnpm/axios@1.3.4/node_modules/axios/lib/helpers/HttpStatusCode.js","node_modules/.pnpm/axios@1.3.4/node_modules/axios/lib/axios.js","src/util/index.ts","node_modules/.pnpm/inversify@6.0.1/node_modules/inversify/es/constants/metadata_keys.js","node_modules/.pnpm/inversify@6.0.1/node_modules/inversify/es/constants/literal_types.js","node_modules/.pnpm/inversify@6.0.1/node_modules/inversify/es/utils/id.js","node_modules/.pnpm/inversify@6.0.1/node_modules/inversify/es/bindings/binding.js","node_modules/.pnpm/inversify@6.0.1/node_modules/inversify/es/constants/error_msgs.js","node_modules/.pnpm/inversify@6.0.1/node_modules/inversify/es/planning/metadata_reader.js","node_modules/.pnpm/inversify@6.0.1/node_modules/inversify/es/bindings/binding_count.js","node_modules/.pnpm/inversify@6.0.1/node_modules/inversify/es/utils/exceptions.js","node_modules/.pnpm/inversify@6.0.1/node_modules/inversify/es/utils/serialization.js","node_modules/.pnpm/inversify@6.0.1/node_modules/inversify/es/planning/context.js","node_modules/.pnpm/inversify@6.0.1/node_modules/inversify/es/planning/metadata.js","node_modules/.pnpm/inversify@6.0.1/node_modules/inversify/es/planning/plan.js","node_modules/.pnpm/inversify@6.0.1/node_modules/inversify/es/annotation/lazy_service_identifier.js","node_modules/.pnpm/inversify@6.0.1/node_modules/inversify/es/planning/queryable_string.js","node_modules/.pnpm/inversify@6.0.1/node_modules/inversify/es/planning/target.js","node_modules/.pnpm/inversify@6.0.1/node_modules/inversify/es/planning/reflection_utils.js","node_modules/.pnpm/inversify@6.0.1/node_modules/inversify/es/planning/request.js","node_modules/.pnpm/inversify@6.0.1/node_modules/inversify/es/planning/planner.js","node_modules/.pnpm/inversify@6.0.1/node_modules/inversify/es/utils/async.js","node_modules/.pnpm/inversify@6.0.1/node_modules/inversify/es/scope/scope.js","node_modules/.pnpm/inversify@6.0.1/node_modules/inversify/es/utils/factory_type.js","node_modules/.pnpm/inversify@6.0.1/node_modules/inversify/es/utils/binding_utils.js","node_modules/.pnpm/inversify@6.0.1/node_modules/inversify/es/resolution/instantiation.js","node_modules/.pnpm/inversify@6.0.1/node_modules/inversify/es/resolution/resolver.js","node_modules/.pnpm/inversify@6.0.1/node_modules/inversify/es/syntax/constraint_helpers.js","node_modules/.pnpm/inversify@6.0.1/node_modules/inversify/es/syntax/binding_when_syntax.js","node_modules/.pnpm/inversify@6.0.1/node_modules/inversify/es/syntax/binding_on_syntax.js","node_modules/.pnpm/inversify@6.0.1/node_modules/inversify/es/syntax/binding_when_on_syntax.js","node_modules/.pnpm/inversify@6.0.1/node_modules/inversify/es/syntax/binding_in_syntax.js","node_modules/.pnpm/inversify@6.0.1/node_modules/inversify/es/syntax/binding_in_when_on_syntax.js","node_modules/.pnpm/inversify@6.0.1/node_modules/inversify/es/syntax/binding_to_syntax.js","node_modules/.pnpm/inversify@6.0.1/node_modules/inversify/es/container/container_snapshot.js","node_modules/.pnpm/inversify@6.0.1/node_modules/inversify/es/utils/clonable.js","node_modules/.pnpm/inversify@6.0.1/node_modules/inversify/es/container/lookup.js","node_modules/.pnpm/inversify@6.0.1/node_modules/inversify/es/container/module_activation_store.js","node_modules/.pnpm/inversify@6.0.1/node_modules/inversify/es/container/container.js","node_modules/.pnpm/inversify@6.0.1/node_modules/inversify/es/utils/js.js","node_modules/.pnpm/inversify@6.0.1/node_modules/inversify/es/annotation/decorator_utils.js","node_modules/.pnpm/inversify@6.0.1/node_modules/inversify/es/annotation/injectable.js","node_modules/.pnpm/inversify@6.0.1/node_modules/inversify/es/annotation/inject_base.js","node_modules/.pnpm/inversify@6.0.1/node_modules/inversify/es/annotation/inject.js","src/core/plugin-config.ts","node_modules/.pnpm/svelte@3.55.1/node_modules/svelte/internal/index.mjs","src/internal/plugins/command-panel/command-panel.svelte","src/internal/plugins/command-panel/index.ts","src/internal/plugins/setting/setting-common.svelte","src/internal/plugins/setting/setting-list.svelte","src/core/store.ts","src/internal/components/Button.svelte","src/internal/plugins/setting/setting-preview.svelte","src/internal/plugins/setting/setting-store.svelte","src/internal/plugins/setting/setting-custom.svelte","src/internal/plugins/setting/setting.svelte","src/internal/plugins/setting/index.ts","src/internal/index.ts","node_modules/.pnpm/truncate-utf8-bytes@1.0.2/node_modules/truncate-utf8-bytes/lib/truncate.js","node_modules/.pnpm/utf8-byte-length@1.0.4/node_modules/utf8-byte-length/browser.js","node_modules/.pnpm/truncate-utf8-bytes@1.0.2/node_modules/truncate-utf8-bytes/browser.js","node_modules/.pnpm/sanitize-filename@1.6.3/node_modules/sanitize-filename/index.js","src/core/storage-manager.ts","src/core/index.ts","src/util/migrate.ts","src/core/system-manager.ts","src/core/loader.ts","src/core/plugin-file-manager.ts","src/core/event-bus.ts","src/core/command-manager.ts","node_modules/.pnpm/hotkeys-js@3.10.1/node_modules/hotkeys-js/dist/hotkeys.esm.js","src/core/shortcut.ts","src/core/setting-manager.ts","src/container.ts","src/export.ts"],"sourcesContent":["/*! *****************************************************************************\nCopyright (C) Microsoft. All rights reserved.\nLicensed under the Apache License, Version 2.0 (the \"License\"); you may not use\nthis file except in compliance with the License. You may obtain a copy of the\nLicense at http://www.apache.org/licenses/LICENSE-2.0\n\nTHIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\nKIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED\nWARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,\nMERCHANTABLITY OR NON-INFRINGEMENT.\n\nSee the Apache Version 2.0 License for specific language governing permissions\nand limitations under the License.\n***************************************************************************** */\nvar Reflect;\n(function (Reflect) {\n    // Metadata Proposal\n    // https://rbuckton.github.io/reflect-metadata/\n    (function (factory) {\n        var root = typeof global === \"object\" ? global :\n            typeof self === \"object\" ? self :\n                typeof this === \"object\" ? this :\n                    Function(\"return this;\")();\n        var exporter = makeExporter(Reflect);\n        if (typeof root.Reflect === \"undefined\") {\n            root.Reflect = Reflect;\n        }\n        else {\n            exporter = makeExporter(root.Reflect, exporter);\n        }\n        factory(exporter);\n        function makeExporter(target, previous) {\n            return function (key, value) {\n                if (typeof target[key] !== \"function\") {\n                    Object.defineProperty(target, key, { configurable: true, writable: true, value: value });\n                }\n                if (previous)\n                    previous(key, value);\n            };\n        }\n    })(function (exporter) {\n        var hasOwn = Object.prototype.hasOwnProperty;\n        // feature test for Symbol support\n        var supportsSymbol = typeof Symbol === \"function\";\n        var toPrimitiveSymbol = supportsSymbol && typeof Symbol.toPrimitive !== \"undefined\" ? Symbol.toPrimitive : \"@@toPrimitive\";\n        var iteratorSymbol = supportsSymbol && typeof Symbol.iterator !== \"undefined\" ? Symbol.iterator : \"@@iterator\";\n        var supportsCreate = typeof Object.create === \"function\"; // feature test for Object.create support\n        var supportsProto = { __proto__: [] } instanceof Array; // feature test for __proto__ support\n        var downLevel = !supportsCreate && !supportsProto;\n        var HashMap = {\n            // create an object in dictionary mode (a.k.a. \"slow\" mode in v8)\n            create: supportsCreate\n                ? function () { return MakeDictionary(Object.create(null)); }\n                : supportsProto\n                    ? function () { return MakeDictionary({ __proto__: null }); }\n                    : function () { return MakeDictionary({}); },\n            has: downLevel\n                ? function (map, key) { return hasOwn.call(map, key); }\n                : function (map, key) { return key in map; },\n            get: downLevel\n                ? function (map, key) { return hasOwn.call(map, key) ? map[key] : undefined; }\n                : function (map, key) { return map[key]; },\n        };\n        // Load global or shim versions of Map, Set, and WeakMap\n        var functionPrototype = Object.getPrototypeOf(Function);\n        var usePolyfill = typeof process === \"object\" && process.env && process.env[\"REFLECT_METADATA_USE_MAP_POLYFILL\"] === \"true\";\n        var _Map = !usePolyfill && typeof Map === \"function\" && typeof Map.prototype.entries === \"function\" ? Map : CreateMapPolyfill();\n        var _Set = !usePolyfill && typeof Set === \"function\" && typeof Set.prototype.entries === \"function\" ? Set : CreateSetPolyfill();\n        var _WeakMap = !usePolyfill && typeof WeakMap === \"function\" ? WeakMap : CreateWeakMapPolyfill();\n        // [[Metadata]] internal slot\n        // https://rbuckton.github.io/reflect-metadata/#ordinary-object-internal-methods-and-internal-slots\n        var Metadata = new _WeakMap();\n        /**\n         * Applies a set of decorators to a property of a target object.\n         * @param decorators An array of decorators.\n         * @param target The target object.\n         * @param propertyKey (Optional) The property key to decorate.\n         * @param attributes (Optional) The property descriptor for the target key.\n         * @remarks Decorators are applied in reverse order.\n         * @example\n         *\n         *     class Example {\n         *         // property declarations are not part of ES6, though they are valid in TypeScript:\n         *         // static staticProperty;\n         *         // property;\n         *\n         *         constructor(p) { }\n         *         static staticMethod(p) { }\n         *         method(p) { }\n         *     }\n         *\n         *     // constructor\n         *     Example = Reflect.decorate(decoratorsArray, Example);\n         *\n         *     // property (on constructor)\n         *     Reflect.decorate(decoratorsArray, Example, \"staticProperty\");\n         *\n         *     // property (on prototype)\n         *     Reflect.decorate(decoratorsArray, Example.prototype, \"property\");\n         *\n         *     // method (on constructor)\n         *     Object.defineProperty(Example, \"staticMethod\",\n         *         Reflect.decorate(decoratorsArray, Example, \"staticMethod\",\n         *             Object.getOwnPropertyDescriptor(Example, \"staticMethod\")));\n         *\n         *     // method (on prototype)\n         *     Object.defineProperty(Example.prototype, \"method\",\n         *         Reflect.decorate(decoratorsArray, Example.prototype, \"method\",\n         *             Object.getOwnPropertyDescriptor(Example.prototype, \"method\")));\n         *\n         */\n        function decorate(decorators, target, propertyKey, attributes) {\n            if (!IsUndefined(propertyKey)) {\n                if (!IsArray(decorators))\n                    throw new TypeError();\n                if (!IsObject(target))\n                    throw new TypeError();\n                if (!IsObject(attributes) && !IsUndefined(attributes) && !IsNull(attributes))\n                    throw new TypeError();\n                if (IsNull(attributes))\n                    attributes = undefined;\n                propertyKey = ToPropertyKey(propertyKey);\n                return DecorateProperty(decorators, target, propertyKey, attributes);\n            }\n            else {\n                if (!IsArray(decorators))\n                    throw new TypeError();\n                if (!IsConstructor(target))\n                    throw new TypeError();\n                return DecorateConstructor(decorators, target);\n            }\n        }\n        exporter(\"decorate\", decorate);\n        // 4.1.2 Reflect.metadata(metadataKey, metadataValue)\n        // https://rbuckton.github.io/reflect-metadata/#reflect.metadata\n        /**\n         * A default metadata decorator factory that can be used on a class, class member, or parameter.\n         * @param metadataKey The key for the metadata entry.\n         * @param metadataValue The value for the metadata entry.\n         * @returns A decorator function.\n         * @remarks\n         * If `metadataKey` is already defined for the target and target key, the\n         * metadataValue for that key will be overwritten.\n         * @example\n         *\n         *     // constructor\n         *     @Reflect.metadata(key, value)\n         *     class Example {\n         *     }\n         *\n         *     // property (on constructor, TypeScript only)\n         *     class Example {\n         *         @Reflect.metadata(key, value)\n         *         static staticProperty;\n         *     }\n         *\n         *     // property (on prototype, TypeScript only)\n         *     class Example {\n         *         @Reflect.metadata(key, value)\n         *         property;\n         *     }\n         *\n         *     // method (on constructor)\n         *     class Example {\n         *         @Reflect.metadata(key, value)\n         *         static staticMethod() { }\n         *     }\n         *\n         *     // method (on prototype)\n         *     class Example {\n         *         @Reflect.metadata(key, value)\n         *         method() { }\n         *     }\n         *\n         */\n        function metadata(metadataKey, metadataValue) {\n            function decorator(target, propertyKey) {\n                if (!IsObject(target))\n                    throw new TypeError();\n                if (!IsUndefined(propertyKey) && !IsPropertyKey(propertyKey))\n                    throw new TypeError();\n                OrdinaryDefineOwnMetadata(metadataKey, metadataValue, target, propertyKey);\n            }\n            return decorator;\n        }\n        exporter(\"metadata\", metadata);\n        /**\n         * Define a unique metadata entry on the target.\n         * @param metadataKey A key used to store and retrieve metadata.\n         * @param metadataValue A value that contains attached metadata.\n         * @param target The target object on which to define metadata.\n         * @param propertyKey (Optional) The property key for the target.\n         * @example\n         *\n         *     class Example {\n         *         // property declarations are not part of ES6, though they are valid in TypeScript:\n         *         // static staticProperty;\n         *         // property;\n         *\n         *         constructor(p) { }\n         *         static staticMethod(p) { }\n         *         method(p) { }\n         *     }\n         *\n         *     // constructor\n         *     Reflect.defineMetadata(\"custom:annotation\", options, Example);\n         *\n         *     // property (on constructor)\n         *     Reflect.defineMetadata(\"custom:annotation\", options, Example, \"staticProperty\");\n         *\n         *     // property (on prototype)\n         *     Reflect.defineMetadata(\"custom:annotation\", options, Example.prototype, \"property\");\n         *\n         *     // method (on constructor)\n         *     Reflect.defineMetadata(\"custom:annotation\", options, Example, \"staticMethod\");\n         *\n         *     // method (on prototype)\n         *     Reflect.defineMetadata(\"custom:annotation\", options, Example.prototype, \"method\");\n         *\n         *     // decorator factory as metadata-producing annotation.\n         *     function MyAnnotation(options): Decorator {\n         *         return (target, key?) => Reflect.defineMetadata(\"custom:annotation\", options, target, key);\n         *     }\n         *\n         */\n        function defineMetadata(metadataKey, metadataValue, target, propertyKey) {\n            if (!IsObject(target))\n                throw new TypeError();\n            if (!IsUndefined(propertyKey))\n                propertyKey = ToPropertyKey(propertyKey);\n            return OrdinaryDefineOwnMetadata(metadataKey, metadataValue, target, propertyKey);\n        }\n        exporter(\"defineMetadata\", defineMetadata);\n        /**\n         * Gets a value indicating whether the target object or its prototype chain has the provided metadata key defined.\n         * @param metadataKey A key used to store and retrieve metadata.\n         * @param target The target object on which the metadata is defined.\n         * @param propertyKey (Optional) The property key for the target.\n         * @returns `true` if the metadata key was defined on the target object or its prototype chain; otherwise, `false`.\n         * @example\n         *\n         *     class Example {\n         *         // property declarations are not part of ES6, though they are valid in TypeScript:\n         *         // static staticProperty;\n         *         // property;\n         *\n         *         constructor(p) { }\n         *         static staticMethod(p) { }\n         *         method(p) { }\n         *     }\n         *\n         *     // constructor\n         *     result = Reflect.hasMetadata(\"custom:annotation\", Example);\n         *\n         *     // property (on constructor)\n         *     result = Reflect.hasMetadata(\"custom:annotation\", Example, \"staticProperty\");\n         *\n         *     // property (on prototype)\n         *     result = Reflect.hasMetadata(\"custom:annotation\", Example.prototype, \"property\");\n         *\n         *     // method (on constructor)\n         *     result = Reflect.hasMetadata(\"custom:annotation\", Example, \"staticMethod\");\n         *\n         *     // method (on prototype)\n         *     result = Reflect.hasMetadata(\"custom:annotation\", Example.prototype, \"method\");\n         *\n         */\n        function hasMetadata(metadataKey, target, propertyKey) {\n            if (!IsObject(target))\n                throw new TypeError();\n            if (!IsUndefined(propertyKey))\n                propertyKey = ToPropertyKey(propertyKey);\n            return OrdinaryHasMetadata(metadataKey, target, propertyKey);\n        }\n        exporter(\"hasMetadata\", hasMetadata);\n        /**\n         * Gets a value indicating whether the target object has the provided metadata key defined.\n         * @param metadataKey A key used to store and retrieve metadata.\n         * @param target The target object on which the metadata is defined.\n         * @param propertyKey (Optional) The property key for the target.\n         * @returns `true` if the metadata key was defined on the target object; otherwise, `false`.\n         * @example\n         *\n         *     class Example {\n         *         // property declarations are not part of ES6, though they are valid in TypeScript:\n         *         // static staticProperty;\n         *         // property;\n         *\n         *         constructor(p) { }\n         *         static staticMethod(p) { }\n         *         method(p) { }\n         *     }\n         *\n         *     // constructor\n         *     result = Reflect.hasOwnMetadata(\"custom:annotation\", Example);\n         *\n         *     // property (on constructor)\n         *     result = Reflect.hasOwnMetadata(\"custom:annotation\", Example, \"staticProperty\");\n         *\n         *     // property (on prototype)\n         *     result = Reflect.hasOwnMetadata(\"custom:annotation\", Example.prototype, \"property\");\n         *\n         *     // method (on constructor)\n         *     result = Reflect.hasOwnMetadata(\"custom:annotation\", Example, \"staticMethod\");\n         *\n         *     // method (on prototype)\n         *     result = Reflect.hasOwnMetadata(\"custom:annotation\", Example.prototype, \"method\");\n         *\n         */\n        function hasOwnMetadata(metadataKey, target, propertyKey) {\n            if (!IsObject(target))\n                throw new TypeError();\n            if (!IsUndefined(propertyKey))\n                propertyKey = ToPropertyKey(propertyKey);\n            return OrdinaryHasOwnMetadata(metadataKey, target, propertyKey);\n        }\n        exporter(\"hasOwnMetadata\", hasOwnMetadata);\n        /**\n         * Gets the metadata value for the provided metadata key on the target object or its prototype chain.\n         * @param metadataKey A key used to store and retrieve metadata.\n         * @param target The target object on which the metadata is defined.\n         * @param propertyKey (Optional) The property key for the target.\n         * @returns The metadata value for the metadata key if found; otherwise, `undefined`.\n         * @example\n         *\n         *     class Example {\n         *         // property declarations are not part of ES6, though they are valid in TypeScript:\n         *         // static staticProperty;\n         *         // property;\n         *\n         *         constructor(p) { }\n         *         static staticMethod(p) { }\n         *         method(p) { }\n         *     }\n         *\n         *     // constructor\n         *     result = Reflect.getMetadata(\"custom:annotation\", Example);\n         *\n         *     // property (on constructor)\n         *     result = Reflect.getMetadata(\"custom:annotation\", Example, \"staticProperty\");\n         *\n         *     // property (on prototype)\n         *     result = Reflect.getMetadata(\"custom:annotation\", Example.prototype, \"property\");\n         *\n         *     // method (on constructor)\n         *     result = Reflect.getMetadata(\"custom:annotation\", Example, \"staticMethod\");\n         *\n         *     // method (on prototype)\n         *     result = Reflect.getMetadata(\"custom:annotation\", Example.prototype, \"method\");\n         *\n         */\n        function getMetadata(metadataKey, target, propertyKey) {\n            if (!IsObject(target))\n                throw new TypeError();\n            if (!IsUndefined(propertyKey))\n                propertyKey = ToPropertyKey(propertyKey);\n            return OrdinaryGetMetadata(metadataKey, target, propertyKey);\n        }\n        exporter(\"getMetadata\", getMetadata);\n        /**\n         * Gets the metadata value for the provided metadata key on the target object.\n         * @param metadataKey A key used to store and retrieve metadata.\n         * @param target The target object on which the metadata is defined.\n         * @param propertyKey (Optional) The property key for the target.\n         * @returns The metadata value for the metadata key if found; otherwise, `undefined`.\n         * @example\n         *\n         *     class Example {\n         *         // property declarations are not part of ES6, though they are valid in TypeScript:\n         *         // static staticProperty;\n         *         // property;\n         *\n         *         constructor(p) { }\n         *         static staticMethod(p) { }\n         *         method(p) { }\n         *     }\n         *\n         *     // constructor\n         *     result = Reflect.getOwnMetadata(\"custom:annotation\", Example);\n         *\n         *     // property (on constructor)\n         *     result = Reflect.getOwnMetadata(\"custom:annotation\", Example, \"staticProperty\");\n         *\n         *     // property (on prototype)\n         *     result = Reflect.getOwnMetadata(\"custom:annotation\", Example.prototype, \"property\");\n         *\n         *     // method (on constructor)\n         *     result = Reflect.getOwnMetadata(\"custom:annotation\", Example, \"staticMethod\");\n         *\n         *     // method (on prototype)\n         *     result = Reflect.getOwnMetadata(\"custom:annotation\", Example.prototype, \"method\");\n         *\n         */\n        function getOwnMetadata(metadataKey, target, propertyKey) {\n            if (!IsObject(target))\n                throw new TypeError();\n            if (!IsUndefined(propertyKey))\n                propertyKey = ToPropertyKey(propertyKey);\n            return OrdinaryGetOwnMetadata(metadataKey, target, propertyKey);\n        }\n        exporter(\"getOwnMetadata\", getOwnMetadata);\n        /**\n         * Gets the metadata keys defined on the target object or its prototype chain.\n         * @param target The target object on which the metadata is defined.\n         * @param propertyKey (Optional) The property key for the target.\n         * @returns An array of unique metadata keys.\n         * @example\n         *\n         *     class Example {\n         *         // property declarations are not part of ES6, though they are valid in TypeScript:\n         *         // static staticProperty;\n         *         // property;\n         *\n         *         constructor(p) { }\n         *         static staticMethod(p) { }\n         *         method(p) { }\n         *     }\n         *\n         *     // constructor\n         *     result = Reflect.getMetadataKeys(Example);\n         *\n         *     // property (on constructor)\n         *     result = Reflect.getMetadataKeys(Example, \"staticProperty\");\n         *\n         *     // property (on prototype)\n         *     result = Reflect.getMetadataKeys(Example.prototype, \"property\");\n         *\n         *     // method (on constructor)\n         *     result = Reflect.getMetadataKeys(Example, \"staticMethod\");\n         *\n         *     // method (on prototype)\n         *     result = Reflect.getMetadataKeys(Example.prototype, \"method\");\n         *\n         */\n        function getMetadataKeys(target, propertyKey) {\n            if (!IsObject(target))\n                throw new TypeError();\n            if (!IsUndefined(propertyKey))\n                propertyKey = ToPropertyKey(propertyKey);\n            return OrdinaryMetadataKeys(target, propertyKey);\n        }\n        exporter(\"getMetadataKeys\", getMetadataKeys);\n        /**\n         * Gets the unique metadata keys defined on the target object.\n         * @param target The target object on which the metadata is defined.\n         * @param propertyKey (Optional) The property key for the target.\n         * @returns An array of unique metadata keys.\n         * @example\n         *\n         *     class Example {\n         *         // property declarations are not part of ES6, though they are valid in TypeScript:\n         *         // static staticProperty;\n         *         // property;\n         *\n         *         constructor(p) { }\n         *         static staticMethod(p) { }\n         *         method(p) { }\n         *     }\n         *\n         *     // constructor\n         *     result = Reflect.getOwnMetadataKeys(Example);\n         *\n         *     // property (on constructor)\n         *     result = Reflect.getOwnMetadataKeys(Example, \"staticProperty\");\n         *\n         *     // property (on prototype)\n         *     result = Reflect.getOwnMetadataKeys(Example.prototype, \"property\");\n         *\n         *     // method (on constructor)\n         *     result = Reflect.getOwnMetadataKeys(Example, \"staticMethod\");\n         *\n         *     // method (on prototype)\n         *     result = Reflect.getOwnMetadataKeys(Example.prototype, \"method\");\n         *\n         */\n        function getOwnMetadataKeys(target, propertyKey) {\n            if (!IsObject(target))\n                throw new TypeError();\n            if (!IsUndefined(propertyKey))\n                propertyKey = ToPropertyKey(propertyKey);\n            return OrdinaryOwnMetadataKeys(target, propertyKey);\n        }\n        exporter(\"getOwnMetadataKeys\", getOwnMetadataKeys);\n        /**\n         * Deletes the metadata entry from the target object with the provided key.\n         * @param metadataKey A key used to store and retrieve metadata.\n         * @param target The target object on which the metadata is defined.\n         * @param propertyKey (Optional) The property key for the target.\n         * @returns `true` if the metadata entry was found and deleted; otherwise, false.\n         * @example\n         *\n         *     class Example {\n         *         // property declarations are not part of ES6, though they are valid in TypeScript:\n         *         // static staticProperty;\n         *         // property;\n         *\n         *         constructor(p) { }\n         *         static staticMethod(p) { }\n         *         method(p) { }\n         *     }\n         *\n         *     // constructor\n         *     result = Reflect.deleteMetadata(\"custom:annotation\", Example);\n         *\n         *     // property (on constructor)\n         *     result = Reflect.deleteMetadata(\"custom:annotation\", Example, \"staticProperty\");\n         *\n         *     // property (on prototype)\n         *     result = Reflect.deleteMetadata(\"custom:annotation\", Example.prototype, \"property\");\n         *\n         *     // method (on constructor)\n         *     result = Reflect.deleteMetadata(\"custom:annotation\", Example, \"staticMethod\");\n         *\n         *     // method (on prototype)\n         *     result = Reflect.deleteMetadata(\"custom:annotation\", Example.prototype, \"method\");\n         *\n         */\n        function deleteMetadata(metadataKey, target, propertyKey) {\n            if (!IsObject(target))\n                throw new TypeError();\n            if (!IsUndefined(propertyKey))\n                propertyKey = ToPropertyKey(propertyKey);\n            var metadataMap = GetOrCreateMetadataMap(target, propertyKey, /*Create*/ false);\n            if (IsUndefined(metadataMap))\n                return false;\n            if (!metadataMap.delete(metadataKey))\n                return false;\n            if (metadataMap.size > 0)\n                return true;\n            var targetMetadata = Metadata.get(target);\n            targetMetadata.delete(propertyKey);\n            if (targetMetadata.size > 0)\n                return true;\n            Metadata.delete(target);\n            return true;\n        }\n        exporter(\"deleteMetadata\", deleteMetadata);\n        function DecorateConstructor(decorators, target) {\n            for (var i = decorators.length - 1; i >= 0; --i) {\n                var decorator = decorators[i];\n                var decorated = decorator(target);\n                if (!IsUndefined(decorated) && !IsNull(decorated)) {\n                    if (!IsConstructor(decorated))\n                        throw new TypeError();\n                    target = decorated;\n                }\n            }\n            return target;\n        }\n        function DecorateProperty(decorators, target, propertyKey, descriptor) {\n            for (var i = decorators.length - 1; i >= 0; --i) {\n                var decorator = decorators[i];\n                var decorated = decorator(target, propertyKey, descriptor);\n                if (!IsUndefined(decorated) && !IsNull(decorated)) {\n                    if (!IsObject(decorated))\n                        throw new TypeError();\n                    descriptor = decorated;\n                }\n            }\n            return descriptor;\n        }\n        function GetOrCreateMetadataMap(O, P, Create) {\n            var targetMetadata = Metadata.get(O);\n            if (IsUndefined(targetMetadata)) {\n                if (!Create)\n                    return undefined;\n                targetMetadata = new _Map();\n                Metadata.set(O, targetMetadata);\n            }\n            var metadataMap = targetMetadata.get(P);\n            if (IsUndefined(metadataMap)) {\n                if (!Create)\n                    return undefined;\n                metadataMap = new _Map();\n                targetMetadata.set(P, metadataMap);\n            }\n            return metadataMap;\n        }\n        // 3.1.1.1 OrdinaryHasMetadata(MetadataKey, O, P)\n        // https://rbuckton.github.io/reflect-metadata/#ordinaryhasmetadata\n        function OrdinaryHasMetadata(MetadataKey, O, P) {\n            var hasOwn = OrdinaryHasOwnMetadata(MetadataKey, O, P);\n            if (hasOwn)\n                return true;\n            var parent = OrdinaryGetPrototypeOf(O);\n            if (!IsNull(parent))\n                return OrdinaryHasMetadata(MetadataKey, parent, P);\n            return false;\n        }\n        // 3.1.2.1 OrdinaryHasOwnMetadata(MetadataKey, O, P)\n        // https://rbuckton.github.io/reflect-metadata/#ordinaryhasownmetadata\n        function OrdinaryHasOwnMetadata(MetadataKey, O, P) {\n            var metadataMap = GetOrCreateMetadataMap(O, P, /*Create*/ false);\n            if (IsUndefined(metadataMap))\n                return false;\n            return ToBoolean(metadataMap.has(MetadataKey));\n        }\n        // 3.1.3.1 OrdinaryGetMetadata(MetadataKey, O, P)\n        // https://rbuckton.github.io/reflect-metadata/#ordinarygetmetadata\n        function OrdinaryGetMetadata(MetadataKey, O, P) {\n            var hasOwn = OrdinaryHasOwnMetadata(MetadataKey, O, P);\n            if (hasOwn)\n                return OrdinaryGetOwnMetadata(MetadataKey, O, P);\n            var parent = OrdinaryGetPrototypeOf(O);\n            if (!IsNull(parent))\n                return OrdinaryGetMetadata(MetadataKey, parent, P);\n            return undefined;\n        }\n        // 3.1.4.1 OrdinaryGetOwnMetadata(MetadataKey, O, P)\n        // https://rbuckton.github.io/reflect-metadata/#ordinarygetownmetadata\n        function OrdinaryGetOwnMetadata(MetadataKey, O, P) {\n            var metadataMap = GetOrCreateMetadataMap(O, P, /*Create*/ false);\n            if (IsUndefined(metadataMap))\n                return undefined;\n            return metadataMap.get(MetadataKey);\n        }\n        // 3.1.5.1 OrdinaryDefineOwnMetadata(MetadataKey, MetadataValue, O, P)\n        // https://rbuckton.github.io/reflect-metadata/#ordinarydefineownmetadata\n        function OrdinaryDefineOwnMetadata(MetadataKey, MetadataValue, O, P) {\n            var metadataMap = GetOrCreateMetadataMap(O, P, /*Create*/ true);\n            metadataMap.set(MetadataKey, MetadataValue);\n        }\n        // 3.1.6.1 OrdinaryMetadataKeys(O, P)\n        // https://rbuckton.github.io/reflect-metadata/#ordinarymetadatakeys\n        function OrdinaryMetadataKeys(O, P) {\n            var ownKeys = OrdinaryOwnMetadataKeys(O, P);\n            var parent = OrdinaryGetPrototypeOf(O);\n            if (parent === null)\n                return ownKeys;\n            var parentKeys = OrdinaryMetadataKeys(parent, P);\n            if (parentKeys.length <= 0)\n                return ownKeys;\n            if (ownKeys.length <= 0)\n                return parentKeys;\n            var set = new _Set();\n            var keys = [];\n            for (var _i = 0, ownKeys_1 = ownKeys; _i < ownKeys_1.length; _i++) {\n                var key = ownKeys_1[_i];\n                var hasKey = set.has(key);\n                if (!hasKey) {\n                    set.add(key);\n                    keys.push(key);\n                }\n            }\n            for (var _a = 0, parentKeys_1 = parentKeys; _a < parentKeys_1.length; _a++) {\n                var key = parentKeys_1[_a];\n                var hasKey = set.has(key);\n                if (!hasKey) {\n                    set.add(key);\n                    keys.push(key);\n                }\n            }\n            return keys;\n        }\n        // 3.1.7.1 OrdinaryOwnMetadataKeys(O, P)\n        // https://rbuckton.github.io/reflect-metadata/#ordinaryownmetadatakeys\n        function OrdinaryOwnMetadataKeys(O, P) {\n            var keys = [];\n            var metadataMap = GetOrCreateMetadataMap(O, P, /*Create*/ false);\n            if (IsUndefined(metadataMap))\n                return keys;\n            var keysObj = metadataMap.keys();\n            var iterator = GetIterator(keysObj);\n            var k = 0;\n            while (true) {\n                var next = IteratorStep(iterator);\n                if (!next) {\n                    keys.length = k;\n                    return keys;\n                }\n                var nextValue = IteratorValue(next);\n                try {\n                    keys[k] = nextValue;\n                }\n                catch (e) {\n                    try {\n                        IteratorClose(iterator);\n                    }\n                    finally {\n                        throw e;\n                    }\n                }\n                k++;\n            }\n        }\n        // 6 ECMAScript Data Typ0es and Values\n        // https://tc39.github.io/ecma262/#sec-ecmascript-data-types-and-values\n        function Type(x) {\n            if (x === null)\n                return 1 /* Null */;\n            switch (typeof x) {\n                case \"undefined\": return 0 /* Undefined */;\n                case \"boolean\": return 2 /* Boolean */;\n                case \"string\": return 3 /* String */;\n                case \"symbol\": return 4 /* Symbol */;\n                case \"number\": return 5 /* Number */;\n                case \"object\": return x === null ? 1 /* Null */ : 6 /* Object */;\n                default: return 6 /* Object */;\n            }\n        }\n        // 6.1.1 The Undefined Type\n        // https://tc39.github.io/ecma262/#sec-ecmascript-language-types-undefined-type\n        function IsUndefined(x) {\n            return x === undefined;\n        }\n        // 6.1.2 The Null Type\n        // https://tc39.github.io/ecma262/#sec-ecmascript-language-types-null-type\n        function IsNull(x) {\n            return x === null;\n        }\n        // 6.1.5 The Symbol Type\n        // https://tc39.github.io/ecma262/#sec-ecmascript-language-types-symbol-type\n        function IsSymbol(x) {\n            return typeof x === \"symbol\";\n        }\n        // 6.1.7 The Object Type\n        // https://tc39.github.io/ecma262/#sec-object-type\n        function IsObject(x) {\n            return typeof x === \"object\" ? x !== null : typeof x === \"function\";\n        }\n        // 7.1 Type Conversion\n        // https://tc39.github.io/ecma262/#sec-type-conversion\n        // 7.1.1 ToPrimitive(input [, PreferredType])\n        // https://tc39.github.io/ecma262/#sec-toprimitive\n        function ToPrimitive(input, PreferredType) {\n            switch (Type(input)) {\n                case 0 /* Undefined */: return input;\n                case 1 /* Null */: return input;\n                case 2 /* Boolean */: return input;\n                case 3 /* String */: return input;\n                case 4 /* Symbol */: return input;\n                case 5 /* Number */: return input;\n            }\n            var hint = PreferredType === 3 /* String */ ? \"string\" : PreferredType === 5 /* Number */ ? \"number\" : \"default\";\n            var exoticToPrim = GetMethod(input, toPrimitiveSymbol);\n            if (exoticToPrim !== undefined) {\n                var result = exoticToPrim.call(input, hint);\n                if (IsObject(result))\n                    throw new TypeError();\n                return result;\n            }\n            return OrdinaryToPrimitive(input, hint === \"default\" ? \"number\" : hint);\n        }\n        // 7.1.1.1 OrdinaryToPrimitive(O, hint)\n        // https://tc39.github.io/ecma262/#sec-ordinarytoprimitive\n        function OrdinaryToPrimitive(O, hint) {\n            if (hint === \"string\") {\n                var toString_1 = O.toString;\n                if (IsCallable(toString_1)) {\n                    var result = toString_1.call(O);\n                    if (!IsObject(result))\n                        return result;\n                }\n                var valueOf = O.valueOf;\n                if (IsCallable(valueOf)) {\n                    var result = valueOf.call(O);\n                    if (!IsObject(result))\n                        return result;\n                }\n            }\n            else {\n                var valueOf = O.valueOf;\n                if (IsCallable(valueOf)) {\n                    var result = valueOf.call(O);\n                    if (!IsObject(result))\n                        return result;\n                }\n                var toString_2 = O.toString;\n                if (IsCallable(toString_2)) {\n                    var result = toString_2.call(O);\n                    if (!IsObject(result))\n                        return result;\n                }\n            }\n            throw new TypeError();\n        }\n        // 7.1.2 ToBoolean(argument)\n        // https://tc39.github.io/ecma262/2016/#sec-toboolean\n        function ToBoolean(argument) {\n            return !!argument;\n        }\n        // 7.1.12 ToString(argument)\n        // https://tc39.github.io/ecma262/#sec-tostring\n        function ToString(argument) {\n            return \"\" + argument;\n        }\n        // 7.1.14 ToPropertyKey(argument)\n        // https://tc39.github.io/ecma262/#sec-topropertykey\n        function ToPropertyKey(argument) {\n            var key = ToPrimitive(argument, 3 /* String */);\n            if (IsSymbol(key))\n                return key;\n            return ToString(key);\n        }\n        // 7.2 Testing and Comparison Operations\n        // https://tc39.github.io/ecma262/#sec-testing-and-comparison-operations\n        // 7.2.2 IsArray(argument)\n        // https://tc39.github.io/ecma262/#sec-isarray\n        function IsArray(argument) {\n            return Array.isArray\n                ? Array.isArray(argument)\n                : argument instanceof Object\n                    ? argument instanceof Array\n                    : Object.prototype.toString.call(argument) === \"[object Array]\";\n        }\n        // 7.2.3 IsCallable(argument)\n        // https://tc39.github.io/ecma262/#sec-iscallable\n        function IsCallable(argument) {\n            // NOTE: This is an approximation as we cannot check for [[Call]] internal method.\n            return typeof argument === \"function\";\n        }\n        // 7.2.4 IsConstructor(argument)\n        // https://tc39.github.io/ecma262/#sec-isconstructor\n        function IsConstructor(argument) {\n            // NOTE: This is an approximation as we cannot check for [[Construct]] internal method.\n            return typeof argument === \"function\";\n        }\n        // 7.2.7 IsPropertyKey(argument)\n        // https://tc39.github.io/ecma262/#sec-ispropertykey\n        function IsPropertyKey(argument) {\n            switch (Type(argument)) {\n                case 3 /* String */: return true;\n                case 4 /* Symbol */: return true;\n                default: return false;\n            }\n        }\n        // 7.3 Operations on Objects\n        // https://tc39.github.io/ecma262/#sec-operations-on-objects\n        // 7.3.9 GetMethod(V, P)\n        // https://tc39.github.io/ecma262/#sec-getmethod\n        function GetMethod(V, P) {\n            var func = V[P];\n            if (func === undefined || func === null)\n                return undefined;\n            if (!IsCallable(func))\n                throw new TypeError();\n            return func;\n        }\n        // 7.4 Operations on Iterator Objects\n        // https://tc39.github.io/ecma262/#sec-operations-on-iterator-objects\n        function GetIterator(obj) {\n            var method = GetMethod(obj, iteratorSymbol);\n            if (!IsCallable(method))\n                throw new TypeError(); // from Call\n            var iterator = method.call(obj);\n            if (!IsObject(iterator))\n                throw new TypeError();\n            return iterator;\n        }\n        // 7.4.4 IteratorValue(iterResult)\n        // https://tc39.github.io/ecma262/2016/#sec-iteratorvalue\n        function IteratorValue(iterResult) {\n            return iterResult.value;\n        }\n        // 7.4.5 IteratorStep(iterator)\n        // https://tc39.github.io/ecma262/#sec-iteratorstep\n        function IteratorStep(iterator) {\n            var result = iterator.next();\n            return result.done ? false : result;\n        }\n        // 7.4.6 IteratorClose(iterator, completion)\n        // https://tc39.github.io/ecma262/#sec-iteratorclose\n        function IteratorClose(iterator) {\n            var f = iterator[\"return\"];\n            if (f)\n                f.call(iterator);\n        }\n        // 9.1 Ordinary Object Internal Methods and Internal Slots\n        // https://tc39.github.io/ecma262/#sec-ordinary-object-internal-methods-and-internal-slots\n        // 9.1.1.1 OrdinaryGetPrototypeOf(O)\n        // https://tc39.github.io/ecma262/#sec-ordinarygetprototypeof\n        function OrdinaryGetPrototypeOf(O) {\n            var proto = Object.getPrototypeOf(O);\n            if (typeof O !== \"function\" || O === functionPrototype)\n                return proto;\n            // TypeScript doesn't set __proto__ in ES5, as it's non-standard.\n            // Try to determine the superclass constructor. Compatible implementations\n            // must either set __proto__ on a subclass constructor to the superclass constructor,\n            // or ensure each class has a valid `constructor` property on its prototype that\n            // points back to the constructor.\n            // If this is not the same as Function.[[Prototype]], then this is definately inherited.\n            // This is the case when in ES6 or when using __proto__ in a compatible browser.\n            if (proto !== functionPrototype)\n                return proto;\n            // If the super prototype is Object.prototype, null, or undefined, then we cannot determine the heritage.\n            var prototype = O.prototype;\n            var prototypeProto = prototype && Object.getPrototypeOf(prototype);\n            if (prototypeProto == null || prototypeProto === Object.prototype)\n                return proto;\n            // If the constructor was not a function, then we cannot determine the heritage.\n            var constructor = prototypeProto.constructor;\n            if (typeof constructor !== \"function\")\n                return proto;\n            // If we have some kind of self-reference, then we cannot determine the heritage.\n            if (constructor === O)\n                return proto;\n            // we have a pretty good guess at the heritage.\n            return constructor;\n        }\n        // naive Map shim\n        function CreateMapPolyfill() {\n            var cacheSentinel = {};\n            var arraySentinel = [];\n            var MapIterator = /** @class */ (function () {\n                function MapIterator(keys, values, selector) {\n                    this._index = 0;\n                    this._keys = keys;\n                    this._values = values;\n                    this._selector = selector;\n                }\n                MapIterator.prototype[\"@@iterator\"] = function () { return this; };\n                MapIterator.prototype[iteratorSymbol] = function () { return this; };\n                MapIterator.prototype.next = function () {\n                    var index = this._index;\n                    if (index >= 0 && index < this._keys.length) {\n                        var result = this._selector(this._keys[index], this._values[index]);\n                        if (index + 1 >= this._keys.length) {\n                            this._index = -1;\n                            this._keys = arraySentinel;\n                            this._values = arraySentinel;\n                        }\n                        else {\n                            this._index++;\n                        }\n                        return { value: result, done: false };\n                    }\n                    return { value: undefined, done: true };\n                };\n                MapIterator.prototype.throw = function (error) {\n                    if (this._index >= 0) {\n                        this._index = -1;\n                        this._keys = arraySentinel;\n                        this._values = arraySentinel;\n                    }\n                    throw error;\n                };\n                MapIterator.prototype.return = function (value) {\n                    if (this._index >= 0) {\n                        this._index = -1;\n                        this._keys = arraySentinel;\n                        this._values = arraySentinel;\n                    }\n                    return { value: value, done: true };\n                };\n                return MapIterator;\n            }());\n            return /** @class */ (function () {\n                function Map() {\n                    this._keys = [];\n                    this._values = [];\n                    this._cacheKey = cacheSentinel;\n                    this._cacheIndex = -2;\n                }\n                Object.defineProperty(Map.prototype, \"size\", {\n                    get: function () { return this._keys.length; },\n                    enumerable: true,\n                    configurable: true\n                });\n                Map.prototype.has = function (key) { return this._find(key, /*insert*/ false) >= 0; };\n                Map.prototype.get = function (key) {\n                    var index = this._find(key, /*insert*/ false);\n                    return index >= 0 ? this._values[index] : undefined;\n                };\n                Map.prototype.set = function (key, value) {\n                    var index = this._find(key, /*insert*/ true);\n                    this._values[index] = value;\n                    return this;\n                };\n                Map.prototype.delete = function (key) {\n                    var index = this._find(key, /*insert*/ false);\n                    if (index >= 0) {\n                        var size = this._keys.length;\n                        for (var i = index + 1; i < size; i++) {\n                            this._keys[i - 1] = this._keys[i];\n                            this._values[i - 1] = this._values[i];\n                        }\n                        this._keys.length--;\n                        this._values.length--;\n                        if (key === this._cacheKey) {\n                            this._cacheKey = cacheSentinel;\n                            this._cacheIndex = -2;\n                        }\n                        return true;\n                    }\n                    return false;\n                };\n                Map.prototype.clear = function () {\n                    this._keys.length = 0;\n                    this._values.length = 0;\n                    this._cacheKey = cacheSentinel;\n                    this._cacheIndex = -2;\n                };\n                Map.prototype.keys = function () { return new MapIterator(this._keys, this._values, getKey); };\n                Map.prototype.values = function () { return new MapIterator(this._keys, this._values, getValue); };\n                Map.prototype.entries = function () { return new MapIterator(this._keys, this._values, getEntry); };\n                Map.prototype[\"@@iterator\"] = function () { return this.entries(); };\n                Map.prototype[iteratorSymbol] = function () { return this.entries(); };\n                Map.prototype._find = function (key, insert) {\n                    if (this._cacheKey !== key) {\n                        this._cacheIndex = this._keys.indexOf(this._cacheKey = key);\n                    }\n                    if (this._cacheIndex < 0 && insert) {\n                        this._cacheIndex = this._keys.length;\n                        this._keys.push(key);\n                        this._values.push(undefined);\n                    }\n                    return this._cacheIndex;\n                };\n                return Map;\n            }());\n            function getKey(key, _) {\n                return key;\n            }\n            function getValue(_, value) {\n                return value;\n            }\n            function getEntry(key, value) {\n                return [key, value];\n            }\n        }\n        // naive Set shim\n        function CreateSetPolyfill() {\n            return /** @class */ (function () {\n                function Set() {\n                    this._map = new _Map();\n                }\n                Object.defineProperty(Set.prototype, \"size\", {\n                    get: function () { return this._map.size; },\n                    enumerable: true,\n                    configurable: true\n                });\n                Set.prototype.has = function (value) { return this._map.has(value); };\n                Set.prototype.add = function (value) { return this._map.set(value, value), this; };\n                Set.prototype.delete = function (value) { return this._map.delete(value); };\n                Set.prototype.clear = function () { this._map.clear(); };\n                Set.prototype.keys = function () { return this._map.keys(); };\n                Set.prototype.values = function () { return this._map.values(); };\n                Set.prototype.entries = function () { return this._map.entries(); };\n                Set.prototype[\"@@iterator\"] = function () { return this.keys(); };\n                Set.prototype[iteratorSymbol] = function () { return this.keys(); };\n                return Set;\n            }());\n        }\n        // naive WeakMap shim\n        function CreateWeakMapPolyfill() {\n            var UUID_SIZE = 16;\n            var keys = HashMap.create();\n            var rootKey = CreateUniqueKey();\n            return /** @class */ (function () {\n                function WeakMap() {\n                    this._key = CreateUniqueKey();\n                }\n                WeakMap.prototype.has = function (target) {\n                    var table = GetOrCreateWeakMapTable(target, /*create*/ false);\n                    return table !== undefined ? HashMap.has(table, this._key) : false;\n                };\n                WeakMap.prototype.get = function (target) {\n                    var table = GetOrCreateWeakMapTable(target, /*create*/ false);\n                    return table !== undefined ? HashMap.get(table, this._key) : undefined;\n                };\n                WeakMap.prototype.set = function (target, value) {\n                    var table = GetOrCreateWeakMapTable(target, /*create*/ true);\n                    table[this._key] = value;\n                    return this;\n                };\n                WeakMap.prototype.delete = function (target) {\n                    var table = GetOrCreateWeakMapTable(target, /*create*/ false);\n                    return table !== undefined ? delete table[this._key] : false;\n                };\n                WeakMap.prototype.clear = function () {\n                    // NOTE: not a real clear, just makes the previous data unreachable\n                    this._key = CreateUniqueKey();\n                };\n                return WeakMap;\n            }());\n            function CreateUniqueKey() {\n                var key;\n                do\n                    key = \"@@WeakMap@@\" + CreateUUID();\n                while (HashMap.has(keys, key));\n                keys[key] = true;\n                return key;\n            }\n            function GetOrCreateWeakMapTable(target, create) {\n                if (!hasOwn.call(target, rootKey)) {\n                    if (!create)\n                        return undefined;\n                    Object.defineProperty(target, rootKey, { value: HashMap.create() });\n                }\n                return target[rootKey];\n            }\n            function FillRandomBytes(buffer, size) {\n                for (var i = 0; i < size; ++i)\n                    buffer[i] = Math.random() * 0xff | 0;\n                return buffer;\n            }\n            function GenRandomBytes(size) {\n                if (typeof Uint8Array === \"function\") {\n                    if (typeof crypto !== \"undefined\")\n                        return crypto.getRandomValues(new Uint8Array(size));\n                    if (typeof msCrypto !== \"undefined\")\n                        return msCrypto.getRandomValues(new Uint8Array(size));\n                    return FillRandomBytes(new Uint8Array(size), size);\n                }\n                return FillRandomBytes(new Array(size), size);\n            }\n            function CreateUUID() {\n                var data = GenRandomBytes(UUID_SIZE);\n                // mark as random - RFC 4122 § 4.4\n                data[6] = data[6] & 0x4f | 0x40;\n                data[8] = data[8] & 0xbf | 0x80;\n                var result = \"\";\n                for (var offset = 0; offset < UUID_SIZE; ++offset) {\n                    var byte = data[offset];\n                    if (offset === 4 || offset === 6 || offset === 8)\n                        result += \"-\";\n                    if (byte < 16)\n                        result += \"0\";\n                    result += byte.toString(16).toLowerCase();\n                }\n                return result;\n            }\n        }\n        // uses a heuristic used by v8 and chakra to force an object into dictionary mode.\n        function MakeDictionary(obj) {\n            obj.__ = undefined;\n            delete obj.__;\n            return obj;\n        }\n    });\n})(Reflect || (Reflect = {}));\n","export const PLUGIN_FOLDER = 'plugins';\n\nexport const VERSION = '__VERSION__';\n\nexport const VERSION_URL = 'https://gitee.com/zuoez02/siyuan-plugin-system/raw/main/VERSION';\n\nexport const SCRIPT_URL = 'https://gitee.com/zuoez02/siyuan-plugin-system/raw/main/main.js';\n\nexport const PLUGIN_SYS_ABS_PATH = '/data/widgets/插件系统/plugin.js';\n\nexport const config = () => ({ token: window.siyuan.config.api.token });\n\nexport const TYPES = {\n    StorageManager: 'StorageManager',\n    PluginSystem: 'PluginSystem',\n    SystemManager: 'PluginSystemLocalManager',\n    PluginLoader: 'PluginLoader',\n    PluginFileManager: 'PluginFileManager',\n    EventBus: 'EventBus',\n    Shortcut: 'Shortcut',\n    CommandManager: 'CommandManager',\n    Store: 'Store',\n    SettingManager: 'SettingManager',\n};\n","/* eslint-disable */\nimport { config } from '../config';\nimport { genUUID } from '../util';\n\nexport async function request(url, data) {\n    let resData = null;\n    await fetch(url, {\n        body: JSON.stringify(data),\n        method: 'POST',\n        headers: {\n            Authorization: `Token ${config().token}`,\n        },\n    }).then(function (response) {\n        resData = response.json();\n    });\n    return resData;\n}\n\nexport async function parseBody(response) {\n    let r = await response;\n    return r.code === 0 ? r.data : null;\n}\n\nexport async function transactions(protyle, transactions = []) {\n    const url = '/api/transactions';\n    const ws_url = new URL(protyle.ws.ws.url);\n    const data = {\n        app: ws_url.searchParams.get('app'),\n        session: ws_url.searchParams.get('id'),\n        transactions: transactions,\n    };\n    return parseBody(request(url, data));\n}\n\nexport async function sql(sql) {\n    let sqldata = {\n        stmt: sql,\n    };\n    let url = '/api/query/sql';\n    return parseBody(request(url, sqldata));\n}\n\nexport async function lsNotebooks(sql) {\n    let sqldata = { stmt: sql };\n    let url = '/api/notebook/lsNotebooks';\n    return parseBody(request(url, sqldata));\n}\n\nexport async function getAnchor(anchorText, name) {\n    anchorText = anchorText.replace('((', '').replace('))', '');\n    let sqlScript = `select * from blocks where id = '${anchorText}'`;\n    let sqlRes = await sql(sqlScript);\n    let anchor = '';\n    if (sqlRes) {\n        try {\n            if (sqlRes[0][name]) {\n                anchor = sqlRes[0][name];\n            } else if (sqlRes[0]['content']) {\n                anchor = sqlRes[0]['content'];\n            } else {\n                anchor = anchorText;\n            }\n        } catch (e) {\n            anchor = '解析错误';\n        }\n    }\n    return anchor;\n}\n\nexport async function openNotebook(notebookId) {\n    let data = {\n        notebook: notebookId,\n    };\n    let url = '/api/notebook/openNotebook';\n    return parseBody(request(url, data));\n    //返回空数据\n}\n\nexport async function closeNotebook(notebookId) {\n    let data = {\n        notebook: notebookId,\n    };\n    let url = '/api/notebook/closeNotebook';\n    return parseBody(request(url, data));\n    //返回空数据\n}\n\nexport async function renameNotebook(notebookId, notebookNewName) {\n    let data = {\n        notebook: notebookId,\n        name: notebookNewName,\n    };\n    let url = '/api/notebook/renameNotebook';\n    return parseBody(request(url, data));\n    //返回空数据\n}\n\nexport async function createNotebook(notebookName) {\n    let data = {\n        name: notebookName,\n    };\n    let url = '/api/notebook/createNotebook';\n    return parseBody(request(url, data));\n    //返回空数据\n}\n\nexport async function removeNotebook(notebookId) {\n    let data = { notebook: notebookId };\n    let url = '/api/notebook/removeNotebook';\n    return parseBody(request(url, data));\n    //返回空数据\n}\n\nexport async function getNotebookConf(notebookId) {\n    let data = { notebook: notebookId };\n    let url = '/api/notebook/getNotebookConf';\n    return parseBody(request(url, data));\n    //返回笔记本配置\n}\n\nexport async function setNotebookConf(notebookId) {\n    let data = { notebook: notebookId };\n    let url = '/api/notebook/setNotebookConf';\n    return parseBody(request(url, data));\n    //返回笔记本配置\n}\n\nexport async function renameDoc(notebookId, path, title) {\n    let data = {\n        notebook: notebookId,\n        path: path,\n        title: title,\n    };\n    let url = '/api/filetree/renameDoc';\n    return parseBody(request(url, data));\n    //返回空数据\n}\n\nexport async function removeDoc(notebookId, path) {\n    let data = {\n        notebook: notebookId,\n        path: path,\n    };\n    let url = '/api/filetree/removeDoc';\n    return parseBody(request(url, data));\n    //返回空数据\n}\n\nexport async function moveDoc(srcNotebookId, srcPath, targetNotebookId, targetPath) {\n    let data = {\n        fromNotebook: srcNotebookId,\n        fromPath: srcPath,\n        toNotebook: targetNotebookId,\n        toPath: targetPath,\n    };\n    let url = '/api/filetree/moveDoc';\n    return parseBody(request(url, data));\n    //返回空数据\n}\n\nexport async function getHPathByPath(notebookId, path) {\n    let data = {\n        Notebook: notebookId,\n        Path: path,\n    };\n    let url = '/api/filetree/getHPathByPath';\n    return parseBody(request(url, data));\n    //返回路径\n}\n\nexport async function getHPathByID(ID) {\n    let data = {\n        id: ID,\n    };\n    let url = '/api/filetree/getHPathByID';\n    return parseBody(request(url, data));\n}\n\n//暂缺上传文件\n\nexport async function getBlockAttrs(blockId) {\n    let data = {\n        id: blockId,\n    };\n    let url = '/api/attr/getBlockAttrs';\n    return parseBody(request(url, data));\n}\n\nexport async function getBlockByID(blockId) {\n    let sqlScript = `select * from blocks where id ='${blockId}'`;\n    let data = await sql(sqlScript);\n    return data[0];\n}\n\nexport async function getBlockKramdown(blockId) {\n    const data = {\n        id: blockId,\n    };\n    const url = '/api/block/getBlockKramdown';\n    return parseBody(request(url, data));\n}\n\nexport async function getBlockBreadcrumb(ID) {\n    const data = {\n        id: ID,\n    };\n    const url = '/api/block/getBlockBreadcrumb';\n    return parseBody(request(url, data));\n}\n\nexport async function setBlockAttrs(blockId, attrs) {\n    let url = '/api/attr/setBlockAttrs';\n    return parseBody(\n        request(url, {\n            id: blockId,\n            attrs: attrs,\n        })\n    );\n}\n\nexport async function exportMdContent(docId) {\n    let data = {\n        id: docId,\n    };\n    let url = '/api/export/exportMdContent';\n    return parseBody(request(url, data));\n    //文档hepath与Markdown 内容\n}\n\nexport async function getDocOutline(docId) {\n    let data = {\n        id: docId,\n    };\n    let url = '/api/outline/getDocOutline';\n    return parseBody(request(url, data));\n}\n\nexport async function listDocsByPath(path) {\n    let data = {\n        path: path,\n    };\n    let url = '/api/filetree/listDocsByPath';\n    return parseBody(request(url, data));\n    //文档hepath与Markdown 内容\n}\n\nfunction html转义(text) {\n    var tempEl = document.createElement('div');\n    tempEl.innerHTML = text;\n    var output = tempEl.innerText || tempEl.textContent;\n    tempEl = null;\n    return output;\n}\n\nexport async function getBacklink(id) {\n    let data = {\n        id: id,\n        beforeLen: 10,\n        k: '',\n        mk: '',\n    };\n    let url = '/api/ref/getBacklink';\n    return parseBody(request(url, data));\n}\n\nexport async function searchEmbedBlock(excludeIds, sql) {\n    let data = {\n        stmt: sql,\n        excludeIDs: excludeIds,\n    };\n    let url = '/api/search/searchEmbedBlock';\n    return parseBody(request(url, data));\n}\nexport async function getDoc(id) {\n    let data = {\n        id: id,\n        k: '',\n        mode: 2,\n        size: 36,\n    };\n    let url = '/api/filetree/getDoc';\n    return parseBody(request(url, data));\n}\nexport async function getFocusedDoc(id) {\n    let data = {\n        id: id,\n        k: '',\n        mode: 0,\n        size: 36,\n    };\n    let url = '/api/filetree/getDoc';\n    return parseBody(request(url, data));\n}\nexport async function getTag() {\n    let data = {};\n    let url = '/api/tag/getTag';\n    return parseBody(request(url, data));\n}\nexport async function getLocalGraph(k, id, conf, reqId) {\n    let data = {\n        id: id,\n        k: k,\n        conf: conf,\n        reqId: reqId,\n    };\n    let url = '/api/graph/getLocalGraph';\n    return parseBody(request(url, data));\n}\nexport async function getGraph(k, conf, reqId) {\n    let data = {\n        k: k,\n        conf: conf,\n        reqId: reqId,\n    };\n    let url = '/api/graph/getGraph';\n    return parseBody(request(url, data));\n}\n\nexport async function searchDocs(k) {\n    let data = {\n        k: k,\n    };\n    let url = '/api/filetree/searchDocs';\n    return parseBody(request(url, data));\n}\nexport async function searchBlock(query) {\n    let data = {\n        query: query,\n    };\n    let url = '/api/search/searchBlock';\n    return parseBody(request(url, data));\n}\nexport async function searchTemplate(k) {\n    let data = {\n        k: k,\n    };\n    let url = '/api/search/searchTemplate';\n    return parseBody(request(url, data));\n}\n\nexport async function createDocWithMd(notebook, path, markdown) {\n    let data = {\n        notebook: notebook,\n        path: path,\n        markdown: markdown,\n    };\n    let url = '/api/filetree/createDocWithMd';\n    return parseBody(request(url, data));\n}\n\nexport async function docSaveAsTemplate(id, overwrite = false) {\n    let url = '/api/template/docSaveAsTemplate';\n    let data = {\n        id: id,\n        overwrite: overwrite,\n    };\n    return parseBody(request(url, data));\n}\n\nexport async function render(data) {\n    let url = '/api/template/render';\n    return parseBody(request(url, data));\n}\n\nexport async function insertBlock(previousID, dataType, data) {\n    let url = '/api/block/insertBlock';\n    return parseBody(\n        request(\n            (url = url),\n            (data = {\n                previousID: previousID,\n                dataType: dataType,\n                data: data,\n            })\n        )\n    );\n}\n\nexport async function prependBlock(parentID, dataType, data) {\n    let url = '/api/block/prependBlock';\n    return parseBody(\n        request(\n            (url = url),\n            (data = {\n                parentID: parentID,\n                dataType: dataType,\n                data: data,\n            })\n        )\n    );\n}\nexport async function appendBlock(parentID, dataType, data) {\n    let url = '/api/block/appendBlock';\n    return parseBody(\n        request(\n            (url = url),\n            (data = {\n                parentID: parentID,\n                dataType: dataType,\n                data: data,\n            })\n        )\n    );\n}\n\nexport async function updateBlock(id, dataType, data) {\n    let url = '/api/block/updateBlock';\n    return parseBody(\n        request(\n            (url = url),\n            (data = {\n                id: id,\n                dataType: dataType,\n                data: data,\n            })\n        )\n    );\n}\n\nexport async function deleteBlock(id) {\n    let url = '/api/block/deleteBlock';\n    return parseBody(request(url, { id }));\n}\n\nexport async function moveBlock(id: string, previousID: string, parentID: string) {\n    let url = '/api/block/moveBlock';\n    return parseBody(\n        request(url, { id: id, previousID: previousID, parentID: parentID })\n    );\n}\n\nexport async function getSysFonts() {\n    let url = '/api/system/getSysFonts';\n    return parseBody(request(url, null));\n}\n\nexport async function getFile(path: string, type: 'json' | 'text' = 'text') {\n    const response = await fetch('/api/file/getFile', {\n        method: 'POST',\n        headers: {\n            Authorization: `Token ${config().token}`,\n        },\n        body: JSON.stringify({\n            path: path,\n        }),\n    });\n    if (response.status === 200) {\n        if (type === 'text') {\n            return await response.text();\n        }\n        if (type === 'json') {\n            return (await response.json()).data;\n        }\n    }\n    return null;\n}\n\nexport async function putFile(path, filedata, isDir = false, modTime = Date.now()) {\n    let blob = new Blob([filedata]);\n    let file = new File([blob], path.split('/').pop());\n    let formdata = new FormData();\n    formdata.append('path', path);\n    formdata.append('file', file);\n    formdata.append('isDir', String(isDir));\n    formdata.append('modTime', String(modTime));\n    const response = await fetch('/api/file/putFile', {\n        body: formdata,\n        method: 'POST',\n        headers: {\n            Authorization: `Token ${config().token}`,\n        },\n    });\n    if (response.status === 200) return await response.json();\n    else return null;\n}\n\nexport async function readDir(path: string) {\n    const response = await fetch('/api/file/readDir', {\n        method: 'POST',\n        headers: {\n            Authorization: `Token ${config().token}`,\n        },\n        body: JSON.stringify({\n            path: path,\n        }),\n    });\n    if (response.status === 200) {\n        return (await response.json()).data;\n    };\n    return null;\n}\n\nexport async function removeFile(path) {\n    const response = await fetch('/api/file/removeFile', {\n        method: 'POST',\n        headers: {\n            Authorization: `Token ${config().token}`,\n        },\n        body: JSON.stringify({\n            path: path,\n        }),\n    });\n    if (response.status === 200) return;\n    else return null;\n}\n\nconst language = window.theme?.languageMode;\n\nexport async function pushMsg(message = null, text = null, timeout = 7000) {\n    const url = '/api/notification/pushMsg';\n    const data = {\n        msg: message ? message[language] || message.other : text,\n        timeout: timeout,\n    };\n    return parseBody(request(url, data));\n}\n\nexport async function pushErrMsg(message = null, text = null, timeout = 7000) {\n    const url = '/api/notification/pushErrMsg';\n    const data = {\n        msg: message ? message[language] || message.other : text,\n        timeout: timeout,\n    };\n    return parseBody(request(url, data));\n}\n\nexport async function setStorageVal(key: string, val: any) {\n    const url = '/api/storage/setLocalStorageVal';\n    const data = {\n        app: genUUID(),\n        key,\n        val,\n    };\n    return parseBody(request(url, data));\n}\n\nexport async function getLocalStorage() {\n    const url = '/api/storage/getLocalStorage';\n    return parseBody(request(url, null));\n}\n\nexport async function renderSprig(sprig: string) {\n    let url = '/api/template/renderSprig';\n    return parseBody(request(url, {template: sprig}));\n}\n\nexport async function getBazzarWidget() {\n    const url = '/api/bazaar/getBazaarWidget';\n    return parseBody(request(url, null));\n}\n","import * as serverApi from '../../api/server-api';\nimport { INoticationOption, INotification } from '../../types';\n\nexport class Notification implements INotification {\n    constructor(private option: INoticationOption) {}\n\n    show() {\n        if (this.option.type === 'error') {\n            serverApi.pushErrMsg(null, this.option.message, this.option.timeout);\n        } else {\n            serverApi.pushMsg(null, this.option.message, this.option.timeout);\n        }\n    }\n}\n","var z = Object.defineProperty;\nvar D = (i, e, t) => e in i ? z(i, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : i[e] = t;\nvar _ = (i, e, t) => (D(i, typeof e != \"symbol\" ? e + \"\" : e, t), t);\nvar P = typeof globalThis < \"u\" ? globalThis : typeof window < \"u\" ? window : typeof global < \"u\" ? global : typeof self < \"u\" ? self : {}, b = {}, W = {\n  get exports() {\n    return b;\n  },\n  set exports(i) {\n    b = i;\n  }\n};\n(function(i) {\n  (function(e, t) {\n    i.exports ? i.exports = t() : e.log = t();\n  })(P, function() {\n    var e = function() {\n    }, t = \"undefined\", l = typeof window !== t && typeof window.navigator !== t && /Trident\\/|MSIE /.test(window.navigator.userAgent), p = [\n      \"trace\",\n      \"debug\",\n      \"info\",\n      \"warn\",\n      \"error\"\n    ];\n    function c(a, s) {\n      var f = a[s];\n      if (typeof f.bind == \"function\")\n        return f.bind(a);\n      try {\n        return Function.prototype.bind.call(f, a);\n      } catch {\n        return function() {\n          return Function.prototype.apply.apply(f, [a, arguments]);\n        };\n      }\n    }\n    function g() {\n      console.log && (console.log.apply ? console.log.apply(console, arguments) : Function.prototype.apply.apply(console.log, [console, arguments])), console.trace && console.trace();\n    }\n    function w(a) {\n      return a === \"debug\" && (a = \"log\"), typeof console === t ? !1 : a === \"trace\" && l ? g : console[a] !== void 0 ? c(console, a) : console.log !== void 0 ? c(console, \"log\") : e;\n    }\n    function E(a, s) {\n      for (var f = 0; f < p.length; f++) {\n        var o = p[f];\n        this[o] = f < a ? e : this.methodFactory(o, a, s);\n      }\n      this.log = this.debug;\n    }\n    function F(a, s, f) {\n      return function() {\n        typeof console !== t && (E.call(this, s, f), this[a].apply(this, arguments));\n      };\n    }\n    function r(a, s, f) {\n      return w(a) || F.apply(this, arguments);\n    }\n    function v(a, s, f) {\n      var o = this, O;\n      s = s ?? \"WARN\";\n      var u = \"loglevel\";\n      typeof a == \"string\" ? u += \":\" + a : typeof a == \"symbol\" && (u = void 0);\n      function C(n) {\n        var d = (p[n] || \"silent\").toUpperCase();\n        if (!(typeof window === t || !u)) {\n          try {\n            window.localStorage[u] = d;\n            return;\n          } catch {\n          }\n          try {\n            window.document.cookie = encodeURIComponent(u) + \"=\" + d + \";\";\n          } catch {\n          }\n        }\n      }\n      function k() {\n        var n;\n        if (!(typeof window === t || !u)) {\n          try {\n            n = window.localStorage[u];\n          } catch {\n          }\n          if (typeof n === t)\n            try {\n              var d = window.document.cookie, m = d.indexOf(\n                encodeURIComponent(u) + \"=\"\n              );\n              m !== -1 && (n = /^([^;]+)/.exec(d.slice(m))[1]);\n            } catch {\n            }\n          return o.levels[n] === void 0 && (n = void 0), n;\n        }\n      }\n      function V() {\n        if (!(typeof window === t || !u)) {\n          try {\n            window.localStorage.removeItem(u);\n            return;\n          } catch {\n          }\n          try {\n            window.document.cookie = encodeURIComponent(u) + \"=; expires=Thu, 01 Jan 1970 00:00:00 UTC\";\n          } catch {\n          }\n        }\n      }\n      o.name = a, o.levels = {\n        TRACE: 0,\n        DEBUG: 1,\n        INFO: 2,\n        WARN: 3,\n        ERROR: 4,\n        SILENT: 5\n      }, o.methodFactory = f || r, o.getLevel = function() {\n        return O;\n      }, o.setLevel = function(n, d) {\n        if (typeof n == \"string\" && o.levels[n.toUpperCase()] !== void 0 && (n = o.levels[n.toUpperCase()]), typeof n == \"number\" && n >= 0 && n <= o.levels.SILENT) {\n          if (O = n, d !== !1 && C(n), E.call(o, n, a), typeof console === t && n < o.levels.SILENT)\n            return \"No console available for logging\";\n        } else\n          throw \"log.setLevel() called with invalid level: \" + n;\n      }, o.setDefaultLevel = function(n) {\n        s = n, k() || o.setLevel(n, !1);\n      }, o.resetLevel = function() {\n        o.setLevel(s, !1), V();\n      }, o.enableAll = function(n) {\n        o.setLevel(o.levels.TRACE, n);\n      }, o.disableAll = function(n) {\n        o.setLevel(o.levels.SILENT, n);\n      };\n      var y = k();\n      y == null && (y = s), o.setLevel(y, !1);\n    }\n    var L = new v(), h = {};\n    L.getLogger = function(s) {\n      if (typeof s != \"symbol\" && typeof s != \"string\" || s === \"\")\n        throw new TypeError(\"You must supply a name when creating a logger.\");\n      var f = h[s];\n      return f || (f = h[s] = new v(\n        s,\n        L.getLevel(),\n        L.methodFactory\n      )), f;\n    };\n    var G = typeof window !== t ? window.log : void 0;\n    return L.noConflict = function() {\n      return typeof window !== t && window.log === L && (window.log = G), L;\n    }, L.getLoggers = function() {\n      return h;\n    }, L.default = L, L;\n  });\n})(W);\nvar R = {}, B = {\n  get exports() {\n    return R;\n  },\n  set exports(i) {\n    R = i;\n  }\n};\n(function(i) {\n  (function(e, t) {\n    i.exports ? i.exports = t() : e.prefix = t(e);\n  })(P, function(e) {\n    var t = function(r) {\n      for (var v = 1, L = arguments.length, h; v < L; v++)\n        for (h in arguments[v])\n          Object.prototype.hasOwnProperty.call(arguments[v], h) && (r[h] = arguments[v][h]);\n      return r;\n    }, l = {\n      template: \"[%t] %l:\",\n      levelFormatter: function(r) {\n        return r.toUpperCase();\n      },\n      nameFormatter: function(r) {\n        return r || \"root\";\n      },\n      timestampFormatter: function(r) {\n        return r.toTimeString().replace(/.*(\\d{2}:\\d{2}:\\d{2}).*/, \"$1\");\n      },\n      format: void 0\n    }, p, c = {}, g = function(r) {\n      if (!r || !r.getLogger)\n        throw new TypeError(\"Argument is not a root logger\");\n      p = r;\n    }, w = function(r, v) {\n      if (!r || !r.setLevel)\n        throw new TypeError(\"Argument is not a logger\");\n      var L = r.methodFactory, h = r.name || \"\", G = c[h] || c[\"\"] || l;\n      function a(s, f, o) {\n        var O = L(s, f, o), u = c[o] || c[\"\"], C = u.template.indexOf(\"%t\") !== -1, k = u.template.indexOf(\"%l\") !== -1, V = u.template.indexOf(\"%n\") !== -1;\n        return function() {\n          for (var y = \"\", n = arguments.length, d = Array(n), m = 0; m < n; m++)\n            d[m] = arguments[m];\n          if (h || !c[o]) {\n            var x = u.timestampFormatter(new Date()), U = u.levelFormatter(s), A = u.nameFormatter(o);\n            u.format ? y += u.format(U, A, x) : (y += u.template, C && (y = y.replace(/%t/, x)), k && (y = y.replace(/%l/, U)), V && (y = y.replace(/%n/, A))), d.length && typeof d[0] == \"string\" ? d[0] = y + \" \" + d[0] : d.unshift(y);\n          }\n          O.apply(void 0, d);\n        };\n      }\n      return c[h] || (r.methodFactory = a), v = v || {}, v.template && (v.format = void 0), c[h] = t({}, G, v), r.setLevel(r.getLevel()), p || r.warn(\n        \"It is necessary to call the function reg() of loglevel-plugin-prefix before calling apply. From the next release, it will throw an error. See more: https://github.com/kutuluk/loglevel-plugin-prefix/blob/master/README.md\"\n      ), r;\n    }, E = {\n      reg: g,\n      apply: w\n    }, F;\n    return e && (F = e.prefix, E.noConflict = function() {\n      return e.prefix === E && (e.prefix = F), E;\n    }), E;\n  });\n})(B);\nclass T {\n}\n_(T, \"LOG_LEVEL_KEY\", \"VITE_LOG_LEVEL\"), _(T, \"LOG_PREFIX_KEY\", \"VITE_LOG_PREFIX\");\nvar S = /* @__PURE__ */ ((i) => (i.LOG_LEVEL_DEBUG = \"DEBUG\", i.LOG_LEVEL_INFO = \"INFO\", i.LOG_LEVEL_WARN = \"WARN\", i.LOG_LEVEL_ERROR = \"ERROR\", i))(S || {});\nfunction K() {\n  const i = Error.prepareStackTrace;\n  Error.prepareStackTrace = (t, l) => l;\n  const e = new Error().stack.slice(1);\n  return Error.prepareStackTrace = i, e;\n}\nclass I {\n  /**\n   * 解析日志级别为枚举\n   *\n   * @param enumObj 枚举对象\n   * @param value 配置的值\n   */\n  static stringToEnumValue(e, t) {\n    return e[Object.keys(e).filter(\n      (l) => e[l].toString() === t\n    )[0]];\n  }\n  /**\n   * 获取配置的日志级别\n   */\n  static getEnvLevel(e) {\n    if (!e)\n      return;\n    const t = e.getEnvOrDefault(\n      T.LOG_LEVEL_KEY,\n      S.LOG_LEVEL_INFO\n    ), l = I.stringToEnumValue(\n      S,\n      t.toUpperCase()\n    );\n    return l || console.warn(\n      \"[zhi-log] LOG_LEVEL is invalid in you .env file.Must be either debug, info, warn or error, fallback to default info level\"\n    ), l;\n  }\n  /**\n   * 获取默认日志\n   */\n  static getEnvLogger(e) {\n    if (e)\n      return e.getEnv(T.LOG_PREFIX_KEY);\n  }\n}\nclass Y {\n  constructor(e, t, l) {\n    _(this, \"consoleLogger\", \"console\");\n    _(this, \"stackSize\", 1);\n    /**\n     * 获取日志记录器\n     *\n     * @param loggerName - 日志记录器，默认为 console\n     * @author terwer\n     * @since 1.0.0\n     */\n    _(this, \"getLogger\", (e) => {\n      let t;\n      if (e)\n        t = e;\n      else {\n        const l = this.getCallStack(), p = [], c = [];\n        for (let g = 0; g < l.length; g++) {\n          const w = l[g], E = w.getFileName() ?? \"none\";\n          if (g > this.stackSize - 1)\n            break;\n          const F = E + \"-\" + w.getLineNumber() + \":\" + w.getColumnNumber();\n          p.push(F);\n        }\n        c.length > 0 && (t = p.join(\" -> \"));\n      }\n      return (!t || t.trim().length === 0) && (t = this.consoleLogger), b.getLogger(t);\n    });\n    this.stackSize = 1;\n    let p;\n    e ? p = e : p = I.getEnvLevel(l), p = p ?? S.LOG_LEVEL_INFO, b.setLevel(p);\n    const c = {\n      gray: (g) => g.toString(),\n      green: (g) => g.toString(),\n      yellow: (g) => g.toString(),\n      red: (g) => g.toString()\n    };\n    R.reg(b), R.apply(b, {\n      format(g, w, E) {\n        const r = [\"[\" + (t ?? I.getEnvLogger(l) ?? \"zhi\") + \"]\"];\n        switch (r.push(\n          c.gray(\"[\") + c.green(E).toString() + c.gray(\"]\")\n        ), g) {\n          case S.LOG_LEVEL_DEBUG:\n            r.push(c.gray(g.toUpperCase().toString()));\n            break;\n          case S.LOG_LEVEL_INFO:\n            r.push(c.green(g.toUpperCase().toString()));\n            break;\n          case S.LOG_LEVEL_WARN:\n            r.push(c.yellow(g.toUpperCase().toString()));\n            break;\n          case S.LOG_LEVEL_ERROR:\n            r.push(c.red(g.toUpperCase().toString()));\n            break;\n        }\n        return r.push(c.green(w).toString()), r.push(c.gray(\":\")), r.join(\" \");\n      }\n    });\n  }\n  /**\n   * 设置输出栈的深度，默认1\n   *\n   * @param stackSize - 栈的深度\n   */\n  setStackSize(e) {\n    this.stackSize = e ?? 1;\n  }\n  /**\n   * 获取调用堆栈，若未获取到直接返回空数组\n   *\n   * @author terwer\n   * @since 1.6.0\n   */\n  getCallStack() {\n    let e;\n    try {\n      e = K();\n    } catch {\n      e = [];\n    }\n    return e;\n  }\n}\nclass X {\n  /**\n   * 默认日志级别\n   *\n   * @param level - 可选，未设置默认INFO\n   * @param sign - 可选前缀，默认zhi\n   * @param env - 可选环境变量实例\n   */\n  constructor(e, t, l) {\n    _(this, \"logger\");\n    this.logger = new Y(e, t, l);\n  }\n  /**\n   * 获取日志记录器\n   *\n   * @param loggerName - 日志记录器名称\n   * @param stackSize - 打印栈的深度\n   * @protected\n   */\n  getLogger(e, t) {\n    return this.logger.setStackSize(t), this.logger.getLogger(e);\n  }\n}\nclass N extends X {\n  constructor(e, t, l) {\n    super(e, t, l);\n  }\n  /**\n   * 获取默认的日志记录器\n   *\n   * @param loggerName - 日志记录器名称\n   * @param stackSize - 打印栈的深度\n   */\n  getLogger(e, t) {\n    return super.getLogger(e, t);\n  }\n}\nclass M {\n  /**\n   * 默认日志记录器\n   *\n   * @param stackSize - 栈的深度\n   * @param env - 环境变量实例\n   */\n  static defaultLogger(e, t) {\n    return M.customLogFactory(void 0, void 0, e).getLogger(\n      void 0,\n      t\n    );\n  }\n  /**\n   * 自定义日志工厂\n   */\n  static customLogFactory(e, t, l) {\n    return new N(e, t, l);\n  }\n  /**\n   * 自定义日志工厂，自定义前缀\n   */\n  static customSignLogFactory(e, t) {\n    return new N(void 0, e, t);\n  }\n}\nexport {\n  X as AbstractLogFactory,\n  N as CustomLogFactory,\n  S as LogLevelEnum,\n  M as default\n};\n","import { getLogger } from '../util';\n\nfunction insertBefore(positionEl: Element, el: Element) {\n    return positionEl.insertAdjacentElement('beforebegin', el);\n}\n\nfunction insertAfter(positionEl: Element, el: Element) {\n    return positionEl.insertAdjacentElement('afterend', el);\n}\n\nexport function addToolbarLeft(el: Element) {\n    const title = document.getElementById('toolbar')?.getElementsByClassName('fn__ellipsis');\n    if (!title) {\n        return;\n    }\n    insertBefore(title[0], el);\n}\n\nexport function addToolbarRight(el: Element) {\n    const title = document.getElementById('toolbar')?.getElementsByClassName('fn__ellipsis');\n    if (!title) {\n        return;\n    }\n    insertAfter(title[0], el);\n}\n\nexport const createLogger = (name: string) => getLogger(name);\n","export interface IMenuItemOption {\n    label?: string;\n    click?: (element: HTMLElement) => void;\n    type?: 'separator' | 'submenu' | 'readonly';\n    accelerator?: string;\n    action?: string;\n    id?: string;\n    submenu?: IMenuItemOption[];\n    disabled?: boolean;\n    icon?: string;\n    iconHTML?: string;\n    current?: boolean;\n    bind?: (element: HTMLElement) => void;\n}\n\nexport class Menu {\n    menu: any;\n\n    constructor(id: string) {\n        const menu = window.siyuan?.menus?.menu;\n        if (!menu) {\n            throw Error('Siyuan internal menu not found!');\n        }\n        this.menu = menu;\n        if (!id) {\n            throw Error('Menu must has an id, got empty or undefined!');\n        }\n        menu.remove();\n        menu.element.setAttribute('data-name', id);\n    }\n\n    addItem(item: MenuItem) {\n        this.menu.append(item.element);\n        return this;\n    }\n\n    addSeparator() {\n        this.addItem(new MenuItem({ type: 'separator' }));\n        return this;\n    }\n\n    showAtMouseEvent(event: MouseEvent) {\n        this.menu.popup({ x: event.clientX, y: event.clientY });\n        return this;\n    }\n\n    showAtPosition(position: { x: number; y: number }) {\n        this.menu.popup({ x: position.x, y: position.y });\n        return this;\n    }\n\n    close() {\n        this.menu.remove();\n    }\n}\n\n/**\n * Copy from siyuan source code\n */\nexport class MenuItem {\n    public element: HTMLElement;\n\n    constructor(options: IMenuItemOption) {\n        this.element = document.createElement('button');\n        if (options.disabled) {\n            this.element.setAttribute('disabled', 'disabled');\n        }\n        if (options.type === 'separator') {\n            this.element.classList.add('b3-menu__separator');\n            return;\n        }\n        this.element.classList.add('b3-menu__item');\n        if (options.current) {\n            this.element.classList.add('b3-menu__item--selected');\n        }\n        if (options.click) {\n            // 需使用 click，否则移动端无法滚动\n            this.element.addEventListener('click', (event) => {\n                if (this.element.getAttribute('disabled')) {\n                    return;\n                }\n                options.click(this.element);\n                event.preventDefault();\n                event.stopImmediatePropagation();\n                event.stopPropagation();\n                window.siyuan.menus.menu.remove();\n            });\n        }\n        let html = `<span class=\"b3-menu__label\">${options.label}</span>`;\n        if (options.iconHTML) {\n            html = options.iconHTML + html;\n        } else {\n            html = `<svg class=\"b3-menu__icon${\n                ['HTML (SiYuan)', window.siyuan.languages.template].includes(options.label) ? ' ft__error' : ''\n            }\" style=\"${options.icon === 'iconClose' ? 'height:10px;' : ''}\"><use xlink:href=\"#${options.icon || ''}\"></use></svg>${html}`;\n        }\n        // if (options.accelerator) {\n        //     html += `<span class=\"b3-menu__accelerator\">${updateHotkeyTip(options.accelerator)}</span>`;\n        // }\n        if (options.action) {\n            html += `<svg class=\"b3-menu__action\"><use xlink:href=\"#${options.action}\"></use></svg>`;\n        }\n        if (options.id) {\n            this.element.setAttribute('data-id', options.id);\n        }\n        if (options.type === 'readonly') {\n            this.element.classList.add('b3-menu__item--readonly');\n        }\n        this.element.innerHTML = html;\n        if (options.bind) {\n            // 主题 rem craft 需要使用 b3-menu__item--custom 来区分自定义菜单 by 281261361\n            this.element.classList.add('b3-menu__item--custom');\n            options.bind(this.element);\n        }\n        if (options.submenu) {\n            const submenuElement = document.createElement('div');\n            submenuElement.classList.add('b3-menu__submenu');\n            options.submenu.forEach((item) => {\n                submenuElement.append(new MenuItem(item).element);\n            });\n            this.element.insertAdjacentHTML('beforeend', '<svg class=\"b3-menu__icon b3-menu__icon--arrow\"><use xlink:href=\"#iconRight\"></use></svg>');\n            this.element.append(submenuElement);\n        }\n    }\n}\n\nexport class MenuSeparator {}\n","/**\n * Copy from siyuan source code\n */\nimport { genUUID } from '../../util';\n\nexport class Dialog {\n    private destroyCallback: () => void;\n    public element: HTMLElement;\n    private id: string;\n    private disableClose: boolean;\n\n    constructor(options: {\n        title?: string;\n        transparent?: boolean;\n        content: string;\n        width?: string;\n        height?: string;\n        destroyCallback?: () => void;\n        disableClose?: boolean;\n        disableAnimation?: boolean;\n    }) {\n        this.disableClose = options.disableClose;\n        this.id = genUUID();\n        window.siyuan.dialogs.push(this);\n        this.destroyCallback = options.destroyCallback;\n        this.element = document.createElement('div') as HTMLElement;\n\n        this.element.innerHTML = `<div class=\"b3-dialog\">\n<div class=\"b3-dialog__scrim\"${options.transparent ? 'style=\"background-color:transparent\"' : ''}></div>\n<div class=\"b3-dialog__container\" style=\"width:${options.width || 'auto'}\">\n  <svg class=\"b3-dialog__close fn__a${this.disableClose ? ' fn__none' : ''}\"><use xlink:href=\"#iconClose\"></use></svg>\n  <div class=\"b3-dialog__header${options.title ? '' : ' fn__none'}\" onselectstart=\"return false;\">${options.title || ''}</div>\n  <div style=\"height:${options.height || 'auto'}\">${options.content}</div>\n</div></div>`;\n\n        this.element.querySelector('.b3-dialog__scrim').addEventListener('click', (event) => {\n            if (!this.disableClose) {\n                this.destroy();\n            }\n            event.preventDefault();\n            event.stopPropagation();\n            // https://ld246.com/article/1657969292700/comment/1658147006669#comments\n            window.siyuan.menus.menu.remove();\n        });\n        if (!this.disableClose) {\n            this.element.querySelector('.b3-dialog__close').addEventListener('click', (event) => {\n                this.destroy();\n                event.preventDefault();\n                event.stopPropagation();\n            });\n        }\n        document.body.append(this.element);\n        if (options.disableAnimation) {\n            this.element.classList.add('b3-dialog--open');\n        } else {\n            setTimeout(() => {\n                this.element.classList.add('b3-dialog--open');\n            });\n        }\n        // https://github.com/siyuan-note/siyuan/issues/6783\n        window.siyuan.menus.menu.remove();\n    }\n\n    static destroyAll() {\n        window.siyuan.dialogs.forEach((p) => p.destroy());\n    }\n\n    public destroy() {\n        this.element.remove();\n        // https://github.com/siyuan-note/siyuan/issues/6783\n        window.siyuan.menus.menu.remove();\n        if (this.destroyCallback) {\n            this.destroyCallback();\n        }\n        window.siyuan.dialogs.find((item, index) => {\n            if (item.id === this.id) {\n                window.siyuan.dialogs.splice(index, 1);\n                return true;\n            }\n        });\n    }\n\n    public bindInput(inputElement: HTMLInputElement | HTMLTextAreaElement, enterEvent?: () => void) {\n        inputElement.focus();\n        inputElement.addEventListener('keydown', (event: KeyboardEvent) => {\n            if (event.isComposing) {\n                event.preventDefault();\n                return;\n            }\n            if (event.key === 'Escape') {\n                this.destroy();\n                event.preventDefault();\n                event.stopPropagation();\n                return;\n            }\n            if (event.key === 'Enter' && enterEvent) {\n                enterEvent();\n                event.preventDefault();\n            }\n        });\n    }\n}\n","/* eslint-disable */\nimport { IPlugin, IPluginCommand, SettingRender } from '../types';\n\nexport class Plugin implements IPlugin {\n    _id: string;\n    onload() {}\n    onunload() {}\n    registerCommand(command: IPluginCommand) {}\n    registerSettingRender(settingRender: SettingRender) {}\n    async loadStorage(filename: string) {\n        return null;\n    }\n    async writeStorage(filename: string, content: any) {}\n}\n","import * as serverApi from './api/server-api';\nimport * as clientApi from './api/client-api';\nimport { Menu, MenuItem, MenuSeparator } from './internal/classes/menu';\nimport { Dialog } from './internal/classes/dialog';\nimport { Notification } from './internal/classes/notification';\nimport { Plugin } from './api/plugin';\n\nexport { clientApi, serverApi, Menu, MenuItem, MenuSeparator, Notification, Dialog, Plugin };\n\nexport default {\n    clientApi,\n    serverApi,\n    Plugin,\n    Menu,\n    MenuItem,\n    MenuSeparator,\n    Notification,\n    Dialog,\n};\n","// Note: this is the semver.org version of the spec that it implements\n// Not necessarily the package version of this code.\nconst SEMVER_SPEC_VERSION = '2.0.0'\n\nconst MAX_LENGTH = 256\nconst MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER ||\n/* istanbul ignore next */ 9007199254740991\n\n// Max safe segment length for coercion.\nconst MAX_SAFE_COMPONENT_LENGTH = 16\n\nmodule.exports = {\n  SEMVER_SPEC_VERSION,\n  MAX_LENGTH,\n  MAX_SAFE_INTEGER,\n  MAX_SAFE_COMPONENT_LENGTH,\n}\n","const debug = (\n  typeof process === 'object' &&\n  process.env &&\n  process.env.NODE_DEBUG &&\n  /\\bsemver\\b/i.test(process.env.NODE_DEBUG)\n) ? (...args) => console.error('SEMVER', ...args)\n  : () => {}\n\nmodule.exports = debug\n","const { MAX_SAFE_COMPONENT_LENGTH } = require('./constants')\nconst debug = require('./debug')\nexports = module.exports = {}\n\n// The actual regexps go on exports.re\nconst re = exports.re = []\nconst src = exports.src = []\nconst t = exports.t = {}\nlet R = 0\n\nconst createToken = (name, value, isGlobal) => {\n  const index = R++\n  debug(name, index, value)\n  t[name] = index\n  src[index] = value\n  re[index] = new RegExp(value, isGlobal ? 'g' : undefined)\n}\n\n// The following Regular Expressions can be used for tokenizing,\n// validating, and parsing SemVer version strings.\n\n// ## Numeric Identifier\n// A single `0`, or a non-zero digit followed by zero or more digits.\n\ncreateToken('NUMERICIDENTIFIER', '0|[1-9]\\\\d*')\ncreateToken('NUMERICIDENTIFIERLOOSE', '[0-9]+')\n\n// ## Non-numeric Identifier\n// Zero or more digits, followed by a letter or hyphen, and then zero or\n// more letters, digits, or hyphens.\n\ncreateToken('NONNUMERICIDENTIFIER', '\\\\d*[a-zA-Z-][a-zA-Z0-9-]*')\n\n// ## Main Version\n// Three dot-separated numeric identifiers.\n\ncreateToken('MAINVERSION', `(${src[t.NUMERICIDENTIFIER]})\\\\.` +\n                   `(${src[t.NUMERICIDENTIFIER]})\\\\.` +\n                   `(${src[t.NUMERICIDENTIFIER]})`)\n\ncreateToken('MAINVERSIONLOOSE', `(${src[t.NUMERICIDENTIFIERLOOSE]})\\\\.` +\n                        `(${src[t.NUMERICIDENTIFIERLOOSE]})\\\\.` +\n                        `(${src[t.NUMERICIDENTIFIERLOOSE]})`)\n\n// ## Pre-release Version Identifier\n// A numeric identifier, or a non-numeric identifier.\n\ncreateToken('PRERELEASEIDENTIFIER', `(?:${src[t.NUMERICIDENTIFIER]\n}|${src[t.NONNUMERICIDENTIFIER]})`)\n\ncreateToken('PRERELEASEIDENTIFIERLOOSE', `(?:${src[t.NUMERICIDENTIFIERLOOSE]\n}|${src[t.NONNUMERICIDENTIFIER]})`)\n\n// ## Pre-release Version\n// Hyphen, followed by one or more dot-separated pre-release version\n// identifiers.\n\ncreateToken('PRERELEASE', `(?:-(${src[t.PRERELEASEIDENTIFIER]\n}(?:\\\\.${src[t.PRERELEASEIDENTIFIER]})*))`)\n\ncreateToken('PRERELEASELOOSE', `(?:-?(${src[t.PRERELEASEIDENTIFIERLOOSE]\n}(?:\\\\.${src[t.PRERELEASEIDENTIFIERLOOSE]})*))`)\n\n// ## Build Metadata Identifier\n// Any combination of digits, letters, or hyphens.\n\ncreateToken('BUILDIDENTIFIER', '[0-9A-Za-z-]+')\n\n// ## Build Metadata\n// Plus sign, followed by one or more period-separated build metadata\n// identifiers.\n\ncreateToken('BUILD', `(?:\\\\+(${src[t.BUILDIDENTIFIER]\n}(?:\\\\.${src[t.BUILDIDENTIFIER]})*))`)\n\n// ## Full Version String\n// A main version, followed optionally by a pre-release version and\n// build metadata.\n\n// Note that the only major, minor, patch, and pre-release sections of\n// the version string are capturing groups.  The build metadata is not a\n// capturing group, because it should not ever be used in version\n// comparison.\n\ncreateToken('FULLPLAIN', `v?${src[t.MAINVERSION]\n}${src[t.PRERELEASE]}?${\n  src[t.BUILD]}?`)\n\ncreateToken('FULL', `^${src[t.FULLPLAIN]}$`)\n\n// like full, but allows v1.2.3 and =1.2.3, which people do sometimes.\n// also, 1.0.0alpha1 (prerelease without the hyphen) which is pretty\n// common in the npm registry.\ncreateToken('LOOSEPLAIN', `[v=\\\\s]*${src[t.MAINVERSIONLOOSE]\n}${src[t.PRERELEASELOOSE]}?${\n  src[t.BUILD]}?`)\n\ncreateToken('LOOSE', `^${src[t.LOOSEPLAIN]}$`)\n\ncreateToken('GTLT', '((?:<|>)?=?)')\n\n// Something like \"2.*\" or \"1.2.x\".\n// Note that \"x.x\" is a valid xRange identifer, meaning \"any version\"\n// Only the first item is strictly required.\ncreateToken('XRANGEIDENTIFIERLOOSE', `${src[t.NUMERICIDENTIFIERLOOSE]}|x|X|\\\\*`)\ncreateToken('XRANGEIDENTIFIER', `${src[t.NUMERICIDENTIFIER]}|x|X|\\\\*`)\n\ncreateToken('XRANGEPLAIN', `[v=\\\\s]*(${src[t.XRANGEIDENTIFIER]})` +\n                   `(?:\\\\.(${src[t.XRANGEIDENTIFIER]})` +\n                   `(?:\\\\.(${src[t.XRANGEIDENTIFIER]})` +\n                   `(?:${src[t.PRERELEASE]})?${\n                     src[t.BUILD]}?` +\n                   `)?)?`)\n\ncreateToken('XRANGEPLAINLOOSE', `[v=\\\\s]*(${src[t.XRANGEIDENTIFIERLOOSE]})` +\n                        `(?:\\\\.(${src[t.XRANGEIDENTIFIERLOOSE]})` +\n                        `(?:\\\\.(${src[t.XRANGEIDENTIFIERLOOSE]})` +\n                        `(?:${src[t.PRERELEASELOOSE]})?${\n                          src[t.BUILD]}?` +\n                        `)?)?`)\n\ncreateToken('XRANGE', `^${src[t.GTLT]}\\\\s*${src[t.XRANGEPLAIN]}$`)\ncreateToken('XRANGELOOSE', `^${src[t.GTLT]}\\\\s*${src[t.XRANGEPLAINLOOSE]}$`)\n\n// Coercion.\n// Extract anything that could conceivably be a part of a valid semver\ncreateToken('COERCE', `${'(^|[^\\\\d])' +\n              '(\\\\d{1,'}${MAX_SAFE_COMPONENT_LENGTH}})` +\n              `(?:\\\\.(\\\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?` +\n              `(?:\\\\.(\\\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?` +\n              `(?:$|[^\\\\d])`)\ncreateToken('COERCERTL', src[t.COERCE], true)\n\n// Tilde ranges.\n// Meaning is \"reasonably at or greater than\"\ncreateToken('LONETILDE', '(?:~>?)')\n\ncreateToken('TILDETRIM', `(\\\\s*)${src[t.LONETILDE]}\\\\s+`, true)\nexports.tildeTrimReplace = '$1~'\n\ncreateToken('TILDE', `^${src[t.LONETILDE]}${src[t.XRANGEPLAIN]}$`)\ncreateToken('TILDELOOSE', `^${src[t.LONETILDE]}${src[t.XRANGEPLAINLOOSE]}$`)\n\n// Caret ranges.\n// Meaning is \"at least and backwards compatible with\"\ncreateToken('LONECARET', '(?:\\\\^)')\n\ncreateToken('CARETTRIM', `(\\\\s*)${src[t.LONECARET]}\\\\s+`, true)\nexports.caretTrimReplace = '$1^'\n\ncreateToken('CARET', `^${src[t.LONECARET]}${src[t.XRANGEPLAIN]}$`)\ncreateToken('CARETLOOSE', `^${src[t.LONECARET]}${src[t.XRANGEPLAINLOOSE]}$`)\n\n// A simple gt/lt/eq thing, or just \"\" to indicate \"any version\"\ncreateToken('COMPARATORLOOSE', `^${src[t.GTLT]}\\\\s*(${src[t.LOOSEPLAIN]})$|^$`)\ncreateToken('COMPARATOR', `^${src[t.GTLT]}\\\\s*(${src[t.FULLPLAIN]})$|^$`)\n\n// An expression to strip any whitespace between the gtlt and the thing\n// it modifies, so that `> 1.2.3` ==> `>1.2.3`\ncreateToken('COMPARATORTRIM', `(\\\\s*)${src[t.GTLT]\n}\\\\s*(${src[t.LOOSEPLAIN]}|${src[t.XRANGEPLAIN]})`, true)\nexports.comparatorTrimReplace = '$1$2$3'\n\n// Something like `1.2.3 - 1.2.4`\n// Note that these all use the loose form, because they'll be\n// checked against either the strict or loose comparator form\n// later.\ncreateToken('HYPHENRANGE', `^\\\\s*(${src[t.XRANGEPLAIN]})` +\n                   `\\\\s+-\\\\s+` +\n                   `(${src[t.XRANGEPLAIN]})` +\n                   `\\\\s*$`)\n\ncreateToken('HYPHENRANGELOOSE', `^\\\\s*(${src[t.XRANGEPLAINLOOSE]})` +\n                        `\\\\s+-\\\\s+` +\n                        `(${src[t.XRANGEPLAINLOOSE]})` +\n                        `\\\\s*$`)\n\n// Star ranges basically just allow anything at all.\ncreateToken('STAR', '(<|>)?=?\\\\s*\\\\*')\n// >=0.0.0 is like a star\ncreateToken('GTE0', '^\\\\s*>=\\\\s*0\\\\.0\\\\.0\\\\s*$')\ncreateToken('GTE0PRE', '^\\\\s*>=\\\\s*0\\\\.0\\\\.0-0\\\\s*$')\n","// parse out just the options we care about so we always get a consistent\n// obj with keys in a consistent order.\nconst opts = ['includePrerelease', 'loose', 'rtl']\nconst parseOptions = options =>\n  !options ? {}\n  : typeof options !== 'object' ? { loose: true }\n  : opts.filter(k => options[k]).reduce((o, k) => {\n    o[k] = true\n    return o\n  }, {})\nmodule.exports = parseOptions\n","const numeric = /^[0-9]+$/\nconst compareIdentifiers = (a, b) => {\n  const anum = numeric.test(a)\n  const bnum = numeric.test(b)\n\n  if (anum && bnum) {\n    a = +a\n    b = +b\n  }\n\n  return a === b ? 0\n    : (anum && !bnum) ? -1\n    : (bnum && !anum) ? 1\n    : a < b ? -1\n    : 1\n}\n\nconst rcompareIdentifiers = (a, b) => compareIdentifiers(b, a)\n\nmodule.exports = {\n  compareIdentifiers,\n  rcompareIdentifiers,\n}\n","const debug = require('../internal/debug')\nconst { MAX_LENGTH, MAX_SAFE_INTEGER } = require('../internal/constants')\nconst { re, t } = require('../internal/re')\n\nconst parseOptions = require('../internal/parse-options')\nconst { compareIdentifiers } = require('../internal/identifiers')\nclass SemVer {\n  constructor (version, options) {\n    options = parseOptions(options)\n\n    if (version instanceof SemVer) {\n      if (version.loose === !!options.loose &&\n          version.includePrerelease === !!options.includePrerelease) {\n        return version\n      } else {\n        version = version.version\n      }\n    } else if (typeof version !== 'string') {\n      throw new TypeError(`Invalid Version: ${version}`)\n    }\n\n    if (version.length > MAX_LENGTH) {\n      throw new TypeError(\n        `version is longer than ${MAX_LENGTH} characters`\n      )\n    }\n\n    debug('SemVer', version, options)\n    this.options = options\n    this.loose = !!options.loose\n    // this isn't actually relevant for versions, but keep it so that we\n    // don't run into trouble passing this.options around.\n    this.includePrerelease = !!options.includePrerelease\n\n    const m = version.trim().match(options.loose ? re[t.LOOSE] : re[t.FULL])\n\n    if (!m) {\n      throw new TypeError(`Invalid Version: ${version}`)\n    }\n\n    this.raw = version\n\n    // these are actually numbers\n    this.major = +m[1]\n    this.minor = +m[2]\n    this.patch = +m[3]\n\n    if (this.major > MAX_SAFE_INTEGER || this.major < 0) {\n      throw new TypeError('Invalid major version')\n    }\n\n    if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) {\n      throw new TypeError('Invalid minor version')\n    }\n\n    if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) {\n      throw new TypeError('Invalid patch version')\n    }\n\n    // numberify any prerelease numeric ids\n    if (!m[4]) {\n      this.prerelease = []\n    } else {\n      this.prerelease = m[4].split('.').map((id) => {\n        if (/^[0-9]+$/.test(id)) {\n          const num = +id\n          if (num >= 0 && num < MAX_SAFE_INTEGER) {\n            return num\n          }\n        }\n        return id\n      })\n    }\n\n    this.build = m[5] ? m[5].split('.') : []\n    this.format()\n  }\n\n  format () {\n    this.version = `${this.major}.${this.minor}.${this.patch}`\n    if (this.prerelease.length) {\n      this.version += `-${this.prerelease.join('.')}`\n    }\n    return this.version\n  }\n\n  toString () {\n    return this.version\n  }\n\n  compare (other) {\n    debug('SemVer.compare', this.version, this.options, other)\n    if (!(other instanceof SemVer)) {\n      if (typeof other === 'string' && other === this.version) {\n        return 0\n      }\n      other = new SemVer(other, this.options)\n    }\n\n    if (other.version === this.version) {\n      return 0\n    }\n\n    return this.compareMain(other) || this.comparePre(other)\n  }\n\n  compareMain (other) {\n    if (!(other instanceof SemVer)) {\n      other = new SemVer(other, this.options)\n    }\n\n    return (\n      compareIdentifiers(this.major, other.major) ||\n      compareIdentifiers(this.minor, other.minor) ||\n      compareIdentifiers(this.patch, other.patch)\n    )\n  }\n\n  comparePre (other) {\n    if (!(other instanceof SemVer)) {\n      other = new SemVer(other, this.options)\n    }\n\n    // NOT having a prerelease is > having one\n    if (this.prerelease.length && !other.prerelease.length) {\n      return -1\n    } else if (!this.prerelease.length && other.prerelease.length) {\n      return 1\n    } else if (!this.prerelease.length && !other.prerelease.length) {\n      return 0\n    }\n\n    let i = 0\n    do {\n      const a = this.prerelease[i]\n      const b = other.prerelease[i]\n      debug('prerelease compare', i, a, b)\n      if (a === undefined && b === undefined) {\n        return 0\n      } else if (b === undefined) {\n        return 1\n      } else if (a === undefined) {\n        return -1\n      } else if (a === b) {\n        continue\n      } else {\n        return compareIdentifiers(a, b)\n      }\n    } while (++i)\n  }\n\n  compareBuild (other) {\n    if (!(other instanceof SemVer)) {\n      other = new SemVer(other, this.options)\n    }\n\n    let i = 0\n    do {\n      const a = this.build[i]\n      const b = other.build[i]\n      debug('prerelease compare', i, a, b)\n      if (a === undefined && b === undefined) {\n        return 0\n      } else if (b === undefined) {\n        return 1\n      } else if (a === undefined) {\n        return -1\n      } else if (a === b) {\n        continue\n      } else {\n        return compareIdentifiers(a, b)\n      }\n    } while (++i)\n  }\n\n  // preminor will bump the version up to the next minor release, and immediately\n  // down to pre-release. premajor and prepatch work the same way.\n  inc (release, identifier) {\n    switch (release) {\n      case 'premajor':\n        this.prerelease.length = 0\n        this.patch = 0\n        this.minor = 0\n        this.major++\n        this.inc('pre', identifier)\n        break\n      case 'preminor':\n        this.prerelease.length = 0\n        this.patch = 0\n        this.minor++\n        this.inc('pre', identifier)\n        break\n      case 'prepatch':\n        // If this is already a prerelease, it will bump to the next version\n        // drop any prereleases that might already exist, since they are not\n        // relevant at this point.\n        this.prerelease.length = 0\n        this.inc('patch', identifier)\n        this.inc('pre', identifier)\n        break\n      // If the input is a non-prerelease version, this acts the same as\n      // prepatch.\n      case 'prerelease':\n        if (this.prerelease.length === 0) {\n          this.inc('patch', identifier)\n        }\n        this.inc('pre', identifier)\n        break\n\n      case 'major':\n        // If this is a pre-major version, bump up to the same major version.\n        // Otherwise increment major.\n        // 1.0.0-5 bumps to 1.0.0\n        // 1.1.0 bumps to 2.0.0\n        if (\n          this.minor !== 0 ||\n          this.patch !== 0 ||\n          this.prerelease.length === 0\n        ) {\n          this.major++\n        }\n        this.minor = 0\n        this.patch = 0\n        this.prerelease = []\n        break\n      case 'minor':\n        // If this is a pre-minor version, bump up to the same minor version.\n        // Otherwise increment minor.\n        // 1.2.0-5 bumps to 1.2.0\n        // 1.2.1 bumps to 1.3.0\n        if (this.patch !== 0 || this.prerelease.length === 0) {\n          this.minor++\n        }\n        this.patch = 0\n        this.prerelease = []\n        break\n      case 'patch':\n        // If this is not a pre-release version, it will increment the patch.\n        // If it is a pre-release it will bump up to the same patch version.\n        // 1.2.0-5 patches to 1.2.0\n        // 1.2.0 patches to 1.2.1\n        if (this.prerelease.length === 0) {\n          this.patch++\n        }\n        this.prerelease = []\n        break\n      // This probably shouldn't be used publicly.\n      // 1.0.0 'pre' would become 1.0.0-0 which is the wrong direction.\n      case 'pre':\n        if (this.prerelease.length === 0) {\n          this.prerelease = [0]\n        } else {\n          let i = this.prerelease.length\n          while (--i >= 0) {\n            if (typeof this.prerelease[i] === 'number') {\n              this.prerelease[i]++\n              i = -2\n            }\n          }\n          if (i === -1) {\n            // didn't increment anything\n            this.prerelease.push(0)\n          }\n        }\n        if (identifier) {\n          // 1.2.0-beta.1 bumps to 1.2.0-beta.2,\n          // 1.2.0-beta.fooblz or 1.2.0-beta bumps to 1.2.0-beta.0\n          if (compareIdentifiers(this.prerelease[0], identifier) === 0) {\n            if (isNaN(this.prerelease[1])) {\n              this.prerelease = [identifier, 0]\n            }\n          } else {\n            this.prerelease = [identifier, 0]\n          }\n        }\n        break\n\n      default:\n        throw new Error(`invalid increment argument: ${release}`)\n    }\n    this.format()\n    this.raw = this.version\n    return this\n  }\n}\n\nmodule.exports = SemVer\n","const { MAX_LENGTH } = require('../internal/constants')\nconst { re, t } = require('../internal/re')\nconst SemVer = require('../classes/semver')\n\nconst parseOptions = require('../internal/parse-options')\nconst parse = (version, options) => {\n  options = parseOptions(options)\n\n  if (version instanceof SemVer) {\n    return version\n  }\n\n  if (typeof version !== 'string') {\n    return null\n  }\n\n  if (version.length > MAX_LENGTH) {\n    return null\n  }\n\n  const r = options.loose ? re[t.LOOSE] : re[t.FULL]\n  if (!r.test(version)) {\n    return null\n  }\n\n  try {\n    return new SemVer(version, options)\n  } catch (er) {\n    return null\n  }\n}\n\nmodule.exports = parse\n","const parse = require('./parse')\nconst valid = (version, options) => {\n  const v = parse(version, options)\n  return v ? v.version : null\n}\nmodule.exports = valid\n","const parse = require('./parse')\nconst clean = (version, options) => {\n  const s = parse(version.trim().replace(/^[=v]+/, ''), options)\n  return s ? s.version : null\n}\nmodule.exports = clean\n","const SemVer = require('../classes/semver')\n\nconst inc = (version, release, options, identifier) => {\n  if (typeof (options) === 'string') {\n    identifier = options\n    options = undefined\n  }\n\n  try {\n    return new SemVer(\n      version instanceof SemVer ? version.version : version,\n      options\n    ).inc(release, identifier).version\n  } catch (er) {\n    return null\n  }\n}\nmodule.exports = inc\n","const SemVer = require('../classes/semver')\nconst compare = (a, b, loose) =>\n  new SemVer(a, loose).compare(new SemVer(b, loose))\n\nmodule.exports = compare\n","const compare = require('./compare')\nconst eq = (a, b, loose) => compare(a, b, loose) === 0\nmodule.exports = eq\n","const parse = require('./parse')\nconst eq = require('./eq')\n\nconst diff = (version1, version2) => {\n  if (eq(version1, version2)) {\n    return null\n  } else {\n    const v1 = parse(version1)\n    const v2 = parse(version2)\n    const hasPre = v1.prerelease.length || v2.prerelease.length\n    const prefix = hasPre ? 'pre' : ''\n    const defaultResult = hasPre ? 'prerelease' : ''\n    for (const key in v1) {\n      if (key === 'major' || key === 'minor' || key === 'patch') {\n        if (v1[key] !== v2[key]) {\n          return prefix + key\n        }\n      }\n    }\n    return defaultResult // may be undefined\n  }\n}\nmodule.exports = diff\n","const SemVer = require('../classes/semver')\nconst major = (a, loose) => new SemVer(a, loose).major\nmodule.exports = major\n","const SemVer = require('../classes/semver')\nconst minor = (a, loose) => new SemVer(a, loose).minor\nmodule.exports = minor\n","const SemVer = require('../classes/semver')\nconst patch = (a, loose) => new SemVer(a, loose).patch\nmodule.exports = patch\n","const parse = require('./parse')\nconst prerelease = (version, options) => {\n  const parsed = parse(version, options)\n  return (parsed && parsed.prerelease.length) ? parsed.prerelease : null\n}\nmodule.exports = prerelease\n","const compare = require('./compare')\nconst rcompare = (a, b, loose) => compare(b, a, loose)\nmodule.exports = rcompare\n","const compare = require('./compare')\nconst compareLoose = (a, b) => compare(a, b, true)\nmodule.exports = compareLoose\n","const SemVer = require('../classes/semver')\nconst compareBuild = (a, b, loose) => {\n  const versionA = new SemVer(a, loose)\n  const versionB = new SemVer(b, loose)\n  return versionA.compare(versionB) || versionA.compareBuild(versionB)\n}\nmodule.exports = compareBuild\n","const compareBuild = require('./compare-build')\nconst sort = (list, loose) => list.sort((a, b) => compareBuild(a, b, loose))\nmodule.exports = sort\n","const compareBuild = require('./compare-build')\nconst rsort = (list, loose) => list.sort((a, b) => compareBuild(b, a, loose))\nmodule.exports = rsort\n","const compare = require('./compare')\nconst gt = (a, b, loose) => compare(a, b, loose) > 0\nmodule.exports = gt\n","const compare = require('./compare')\nconst lt = (a, b, loose) => compare(a, b, loose) < 0\nmodule.exports = lt\n","const compare = require('./compare')\nconst neq = (a, b, loose) => compare(a, b, loose) !== 0\nmodule.exports = neq\n","const compare = require('./compare')\nconst gte = (a, b, loose) => compare(a, b, loose) >= 0\nmodule.exports = gte\n","const compare = require('./compare')\nconst lte = (a, b, loose) => compare(a, b, loose) <= 0\nmodule.exports = lte\n","const eq = require('./eq')\nconst neq = require('./neq')\nconst gt = require('./gt')\nconst gte = require('./gte')\nconst lt = require('./lt')\nconst lte = require('./lte')\n\nconst cmp = (a, op, b, loose) => {\n  switch (op) {\n    case '===':\n      if (typeof a === 'object') {\n        a = a.version\n      }\n      if (typeof b === 'object') {\n        b = b.version\n      }\n      return a === b\n\n    case '!==':\n      if (typeof a === 'object') {\n        a = a.version\n      }\n      if (typeof b === 'object') {\n        b = b.version\n      }\n      return a !== b\n\n    case '':\n    case '=':\n    case '==':\n      return eq(a, b, loose)\n\n    case '!=':\n      return neq(a, b, loose)\n\n    case '>':\n      return gt(a, b, loose)\n\n    case '>=':\n      return gte(a, b, loose)\n\n    case '<':\n      return lt(a, b, loose)\n\n    case '<=':\n      return lte(a, b, loose)\n\n    default:\n      throw new TypeError(`Invalid operator: ${op}`)\n  }\n}\nmodule.exports = cmp\n","const SemVer = require('../classes/semver')\nconst parse = require('./parse')\nconst { re, t } = require('../internal/re')\n\nconst coerce = (version, options) => {\n  if (version instanceof SemVer) {\n    return version\n  }\n\n  if (typeof version === 'number') {\n    version = String(version)\n  }\n\n  if (typeof version !== 'string') {\n    return null\n  }\n\n  options = options || {}\n\n  let match = null\n  if (!options.rtl) {\n    match = version.match(re[t.COERCE])\n  } else {\n    // Find the right-most coercible string that does not share\n    // a terminus with a more left-ward coercible string.\n    // Eg, '1.2.3.4' wants to coerce '2.3.4', not '3.4' or '4'\n    //\n    // Walk through the string checking with a /g regexp\n    // Manually set the index so as to pick up overlapping matches.\n    // Stop when we get a match that ends at the string end, since no\n    // coercible string can be more right-ward without the same terminus.\n    let next\n    while ((next = re[t.COERCERTL].exec(version)) &&\n        (!match || match.index + match[0].length !== version.length)\n    ) {\n      if (!match ||\n            next.index + next[0].length !== match.index + match[0].length) {\n        match = next\n      }\n      re[t.COERCERTL].lastIndex = next.index + next[1].length + next[2].length\n    }\n    // leave it in a clean state\n    re[t.COERCERTL].lastIndex = -1\n  }\n\n  if (match === null) {\n    return null\n  }\n\n  return parse(`${match[2]}.${match[3] || '0'}.${match[4] || '0'}`, options)\n}\nmodule.exports = coerce\n","'use strict'\nmodule.exports = function (Yallist) {\n  Yallist.prototype[Symbol.iterator] = function* () {\n    for (let walker = this.head; walker; walker = walker.next) {\n      yield walker.value\n    }\n  }\n}\n","'use strict'\nmodule.exports = Yallist\n\nYallist.Node = Node\nYallist.create = Yallist\n\nfunction Yallist (list) {\n  var self = this\n  if (!(self instanceof Yallist)) {\n    self = new Yallist()\n  }\n\n  self.tail = null\n  self.head = null\n  self.length = 0\n\n  if (list && typeof list.forEach === 'function') {\n    list.forEach(function (item) {\n      self.push(item)\n    })\n  } else if (arguments.length > 0) {\n    for (var i = 0, l = arguments.length; i < l; i++) {\n      self.push(arguments[i])\n    }\n  }\n\n  return self\n}\n\nYallist.prototype.removeNode = function (node) {\n  if (node.list !== this) {\n    throw new Error('removing node which does not belong to this list')\n  }\n\n  var next = node.next\n  var prev = node.prev\n\n  if (next) {\n    next.prev = prev\n  }\n\n  if (prev) {\n    prev.next = next\n  }\n\n  if (node === this.head) {\n    this.head = next\n  }\n  if (node === this.tail) {\n    this.tail = prev\n  }\n\n  node.list.length--\n  node.next = null\n  node.prev = null\n  node.list = null\n\n  return next\n}\n\nYallist.prototype.unshiftNode = function (node) {\n  if (node === this.head) {\n    return\n  }\n\n  if (node.list) {\n    node.list.removeNode(node)\n  }\n\n  var head = this.head\n  node.list = this\n  node.next = head\n  if (head) {\n    head.prev = node\n  }\n\n  this.head = node\n  if (!this.tail) {\n    this.tail = node\n  }\n  this.length++\n}\n\nYallist.prototype.pushNode = function (node) {\n  if (node === this.tail) {\n    return\n  }\n\n  if (node.list) {\n    node.list.removeNode(node)\n  }\n\n  var tail = this.tail\n  node.list = this\n  node.prev = tail\n  if (tail) {\n    tail.next = node\n  }\n\n  this.tail = node\n  if (!this.head) {\n    this.head = node\n  }\n  this.length++\n}\n\nYallist.prototype.push = function () {\n  for (var i = 0, l = arguments.length; i < l; i++) {\n    push(this, arguments[i])\n  }\n  return this.length\n}\n\nYallist.prototype.unshift = function () {\n  for (var i = 0, l = arguments.length; i < l; i++) {\n    unshift(this, arguments[i])\n  }\n  return this.length\n}\n\nYallist.prototype.pop = function () {\n  if (!this.tail) {\n    return undefined\n  }\n\n  var res = this.tail.value\n  this.tail = this.tail.prev\n  if (this.tail) {\n    this.tail.next = null\n  } else {\n    this.head = null\n  }\n  this.length--\n  return res\n}\n\nYallist.prototype.shift = function () {\n  if (!this.head) {\n    return undefined\n  }\n\n  var res = this.head.value\n  this.head = this.head.next\n  if (this.head) {\n    this.head.prev = null\n  } else {\n    this.tail = null\n  }\n  this.length--\n  return res\n}\n\nYallist.prototype.forEach = function (fn, thisp) {\n  thisp = thisp || this\n  for (var walker = this.head, i = 0; walker !== null; i++) {\n    fn.call(thisp, walker.value, i, this)\n    walker = walker.next\n  }\n}\n\nYallist.prototype.forEachReverse = function (fn, thisp) {\n  thisp = thisp || this\n  for (var walker = this.tail, i = this.length - 1; walker !== null; i--) {\n    fn.call(thisp, walker.value, i, this)\n    walker = walker.prev\n  }\n}\n\nYallist.prototype.get = function (n) {\n  for (var i = 0, walker = this.head; walker !== null && i < n; i++) {\n    // abort out of the list early if we hit a cycle\n    walker = walker.next\n  }\n  if (i === n && walker !== null) {\n    return walker.value\n  }\n}\n\nYallist.prototype.getReverse = function (n) {\n  for (var i = 0, walker = this.tail; walker !== null && i < n; i++) {\n    // abort out of the list early if we hit a cycle\n    walker = walker.prev\n  }\n  if (i === n && walker !== null) {\n    return walker.value\n  }\n}\n\nYallist.prototype.map = function (fn, thisp) {\n  thisp = thisp || this\n  var res = new Yallist()\n  for (var walker = this.head; walker !== null;) {\n    res.push(fn.call(thisp, walker.value, this))\n    walker = walker.next\n  }\n  return res\n}\n\nYallist.prototype.mapReverse = function (fn, thisp) {\n  thisp = thisp || this\n  var res = new Yallist()\n  for (var walker = this.tail; walker !== null;) {\n    res.push(fn.call(thisp, walker.value, this))\n    walker = walker.prev\n  }\n  return res\n}\n\nYallist.prototype.reduce = function (fn, initial) {\n  var acc\n  var walker = this.head\n  if (arguments.length > 1) {\n    acc = initial\n  } else if (this.head) {\n    walker = this.head.next\n    acc = this.head.value\n  } else {\n    throw new TypeError('Reduce of empty list with no initial value')\n  }\n\n  for (var i = 0; walker !== null; i++) {\n    acc = fn(acc, walker.value, i)\n    walker = walker.next\n  }\n\n  return acc\n}\n\nYallist.prototype.reduceReverse = function (fn, initial) {\n  var acc\n  var walker = this.tail\n  if (arguments.length > 1) {\n    acc = initial\n  } else if (this.tail) {\n    walker = this.tail.prev\n    acc = this.tail.value\n  } else {\n    throw new TypeError('Reduce of empty list with no initial value')\n  }\n\n  for (var i = this.length - 1; walker !== null; i--) {\n    acc = fn(acc, walker.value, i)\n    walker = walker.prev\n  }\n\n  return acc\n}\n\nYallist.prototype.toArray = function () {\n  var arr = new Array(this.length)\n  for (var i = 0, walker = this.head; walker !== null; i++) {\n    arr[i] = walker.value\n    walker = walker.next\n  }\n  return arr\n}\n\nYallist.prototype.toArrayReverse = function () {\n  var arr = new Array(this.length)\n  for (var i = 0, walker = this.tail; walker !== null; i++) {\n    arr[i] = walker.value\n    walker = walker.prev\n  }\n  return arr\n}\n\nYallist.prototype.slice = function (from, to) {\n  to = to || this.length\n  if (to < 0) {\n    to += this.length\n  }\n  from = from || 0\n  if (from < 0) {\n    from += this.length\n  }\n  var ret = new Yallist()\n  if (to < from || to < 0) {\n    return ret\n  }\n  if (from < 0) {\n    from = 0\n  }\n  if (to > this.length) {\n    to = this.length\n  }\n  for (var i = 0, walker = this.head; walker !== null && i < from; i++) {\n    walker = walker.next\n  }\n  for (; walker !== null && i < to; i++, walker = walker.next) {\n    ret.push(walker.value)\n  }\n  return ret\n}\n\nYallist.prototype.sliceReverse = function (from, to) {\n  to = to || this.length\n  if (to < 0) {\n    to += this.length\n  }\n  from = from || 0\n  if (from < 0) {\n    from += this.length\n  }\n  var ret = new Yallist()\n  if (to < from || to < 0) {\n    return ret\n  }\n  if (from < 0) {\n    from = 0\n  }\n  if (to > this.length) {\n    to = this.length\n  }\n  for (var i = this.length, walker = this.tail; walker !== null && i > to; i--) {\n    walker = walker.prev\n  }\n  for (; walker !== null && i > from; i--, walker = walker.prev) {\n    ret.push(walker.value)\n  }\n  return ret\n}\n\nYallist.prototype.splice = function (start, deleteCount, ...nodes) {\n  if (start > this.length) {\n    start = this.length - 1\n  }\n  if (start < 0) {\n    start = this.length + start;\n  }\n\n  for (var i = 0, walker = this.head; walker !== null && i < start; i++) {\n    walker = walker.next\n  }\n\n  var ret = []\n  for (var i = 0; walker && i < deleteCount; i++) {\n    ret.push(walker.value)\n    walker = this.removeNode(walker)\n  }\n  if (walker === null) {\n    walker = this.tail\n  }\n\n  if (walker !== this.head && walker !== this.tail) {\n    walker = walker.prev\n  }\n\n  for (var i = 0; i < nodes.length; i++) {\n    walker = insert(this, walker, nodes[i])\n  }\n  return ret;\n}\n\nYallist.prototype.reverse = function () {\n  var head = this.head\n  var tail = this.tail\n  for (var walker = head; walker !== null; walker = walker.prev) {\n    var p = walker.prev\n    walker.prev = walker.next\n    walker.next = p\n  }\n  this.head = tail\n  this.tail = head\n  return this\n}\n\nfunction insert (self, node, value) {\n  var inserted = node === self.head ?\n    new Node(value, null, node, self) :\n    new Node(value, node, node.next, self)\n\n  if (inserted.next === null) {\n    self.tail = inserted\n  }\n  if (inserted.prev === null) {\n    self.head = inserted\n  }\n\n  self.length++\n\n  return inserted\n}\n\nfunction push (self, item) {\n  self.tail = new Node(item, self.tail, null, self)\n  if (!self.head) {\n    self.head = self.tail\n  }\n  self.length++\n}\n\nfunction unshift (self, item) {\n  self.head = new Node(item, null, self.head, self)\n  if (!self.tail) {\n    self.tail = self.head\n  }\n  self.length++\n}\n\nfunction Node (value, prev, next, list) {\n  if (!(this instanceof Node)) {\n    return new Node(value, prev, next, list)\n  }\n\n  this.list = list\n  this.value = value\n\n  if (prev) {\n    prev.next = this\n    this.prev = prev\n  } else {\n    this.prev = null\n  }\n\n  if (next) {\n    next.prev = this\n    this.next = next\n  } else {\n    this.next = null\n  }\n}\n\ntry {\n  // add if support for Symbol.iterator is present\n  require('./iterator.js')(Yallist)\n} catch (er) {}\n","'use strict'\n\n// A linked list to keep track of recently-used-ness\nconst Yallist = require('yallist')\n\nconst MAX = Symbol('max')\nconst LENGTH = Symbol('length')\nconst LENGTH_CALCULATOR = Symbol('lengthCalculator')\nconst ALLOW_STALE = Symbol('allowStale')\nconst MAX_AGE = Symbol('maxAge')\nconst DISPOSE = Symbol('dispose')\nconst NO_DISPOSE_ON_SET = Symbol('noDisposeOnSet')\nconst LRU_LIST = Symbol('lruList')\nconst CACHE = Symbol('cache')\nconst UPDATE_AGE_ON_GET = Symbol('updateAgeOnGet')\n\nconst naiveLength = () => 1\n\n// lruList is a yallist where the head is the youngest\n// item, and the tail is the oldest.  the list contains the Hit\n// objects as the entries.\n// Each Hit object has a reference to its Yallist.Node.  This\n// never changes.\n//\n// cache is a Map (or PseudoMap) that matches the keys to\n// the Yallist.Node object.\nclass LRUCache {\n  constructor (options) {\n    if (typeof options === 'number')\n      options = { max: options }\n\n    if (!options)\n      options = {}\n\n    if (options.max && (typeof options.max !== 'number' || options.max < 0))\n      throw new TypeError('max must be a non-negative number')\n    // Kind of weird to have a default max of Infinity, but oh well.\n    const max = this[MAX] = options.max || Infinity\n\n    const lc = options.length || naiveLength\n    this[LENGTH_CALCULATOR] = (typeof lc !== 'function') ? naiveLength : lc\n    this[ALLOW_STALE] = options.stale || false\n    if (options.maxAge && typeof options.maxAge !== 'number')\n      throw new TypeError('maxAge must be a number')\n    this[MAX_AGE] = options.maxAge || 0\n    this[DISPOSE] = options.dispose\n    this[NO_DISPOSE_ON_SET] = options.noDisposeOnSet || false\n    this[UPDATE_AGE_ON_GET] = options.updateAgeOnGet || false\n    this.reset()\n  }\n\n  // resize the cache when the max changes.\n  set max (mL) {\n    if (typeof mL !== 'number' || mL < 0)\n      throw new TypeError('max must be a non-negative number')\n\n    this[MAX] = mL || Infinity\n    trim(this)\n  }\n  get max () {\n    return this[MAX]\n  }\n\n  set allowStale (allowStale) {\n    this[ALLOW_STALE] = !!allowStale\n  }\n  get allowStale () {\n    return this[ALLOW_STALE]\n  }\n\n  set maxAge (mA) {\n    if (typeof mA !== 'number')\n      throw new TypeError('maxAge must be a non-negative number')\n\n    this[MAX_AGE] = mA\n    trim(this)\n  }\n  get maxAge () {\n    return this[MAX_AGE]\n  }\n\n  // resize the cache when the lengthCalculator changes.\n  set lengthCalculator (lC) {\n    if (typeof lC !== 'function')\n      lC = naiveLength\n\n    if (lC !== this[LENGTH_CALCULATOR]) {\n      this[LENGTH_CALCULATOR] = lC\n      this[LENGTH] = 0\n      this[LRU_LIST].forEach(hit => {\n        hit.length = this[LENGTH_CALCULATOR](hit.value, hit.key)\n        this[LENGTH] += hit.length\n      })\n    }\n    trim(this)\n  }\n  get lengthCalculator () { return this[LENGTH_CALCULATOR] }\n\n  get length () { return this[LENGTH] }\n  get itemCount () { return this[LRU_LIST].length }\n\n  rforEach (fn, thisp) {\n    thisp = thisp || this\n    for (let walker = this[LRU_LIST].tail; walker !== null;) {\n      const prev = walker.prev\n      forEachStep(this, fn, walker, thisp)\n      walker = prev\n    }\n  }\n\n  forEach (fn, thisp) {\n    thisp = thisp || this\n    for (let walker = this[LRU_LIST].head; walker !== null;) {\n      const next = walker.next\n      forEachStep(this, fn, walker, thisp)\n      walker = next\n    }\n  }\n\n  keys () {\n    return this[LRU_LIST].toArray().map(k => k.key)\n  }\n\n  values () {\n    return this[LRU_LIST].toArray().map(k => k.value)\n  }\n\n  reset () {\n    if (this[DISPOSE] &&\n        this[LRU_LIST] &&\n        this[LRU_LIST].length) {\n      this[LRU_LIST].forEach(hit => this[DISPOSE](hit.key, hit.value))\n    }\n\n    this[CACHE] = new Map() // hash of items by key\n    this[LRU_LIST] = new Yallist() // list of items in order of use recency\n    this[LENGTH] = 0 // length of items in the list\n  }\n\n  dump () {\n    return this[LRU_LIST].map(hit =>\n      isStale(this, hit) ? false : {\n        k: hit.key,\n        v: hit.value,\n        e: hit.now + (hit.maxAge || 0)\n      }).toArray().filter(h => h)\n  }\n\n  dumpLru () {\n    return this[LRU_LIST]\n  }\n\n  set (key, value, maxAge) {\n    maxAge = maxAge || this[MAX_AGE]\n\n    if (maxAge && typeof maxAge !== 'number')\n      throw new TypeError('maxAge must be a number')\n\n    const now = maxAge ? Date.now() : 0\n    const len = this[LENGTH_CALCULATOR](value, key)\n\n    if (this[CACHE].has(key)) {\n      if (len > this[MAX]) {\n        del(this, this[CACHE].get(key))\n        return false\n      }\n\n      const node = this[CACHE].get(key)\n      const item = node.value\n\n      // dispose of the old one before overwriting\n      // split out into 2 ifs for better coverage tracking\n      if (this[DISPOSE]) {\n        if (!this[NO_DISPOSE_ON_SET])\n          this[DISPOSE](key, item.value)\n      }\n\n      item.now = now\n      item.maxAge = maxAge\n      item.value = value\n      this[LENGTH] += len - item.length\n      item.length = len\n      this.get(key)\n      trim(this)\n      return true\n    }\n\n    const hit = new Entry(key, value, len, now, maxAge)\n\n    // oversized objects fall out of cache automatically.\n    if (hit.length > this[MAX]) {\n      if (this[DISPOSE])\n        this[DISPOSE](key, value)\n\n      return false\n    }\n\n    this[LENGTH] += hit.length\n    this[LRU_LIST].unshift(hit)\n    this[CACHE].set(key, this[LRU_LIST].head)\n    trim(this)\n    return true\n  }\n\n  has (key) {\n    if (!this[CACHE].has(key)) return false\n    const hit = this[CACHE].get(key).value\n    return !isStale(this, hit)\n  }\n\n  get (key) {\n    return get(this, key, true)\n  }\n\n  peek (key) {\n    return get(this, key, false)\n  }\n\n  pop () {\n    const node = this[LRU_LIST].tail\n    if (!node)\n      return null\n\n    del(this, node)\n    return node.value\n  }\n\n  del (key) {\n    del(this, this[CACHE].get(key))\n  }\n\n  load (arr) {\n    // reset the cache\n    this.reset()\n\n    const now = Date.now()\n    // A previous serialized cache has the most recent items first\n    for (let l = arr.length - 1; l >= 0; l--) {\n      const hit = arr[l]\n      const expiresAt = hit.e || 0\n      if (expiresAt === 0)\n        // the item was created without expiration in a non aged cache\n        this.set(hit.k, hit.v)\n      else {\n        const maxAge = expiresAt - now\n        // dont add already expired items\n        if (maxAge > 0) {\n          this.set(hit.k, hit.v, maxAge)\n        }\n      }\n    }\n  }\n\n  prune () {\n    this[CACHE].forEach((value, key) => get(this, key, false))\n  }\n}\n\nconst get = (self, key, doUse) => {\n  const node = self[CACHE].get(key)\n  if (node) {\n    const hit = node.value\n    if (isStale(self, hit)) {\n      del(self, node)\n      if (!self[ALLOW_STALE])\n        return undefined\n    } else {\n      if (doUse) {\n        if (self[UPDATE_AGE_ON_GET])\n          node.value.now = Date.now()\n        self[LRU_LIST].unshiftNode(node)\n      }\n    }\n    return hit.value\n  }\n}\n\nconst isStale = (self, hit) => {\n  if (!hit || (!hit.maxAge && !self[MAX_AGE]))\n    return false\n\n  const diff = Date.now() - hit.now\n  return hit.maxAge ? diff > hit.maxAge\n    : self[MAX_AGE] && (diff > self[MAX_AGE])\n}\n\nconst trim = self => {\n  if (self[LENGTH] > self[MAX]) {\n    for (let walker = self[LRU_LIST].tail;\n      self[LENGTH] > self[MAX] && walker !== null;) {\n      // We know that we're about to delete this one, and also\n      // what the next least recently used key will be, so just\n      // go ahead and set it now.\n      const prev = walker.prev\n      del(self, walker)\n      walker = prev\n    }\n  }\n}\n\nconst del = (self, node) => {\n  if (node) {\n    const hit = node.value\n    if (self[DISPOSE])\n      self[DISPOSE](hit.key, hit.value)\n\n    self[LENGTH] -= hit.length\n    self[CACHE].delete(hit.key)\n    self[LRU_LIST].removeNode(node)\n  }\n}\n\nclass Entry {\n  constructor (key, value, length, now, maxAge) {\n    this.key = key\n    this.value = value\n    this.length = length\n    this.now = now\n    this.maxAge = maxAge || 0\n  }\n}\n\nconst forEachStep = (self, fn, node, thisp) => {\n  let hit = node.value\n  if (isStale(self, hit)) {\n    del(self, node)\n    if (!self[ALLOW_STALE])\n      hit = undefined\n  }\n  if (hit)\n    fn.call(thisp, hit.value, hit.key, self)\n}\n\nmodule.exports = LRUCache\n","// hoisted class for cyclic dependency\nclass Range {\n  constructor (range, options) {\n    options = parseOptions(options)\n\n    if (range instanceof Range) {\n      if (\n        range.loose === !!options.loose &&\n        range.includePrerelease === !!options.includePrerelease\n      ) {\n        return range\n      } else {\n        return new Range(range.raw, options)\n      }\n    }\n\n    if (range instanceof Comparator) {\n      // just put it in the set and return\n      this.raw = range.value\n      this.set = [[range]]\n      this.format()\n      return this\n    }\n\n    this.options = options\n    this.loose = !!options.loose\n    this.includePrerelease = !!options.includePrerelease\n\n    // First, split based on boolean or ||\n    this.raw = range\n    this.set = range\n      .split('||')\n      // map the range to a 2d array of comparators\n      .map(r => this.parseRange(r.trim()))\n      // throw out any comparator lists that are empty\n      // this generally means that it was not a valid range, which is allowed\n      // in loose mode, but will still throw if the WHOLE range is invalid.\n      .filter(c => c.length)\n\n    if (!this.set.length) {\n      throw new TypeError(`Invalid SemVer Range: ${range}`)\n    }\n\n    // if we have any that are not the null set, throw out null sets.\n    if (this.set.length > 1) {\n      // keep the first one, in case they're all null sets\n      const first = this.set[0]\n      this.set = this.set.filter(c => !isNullSet(c[0]))\n      if (this.set.length === 0) {\n        this.set = [first]\n      } else if (this.set.length > 1) {\n        // if we have any that are *, then the range is just *\n        for (const c of this.set) {\n          if (c.length === 1 && isAny(c[0])) {\n            this.set = [c]\n            break\n          }\n        }\n      }\n    }\n\n    this.format()\n  }\n\n  format () {\n    this.range = this.set\n      .map((comps) => {\n        return comps.join(' ').trim()\n      })\n      .join('||')\n      .trim()\n    return this.range\n  }\n\n  toString () {\n    return this.range\n  }\n\n  parseRange (range) {\n    range = range.trim()\n\n    // memoize range parsing for performance.\n    // this is a very hot path, and fully deterministic.\n    const memoOpts = Object.keys(this.options).join(',')\n    const memoKey = `parseRange:${memoOpts}:${range}`\n    const cached = cache.get(memoKey)\n    if (cached) {\n      return cached\n    }\n\n    const loose = this.options.loose\n    // `1.2.3 - 1.2.4` => `>=1.2.3 <=1.2.4`\n    const hr = loose ? re[t.HYPHENRANGELOOSE] : re[t.HYPHENRANGE]\n    range = range.replace(hr, hyphenReplace(this.options.includePrerelease))\n    debug('hyphen replace', range)\n    // `> 1.2.3 < 1.2.5` => `>1.2.3 <1.2.5`\n    range = range.replace(re[t.COMPARATORTRIM], comparatorTrimReplace)\n    debug('comparator trim', range)\n\n    // `~ 1.2.3` => `~1.2.3`\n    range = range.replace(re[t.TILDETRIM], tildeTrimReplace)\n\n    // `^ 1.2.3` => `^1.2.3`\n    range = range.replace(re[t.CARETTRIM], caretTrimReplace)\n\n    // normalize spaces\n    range = range.split(/\\s+/).join(' ')\n\n    // At this point, the range is completely trimmed and\n    // ready to be split into comparators.\n\n    let rangeList = range\n      .split(' ')\n      .map(comp => parseComparator(comp, this.options))\n      .join(' ')\n      .split(/\\s+/)\n      // >=0.0.0 is equivalent to *\n      .map(comp => replaceGTE0(comp, this.options))\n\n    if (loose) {\n      // in loose mode, throw out any that are not valid comparators\n      rangeList = rangeList.filter(comp => {\n        debug('loose invalid filter', comp, this.options)\n        return !!comp.match(re[t.COMPARATORLOOSE])\n      })\n    }\n    debug('range list', rangeList)\n\n    // if any comparators are the null set, then replace with JUST null set\n    // if more than one comparator, remove any * comparators\n    // also, don't include the same comparator more than once\n    const rangeMap = new Map()\n    const comparators = rangeList.map(comp => new Comparator(comp, this.options))\n    for (const comp of comparators) {\n      if (isNullSet(comp)) {\n        return [comp]\n      }\n      rangeMap.set(comp.value, comp)\n    }\n    if (rangeMap.size > 1 && rangeMap.has('')) {\n      rangeMap.delete('')\n    }\n\n    const result = [...rangeMap.values()]\n    cache.set(memoKey, result)\n    return result\n  }\n\n  intersects (range, options) {\n    if (!(range instanceof Range)) {\n      throw new TypeError('a Range is required')\n    }\n\n    return this.set.some((thisComparators) => {\n      return (\n        isSatisfiable(thisComparators, options) &&\n        range.set.some((rangeComparators) => {\n          return (\n            isSatisfiable(rangeComparators, options) &&\n            thisComparators.every((thisComparator) => {\n              return rangeComparators.every((rangeComparator) => {\n                return thisComparator.intersects(rangeComparator, options)\n              })\n            })\n          )\n        })\n      )\n    })\n  }\n\n  // if ANY of the sets match ALL of its comparators, then pass\n  test (version) {\n    if (!version) {\n      return false\n    }\n\n    if (typeof version === 'string') {\n      try {\n        version = new SemVer(version, this.options)\n      } catch (er) {\n        return false\n      }\n    }\n\n    for (let i = 0; i < this.set.length; i++) {\n      if (testSet(this.set[i], version, this.options)) {\n        return true\n      }\n    }\n    return false\n  }\n}\nmodule.exports = Range\n\nconst LRU = require('lru-cache')\nconst cache = new LRU({ max: 1000 })\n\nconst parseOptions = require('../internal/parse-options')\nconst Comparator = require('./comparator')\nconst debug = require('../internal/debug')\nconst SemVer = require('./semver')\nconst {\n  re,\n  t,\n  comparatorTrimReplace,\n  tildeTrimReplace,\n  caretTrimReplace,\n} = require('../internal/re')\n\nconst isNullSet = c => c.value === '<0.0.0-0'\nconst isAny = c => c.value === ''\n\n// take a set of comparators and determine whether there\n// exists a version which can satisfy it\nconst isSatisfiable = (comparators, options) => {\n  let result = true\n  const remainingComparators = comparators.slice()\n  let testComparator = remainingComparators.pop()\n\n  while (result && remainingComparators.length) {\n    result = remainingComparators.every((otherComparator) => {\n      return testComparator.intersects(otherComparator, options)\n    })\n\n    testComparator = remainingComparators.pop()\n  }\n\n  return result\n}\n\n// comprised of xranges, tildes, stars, and gtlt's at this point.\n// already replaced the hyphen ranges\n// turn into a set of JUST comparators.\nconst parseComparator = (comp, options) => {\n  debug('comp', comp, options)\n  comp = replaceCarets(comp, options)\n  debug('caret', comp)\n  comp = replaceTildes(comp, options)\n  debug('tildes', comp)\n  comp = replaceXRanges(comp, options)\n  debug('xrange', comp)\n  comp = replaceStars(comp, options)\n  debug('stars', comp)\n  return comp\n}\n\nconst isX = id => !id || id.toLowerCase() === 'x' || id === '*'\n\n// ~, ~> --> * (any, kinda silly)\n// ~2, ~2.x, ~2.x.x, ~>2, ~>2.x ~>2.x.x --> >=2.0.0 <3.0.0-0\n// ~2.0, ~2.0.x, ~>2.0, ~>2.0.x --> >=2.0.0 <2.1.0-0\n// ~1.2, ~1.2.x, ~>1.2, ~>1.2.x --> >=1.2.0 <1.3.0-0\n// ~1.2.3, ~>1.2.3 --> >=1.2.3 <1.3.0-0\n// ~1.2.0, ~>1.2.0 --> >=1.2.0 <1.3.0-0\n// ~0.0.1 --> >=0.0.1 <0.1.0-0\nconst replaceTildes = (comp, options) =>\n  comp.trim().split(/\\s+/).map((c) => {\n    return replaceTilde(c, options)\n  }).join(' ')\n\nconst replaceTilde = (comp, options) => {\n  const r = options.loose ? re[t.TILDELOOSE] : re[t.TILDE]\n  return comp.replace(r, (_, M, m, p, pr) => {\n    debug('tilde', comp, _, M, m, p, pr)\n    let ret\n\n    if (isX(M)) {\n      ret = ''\n    } else if (isX(m)) {\n      ret = `>=${M}.0.0 <${+M + 1}.0.0-0`\n    } else if (isX(p)) {\n      // ~1.2 == >=1.2.0 <1.3.0-0\n      ret = `>=${M}.${m}.0 <${M}.${+m + 1}.0-0`\n    } else if (pr) {\n      debug('replaceTilde pr', pr)\n      ret = `>=${M}.${m}.${p}-${pr\n      } <${M}.${+m + 1}.0-0`\n    } else {\n      // ~1.2.3 == >=1.2.3 <1.3.0-0\n      ret = `>=${M}.${m}.${p\n      } <${M}.${+m + 1}.0-0`\n    }\n\n    debug('tilde return', ret)\n    return ret\n  })\n}\n\n// ^ --> * (any, kinda silly)\n// ^2, ^2.x, ^2.x.x --> >=2.0.0 <3.0.0-0\n// ^2.0, ^2.0.x --> >=2.0.0 <3.0.0-0\n// ^1.2, ^1.2.x --> >=1.2.0 <2.0.0-0\n// ^1.2.3 --> >=1.2.3 <2.0.0-0\n// ^1.2.0 --> >=1.2.0 <2.0.0-0\n// ^0.0.1 --> >=0.0.1 <0.0.2-0\n// ^0.1.0 --> >=0.1.0 <0.2.0-0\nconst replaceCarets = (comp, options) =>\n  comp.trim().split(/\\s+/).map((c) => {\n    return replaceCaret(c, options)\n  }).join(' ')\n\nconst replaceCaret = (comp, options) => {\n  debug('caret', comp, options)\n  const r = options.loose ? re[t.CARETLOOSE] : re[t.CARET]\n  const z = options.includePrerelease ? '-0' : ''\n  return comp.replace(r, (_, M, m, p, pr) => {\n    debug('caret', comp, _, M, m, p, pr)\n    let ret\n\n    if (isX(M)) {\n      ret = ''\n    } else if (isX(m)) {\n      ret = `>=${M}.0.0${z} <${+M + 1}.0.0-0`\n    } else if (isX(p)) {\n      if (M === '0') {\n        ret = `>=${M}.${m}.0${z} <${M}.${+m + 1}.0-0`\n      } else {\n        ret = `>=${M}.${m}.0${z} <${+M + 1}.0.0-0`\n      }\n    } else if (pr) {\n      debug('replaceCaret pr', pr)\n      if (M === '0') {\n        if (m === '0') {\n          ret = `>=${M}.${m}.${p}-${pr\n          } <${M}.${m}.${+p + 1}-0`\n        } else {\n          ret = `>=${M}.${m}.${p}-${pr\n          } <${M}.${+m + 1}.0-0`\n        }\n      } else {\n        ret = `>=${M}.${m}.${p}-${pr\n        } <${+M + 1}.0.0-0`\n      }\n    } else {\n      debug('no pr')\n      if (M === '0') {\n        if (m === '0') {\n          ret = `>=${M}.${m}.${p\n          }${z} <${M}.${m}.${+p + 1}-0`\n        } else {\n          ret = `>=${M}.${m}.${p\n          }${z} <${M}.${+m + 1}.0-0`\n        }\n      } else {\n        ret = `>=${M}.${m}.${p\n        } <${+M + 1}.0.0-0`\n      }\n    }\n\n    debug('caret return', ret)\n    return ret\n  })\n}\n\nconst replaceXRanges = (comp, options) => {\n  debug('replaceXRanges', comp, options)\n  return comp.split(/\\s+/).map((c) => {\n    return replaceXRange(c, options)\n  }).join(' ')\n}\n\nconst replaceXRange = (comp, options) => {\n  comp = comp.trim()\n  const r = options.loose ? re[t.XRANGELOOSE] : re[t.XRANGE]\n  return comp.replace(r, (ret, gtlt, M, m, p, pr) => {\n    debug('xRange', comp, ret, gtlt, M, m, p, pr)\n    const xM = isX(M)\n    const xm = xM || isX(m)\n    const xp = xm || isX(p)\n    const anyX = xp\n\n    if (gtlt === '=' && anyX) {\n      gtlt = ''\n    }\n\n    // if we're including prereleases in the match, then we need\n    // to fix this to -0, the lowest possible prerelease value\n    pr = options.includePrerelease ? '-0' : ''\n\n    if (xM) {\n      if (gtlt === '>' || gtlt === '<') {\n        // nothing is allowed\n        ret = '<0.0.0-0'\n      } else {\n        // nothing is forbidden\n        ret = '*'\n      }\n    } else if (gtlt && anyX) {\n      // we know patch is an x, because we have any x at all.\n      // replace X with 0\n      if (xm) {\n        m = 0\n      }\n      p = 0\n\n      if (gtlt === '>') {\n        // >1 => >=2.0.0\n        // >1.2 => >=1.3.0\n        gtlt = '>='\n        if (xm) {\n          M = +M + 1\n          m = 0\n          p = 0\n        } else {\n          m = +m + 1\n          p = 0\n        }\n      } else if (gtlt === '<=') {\n        // <=0.7.x is actually <0.8.0, since any 0.7.x should\n        // pass.  Similarly, <=7.x is actually <8.0.0, etc.\n        gtlt = '<'\n        if (xm) {\n          M = +M + 1\n        } else {\n          m = +m + 1\n        }\n      }\n\n      if (gtlt === '<') {\n        pr = '-0'\n      }\n\n      ret = `${gtlt + M}.${m}.${p}${pr}`\n    } else if (xm) {\n      ret = `>=${M}.0.0${pr} <${+M + 1}.0.0-0`\n    } else if (xp) {\n      ret = `>=${M}.${m}.0${pr\n      } <${M}.${+m + 1}.0-0`\n    }\n\n    debug('xRange return', ret)\n\n    return ret\n  })\n}\n\n// Because * is AND-ed with everything else in the comparator,\n// and '' means \"any version\", just remove the *s entirely.\nconst replaceStars = (comp, options) => {\n  debug('replaceStars', comp, options)\n  // Looseness is ignored here.  star is always as loose as it gets!\n  return comp.trim().replace(re[t.STAR], '')\n}\n\nconst replaceGTE0 = (comp, options) => {\n  debug('replaceGTE0', comp, options)\n  return comp.trim()\n    .replace(re[options.includePrerelease ? t.GTE0PRE : t.GTE0], '')\n}\n\n// This function is passed to string.replace(re[t.HYPHENRANGE])\n// M, m, patch, prerelease, build\n// 1.2 - 3.4.5 => >=1.2.0 <=3.4.5\n// 1.2.3 - 3.4 => >=1.2.0 <3.5.0-0 Any 3.4.x will do\n// 1.2 - 3.4 => >=1.2.0 <3.5.0-0\nconst hyphenReplace = incPr => ($0,\n  from, fM, fm, fp, fpr, fb,\n  to, tM, tm, tp, tpr, tb) => {\n  if (isX(fM)) {\n    from = ''\n  } else if (isX(fm)) {\n    from = `>=${fM}.0.0${incPr ? '-0' : ''}`\n  } else if (isX(fp)) {\n    from = `>=${fM}.${fm}.0${incPr ? '-0' : ''}`\n  } else if (fpr) {\n    from = `>=${from}`\n  } else {\n    from = `>=${from}${incPr ? '-0' : ''}`\n  }\n\n  if (isX(tM)) {\n    to = ''\n  } else if (isX(tm)) {\n    to = `<${+tM + 1}.0.0-0`\n  } else if (isX(tp)) {\n    to = `<${tM}.${+tm + 1}.0-0`\n  } else if (tpr) {\n    to = `<=${tM}.${tm}.${tp}-${tpr}`\n  } else if (incPr) {\n    to = `<${tM}.${tm}.${+tp + 1}-0`\n  } else {\n    to = `<=${to}`\n  }\n\n  return (`${from} ${to}`).trim()\n}\n\nconst testSet = (set, version, options) => {\n  for (let i = 0; i < set.length; i++) {\n    if (!set[i].test(version)) {\n      return false\n    }\n  }\n\n  if (version.prerelease.length && !options.includePrerelease) {\n    // Find the set of versions that are allowed to have prereleases\n    // For example, ^1.2.3-pr.1 desugars to >=1.2.3-pr.1 <2.0.0\n    // That should allow `1.2.3-pr.2` to pass.\n    // However, `1.2.4-alpha.notready` should NOT be allowed,\n    // even though it's within the range set by the comparators.\n    for (let i = 0; i < set.length; i++) {\n      debug(set[i].semver)\n      if (set[i].semver === Comparator.ANY) {\n        continue\n      }\n\n      if (set[i].semver.prerelease.length > 0) {\n        const allowed = set[i].semver\n        if (allowed.major === version.major &&\n            allowed.minor === version.minor &&\n            allowed.patch === version.patch) {\n          return true\n        }\n      }\n    }\n\n    // Version has a -pre, but it's not one of the ones we like.\n    return false\n  }\n\n  return true\n}\n","const ANY = Symbol('SemVer ANY')\n// hoisted class for cyclic dependency\nclass Comparator {\n  static get ANY () {\n    return ANY\n  }\n\n  constructor (comp, options) {\n    options = parseOptions(options)\n\n    if (comp instanceof Comparator) {\n      if (comp.loose === !!options.loose) {\n        return comp\n      } else {\n        comp = comp.value\n      }\n    }\n\n    debug('comparator', comp, options)\n    this.options = options\n    this.loose = !!options.loose\n    this.parse(comp)\n\n    if (this.semver === ANY) {\n      this.value = ''\n    } else {\n      this.value = this.operator + this.semver.version\n    }\n\n    debug('comp', this)\n  }\n\n  parse (comp) {\n    const r = this.options.loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR]\n    const m = comp.match(r)\n\n    if (!m) {\n      throw new TypeError(`Invalid comparator: ${comp}`)\n    }\n\n    this.operator = m[1] !== undefined ? m[1] : ''\n    if (this.operator === '=') {\n      this.operator = ''\n    }\n\n    // if it literally is just '>' or '' then allow anything.\n    if (!m[2]) {\n      this.semver = ANY\n    } else {\n      this.semver = new SemVer(m[2], this.options.loose)\n    }\n  }\n\n  toString () {\n    return this.value\n  }\n\n  test (version) {\n    debug('Comparator.test', version, this.options.loose)\n\n    if (this.semver === ANY || version === ANY) {\n      return true\n    }\n\n    if (typeof version === 'string') {\n      try {\n        version = new SemVer(version, this.options)\n      } catch (er) {\n        return false\n      }\n    }\n\n    return cmp(version, this.operator, this.semver, this.options)\n  }\n\n  intersects (comp, options) {\n    if (!(comp instanceof Comparator)) {\n      throw new TypeError('a Comparator is required')\n    }\n\n    if (!options || typeof options !== 'object') {\n      options = {\n        loose: !!options,\n        includePrerelease: false,\n      }\n    }\n\n    if (this.operator === '') {\n      if (this.value === '') {\n        return true\n      }\n      return new Range(comp.value, options).test(this.value)\n    } else if (comp.operator === '') {\n      if (comp.value === '') {\n        return true\n      }\n      return new Range(this.value, options).test(comp.semver)\n    }\n\n    const sameDirectionIncreasing =\n      (this.operator === '>=' || this.operator === '>') &&\n      (comp.operator === '>=' || comp.operator === '>')\n    const sameDirectionDecreasing =\n      (this.operator === '<=' || this.operator === '<') &&\n      (comp.operator === '<=' || comp.operator === '<')\n    const sameSemVer = this.semver.version === comp.semver.version\n    const differentDirectionsInclusive =\n      (this.operator === '>=' || this.operator === '<=') &&\n      (comp.operator === '>=' || comp.operator === '<=')\n    const oppositeDirectionsLessThan =\n      cmp(this.semver, '<', comp.semver, options) &&\n      (this.operator === '>=' || this.operator === '>') &&\n        (comp.operator === '<=' || comp.operator === '<')\n    const oppositeDirectionsGreaterThan =\n      cmp(this.semver, '>', comp.semver, options) &&\n      (this.operator === '<=' || this.operator === '<') &&\n        (comp.operator === '>=' || comp.operator === '>')\n\n    return (\n      sameDirectionIncreasing ||\n      sameDirectionDecreasing ||\n      (sameSemVer && differentDirectionsInclusive) ||\n      oppositeDirectionsLessThan ||\n      oppositeDirectionsGreaterThan\n    )\n  }\n}\n\nmodule.exports = Comparator\n\nconst parseOptions = require('../internal/parse-options')\nconst { re, t } = require('../internal/re')\nconst cmp = require('../functions/cmp')\nconst debug = require('../internal/debug')\nconst SemVer = require('./semver')\nconst Range = require('./range')\n","const Range = require('../classes/range')\nconst satisfies = (version, range, options) => {\n  try {\n    range = new Range(range, options)\n  } catch (er) {\n    return false\n  }\n  return range.test(version)\n}\nmodule.exports = satisfies\n","const Range = require('../classes/range')\n\n// Mostly just for testing and legacy API reasons\nconst toComparators = (range, options) =>\n  new Range(range, options).set\n    .map(comp => comp.map(c => c.value).join(' ').trim().split(' '))\n\nmodule.exports = toComparators\n","const SemVer = require('../classes/semver')\nconst Range = require('../classes/range')\n\nconst maxSatisfying = (versions, range, options) => {\n  let max = null\n  let maxSV = null\n  let rangeObj = null\n  try {\n    rangeObj = new Range(range, options)\n  } catch (er) {\n    return null\n  }\n  versions.forEach((v) => {\n    if (rangeObj.test(v)) {\n      // satisfies(v, range, options)\n      if (!max || maxSV.compare(v) === -1) {\n        // compare(max, v, true)\n        max = v\n        maxSV = new SemVer(max, options)\n      }\n    }\n  })\n  return max\n}\nmodule.exports = maxSatisfying\n","const SemVer = require('../classes/semver')\nconst Range = require('../classes/range')\nconst minSatisfying = (versions, range, options) => {\n  let min = null\n  let minSV = null\n  let rangeObj = null\n  try {\n    rangeObj = new Range(range, options)\n  } catch (er) {\n    return null\n  }\n  versions.forEach((v) => {\n    if (rangeObj.test(v)) {\n      // satisfies(v, range, options)\n      if (!min || minSV.compare(v) === 1) {\n        // compare(min, v, true)\n        min = v\n        minSV = new SemVer(min, options)\n      }\n    }\n  })\n  return min\n}\nmodule.exports = minSatisfying\n","const SemVer = require('../classes/semver')\nconst Range = require('../classes/range')\nconst gt = require('../functions/gt')\n\nconst minVersion = (range, loose) => {\n  range = new Range(range, loose)\n\n  let minver = new SemVer('0.0.0')\n  if (range.test(minver)) {\n    return minver\n  }\n\n  minver = new SemVer('0.0.0-0')\n  if (range.test(minver)) {\n    return minver\n  }\n\n  minver = null\n  for (let i = 0; i < range.set.length; ++i) {\n    const comparators = range.set[i]\n\n    let setMin = null\n    comparators.forEach((comparator) => {\n      // Clone to avoid manipulating the comparator's semver object.\n      const compver = new SemVer(comparator.semver.version)\n      switch (comparator.operator) {\n        case '>':\n          if (compver.prerelease.length === 0) {\n            compver.patch++\n          } else {\n            compver.prerelease.push(0)\n          }\n          compver.raw = compver.format()\n          /* fallthrough */\n        case '':\n        case '>=':\n          if (!setMin || gt(compver, setMin)) {\n            setMin = compver\n          }\n          break\n        case '<':\n        case '<=':\n          /* Ignore maximum versions */\n          break\n        /* istanbul ignore next */\n        default:\n          throw new Error(`Unexpected operation: ${comparator.operator}`)\n      }\n    })\n    if (setMin && (!minver || gt(minver, setMin))) {\n      minver = setMin\n    }\n  }\n\n  if (minver && range.test(minver)) {\n    return minver\n  }\n\n  return null\n}\nmodule.exports = minVersion\n","const Range = require('../classes/range')\nconst validRange = (range, options) => {\n  try {\n    // Return '*' instead of '' so that truthiness works.\n    // This will throw if it's invalid anyway\n    return new Range(range, options).range || '*'\n  } catch (er) {\n    return null\n  }\n}\nmodule.exports = validRange\n","const SemVer = require('../classes/semver')\nconst Comparator = require('../classes/comparator')\nconst { ANY } = Comparator\nconst Range = require('../classes/range')\nconst satisfies = require('../functions/satisfies')\nconst gt = require('../functions/gt')\nconst lt = require('../functions/lt')\nconst lte = require('../functions/lte')\nconst gte = require('../functions/gte')\n\nconst outside = (version, range, hilo, options) => {\n  version = new SemVer(version, options)\n  range = new Range(range, options)\n\n  let gtfn, ltefn, ltfn, comp, ecomp\n  switch (hilo) {\n    case '>':\n      gtfn = gt\n      ltefn = lte\n      ltfn = lt\n      comp = '>'\n      ecomp = '>='\n      break\n    case '<':\n      gtfn = lt\n      ltefn = gte\n      ltfn = gt\n      comp = '<'\n      ecomp = '<='\n      break\n    default:\n      throw new TypeError('Must provide a hilo val of \"<\" or \">\"')\n  }\n\n  // If it satisfies the range it is not outside\n  if (satisfies(version, range, options)) {\n    return false\n  }\n\n  // From now on, variable terms are as if we're in \"gtr\" mode.\n  // but note that everything is flipped for the \"ltr\" function.\n\n  for (let i = 0; i < range.set.length; ++i) {\n    const comparators = range.set[i]\n\n    let high = null\n    let low = null\n\n    comparators.forEach((comparator) => {\n      if (comparator.semver === ANY) {\n        comparator = new Comparator('>=0.0.0')\n      }\n      high = high || comparator\n      low = low || comparator\n      if (gtfn(comparator.semver, high.semver, options)) {\n        high = comparator\n      } else if (ltfn(comparator.semver, low.semver, options)) {\n        low = comparator\n      }\n    })\n\n    // If the edge version comparator has a operator then our version\n    // isn't outside it\n    if (high.operator === comp || high.operator === ecomp) {\n      return false\n    }\n\n    // If the lowest version comparator has an operator and our version\n    // is less than it then it isn't higher than the range\n    if ((!low.operator || low.operator === comp) &&\n        ltefn(version, low.semver)) {\n      return false\n    } else if (low.operator === ecomp && ltfn(version, low.semver)) {\n      return false\n    }\n  }\n  return true\n}\n\nmodule.exports = outside\n","// Determine if version is greater than all the versions possible in the range.\nconst outside = require('./outside')\nconst gtr = (version, range, options) => outside(version, range, '>', options)\nmodule.exports = gtr\n","const outside = require('./outside')\n// Determine if version is less than all the versions possible in the range\nconst ltr = (version, range, options) => outside(version, range, '<', options)\nmodule.exports = ltr\n","const Range = require('../classes/range')\nconst intersects = (r1, r2, options) => {\n  r1 = new Range(r1, options)\n  r2 = new Range(r2, options)\n  return r1.intersects(r2)\n}\nmodule.exports = intersects\n","// given a set of versions and a range, create a \"simplified\" range\n// that includes the same versions that the original range does\n// If the original range is shorter than the simplified one, return that.\nconst satisfies = require('../functions/satisfies.js')\nconst compare = require('../functions/compare.js')\nmodule.exports = (versions, range, options) => {\n  const set = []\n  let first = null\n  let prev = null\n  const v = versions.sort((a, b) => compare(a, b, options))\n  for (const version of v) {\n    const included = satisfies(version, range, options)\n    if (included) {\n      prev = version\n      if (!first) {\n        first = version\n      }\n    } else {\n      if (prev) {\n        set.push([first, prev])\n      }\n      prev = null\n      first = null\n    }\n  }\n  if (first) {\n    set.push([first, null])\n  }\n\n  const ranges = []\n  for (const [min, max] of set) {\n    if (min === max) {\n      ranges.push(min)\n    } else if (!max && min === v[0]) {\n      ranges.push('*')\n    } else if (!max) {\n      ranges.push(`>=${min}`)\n    } else if (min === v[0]) {\n      ranges.push(`<=${max}`)\n    } else {\n      ranges.push(`${min} - ${max}`)\n    }\n  }\n  const simplified = ranges.join(' || ')\n  const original = typeof range.raw === 'string' ? range.raw : String(range)\n  return simplified.length < original.length ? simplified : range\n}\n","const Range = require('../classes/range.js')\nconst Comparator = require('../classes/comparator.js')\nconst { ANY } = Comparator\nconst satisfies = require('../functions/satisfies.js')\nconst compare = require('../functions/compare.js')\n\n// Complex range `r1 || r2 || ...` is a subset of `R1 || R2 || ...` iff:\n// - Every simple range `r1, r2, ...` is a null set, OR\n// - Every simple range `r1, r2, ...` which is not a null set is a subset of\n//   some `R1, R2, ...`\n//\n// Simple range `c1 c2 ...` is a subset of simple range `C1 C2 ...` iff:\n// - If c is only the ANY comparator\n//   - If C is only the ANY comparator, return true\n//   - Else if in prerelease mode, return false\n//   - else replace c with `[>=0.0.0]`\n// - If C is only the ANY comparator\n//   - if in prerelease mode, return true\n//   - else replace C with `[>=0.0.0]`\n// - Let EQ be the set of = comparators in c\n// - If EQ is more than one, return true (null set)\n// - Let GT be the highest > or >= comparator in c\n// - Let LT be the lowest < or <= comparator in c\n// - If GT and LT, and GT.semver > LT.semver, return true (null set)\n// - If any C is a = range, and GT or LT are set, return false\n// - If EQ\n//   - If GT, and EQ does not satisfy GT, return true (null set)\n//   - If LT, and EQ does not satisfy LT, return true (null set)\n//   - If EQ satisfies every C, return true\n//   - Else return false\n// - If GT\n//   - If GT.semver is lower than any > or >= comp in C, return false\n//   - If GT is >=, and GT.semver does not satisfy every C, return false\n//   - If GT.semver has a prerelease, and not in prerelease mode\n//     - If no C has a prerelease and the GT.semver tuple, return false\n// - If LT\n//   - If LT.semver is greater than any < or <= comp in C, return false\n//   - If LT is <=, and LT.semver does not satisfy every C, return false\n//   - If GT.semver has a prerelease, and not in prerelease mode\n//     - If no C has a prerelease and the LT.semver tuple, return false\n// - Else return true\n\nconst subset = (sub, dom, options = {}) => {\n  if (sub === dom) {\n    return true\n  }\n\n  sub = new Range(sub, options)\n  dom = new Range(dom, options)\n  let sawNonNull = false\n\n  OUTER: for (const simpleSub of sub.set) {\n    for (const simpleDom of dom.set) {\n      const isSub = simpleSubset(simpleSub, simpleDom, options)\n      sawNonNull = sawNonNull || isSub !== null\n      if (isSub) {\n        continue OUTER\n      }\n    }\n    // the null set is a subset of everything, but null simple ranges in\n    // a complex range should be ignored.  so if we saw a non-null range,\n    // then we know this isn't a subset, but if EVERY simple range was null,\n    // then it is a subset.\n    if (sawNonNull) {\n      return false\n    }\n  }\n  return true\n}\n\nconst simpleSubset = (sub, dom, options) => {\n  if (sub === dom) {\n    return true\n  }\n\n  if (sub.length === 1 && sub[0].semver === ANY) {\n    if (dom.length === 1 && dom[0].semver === ANY) {\n      return true\n    } else if (options.includePrerelease) {\n      sub = [new Comparator('>=0.0.0-0')]\n    } else {\n      sub = [new Comparator('>=0.0.0')]\n    }\n  }\n\n  if (dom.length === 1 && dom[0].semver === ANY) {\n    if (options.includePrerelease) {\n      return true\n    } else {\n      dom = [new Comparator('>=0.0.0')]\n    }\n  }\n\n  const eqSet = new Set()\n  let gt, lt\n  for (const c of sub) {\n    if (c.operator === '>' || c.operator === '>=') {\n      gt = higherGT(gt, c, options)\n    } else if (c.operator === '<' || c.operator === '<=') {\n      lt = lowerLT(lt, c, options)\n    } else {\n      eqSet.add(c.semver)\n    }\n  }\n\n  if (eqSet.size > 1) {\n    return null\n  }\n\n  let gtltComp\n  if (gt && lt) {\n    gtltComp = compare(gt.semver, lt.semver, options)\n    if (gtltComp > 0) {\n      return null\n    } else if (gtltComp === 0 && (gt.operator !== '>=' || lt.operator !== '<=')) {\n      return null\n    }\n  }\n\n  // will iterate one or zero times\n  for (const eq of eqSet) {\n    if (gt && !satisfies(eq, String(gt), options)) {\n      return null\n    }\n\n    if (lt && !satisfies(eq, String(lt), options)) {\n      return null\n    }\n\n    for (const c of dom) {\n      if (!satisfies(eq, String(c), options)) {\n        return false\n      }\n    }\n\n    return true\n  }\n\n  let higher, lower\n  let hasDomLT, hasDomGT\n  // if the subset has a prerelease, we need a comparator in the superset\n  // with the same tuple and a prerelease, or it's not a subset\n  let needDomLTPre = lt &&\n    !options.includePrerelease &&\n    lt.semver.prerelease.length ? lt.semver : false\n  let needDomGTPre = gt &&\n    !options.includePrerelease &&\n    gt.semver.prerelease.length ? gt.semver : false\n  // exception: <1.2.3-0 is the same as <1.2.3\n  if (needDomLTPre && needDomLTPre.prerelease.length === 1 &&\n      lt.operator === '<' && needDomLTPre.prerelease[0] === 0) {\n    needDomLTPre = false\n  }\n\n  for (const c of dom) {\n    hasDomGT = hasDomGT || c.operator === '>' || c.operator === '>='\n    hasDomLT = hasDomLT || c.operator === '<' || c.operator === '<='\n    if (gt) {\n      if (needDomGTPre) {\n        if (c.semver.prerelease && c.semver.prerelease.length &&\n            c.semver.major === needDomGTPre.major &&\n            c.semver.minor === needDomGTPre.minor &&\n            c.semver.patch === needDomGTPre.patch) {\n          needDomGTPre = false\n        }\n      }\n      if (c.operator === '>' || c.operator === '>=') {\n        higher = higherGT(gt, c, options)\n        if (higher === c && higher !== gt) {\n          return false\n        }\n      } else if (gt.operator === '>=' && !satisfies(gt.semver, String(c), options)) {\n        return false\n      }\n    }\n    if (lt) {\n      if (needDomLTPre) {\n        if (c.semver.prerelease && c.semver.prerelease.length &&\n            c.semver.major === needDomLTPre.major &&\n            c.semver.minor === needDomLTPre.minor &&\n            c.semver.patch === needDomLTPre.patch) {\n          needDomLTPre = false\n        }\n      }\n      if (c.operator === '<' || c.operator === '<=') {\n        lower = lowerLT(lt, c, options)\n        if (lower === c && lower !== lt) {\n          return false\n        }\n      } else if (lt.operator === '<=' && !satisfies(lt.semver, String(c), options)) {\n        return false\n      }\n    }\n    if (!c.operator && (lt || gt) && gtltComp !== 0) {\n      return false\n    }\n  }\n\n  // if there was a < or >, and nothing in the dom, then must be false\n  // UNLESS it was limited by another range in the other direction.\n  // Eg, >1.0.0 <1.0.1 is still a subset of <2.0.0\n  if (gt && hasDomLT && !lt && gtltComp !== 0) {\n    return false\n  }\n\n  if (lt && hasDomGT && !gt && gtltComp !== 0) {\n    return false\n  }\n\n  // we needed a prerelease range in a specific tuple, but didn't get one\n  // then this isn't a subset.  eg >=1.2.3-pre is not a subset of >=1.0.0,\n  // because it includes prereleases in the 1.2.3 tuple\n  if (needDomGTPre || needDomLTPre) {\n    return false\n  }\n\n  return true\n}\n\n// >=1.2.3 is lower than >1.2.3\nconst higherGT = (a, b, options) => {\n  if (!a) {\n    return b\n  }\n  const comp = compare(a.semver, b.semver, options)\n  return comp > 0 ? a\n    : comp < 0 ? b\n    : b.operator === '>' && a.operator === '>=' ? b\n    : a\n}\n\n// <=1.2.3 is higher than <1.2.3\nconst lowerLT = (a, b, options) => {\n  if (!a) {\n    return b\n  }\n  const comp = compare(a.semver, b.semver, options)\n  return comp < 0 ? a\n    : comp > 0 ? b\n    : b.operator === '<' && a.operator === '<=' ? b\n    : a\n}\n\nmodule.exports = subset\n","// just pre-load all the stuff that index.js lazily exports\nconst internalRe = require('./internal/re')\nconst constants = require('./internal/constants')\nconst SemVer = require('./classes/semver')\nconst identifiers = require('./internal/identifiers')\nconst parse = require('./functions/parse')\nconst valid = require('./functions/valid')\nconst clean = require('./functions/clean')\nconst inc = require('./functions/inc')\nconst diff = require('./functions/diff')\nconst major = require('./functions/major')\nconst minor = require('./functions/minor')\nconst patch = require('./functions/patch')\nconst prerelease = require('./functions/prerelease')\nconst compare = require('./functions/compare')\nconst rcompare = require('./functions/rcompare')\nconst compareLoose = require('./functions/compare-loose')\nconst compareBuild = require('./functions/compare-build')\nconst sort = require('./functions/sort')\nconst rsort = require('./functions/rsort')\nconst gt = require('./functions/gt')\nconst lt = require('./functions/lt')\nconst eq = require('./functions/eq')\nconst neq = require('./functions/neq')\nconst gte = require('./functions/gte')\nconst lte = require('./functions/lte')\nconst cmp = require('./functions/cmp')\nconst coerce = require('./functions/coerce')\nconst Comparator = require('./classes/comparator')\nconst Range = require('./classes/range')\nconst satisfies = require('./functions/satisfies')\nconst toComparators = require('./ranges/to-comparators')\nconst maxSatisfying = require('./ranges/max-satisfying')\nconst minSatisfying = require('./ranges/min-satisfying')\nconst minVersion = require('./ranges/min-version')\nconst validRange = require('./ranges/valid')\nconst outside = require('./ranges/outside')\nconst gtr = require('./ranges/gtr')\nconst ltr = require('./ranges/ltr')\nconst intersects = require('./ranges/intersects')\nconst simplifyRange = require('./ranges/simplify')\nconst subset = require('./ranges/subset')\nmodule.exports = {\n  parse,\n  valid,\n  clean,\n  inc,\n  diff,\n  major,\n  minor,\n  patch,\n  prerelease,\n  compare,\n  rcompare,\n  compareLoose,\n  compareBuild,\n  sort,\n  rsort,\n  gt,\n  lt,\n  eq,\n  neq,\n  gte,\n  lte,\n  cmp,\n  coerce,\n  Comparator,\n  Range,\n  satisfies,\n  toComparators,\n  maxSatisfying,\n  minSatisfying,\n  minVersion,\n  validRange,\n  outside,\n  gtr,\n  ltr,\n  intersects,\n  simplifyRange,\n  subset,\n  SemVer,\n  re: internalRe.re,\n  src: internalRe.src,\n  tokens: internalRe.t,\n  SEMVER_SPEC_VERSION: constants.SEMVER_SPEC_VERSION,\n  compareIdentifiers: identifiers.compareIdentifiers,\n  rcompareIdentifiers: identifiers.rcompareIdentifiers,\n}\n","import { serverApi } from '../api';\nimport { log } from '../util';\nimport { Stats } from 'fs';\nimport semver from 'semver';\n\nexport class FileClient {\n    static fileClient: FileClient;\n\n    getVersion() {\n        return window.siyuan.config.system.kernelVersion;\n    }\n\n    fileApi: {\n        readDir: (path: string) => Promise<Array<{ isDir: boolean; name: string }>>;\n        getFile: (path: string, type?: 'json' | 'text') => Promise<any>;\n        putFile: (path, filedata, isDir?: boolean, modTime?: number) => Promise<any>;\n        removeFile: (path: string) => Promise<void>;\n    };\n\n    private constructor() {\n        const v = this.getVersion();\n        if (semver.compare(v, '2.8.1') < 0) {\n            // old version, electron api support\n            this.fileApi = this.electronApi;\n        } else {\n            // new api, file api support\n            this.fileApi = this.serverApi;\n        }\n    }\n\n    static getInstanceApi() {\n        if (!this.fileClient) {\n            this.fileClient = new FileClient();\n        }\n        return this.fileClient;\n    }\n\n    electronApi = {\n        readDir(p: string): Promise<Array<{ isDir: boolean; name: string }>> {\n            const fs = window.require('fs');\n            const path = window.require('path');\n            const SIYUAN_WORKSPACE = path.join(window.siyuan.config.system.dataDir, '..');\n            return new Promise((resolve) => {\n                fs.readdir(path.join(SIYUAN_WORKSPACE, p), (err, files: string[]) => {\n                    if (err) {\n                        resolve([]);\n                        return;\n                    }\n                    const result = files.map<{ isDir: boolean; name: string }>((f: string) => ({\n                        isDir: (fs.statSync(path.join(SIYUAN_WORKSPACE, p, f)) as Stats).isDirectory(),\n                        name: f,\n                    }));\n                    resolve(result);\n                });\n            });\n        },\n        getFile(f: string, type: 'json' | 'text' = 'text') {\n            return new Promise((resolve, reject) => {\n                const fs = window.require('fs');\n                const path = window.require('path');\n                const SIYUAN_WORKSPACE = path.join(window.siyuan.config.system.dataDir, '..');\n                fs.readFile(path.join(SIYUAN_WORKSPACE, f), (err, data) => {\n                    if (err) {\n                        return reject(err);\n                    }\n                    const text = data.toString('utf8');\n                    if (type === 'json') {\n                        try {\n                            return resolve(JSON.parse(text));\n                        } catch (e) {\n                            reject(e);\n                            return;\n                        }\n                    }\n                    return resolve(text);\n                });\n            });\n        },\n        putFile: serverApi.putFile,\n        removeFile(f: string): Promise<void> {\n            return new Promise((resolve, reject) => {\n                const fs = window.require('fs');\n                const path = window.require('path');\n                const SIYUAN_WORKSPACE = path.join(window.siyuan.config.system.dataDir, '..');\n                const p = path.join(SIYUAN_WORKSPACE, f);\n                log('Remove files from', p);\n                fs.rm(p, { recursive: true, force: true }, (err) => {\n                    if (err) {\n                        return reject(err);\n                    }\n                    resolve(null);\n                });\n            });\n        },\n    };\n\n    serverApi = {\n        readDir: serverApi.readDir,\n        getFile: serverApi.getFile,\n        putFile: serverApi.putFile,\n        removeFile: serverApi.removeFile,\n    };\n}\n","'use strict';\n\nexport default function bind(fn, thisArg) {\n  return function wrap() {\n    return fn.apply(thisArg, arguments);\n  };\n}\n","'use strict';\n\nimport bind from './helpers/bind.js';\n\n// utils is a library of generic helper functions non-specific to axios\n\nconst {toString} = Object.prototype;\nconst {getPrototypeOf} = Object;\n\nconst kindOf = (cache => thing => {\n    const str = toString.call(thing);\n    return cache[str] || (cache[str] = str.slice(8, -1).toLowerCase());\n})(Object.create(null));\n\nconst kindOfTest = (type) => {\n  type = type.toLowerCase();\n  return (thing) => kindOf(thing) === type\n}\n\nconst typeOfTest = type => thing => typeof thing === type;\n\n/**\n * Determine if a value is an Array\n *\n * @param {Object} val The value to test\n *\n * @returns {boolean} True if value is an Array, otherwise false\n */\nconst {isArray} = Array;\n\n/**\n * Determine if a value is undefined\n *\n * @param {*} val The value to test\n *\n * @returns {boolean} True if the value is undefined, otherwise false\n */\nconst isUndefined = typeOfTest('undefined');\n\n/**\n * Determine if a value is a Buffer\n *\n * @param {*} val The value to test\n *\n * @returns {boolean} True if value is a Buffer, otherwise false\n */\nfunction isBuffer(val) {\n  return val !== null && !isUndefined(val) && val.constructor !== null && !isUndefined(val.constructor)\n    && isFunction(val.constructor.isBuffer) && val.constructor.isBuffer(val);\n}\n\n/**\n * Determine if a value is an ArrayBuffer\n *\n * @param {*} val The value to test\n *\n * @returns {boolean} True if value is an ArrayBuffer, otherwise false\n */\nconst isArrayBuffer = kindOfTest('ArrayBuffer');\n\n\n/**\n * Determine if a value is a view on an ArrayBuffer\n *\n * @param {*} val The value to test\n *\n * @returns {boolean} True if value is a view on an ArrayBuffer, otherwise false\n */\nfunction isArrayBufferView(val) {\n  let result;\n  if ((typeof ArrayBuffer !== 'undefined') && (ArrayBuffer.isView)) {\n    result = ArrayBuffer.isView(val);\n  } else {\n    result = (val) && (val.buffer) && (isArrayBuffer(val.buffer));\n  }\n  return result;\n}\n\n/**\n * Determine if a value is a String\n *\n * @param {*} val The value to test\n *\n * @returns {boolean} True if value is a String, otherwise false\n */\nconst isString = typeOfTest('string');\n\n/**\n * Determine if a value is a Function\n *\n * @param {*} val The value to test\n * @returns {boolean} True if value is a Function, otherwise false\n */\nconst isFunction = typeOfTest('function');\n\n/**\n * Determine if a value is a Number\n *\n * @param {*} val The value to test\n *\n * @returns {boolean} True if value is a Number, otherwise false\n */\nconst isNumber = typeOfTest('number');\n\n/**\n * Determine if a value is an Object\n *\n * @param {*} thing The value to test\n *\n * @returns {boolean} True if value is an Object, otherwise false\n */\nconst isObject = (thing) => thing !== null && typeof thing === 'object';\n\n/**\n * Determine if a value is a Boolean\n *\n * @param {*} thing The value to test\n * @returns {boolean} True if value is a Boolean, otherwise false\n */\nconst isBoolean = thing => thing === true || thing === false;\n\n/**\n * Determine if a value is a plain Object\n *\n * @param {*} val The value to test\n *\n * @returns {boolean} True if value is a plain Object, otherwise false\n */\nconst isPlainObject = (val) => {\n  if (kindOf(val) !== 'object') {\n    return false;\n  }\n\n  const prototype = getPrototypeOf(val);\n  return (prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(Symbol.toStringTag in val) && !(Symbol.iterator in val);\n}\n\n/**\n * Determine if a value is a Date\n *\n * @param {*} val The value to test\n *\n * @returns {boolean} True if value is a Date, otherwise false\n */\nconst isDate = kindOfTest('Date');\n\n/**\n * Determine if a value is a File\n *\n * @param {*} val The value to test\n *\n * @returns {boolean} True if value is a File, otherwise false\n */\nconst isFile = kindOfTest('File');\n\n/**\n * Determine if a value is a Blob\n *\n * @param {*} val The value to test\n *\n * @returns {boolean} True if value is a Blob, otherwise false\n */\nconst isBlob = kindOfTest('Blob');\n\n/**\n * Determine if a value is a FileList\n *\n * @param {*} val The value to test\n *\n * @returns {boolean} True if value is a File, otherwise false\n */\nconst isFileList = kindOfTest('FileList');\n\n/**\n * Determine if a value is a Stream\n *\n * @param {*} val The value to test\n *\n * @returns {boolean} True if value is a Stream, otherwise false\n */\nconst isStream = (val) => isObject(val) && isFunction(val.pipe);\n\n/**\n * Determine if a value is a FormData\n *\n * @param {*} thing The value to test\n *\n * @returns {boolean} True if value is an FormData, otherwise false\n */\nconst isFormData = (thing) => {\n  const pattern = '[object FormData]';\n  return thing && (\n    (typeof FormData === 'function' && thing instanceof FormData) ||\n    toString.call(thing) === pattern ||\n    (isFunction(thing.toString) && thing.toString() === pattern)\n  );\n}\n\n/**\n * Determine if a value is a URLSearchParams object\n *\n * @param {*} val The value to test\n *\n * @returns {boolean} True if value is a URLSearchParams object, otherwise false\n */\nconst isURLSearchParams = kindOfTest('URLSearchParams');\n\n/**\n * Trim excess whitespace off the beginning and end of a string\n *\n * @param {String} str The String to trim\n *\n * @returns {String} The String freed of excess whitespace\n */\nconst trim = (str) => str.trim ?\n  str.trim() : str.replace(/^[\\s\\uFEFF\\xA0]+|[\\s\\uFEFF\\xA0]+$/g, '');\n\n/**\n * Iterate over an Array or an Object invoking a function for each item.\n *\n * If `obj` is an Array callback will be called passing\n * the value, index, and complete array for each item.\n *\n * If 'obj' is an Object callback will be called passing\n * the value, key, and complete object for each property.\n *\n * @param {Object|Array} obj The object to iterate\n * @param {Function} fn The callback to invoke for each item\n *\n * @param {Boolean} [allOwnKeys = false]\n * @returns {any}\n */\nfunction forEach(obj, fn, {allOwnKeys = false} = {}) {\n  // Don't bother if no value provided\n  if (obj === null || typeof obj === 'undefined') {\n    return;\n  }\n\n  let i;\n  let l;\n\n  // Force an array if not already something iterable\n  if (typeof obj !== 'object') {\n    /*eslint no-param-reassign:0*/\n    obj = [obj];\n  }\n\n  if (isArray(obj)) {\n    // Iterate over array values\n    for (i = 0, l = obj.length; i < l; i++) {\n      fn.call(null, obj[i], i, obj);\n    }\n  } else {\n    // Iterate over object keys\n    const keys = allOwnKeys ? Object.getOwnPropertyNames(obj) : Object.keys(obj);\n    const len = keys.length;\n    let key;\n\n    for (i = 0; i < len; i++) {\n      key = keys[i];\n      fn.call(null, obj[key], key, obj);\n    }\n  }\n}\n\nfunction findKey(obj, key) {\n  key = key.toLowerCase();\n  const keys = Object.keys(obj);\n  let i = keys.length;\n  let _key;\n  while (i-- > 0) {\n    _key = keys[i];\n    if (key === _key.toLowerCase()) {\n      return _key;\n    }\n  }\n  return null;\n}\n\nconst _global = (() => {\n  /*eslint no-undef:0*/\n  if (typeof globalThis !== \"undefined\") return globalThis;\n  return typeof self !== \"undefined\" ? self : (typeof window !== 'undefined' ? window : global)\n})();\n\nconst isContextDefined = (context) => !isUndefined(context) && context !== _global;\n\n/**\n * Accepts varargs expecting each argument to be an object, then\n * immutably merges the properties of each object and returns result.\n *\n * When multiple objects contain the same key the later object in\n * the arguments list will take precedence.\n *\n * Example:\n *\n * ```js\n * var result = merge({foo: 123}, {foo: 456});\n * console.log(result.foo); // outputs 456\n * ```\n *\n * @param {Object} obj1 Object to merge\n *\n * @returns {Object} Result of all merge properties\n */\nfunction merge(/* obj1, obj2, obj3, ... */) {\n  const {caseless} = isContextDefined(this) && this || {};\n  const result = {};\n  const assignValue = (val, key) => {\n    const targetKey = caseless && findKey(result, key) || key;\n    if (isPlainObject(result[targetKey]) && isPlainObject(val)) {\n      result[targetKey] = merge(result[targetKey], val);\n    } else if (isPlainObject(val)) {\n      result[targetKey] = merge({}, val);\n    } else if (isArray(val)) {\n      result[targetKey] = val.slice();\n    } else {\n      result[targetKey] = val;\n    }\n  }\n\n  for (let i = 0, l = arguments.length; i < l; i++) {\n    arguments[i] && forEach(arguments[i], assignValue);\n  }\n  return result;\n}\n\n/**\n * Extends object a by mutably adding to it the properties of object b.\n *\n * @param {Object} a The object to be extended\n * @param {Object} b The object to copy properties from\n * @param {Object} thisArg The object to bind function to\n *\n * @param {Boolean} [allOwnKeys]\n * @returns {Object} The resulting value of object a\n */\nconst extend = (a, b, thisArg, {allOwnKeys}= {}) => {\n  forEach(b, (val, key) => {\n    if (thisArg && isFunction(val)) {\n      a[key] = bind(val, thisArg);\n    } else {\n      a[key] = val;\n    }\n  }, {allOwnKeys});\n  return a;\n}\n\n/**\n * Remove byte order marker. This catches EF BB BF (the UTF-8 BOM)\n *\n * @param {string} content with BOM\n *\n * @returns {string} content value without BOM\n */\nconst stripBOM = (content) => {\n  if (content.charCodeAt(0) === 0xFEFF) {\n    content = content.slice(1);\n  }\n  return content;\n}\n\n/**\n * Inherit the prototype methods from one constructor into another\n * @param {function} constructor\n * @param {function} superConstructor\n * @param {object} [props]\n * @param {object} [descriptors]\n *\n * @returns {void}\n */\nconst inherits = (constructor, superConstructor, props, descriptors) => {\n  constructor.prototype = Object.create(superConstructor.prototype, descriptors);\n  constructor.prototype.constructor = constructor;\n  Object.defineProperty(constructor, 'super', {\n    value: superConstructor.prototype\n  });\n  props && Object.assign(constructor.prototype, props);\n}\n\n/**\n * Resolve object with deep prototype chain to a flat object\n * @param {Object} sourceObj source object\n * @param {Object} [destObj]\n * @param {Function|Boolean} [filter]\n * @param {Function} [propFilter]\n *\n * @returns {Object}\n */\nconst toFlatObject = (sourceObj, destObj, filter, propFilter) => {\n  let props;\n  let i;\n  let prop;\n  const merged = {};\n\n  destObj = destObj || {};\n  // eslint-disable-next-line no-eq-null,eqeqeq\n  if (sourceObj == null) return destObj;\n\n  do {\n    props = Object.getOwnPropertyNames(sourceObj);\n    i = props.length;\n    while (i-- > 0) {\n      prop = props[i];\n      if ((!propFilter || propFilter(prop, sourceObj, destObj)) && !merged[prop]) {\n        destObj[prop] = sourceObj[prop];\n        merged[prop] = true;\n      }\n    }\n    sourceObj = filter !== false && getPrototypeOf(sourceObj);\n  } while (sourceObj && (!filter || filter(sourceObj, destObj)) && sourceObj !== Object.prototype);\n\n  return destObj;\n}\n\n/**\n * Determines whether a string ends with the characters of a specified string\n *\n * @param {String} str\n * @param {String} searchString\n * @param {Number} [position= 0]\n *\n * @returns {boolean}\n */\nconst endsWith = (str, searchString, position) => {\n  str = String(str);\n  if (position === undefined || position > str.length) {\n    position = str.length;\n  }\n  position -= searchString.length;\n  const lastIndex = str.indexOf(searchString, position);\n  return lastIndex !== -1 && lastIndex === position;\n}\n\n\n/**\n * Returns new array from array like object or null if failed\n *\n * @param {*} [thing]\n *\n * @returns {?Array}\n */\nconst toArray = (thing) => {\n  if (!thing) return null;\n  if (isArray(thing)) return thing;\n  let i = thing.length;\n  if (!isNumber(i)) return null;\n  const arr = new Array(i);\n  while (i-- > 0) {\n    arr[i] = thing[i];\n  }\n  return arr;\n}\n\n/**\n * Checking if the Uint8Array exists and if it does, it returns a function that checks if the\n * thing passed in is an instance of Uint8Array\n *\n * @param {TypedArray}\n *\n * @returns {Array}\n */\n// eslint-disable-next-line func-names\nconst isTypedArray = (TypedArray => {\n  // eslint-disable-next-line func-names\n  return thing => {\n    return TypedArray && thing instanceof TypedArray;\n  };\n})(typeof Uint8Array !== 'undefined' && getPrototypeOf(Uint8Array));\n\n/**\n * For each entry in the object, call the function with the key and value.\n *\n * @param {Object<any, any>} obj - The object to iterate over.\n * @param {Function} fn - The function to call for each entry.\n *\n * @returns {void}\n */\nconst forEachEntry = (obj, fn) => {\n  const generator = obj && obj[Symbol.iterator];\n\n  const iterator = generator.call(obj);\n\n  let result;\n\n  while ((result = iterator.next()) && !result.done) {\n    const pair = result.value;\n    fn.call(obj, pair[0], pair[1]);\n  }\n}\n\n/**\n * It takes a regular expression and a string, and returns an array of all the matches\n *\n * @param {string} regExp - The regular expression to match against.\n * @param {string} str - The string to search.\n *\n * @returns {Array<boolean>}\n */\nconst matchAll = (regExp, str) => {\n  let matches;\n  const arr = [];\n\n  while ((matches = regExp.exec(str)) !== null) {\n    arr.push(matches);\n  }\n\n  return arr;\n}\n\n/* Checking if the kindOfTest function returns true when passed an HTMLFormElement. */\nconst isHTMLForm = kindOfTest('HTMLFormElement');\n\nconst toCamelCase = str => {\n  return str.toLowerCase().replace(/[-_\\s]([a-z\\d])(\\w*)/g,\n    function replacer(m, p1, p2) {\n      return p1.toUpperCase() + p2;\n    }\n  );\n};\n\n/* Creating a function that will check if an object has a property. */\nconst hasOwnProperty = (({hasOwnProperty}) => (obj, prop) => hasOwnProperty.call(obj, prop))(Object.prototype);\n\n/**\n * Determine if a value is a RegExp object\n *\n * @param {*} val The value to test\n *\n * @returns {boolean} True if value is a RegExp object, otherwise false\n */\nconst isRegExp = kindOfTest('RegExp');\n\nconst reduceDescriptors = (obj, reducer) => {\n  const descriptors = Object.getOwnPropertyDescriptors(obj);\n  const reducedDescriptors = {};\n\n  forEach(descriptors, (descriptor, name) => {\n    if (reducer(descriptor, name, obj) !== false) {\n      reducedDescriptors[name] = descriptor;\n    }\n  });\n\n  Object.defineProperties(obj, reducedDescriptors);\n}\n\n/**\n * Makes all methods read-only\n * @param {Object} obj\n */\n\nconst freezeMethods = (obj) => {\n  reduceDescriptors(obj, (descriptor, name) => {\n    // skip restricted props in strict mode\n    if (isFunction(obj) && ['arguments', 'caller', 'callee'].indexOf(name) !== -1) {\n      return false;\n    }\n\n    const value = obj[name];\n\n    if (!isFunction(value)) return;\n\n    descriptor.enumerable = false;\n\n    if ('writable' in descriptor) {\n      descriptor.writable = false;\n      return;\n    }\n\n    if (!descriptor.set) {\n      descriptor.set = () => {\n        throw Error('Can not rewrite read-only method \\'' + name + '\\'');\n      };\n    }\n  });\n}\n\nconst toObjectSet = (arrayOrString, delimiter) => {\n  const obj = {};\n\n  const define = (arr) => {\n    arr.forEach(value => {\n      obj[value] = true;\n    });\n  }\n\n  isArray(arrayOrString) ? define(arrayOrString) : define(String(arrayOrString).split(delimiter));\n\n  return obj;\n}\n\nconst noop = () => {}\n\nconst toFiniteNumber = (value, defaultValue) => {\n  value = +value;\n  return Number.isFinite(value) ? value : defaultValue;\n}\n\nconst ALPHA = 'abcdefghijklmnopqrstuvwxyz'\n\nconst DIGIT = '0123456789';\n\nconst ALPHABET = {\n  DIGIT,\n  ALPHA,\n  ALPHA_DIGIT: ALPHA + ALPHA.toUpperCase() + DIGIT\n}\n\nconst generateString = (size = 16, alphabet = ALPHABET.ALPHA_DIGIT) => {\n  let str = '';\n  const {length} = alphabet;\n  while (size--) {\n    str += alphabet[Math.random() * length|0]\n  }\n\n  return str;\n}\n\n/**\n * If the thing is a FormData object, return true, otherwise return false.\n *\n * @param {unknown} thing - The thing to check.\n *\n * @returns {boolean}\n */\nfunction isSpecCompliantForm(thing) {\n  return !!(thing && isFunction(thing.append) && thing[Symbol.toStringTag] === 'FormData' && thing[Symbol.iterator]);\n}\n\nconst toJSONObject = (obj) => {\n  const stack = new Array(10);\n\n  const visit = (source, i) => {\n\n    if (isObject(source)) {\n      if (stack.indexOf(source) >= 0) {\n        return;\n      }\n\n      if(!('toJSON' in source)) {\n        stack[i] = source;\n        const target = isArray(source) ? [] : {};\n\n        forEach(source, (value, key) => {\n          const reducedValue = visit(value, i + 1);\n          !isUndefined(reducedValue) && (target[key] = reducedValue);\n        });\n\n        stack[i] = undefined;\n\n        return target;\n      }\n    }\n\n    return source;\n  }\n\n  return visit(obj, 0);\n}\n\nexport default {\n  isArray,\n  isArrayBuffer,\n  isBuffer,\n  isFormData,\n  isArrayBufferView,\n  isString,\n  isNumber,\n  isBoolean,\n  isObject,\n  isPlainObject,\n  isUndefined,\n  isDate,\n  isFile,\n  isBlob,\n  isRegExp,\n  isFunction,\n  isStream,\n  isURLSearchParams,\n  isTypedArray,\n  isFileList,\n  forEach,\n  merge,\n  extend,\n  trim,\n  stripBOM,\n  inherits,\n  toFlatObject,\n  kindOf,\n  kindOfTest,\n  endsWith,\n  toArray,\n  forEachEntry,\n  matchAll,\n  isHTMLForm,\n  hasOwnProperty,\n  hasOwnProp: hasOwnProperty, // an alias to avoid ESLint no-prototype-builtins detection\n  reduceDescriptors,\n  freezeMethods,\n  toObjectSet,\n  toCamelCase,\n  noop,\n  toFiniteNumber,\n  findKey,\n  global: _global,\n  isContextDefined,\n  ALPHABET,\n  generateString,\n  isSpecCompliantForm,\n  toJSONObject\n};\n","'use strict';\n\nimport utils from '../utils.js';\n\n/**\n * Create an Error with the specified message, config, error code, request and response.\n *\n * @param {string} message The error message.\n * @param {string} [code] The error code (for example, 'ECONNABORTED').\n * @param {Object} [config] The config.\n * @param {Object} [request] The request.\n * @param {Object} [response] The response.\n *\n * @returns {Error} The created error.\n */\nfunction AxiosError(message, code, config, request, response) {\n  Error.call(this);\n\n  if (Error.captureStackTrace) {\n    Error.captureStackTrace(this, this.constructor);\n  } else {\n    this.stack = (new Error()).stack;\n  }\n\n  this.message = message;\n  this.name = 'AxiosError';\n  code && (this.code = code);\n  config && (this.config = config);\n  request && (this.request = request);\n  response && (this.response = response);\n}\n\nutils.inherits(AxiosError, Error, {\n  toJSON: function toJSON() {\n    return {\n      // Standard\n      message: this.message,\n      name: this.name,\n      // Microsoft\n      description: this.description,\n      number: this.number,\n      // Mozilla\n      fileName: this.fileName,\n      lineNumber: this.lineNumber,\n      columnNumber: this.columnNumber,\n      stack: this.stack,\n      // Axios\n      config: utils.toJSONObject(this.config),\n      code: this.code,\n      status: this.response && this.response.status ? this.response.status : null\n    };\n  }\n});\n\nconst prototype = AxiosError.prototype;\nconst descriptors = {};\n\n[\n  'ERR_BAD_OPTION_VALUE',\n  'ERR_BAD_OPTION',\n  'ECONNABORTED',\n  'ETIMEDOUT',\n  'ERR_NETWORK',\n  'ERR_FR_TOO_MANY_REDIRECTS',\n  'ERR_DEPRECATED',\n  'ERR_BAD_RESPONSE',\n  'ERR_BAD_REQUEST',\n  'ERR_CANCELED',\n  'ERR_NOT_SUPPORT',\n  'ERR_INVALID_URL'\n// eslint-disable-next-line func-names\n].forEach(code => {\n  descriptors[code] = {value: code};\n});\n\nObject.defineProperties(AxiosError, descriptors);\nObject.defineProperty(prototype, 'isAxiosError', {value: true});\n\n// eslint-disable-next-line func-names\nAxiosError.from = (error, code, config, request, response, customProps) => {\n  const axiosError = Object.create(prototype);\n\n  utils.toFlatObject(error, axiosError, function filter(obj) {\n    return obj !== Error.prototype;\n  }, prop => {\n    return prop !== 'isAxiosError';\n  });\n\n  AxiosError.call(axiosError, error.message, code, config, request, response);\n\n  axiosError.cause = error;\n\n  axiosError.name = error.name;\n\n  customProps && Object.assign(axiosError, customProps);\n\n  return axiosError;\n};\n\nexport default AxiosError;\n","// eslint-disable-next-line strict\nexport default null;\n","'use strict';\n\nimport utils from '../utils.js';\nimport AxiosError from '../core/AxiosError.js';\n// temporary hotfix to avoid circular references until AxiosURLSearchParams is refactored\nimport PlatformFormData from '../platform/node/classes/FormData.js';\n\n/**\n * Determines if the given thing is a array or js object.\n *\n * @param {string} thing - The object or array to be visited.\n *\n * @returns {boolean}\n */\nfunction isVisitable(thing) {\n  return utils.isPlainObject(thing) || utils.isArray(thing);\n}\n\n/**\n * It removes the brackets from the end of a string\n *\n * @param {string} key - The key of the parameter.\n *\n * @returns {string} the key without the brackets.\n */\nfunction removeBrackets(key) {\n  return utils.endsWith(key, '[]') ? key.slice(0, -2) : key;\n}\n\n/**\n * It takes a path, a key, and a boolean, and returns a string\n *\n * @param {string} path - The path to the current key.\n * @param {string} key - The key of the current object being iterated over.\n * @param {string} dots - If true, the key will be rendered with dots instead of brackets.\n *\n * @returns {string} The path to the current key.\n */\nfunction renderKey(path, key, dots) {\n  if (!path) return key;\n  return path.concat(key).map(function each(token, i) {\n    // eslint-disable-next-line no-param-reassign\n    token = removeBrackets(token);\n    return !dots && i ? '[' + token + ']' : token;\n  }).join(dots ? '.' : '');\n}\n\n/**\n * If the array is an array and none of its elements are visitable, then it's a flat array.\n *\n * @param {Array<any>} arr - The array to check\n *\n * @returns {boolean}\n */\nfunction isFlatArray(arr) {\n  return utils.isArray(arr) && !arr.some(isVisitable);\n}\n\nconst predicates = utils.toFlatObject(utils, {}, null, function filter(prop) {\n  return /^is[A-Z]/.test(prop);\n});\n\n/**\n * Convert a data object to FormData\n *\n * @param {Object} obj\n * @param {?Object} [formData]\n * @param {?Object} [options]\n * @param {Function} [options.visitor]\n * @param {Boolean} [options.metaTokens = true]\n * @param {Boolean} [options.dots = false]\n * @param {?Boolean} [options.indexes = false]\n *\n * @returns {Object}\n **/\n\n/**\n * It converts an object into a FormData object\n *\n * @param {Object<any, any>} obj - The object to convert to form data.\n * @param {string} formData - The FormData object to append to.\n * @param {Object<string, any>} options\n *\n * @returns\n */\nfunction toFormData(obj, formData, options) {\n  if (!utils.isObject(obj)) {\n    throw new TypeError('target must be an object');\n  }\n\n  // eslint-disable-next-line no-param-reassign\n  formData = formData || new (PlatformFormData || FormData)();\n\n  // eslint-disable-next-line no-param-reassign\n  options = utils.toFlatObject(options, {\n    metaTokens: true,\n    dots: false,\n    indexes: false\n  }, false, function defined(option, source) {\n    // eslint-disable-next-line no-eq-null,eqeqeq\n    return !utils.isUndefined(source[option]);\n  });\n\n  const metaTokens = options.metaTokens;\n  // eslint-disable-next-line no-use-before-define\n  const visitor = options.visitor || defaultVisitor;\n  const dots = options.dots;\n  const indexes = options.indexes;\n  const _Blob = options.Blob || typeof Blob !== 'undefined' && Blob;\n  const useBlob = _Blob && utils.isSpecCompliantForm(formData);\n\n  if (!utils.isFunction(visitor)) {\n    throw new TypeError('visitor must be a function');\n  }\n\n  function convertValue(value) {\n    if (value === null) return '';\n\n    if (utils.isDate(value)) {\n      return value.toISOString();\n    }\n\n    if (!useBlob && utils.isBlob(value)) {\n      throw new AxiosError('Blob is not supported. Use a Buffer instead.');\n    }\n\n    if (utils.isArrayBuffer(value) || utils.isTypedArray(value)) {\n      return useBlob && typeof Blob === 'function' ? new Blob([value]) : Buffer.from(value);\n    }\n\n    return value;\n  }\n\n  /**\n   * Default visitor.\n   *\n   * @param {*} value\n   * @param {String|Number} key\n   * @param {Array<String|Number>} path\n   * @this {FormData}\n   *\n   * @returns {boolean} return true to visit the each prop of the value recursively\n   */\n  function defaultVisitor(value, key, path) {\n    let arr = value;\n\n    if (value && !path && typeof value === 'object') {\n      if (utils.endsWith(key, '{}')) {\n        // eslint-disable-next-line no-param-reassign\n        key = metaTokens ? key : key.slice(0, -2);\n        // eslint-disable-next-line no-param-reassign\n        value = JSON.stringify(value);\n      } else if (\n        (utils.isArray(value) && isFlatArray(value)) ||\n        ((utils.isFileList(value) || utils.endsWith(key, '[]')) && (arr = utils.toArray(value))\n        )) {\n        // eslint-disable-next-line no-param-reassign\n        key = removeBrackets(key);\n\n        arr.forEach(function each(el, index) {\n          !(utils.isUndefined(el) || el === null) && formData.append(\n            // eslint-disable-next-line no-nested-ternary\n            indexes === true ? renderKey([key], index, dots) : (indexes === null ? key : key + '[]'),\n            convertValue(el)\n          );\n        });\n        return false;\n      }\n    }\n\n    if (isVisitable(value)) {\n      return true;\n    }\n\n    formData.append(renderKey(path, key, dots), convertValue(value));\n\n    return false;\n  }\n\n  const stack = [];\n\n  const exposedHelpers = Object.assign(predicates, {\n    defaultVisitor,\n    convertValue,\n    isVisitable\n  });\n\n  function build(value, path) {\n    if (utils.isUndefined(value)) return;\n\n    if (stack.indexOf(value) !== -1) {\n      throw Error('Circular reference detected in ' + path.join('.'));\n    }\n\n    stack.push(value);\n\n    utils.forEach(value, function each(el, key) {\n      const result = !(utils.isUndefined(el) || el === null) && visitor.call(\n        formData, el, utils.isString(key) ? key.trim() : key, path, exposedHelpers\n      );\n\n      if (result === true) {\n        build(el, path ? path.concat(key) : [key]);\n      }\n    });\n\n    stack.pop();\n  }\n\n  if (!utils.isObject(obj)) {\n    throw new TypeError('data must be an object');\n  }\n\n  build(obj);\n\n  return formData;\n}\n\nexport default toFormData;\n","'use strict';\n\nimport toFormData from './toFormData.js';\n\n/**\n * It encodes a string by replacing all characters that are not in the unreserved set with\n * their percent-encoded equivalents\n *\n * @param {string} str - The string to encode.\n *\n * @returns {string} The encoded string.\n */\nfunction encode(str) {\n  const charMap = {\n    '!': '%21',\n    \"'\": '%27',\n    '(': '%28',\n    ')': '%29',\n    '~': '%7E',\n    '%20': '+',\n    '%00': '\\x00'\n  };\n  return encodeURIComponent(str).replace(/[!'()~]|%20|%00/g, function replacer(match) {\n    return charMap[match];\n  });\n}\n\n/**\n * It takes a params object and converts it to a FormData object\n *\n * @param {Object<string, any>} params - The parameters to be converted to a FormData object.\n * @param {Object<string, any>} options - The options object passed to the Axios constructor.\n *\n * @returns {void}\n */\nfunction AxiosURLSearchParams(params, options) {\n  this._pairs = [];\n\n  params && toFormData(params, this, options);\n}\n\nconst prototype = AxiosURLSearchParams.prototype;\n\nprototype.append = function append(name, value) {\n  this._pairs.push([name, value]);\n};\n\nprototype.toString = function toString(encoder) {\n  const _encode = encoder ? function(value) {\n    return encoder.call(this, value, encode);\n  } : encode;\n\n  return this._pairs.map(function each(pair) {\n    return _encode(pair[0]) + '=' + _encode(pair[1]);\n  }, '').join('&');\n};\n\nexport default AxiosURLSearchParams;\n","'use strict';\n\nimport utils from '../utils.js';\nimport AxiosURLSearchParams from '../helpers/AxiosURLSearchParams.js';\n\n/**\n * It replaces all instances of the characters `:`, `$`, `,`, `+`, `[`, and `]` with their\n * URI encoded counterparts\n *\n * @param {string} val The value to be encoded.\n *\n * @returns {string} The encoded value.\n */\nfunction encode(val) {\n  return encodeURIComponent(val).\n    replace(/%3A/gi, ':').\n    replace(/%24/g, '$').\n    replace(/%2C/gi, ',').\n    replace(/%20/g, '+').\n    replace(/%5B/gi, '[').\n    replace(/%5D/gi, ']');\n}\n\n/**\n * Build a URL by appending params to the end\n *\n * @param {string} url The base of the url (e.g., http://www.google.com)\n * @param {object} [params] The params to be appended\n * @param {?object} options\n *\n * @returns {string} The formatted url\n */\nexport default function buildURL(url, params, options) {\n  /*eslint no-param-reassign:0*/\n  if (!params) {\n    return url;\n  }\n  \n  const _encode = options && options.encode || encode;\n\n  const serializeFn = options && options.serialize;\n\n  let serializedParams;\n\n  if (serializeFn) {\n    serializedParams = serializeFn(params, options);\n  } else {\n    serializedParams = utils.isURLSearchParams(params) ?\n      params.toString() :\n      new AxiosURLSearchParams(params, options).toString(_encode);\n  }\n\n  if (serializedParams) {\n    const hashmarkIndex = url.indexOf(\"#\");\n\n    if (hashmarkIndex !== -1) {\n      url = url.slice(0, hashmarkIndex);\n    }\n    url += (url.indexOf('?') === -1 ? '?' : '&') + serializedParams;\n  }\n\n  return url;\n}\n","'use strict';\n\nimport utils from './../utils.js';\n\nclass InterceptorManager {\n  constructor() {\n    this.handlers = [];\n  }\n\n  /**\n   * Add a new interceptor to the stack\n   *\n   * @param {Function} fulfilled The function to handle `then` for a `Promise`\n   * @param {Function} rejected The function to handle `reject` for a `Promise`\n   *\n   * @return {Number} An ID used to remove interceptor later\n   */\n  use(fulfilled, rejected, options) {\n    this.handlers.push({\n      fulfilled,\n      rejected,\n      synchronous: options ? options.synchronous : false,\n      runWhen: options ? options.runWhen : null\n    });\n    return this.handlers.length - 1;\n  }\n\n  /**\n   * Remove an interceptor from the stack\n   *\n   * @param {Number} id The ID that was returned by `use`\n   *\n   * @returns {Boolean} `true` if the interceptor was removed, `false` otherwise\n   */\n  eject(id) {\n    if (this.handlers[id]) {\n      this.handlers[id] = null;\n    }\n  }\n\n  /**\n   * Clear all interceptors from the stack\n   *\n   * @returns {void}\n   */\n  clear() {\n    if (this.handlers) {\n      this.handlers = [];\n    }\n  }\n\n  /**\n   * Iterate over all the registered interceptors\n   *\n   * This method is particularly useful for skipping over any\n   * interceptors that may have become `null` calling `eject`.\n   *\n   * @param {Function} fn The function to call for each interceptor\n   *\n   * @returns {void}\n   */\n  forEach(fn) {\n    utils.forEach(this.handlers, function forEachHandler(h) {\n      if (h !== null) {\n        fn(h);\n      }\n    });\n  }\n}\n\nexport default InterceptorManager;\n","'use strict';\n\nexport default {\n  silentJSONParsing: true,\n  forcedJSONParsing: true,\n  clarifyTimeoutError: false\n};\n","'use strict';\n\nimport AxiosURLSearchParams from '../../../helpers/AxiosURLSearchParams.js';\nexport default typeof URLSearchParams !== 'undefined' ? URLSearchParams : AxiosURLSearchParams;\n","'use strict';\n\nexport default typeof FormData !== 'undefined' ? FormData : null;\n","'use strict'\n\nexport default typeof Blob !== 'undefined' ? Blob : null\n","import URLSearchParams from './classes/URLSearchParams.js'\nimport FormData from './classes/FormData.js'\nimport Blob from './classes/Blob.js'\n\n/**\n * Determine if we're running in a standard browser environment\n *\n * This allows axios to run in a web worker, and react-native.\n * Both environments support XMLHttpRequest, but not fully standard globals.\n *\n * web workers:\n *  typeof window -> undefined\n *  typeof document -> undefined\n *\n * react-native:\n *  navigator.product -> 'ReactNative'\n * nativescript\n *  navigator.product -> 'NativeScript' or 'NS'\n *\n * @returns {boolean}\n */\nconst isStandardBrowserEnv = (() => {\n  let product;\n  if (typeof navigator !== 'undefined' && (\n    (product = navigator.product) === 'ReactNative' ||\n    product === 'NativeScript' ||\n    product === 'NS')\n  ) {\n    return false;\n  }\n\n  return typeof window !== 'undefined' && typeof document !== 'undefined';\n})();\n\n/**\n * Determine if we're running in a standard browser webWorker environment\n *\n * Although the `isStandardBrowserEnv` method indicates that\n * `allows axios to run in a web worker`, the WebWorker will still be\n * filtered out due to its judgment standard\n * `typeof window !== 'undefined' && typeof document !== 'undefined'`.\n * This leads to a problem when axios post `FormData` in webWorker\n */\n const isStandardBrowserWebWorkerEnv = (() => {\n  return (\n    typeof WorkerGlobalScope !== 'undefined' &&\n    // eslint-disable-next-line no-undef\n    self instanceof WorkerGlobalScope &&\n    typeof self.importScripts === 'function'\n  );\n})();\n\n\nexport default {\n  isBrowser: true,\n  classes: {\n    URLSearchParams,\n    FormData,\n    Blob\n  },\n  isStandardBrowserEnv,\n  isStandardBrowserWebWorkerEnv,\n  protocols: ['http', 'https', 'file', 'blob', 'url', 'data']\n};\n","'use strict';\n\nimport utils from '../utils.js';\nimport toFormData from './toFormData.js';\nimport platform from '../platform/index.js';\n\nexport default function toURLEncodedForm(data, options) {\n  return toFormData(data, new platform.classes.URLSearchParams(), Object.assign({\n    visitor: function(value, key, path, helpers) {\n      if (platform.isNode && utils.isBuffer(value)) {\n        this.append(key, value.toString('base64'));\n        return false;\n      }\n\n      return helpers.defaultVisitor.apply(this, arguments);\n    }\n  }, options));\n}\n","'use strict';\n\nimport utils from '../utils.js';\n\n/**\n * It takes a string like `foo[x][y][z]` and returns an array like `['foo', 'x', 'y', 'z']\n *\n * @param {string} name - The name of the property to get.\n *\n * @returns An array of strings.\n */\nfunction parsePropPath(name) {\n  // foo[x][y][z]\n  // foo.x.y.z\n  // foo-x-y-z\n  // foo x y z\n  return utils.matchAll(/\\w+|\\[(\\w*)]/g, name).map(match => {\n    return match[0] === '[]' ? '' : match[1] || match[0];\n  });\n}\n\n/**\n * Convert an array to an object.\n *\n * @param {Array<any>} arr - The array to convert to an object.\n *\n * @returns An object with the same keys and values as the array.\n */\nfunction arrayToObject(arr) {\n  const obj = {};\n  const keys = Object.keys(arr);\n  let i;\n  const len = keys.length;\n  let key;\n  for (i = 0; i < len; i++) {\n    key = keys[i];\n    obj[key] = arr[key];\n  }\n  return obj;\n}\n\n/**\n * It takes a FormData object and returns a JavaScript object\n *\n * @param {string} formData The FormData object to convert to JSON.\n *\n * @returns {Object<string, any> | null} The converted object.\n */\nfunction formDataToJSON(formData) {\n  function buildPath(path, value, target, index) {\n    let name = path[index++];\n    const isNumericKey = Number.isFinite(+name);\n    const isLast = index >= path.length;\n    name = !name && utils.isArray(target) ? target.length : name;\n\n    if (isLast) {\n      if (utils.hasOwnProp(target, name)) {\n        target[name] = [target[name], value];\n      } else {\n        target[name] = value;\n      }\n\n      return !isNumericKey;\n    }\n\n    if (!target[name] || !utils.isObject(target[name])) {\n      target[name] = [];\n    }\n\n    const result = buildPath(path, value, target[name], index);\n\n    if (result && utils.isArray(target[name])) {\n      target[name] = arrayToObject(target[name]);\n    }\n\n    return !isNumericKey;\n  }\n\n  if (utils.isFormData(formData) && utils.isFunction(formData.entries)) {\n    const obj = {};\n\n    utils.forEachEntry(formData, (name, value) => {\n      buildPath(parsePropPath(name), value, obj, 0);\n    });\n\n    return obj;\n  }\n\n  return null;\n}\n\nexport default formDataToJSON;\n","'use strict';\n\nimport utils from '../utils.js';\nimport AxiosError from '../core/AxiosError.js';\nimport transitionalDefaults from './transitional.js';\nimport toFormData from '../helpers/toFormData.js';\nimport toURLEncodedForm from '../helpers/toURLEncodedForm.js';\nimport platform from '../platform/index.js';\nimport formDataToJSON from '../helpers/formDataToJSON.js';\n\nconst DEFAULT_CONTENT_TYPE = {\n  'Content-Type': undefined\n};\n\n/**\n * It takes a string, tries to parse it, and if it fails, it returns the stringified version\n * of the input\n *\n * @param {any} rawValue - The value to be stringified.\n * @param {Function} parser - A function that parses a string into a JavaScript object.\n * @param {Function} encoder - A function that takes a value and returns a string.\n *\n * @returns {string} A stringified version of the rawValue.\n */\nfunction stringifySafely(rawValue, parser, encoder) {\n  if (utils.isString(rawValue)) {\n    try {\n      (parser || JSON.parse)(rawValue);\n      return utils.trim(rawValue);\n    } catch (e) {\n      if (e.name !== 'SyntaxError') {\n        throw e;\n      }\n    }\n  }\n\n  return (encoder || JSON.stringify)(rawValue);\n}\n\nconst defaults = {\n\n  transitional: transitionalDefaults,\n\n  adapter: ['xhr', 'http'],\n\n  transformRequest: [function transformRequest(data, headers) {\n    const contentType = headers.getContentType() || '';\n    const hasJSONContentType = contentType.indexOf('application/json') > -1;\n    const isObjectPayload = utils.isObject(data);\n\n    if (isObjectPayload && utils.isHTMLForm(data)) {\n      data = new FormData(data);\n    }\n\n    const isFormData = utils.isFormData(data);\n\n    if (isFormData) {\n      if (!hasJSONContentType) {\n        return data;\n      }\n      return hasJSONContentType ? JSON.stringify(formDataToJSON(data)) : data;\n    }\n\n    if (utils.isArrayBuffer(data) ||\n      utils.isBuffer(data) ||\n      utils.isStream(data) ||\n      utils.isFile(data) ||\n      utils.isBlob(data)\n    ) {\n      return data;\n    }\n    if (utils.isArrayBufferView(data)) {\n      return data.buffer;\n    }\n    if (utils.isURLSearchParams(data)) {\n      headers.setContentType('application/x-www-form-urlencoded;charset=utf-8', false);\n      return data.toString();\n    }\n\n    let isFileList;\n\n    if (isObjectPayload) {\n      if (contentType.indexOf('application/x-www-form-urlencoded') > -1) {\n        return toURLEncodedForm(data, this.formSerializer).toString();\n      }\n\n      if ((isFileList = utils.isFileList(data)) || contentType.indexOf('multipart/form-data') > -1) {\n        const _FormData = this.env && this.env.FormData;\n\n        return toFormData(\n          isFileList ? {'files[]': data} : data,\n          _FormData && new _FormData(),\n          this.formSerializer\n        );\n      }\n    }\n\n    if (isObjectPayload || hasJSONContentType ) {\n      headers.setContentType('application/json', false);\n      return stringifySafely(data);\n    }\n\n    return data;\n  }],\n\n  transformResponse: [function transformResponse(data) {\n    const transitional = this.transitional || defaults.transitional;\n    const forcedJSONParsing = transitional && transitional.forcedJSONParsing;\n    const JSONRequested = this.responseType === 'json';\n\n    if (data && utils.isString(data) && ((forcedJSONParsing && !this.responseType) || JSONRequested)) {\n      const silentJSONParsing = transitional && transitional.silentJSONParsing;\n      const strictJSONParsing = !silentJSONParsing && JSONRequested;\n\n      try {\n        return JSON.parse(data);\n      } catch (e) {\n        if (strictJSONParsing) {\n          if (e.name === 'SyntaxError') {\n            throw AxiosError.from(e, AxiosError.ERR_BAD_RESPONSE, this, null, this.response);\n          }\n          throw e;\n        }\n      }\n    }\n\n    return data;\n  }],\n\n  /**\n   * A timeout in milliseconds to abort a request. If set to 0 (default) a\n   * timeout is not created.\n   */\n  timeout: 0,\n\n  xsrfCookieName: 'XSRF-TOKEN',\n  xsrfHeaderName: 'X-XSRF-TOKEN',\n\n  maxContentLength: -1,\n  maxBodyLength: -1,\n\n  env: {\n    FormData: platform.classes.FormData,\n    Blob: platform.classes.Blob\n  },\n\n  validateStatus: function validateStatus(status) {\n    return status >= 200 && status < 300;\n  },\n\n  headers: {\n    common: {\n      'Accept': 'application/json, text/plain, */*'\n    }\n  }\n};\n\nutils.forEach(['delete', 'get', 'head'], function forEachMethodNoData(method) {\n  defaults.headers[method] = {};\n});\n\nutils.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) {\n  defaults.headers[method] = utils.merge(DEFAULT_CONTENT_TYPE);\n});\n\nexport default defaults;\n","'use strict';\n\nimport utils from './../utils.js';\n\n// RawAxiosHeaders whose duplicates are ignored by node\n// c.f. https://nodejs.org/api/http.html#http_message_headers\nconst ignoreDuplicateOf = utils.toObjectSet([\n  'age', 'authorization', 'content-length', 'content-type', 'etag',\n  'expires', 'from', 'host', 'if-modified-since', 'if-unmodified-since',\n  'last-modified', 'location', 'max-forwards', 'proxy-authorization',\n  'referer', 'retry-after', 'user-agent'\n]);\n\n/**\n * Parse headers into an object\n *\n * ```\n * Date: Wed, 27 Aug 2014 08:58:49 GMT\n * Content-Type: application/json\n * Connection: keep-alive\n * Transfer-Encoding: chunked\n * ```\n *\n * @param {String} rawHeaders Headers needing to be parsed\n *\n * @returns {Object} Headers parsed into an object\n */\nexport default rawHeaders => {\n  const parsed = {};\n  let key;\n  let val;\n  let i;\n\n  rawHeaders && rawHeaders.split('\\n').forEach(function parser(line) {\n    i = line.indexOf(':');\n    key = line.substring(0, i).trim().toLowerCase();\n    val = line.substring(i + 1).trim();\n\n    if (!key || (parsed[key] && ignoreDuplicateOf[key])) {\n      return;\n    }\n\n    if (key === 'set-cookie') {\n      if (parsed[key]) {\n        parsed[key].push(val);\n      } else {\n        parsed[key] = [val];\n      }\n    } else {\n      parsed[key] = parsed[key] ? parsed[key] + ', ' + val : val;\n    }\n  });\n\n  return parsed;\n};\n","'use strict';\n\nimport utils from '../utils.js';\nimport parseHeaders from '../helpers/parseHeaders.js';\n\nconst $internals = Symbol('internals');\n\nfunction normalizeHeader(header) {\n  return header && String(header).trim().toLowerCase();\n}\n\nfunction normalizeValue(value) {\n  if (value === false || value == null) {\n    return value;\n  }\n\n  return utils.isArray(value) ? value.map(normalizeValue) : String(value);\n}\n\nfunction parseTokens(str) {\n  const tokens = Object.create(null);\n  const tokensRE = /([^\\s,;=]+)\\s*(?:=\\s*([^,;]+))?/g;\n  let match;\n\n  while ((match = tokensRE.exec(str))) {\n    tokens[match[1]] = match[2];\n  }\n\n  return tokens;\n}\n\nfunction isValidHeaderName(str) {\n  return /^[-_a-zA-Z]+$/.test(str.trim());\n}\n\nfunction matchHeaderValue(context, value, header, filter, isHeaderNameFilter) {\n  if (utils.isFunction(filter)) {\n    return filter.call(this, value, header);\n  }\n\n  if (isHeaderNameFilter) {\n    value = header;\n  }\n\n  if (!utils.isString(value)) return;\n\n  if (utils.isString(filter)) {\n    return value.indexOf(filter) !== -1;\n  }\n\n  if (utils.isRegExp(filter)) {\n    return filter.test(value);\n  }\n}\n\nfunction formatHeader(header) {\n  return header.trim()\n    .toLowerCase().replace(/([a-z\\d])(\\w*)/g, (w, char, str) => {\n      return char.toUpperCase() + str;\n    });\n}\n\nfunction buildAccessors(obj, header) {\n  const accessorName = utils.toCamelCase(' ' + header);\n\n  ['get', 'set', 'has'].forEach(methodName => {\n    Object.defineProperty(obj, methodName + accessorName, {\n      value: function(arg1, arg2, arg3) {\n        return this[methodName].call(this, header, arg1, arg2, arg3);\n      },\n      configurable: true\n    });\n  });\n}\n\nclass AxiosHeaders {\n  constructor(headers) {\n    headers && this.set(headers);\n  }\n\n  set(header, valueOrRewrite, rewrite) {\n    const self = this;\n\n    function setHeader(_value, _header, _rewrite) {\n      const lHeader = normalizeHeader(_header);\n\n      if (!lHeader) {\n        throw new Error('header name must be a non-empty string');\n      }\n\n      const key = utils.findKey(self, lHeader);\n\n      if(!key || self[key] === undefined || _rewrite === true || (_rewrite === undefined && self[key] !== false)) {\n        self[key || _header] = normalizeValue(_value);\n      }\n    }\n\n    const setHeaders = (headers, _rewrite) =>\n      utils.forEach(headers, (_value, _header) => setHeader(_value, _header, _rewrite));\n\n    if (utils.isPlainObject(header) || header instanceof this.constructor) {\n      setHeaders(header, valueOrRewrite)\n    } else if(utils.isString(header) && (header = header.trim()) && !isValidHeaderName(header)) {\n      setHeaders(parseHeaders(header), valueOrRewrite);\n    } else {\n      header != null && setHeader(valueOrRewrite, header, rewrite);\n    }\n\n    return this;\n  }\n\n  get(header, parser) {\n    header = normalizeHeader(header);\n\n    if (header) {\n      const key = utils.findKey(this, header);\n\n      if (key) {\n        const value = this[key];\n\n        if (!parser) {\n          return value;\n        }\n\n        if (parser === true) {\n          return parseTokens(value);\n        }\n\n        if (utils.isFunction(parser)) {\n          return parser.call(this, value, key);\n        }\n\n        if (utils.isRegExp(parser)) {\n          return parser.exec(value);\n        }\n\n        throw new TypeError('parser must be boolean|regexp|function');\n      }\n    }\n  }\n\n  has(header, matcher) {\n    header = normalizeHeader(header);\n\n    if (header) {\n      const key = utils.findKey(this, header);\n\n      return !!(key && this[key] !== undefined && (!matcher || matchHeaderValue(this, this[key], key, matcher)));\n    }\n\n    return false;\n  }\n\n  delete(header, matcher) {\n    const self = this;\n    let deleted = false;\n\n    function deleteHeader(_header) {\n      _header = normalizeHeader(_header);\n\n      if (_header) {\n        const key = utils.findKey(self, _header);\n\n        if (key && (!matcher || matchHeaderValue(self, self[key], key, matcher))) {\n          delete self[key];\n\n          deleted = true;\n        }\n      }\n    }\n\n    if (utils.isArray(header)) {\n      header.forEach(deleteHeader);\n    } else {\n      deleteHeader(header);\n    }\n\n    return deleted;\n  }\n\n  clear(matcher) {\n    const keys = Object.keys(this);\n    let i = keys.length;\n    let deleted = false;\n\n    while (i--) {\n      const key = keys[i];\n      if(!matcher || matchHeaderValue(this, this[key], key, matcher, true)) {\n        delete this[key];\n        deleted = true;\n      }\n    }\n\n    return deleted;\n  }\n\n  normalize(format) {\n    const self = this;\n    const headers = {};\n\n    utils.forEach(this, (value, header) => {\n      const key = utils.findKey(headers, header);\n\n      if (key) {\n        self[key] = normalizeValue(value);\n        delete self[header];\n        return;\n      }\n\n      const normalized = format ? formatHeader(header) : String(header).trim();\n\n      if (normalized !== header) {\n        delete self[header];\n      }\n\n      self[normalized] = normalizeValue(value);\n\n      headers[normalized] = true;\n    });\n\n    return this;\n  }\n\n  concat(...targets) {\n    return this.constructor.concat(this, ...targets);\n  }\n\n  toJSON(asStrings) {\n    const obj = Object.create(null);\n\n    utils.forEach(this, (value, header) => {\n      value != null && value !== false && (obj[header] = asStrings && utils.isArray(value) ? value.join(', ') : value);\n    });\n\n    return obj;\n  }\n\n  [Symbol.iterator]() {\n    return Object.entries(this.toJSON())[Symbol.iterator]();\n  }\n\n  toString() {\n    return Object.entries(this.toJSON()).map(([header, value]) => header + ': ' + value).join('\\n');\n  }\n\n  get [Symbol.toStringTag]() {\n    return 'AxiosHeaders';\n  }\n\n  static from(thing) {\n    return thing instanceof this ? thing : new this(thing);\n  }\n\n  static concat(first, ...targets) {\n    const computed = new this(first);\n\n    targets.forEach((target) => computed.set(target));\n\n    return computed;\n  }\n\n  static accessor(header) {\n    const internals = this[$internals] = (this[$internals] = {\n      accessors: {}\n    });\n\n    const accessors = internals.accessors;\n    const prototype = this.prototype;\n\n    function defineAccessor(_header) {\n      const lHeader = normalizeHeader(_header);\n\n      if (!accessors[lHeader]) {\n        buildAccessors(prototype, _header);\n        accessors[lHeader] = true;\n      }\n    }\n\n    utils.isArray(header) ? header.forEach(defineAccessor) : defineAccessor(header);\n\n    return this;\n  }\n}\n\nAxiosHeaders.accessor(['Content-Type', 'Content-Length', 'Accept', 'Accept-Encoding', 'User-Agent', 'Authorization']);\n\nutils.freezeMethods(AxiosHeaders.prototype);\nutils.freezeMethods(AxiosHeaders);\n\nexport default AxiosHeaders;\n","'use strict';\n\nimport utils from './../utils.js';\nimport defaults from '../defaults/index.js';\nimport AxiosHeaders from '../core/AxiosHeaders.js';\n\n/**\n * Transform the data for a request or a response\n *\n * @param {Array|Function} fns A single function or Array of functions\n * @param {?Object} response The response object\n *\n * @returns {*} The resulting transformed data\n */\nexport default function transformData(fns, response) {\n  const config = this || defaults;\n  const context = response || config;\n  const headers = AxiosHeaders.from(context.headers);\n  let data = context.data;\n\n  utils.forEach(fns, function transform(fn) {\n    data = fn.call(config, data, headers.normalize(), response ? response.status : undefined);\n  });\n\n  headers.normalize();\n\n  return data;\n}\n","'use strict';\n\nexport default function isCancel(value) {\n  return !!(value && value.__CANCEL__);\n}\n","'use strict';\n\nimport AxiosError from '../core/AxiosError.js';\nimport utils from '../utils.js';\n\n/**\n * A `CanceledError` is an object that is thrown when an operation is canceled.\n *\n * @param {string=} message The message.\n * @param {Object=} config The config.\n * @param {Object=} request The request.\n *\n * @returns {CanceledError} The created error.\n */\nfunction CanceledError(message, config, request) {\n  // eslint-disable-next-line no-eq-null,eqeqeq\n  AxiosError.call(this, message == null ? 'canceled' : message, AxiosError.ERR_CANCELED, config, request);\n  this.name = 'CanceledError';\n}\n\nutils.inherits(CanceledError, AxiosError, {\n  __CANCEL__: true\n});\n\nexport default CanceledError;\n","'use strict';\n\nimport AxiosError from './AxiosError.js';\n\n/**\n * Resolve or reject a Promise based on response status.\n *\n * @param {Function} resolve A function that resolves the promise.\n * @param {Function} reject A function that rejects the promise.\n * @param {object} response The response.\n *\n * @returns {object} The response.\n */\nexport default function settle(resolve, reject, response) {\n  const validateStatus = response.config.validateStatus;\n  if (!response.status || !validateStatus || validateStatus(response.status)) {\n    resolve(response);\n  } else {\n    reject(new AxiosError(\n      'Request failed with status code ' + response.status,\n      [AxiosError.ERR_BAD_REQUEST, AxiosError.ERR_BAD_RESPONSE][Math.floor(response.status / 100) - 4],\n      response.config,\n      response.request,\n      response\n    ));\n  }\n}\n","'use strict';\n\nimport utils from './../utils.js';\nimport platform from '../platform/index.js';\n\nexport default platform.isStandardBrowserEnv ?\n\n// Standard browser envs support document.cookie\n  (function standardBrowserEnv() {\n    return {\n      write: function write(name, value, expires, path, domain, secure) {\n        const cookie = [];\n        cookie.push(name + '=' + encodeURIComponent(value));\n\n        if (utils.isNumber(expires)) {\n          cookie.push('expires=' + new Date(expires).toGMTString());\n        }\n\n        if (utils.isString(path)) {\n          cookie.push('path=' + path);\n        }\n\n        if (utils.isString(domain)) {\n          cookie.push('domain=' + domain);\n        }\n\n        if (secure === true) {\n          cookie.push('secure');\n        }\n\n        document.cookie = cookie.join('; ');\n      },\n\n      read: function read(name) {\n        const match = document.cookie.match(new RegExp('(^|;\\\\s*)(' + name + ')=([^;]*)'));\n        return (match ? decodeURIComponent(match[3]) : null);\n      },\n\n      remove: function remove(name) {\n        this.write(name, '', Date.now() - 86400000);\n      }\n    };\n  })() :\n\n// Non standard browser env (web workers, react-native) lack needed support.\n  (function nonStandardBrowserEnv() {\n    return {\n      write: function write() {},\n      read: function read() { return null; },\n      remove: function remove() {}\n    };\n  })();\n","'use strict';\n\n/**\n * Determines whether the specified URL is absolute\n *\n * @param {string} url The URL to test\n *\n * @returns {boolean} True if the specified URL is absolute, otherwise false\n */\nexport default function isAbsoluteURL(url) {\n  // A URL is considered absolute if it begins with \"<scheme>://\" or \"//\" (protocol-relative URL).\n  // RFC 3986 defines scheme name as a sequence of characters beginning with a letter and followed\n  // by any combination of letters, digits, plus, period, or hyphen.\n  return /^([a-z][a-z\\d+\\-.]*:)?\\/\\//i.test(url);\n}\n","'use strict';\n\n/**\n * Creates a new URL by combining the specified URLs\n *\n * @param {string} baseURL The base URL\n * @param {string} relativeURL The relative URL\n *\n * @returns {string} The combined URL\n */\nexport default function combineURLs(baseURL, relativeURL) {\n  return relativeURL\n    ? baseURL.replace(/\\/+$/, '') + '/' + relativeURL.replace(/^\\/+/, '')\n    : baseURL;\n}\n","'use strict';\n\nimport isAbsoluteURL from '../helpers/isAbsoluteURL.js';\nimport combineURLs from '../helpers/combineURLs.js';\n\n/**\n * Creates a new URL by combining the baseURL with the requestedURL,\n * only when the requestedURL is not already an absolute URL.\n * If the requestURL is absolute, this function returns the requestedURL untouched.\n *\n * @param {string} baseURL The base URL\n * @param {string} requestedURL Absolute or relative URL to combine\n *\n * @returns {string} The combined full path\n */\nexport default function buildFullPath(baseURL, requestedURL) {\n  if (baseURL && !isAbsoluteURL(requestedURL)) {\n    return combineURLs(baseURL, requestedURL);\n  }\n  return requestedURL;\n}\n","'use strict';\n\nimport utils from './../utils.js';\nimport platform from '../platform/index.js';\n\nexport default platform.isStandardBrowserEnv ?\n\n// Standard browser envs have full support of the APIs needed to test\n// whether the request URL is of the same origin as current location.\n  (function standardBrowserEnv() {\n    const msie = /(msie|trident)/i.test(navigator.userAgent);\n    const urlParsingNode = document.createElement('a');\n    let originURL;\n\n    /**\n    * Parse a URL to discover it's components\n    *\n    * @param {String} url The URL to be parsed\n    * @returns {Object}\n    */\n    function resolveURL(url) {\n      let href = url;\n\n      if (msie) {\n        // IE needs attribute set twice to normalize properties\n        urlParsingNode.setAttribute('href', href);\n        href = urlParsingNode.href;\n      }\n\n      urlParsingNode.setAttribute('href', href);\n\n      // urlParsingNode provides the UrlUtils interface - http://url.spec.whatwg.org/#urlutils\n      return {\n        href: urlParsingNode.href,\n        protocol: urlParsingNode.protocol ? urlParsingNode.protocol.replace(/:$/, '') : '',\n        host: urlParsingNode.host,\n        search: urlParsingNode.search ? urlParsingNode.search.replace(/^\\?/, '') : '',\n        hash: urlParsingNode.hash ? urlParsingNode.hash.replace(/^#/, '') : '',\n        hostname: urlParsingNode.hostname,\n        port: urlParsingNode.port,\n        pathname: (urlParsingNode.pathname.charAt(0) === '/') ?\n          urlParsingNode.pathname :\n          '/' + urlParsingNode.pathname\n      };\n    }\n\n    originURL = resolveURL(window.location.href);\n\n    /**\n    * Determine if a URL shares the same origin as the current location\n    *\n    * @param {String} requestURL The URL to test\n    * @returns {boolean} True if URL shares the same origin, otherwise false\n    */\n    return function isURLSameOrigin(requestURL) {\n      const parsed = (utils.isString(requestURL)) ? resolveURL(requestURL) : requestURL;\n      return (parsed.protocol === originURL.protocol &&\n          parsed.host === originURL.host);\n    };\n  })() :\n\n  // Non standard browser envs (web workers, react-native) lack needed support.\n  (function nonStandardBrowserEnv() {\n    return function isURLSameOrigin() {\n      return true;\n    };\n  })();\n","'use strict';\n\nexport default function parseProtocol(url) {\n  const match = /^([-+\\w]{1,25})(:?\\/\\/|:)/.exec(url);\n  return match && match[1] || '';\n}\n","'use strict';\n\n/**\n * Calculate data maxRate\n * @param {Number} [samplesCount= 10]\n * @param {Number} [min= 1000]\n * @returns {Function}\n */\nfunction speedometer(samplesCount, min) {\n  samplesCount = samplesCount || 10;\n  const bytes = new Array(samplesCount);\n  const timestamps = new Array(samplesCount);\n  let head = 0;\n  let tail = 0;\n  let firstSampleTS;\n\n  min = min !== undefined ? min : 1000;\n\n  return function push(chunkLength) {\n    const now = Date.now();\n\n    const startedAt = timestamps[tail];\n\n    if (!firstSampleTS) {\n      firstSampleTS = now;\n    }\n\n    bytes[head] = chunkLength;\n    timestamps[head] = now;\n\n    let i = tail;\n    let bytesCount = 0;\n\n    while (i !== head) {\n      bytesCount += bytes[i++];\n      i = i % samplesCount;\n    }\n\n    head = (head + 1) % samplesCount;\n\n    if (head === tail) {\n      tail = (tail + 1) % samplesCount;\n    }\n\n    if (now - firstSampleTS < min) {\n      return;\n    }\n\n    const passed = startedAt && now - startedAt;\n\n    return passed ? Math.round(bytesCount * 1000 / passed) : undefined;\n  };\n}\n\nexport default speedometer;\n","'use strict';\n\nimport utils from './../utils.js';\nimport settle from './../core/settle.js';\nimport cookies from './../helpers/cookies.js';\nimport buildURL from './../helpers/buildURL.js';\nimport buildFullPath from '../core/buildFullPath.js';\nimport isURLSameOrigin from './../helpers/isURLSameOrigin.js';\nimport transitionalDefaults from '../defaults/transitional.js';\nimport AxiosError from '../core/AxiosError.js';\nimport CanceledError from '../cancel/CanceledError.js';\nimport parseProtocol from '../helpers/parseProtocol.js';\nimport platform from '../platform/index.js';\nimport AxiosHeaders from '../core/AxiosHeaders.js';\nimport speedometer from '../helpers/speedometer.js';\n\nfunction progressEventReducer(listener, isDownloadStream) {\n  let bytesNotified = 0;\n  const _speedometer = speedometer(50, 250);\n\n  return e => {\n    const loaded = e.loaded;\n    const total = e.lengthComputable ? e.total : undefined;\n    const progressBytes = loaded - bytesNotified;\n    const rate = _speedometer(progressBytes);\n    const inRange = loaded <= total;\n\n    bytesNotified = loaded;\n\n    const data = {\n      loaded,\n      total,\n      progress: total ? (loaded / total) : undefined,\n      bytes: progressBytes,\n      rate: rate ? rate : undefined,\n      estimated: rate && total && inRange ? (total - loaded) / rate : undefined,\n      event: e\n    };\n\n    data[isDownloadStream ? 'download' : 'upload'] = true;\n\n    listener(data);\n  };\n}\n\nconst isXHRAdapterSupported = typeof XMLHttpRequest !== 'undefined';\n\nexport default isXHRAdapterSupported && function (config) {\n  return new Promise(function dispatchXhrRequest(resolve, reject) {\n    let requestData = config.data;\n    const requestHeaders = AxiosHeaders.from(config.headers).normalize();\n    const responseType = config.responseType;\n    let onCanceled;\n    function done() {\n      if (config.cancelToken) {\n        config.cancelToken.unsubscribe(onCanceled);\n      }\n\n      if (config.signal) {\n        config.signal.removeEventListener('abort', onCanceled);\n      }\n    }\n\n    if (utils.isFormData(requestData) && (platform.isStandardBrowserEnv || platform.isStandardBrowserWebWorkerEnv)) {\n      requestHeaders.setContentType(false); // Let the browser set it\n    }\n\n    let request = new XMLHttpRequest();\n\n    // HTTP basic authentication\n    if (config.auth) {\n      const username = config.auth.username || '';\n      const password = config.auth.password ? unescape(encodeURIComponent(config.auth.password)) : '';\n      requestHeaders.set('Authorization', 'Basic ' + btoa(username + ':' + password));\n    }\n\n    const fullPath = buildFullPath(config.baseURL, config.url);\n\n    request.open(config.method.toUpperCase(), buildURL(fullPath, config.params, config.paramsSerializer), true);\n\n    // Set the request timeout in MS\n    request.timeout = config.timeout;\n\n    function onloadend() {\n      if (!request) {\n        return;\n      }\n      // Prepare the response\n      const responseHeaders = AxiosHeaders.from(\n        'getAllResponseHeaders' in request && request.getAllResponseHeaders()\n      );\n      const responseData = !responseType || responseType === 'text' || responseType === 'json' ?\n        request.responseText : request.response;\n      const response = {\n        data: responseData,\n        status: request.status,\n        statusText: request.statusText,\n        headers: responseHeaders,\n        config,\n        request\n      };\n\n      settle(function _resolve(value) {\n        resolve(value);\n        done();\n      }, function _reject(err) {\n        reject(err);\n        done();\n      }, response);\n\n      // Clean up request\n      request = null;\n    }\n\n    if ('onloadend' in request) {\n      // Use onloadend if available\n      request.onloadend = onloadend;\n    } else {\n      // Listen for ready state to emulate onloadend\n      request.onreadystatechange = function handleLoad() {\n        if (!request || request.readyState !== 4) {\n          return;\n        }\n\n        // The request errored out and we didn't get a response, this will be\n        // handled by onerror instead\n        // With one exception: request that using file: protocol, most browsers\n        // will return status as 0 even though it's a successful request\n        if (request.status === 0 && !(request.responseURL && request.responseURL.indexOf('file:') === 0)) {\n          return;\n        }\n        // readystate handler is calling before onerror or ontimeout handlers,\n        // so we should call onloadend on the next 'tick'\n        setTimeout(onloadend);\n      };\n    }\n\n    // Handle browser request cancellation (as opposed to a manual cancellation)\n    request.onabort = function handleAbort() {\n      if (!request) {\n        return;\n      }\n\n      reject(new AxiosError('Request aborted', AxiosError.ECONNABORTED, config, request));\n\n      // Clean up request\n      request = null;\n    };\n\n    // Handle low level network errors\n    request.onerror = function handleError() {\n      // Real errors are hidden from us by the browser\n      // onerror should only fire if it's a network error\n      reject(new AxiosError('Network Error', AxiosError.ERR_NETWORK, config, request));\n\n      // Clean up request\n      request = null;\n    };\n\n    // Handle timeout\n    request.ontimeout = function handleTimeout() {\n      let timeoutErrorMessage = config.timeout ? 'timeout of ' + config.timeout + 'ms exceeded' : 'timeout exceeded';\n      const transitional = config.transitional || transitionalDefaults;\n      if (config.timeoutErrorMessage) {\n        timeoutErrorMessage = config.timeoutErrorMessage;\n      }\n      reject(new AxiosError(\n        timeoutErrorMessage,\n        transitional.clarifyTimeoutError ? AxiosError.ETIMEDOUT : AxiosError.ECONNABORTED,\n        config,\n        request));\n\n      // Clean up request\n      request = null;\n    };\n\n    // Add xsrf header\n    // This is only done if running in a standard browser environment.\n    // Specifically not if we're in a web worker, or react-native.\n    if (platform.isStandardBrowserEnv) {\n      // Add xsrf header\n      const xsrfValue = (config.withCredentials || isURLSameOrigin(fullPath))\n        && config.xsrfCookieName && cookies.read(config.xsrfCookieName);\n\n      if (xsrfValue) {\n        requestHeaders.set(config.xsrfHeaderName, xsrfValue);\n      }\n    }\n\n    // Remove Content-Type if data is undefined\n    requestData === undefined && requestHeaders.setContentType(null);\n\n    // Add headers to the request\n    if ('setRequestHeader' in request) {\n      utils.forEach(requestHeaders.toJSON(), function setRequestHeader(val, key) {\n        request.setRequestHeader(key, val);\n      });\n    }\n\n    // Add withCredentials to request if needed\n    if (!utils.isUndefined(config.withCredentials)) {\n      request.withCredentials = !!config.withCredentials;\n    }\n\n    // Add responseType to request if needed\n    if (responseType && responseType !== 'json') {\n      request.responseType = config.responseType;\n    }\n\n    // Handle progress if needed\n    if (typeof config.onDownloadProgress === 'function') {\n      request.addEventListener('progress', progressEventReducer(config.onDownloadProgress, true));\n    }\n\n    // Not all browsers support upload events\n    if (typeof config.onUploadProgress === 'function' && request.upload) {\n      request.upload.addEventListener('progress', progressEventReducer(config.onUploadProgress));\n    }\n\n    if (config.cancelToken || config.signal) {\n      // Handle cancellation\n      // eslint-disable-next-line func-names\n      onCanceled = cancel => {\n        if (!request) {\n          return;\n        }\n        reject(!cancel || cancel.type ? new CanceledError(null, config, request) : cancel);\n        request.abort();\n        request = null;\n      };\n\n      config.cancelToken && config.cancelToken.subscribe(onCanceled);\n      if (config.signal) {\n        config.signal.aborted ? onCanceled() : config.signal.addEventListener('abort', onCanceled);\n      }\n    }\n\n    const protocol = parseProtocol(fullPath);\n\n    if (protocol && platform.protocols.indexOf(protocol) === -1) {\n      reject(new AxiosError('Unsupported protocol ' + protocol + ':', AxiosError.ERR_BAD_REQUEST, config));\n      return;\n    }\n\n\n    // Send the request\n    request.send(requestData || null);\n  });\n}\n","import utils from '../utils.js';\nimport httpAdapter from './http.js';\nimport xhrAdapter from './xhr.js';\nimport AxiosError from \"../core/AxiosError.js\";\n\nconst knownAdapters = {\n  http: httpAdapter,\n  xhr: xhrAdapter\n}\n\nutils.forEach(knownAdapters, (fn, value) => {\n  if(fn) {\n    try {\n      Object.defineProperty(fn, 'name', {value});\n    } catch (e) {\n      // eslint-disable-next-line no-empty\n    }\n    Object.defineProperty(fn, 'adapterName', {value});\n  }\n});\n\nexport default {\n  getAdapter: (adapters) => {\n    adapters = utils.isArray(adapters) ? adapters : [adapters];\n\n    const {length} = adapters;\n    let nameOrAdapter;\n    let adapter;\n\n    for (let i = 0; i < length; i++) {\n      nameOrAdapter = adapters[i];\n      if((adapter = utils.isString(nameOrAdapter) ? knownAdapters[nameOrAdapter.toLowerCase()] : nameOrAdapter)) {\n        break;\n      }\n    }\n\n    if (!adapter) {\n      if (adapter === false) {\n        throw new AxiosError(\n          `Adapter ${nameOrAdapter} is not supported by the environment`,\n          'ERR_NOT_SUPPORT'\n        );\n      }\n\n      throw new Error(\n        utils.hasOwnProp(knownAdapters, nameOrAdapter) ?\n          `Adapter '${nameOrAdapter}' is not available in the build` :\n          `Unknown adapter '${nameOrAdapter}'`\n      );\n    }\n\n    if (!utils.isFunction(adapter)) {\n      throw new TypeError('adapter is not a function');\n    }\n\n    return adapter;\n  },\n  adapters: knownAdapters\n}\n","'use strict';\n\nimport transformData from './transformData.js';\nimport isCancel from '../cancel/isCancel.js';\nimport defaults from '../defaults/index.js';\nimport CanceledError from '../cancel/CanceledError.js';\nimport AxiosHeaders from '../core/AxiosHeaders.js';\nimport adapters from \"../adapters/adapters.js\";\n\n/**\n * Throws a `CanceledError` if cancellation has been requested.\n *\n * @param {Object} config The config that is to be used for the request\n *\n * @returns {void}\n */\nfunction throwIfCancellationRequested(config) {\n  if (config.cancelToken) {\n    config.cancelToken.throwIfRequested();\n  }\n\n  if (config.signal && config.signal.aborted) {\n    throw new CanceledError(null, config);\n  }\n}\n\n/**\n * Dispatch a request to the server using the configured adapter.\n *\n * @param {object} config The config that is to be used for the request\n *\n * @returns {Promise} The Promise to be fulfilled\n */\nexport default function dispatchRequest(config) {\n  throwIfCancellationRequested(config);\n\n  config.headers = AxiosHeaders.from(config.headers);\n\n  // Transform request data\n  config.data = transformData.call(\n    config,\n    config.transformRequest\n  );\n\n  if (['post', 'put', 'patch'].indexOf(config.method) !== -1) {\n    config.headers.setContentType('application/x-www-form-urlencoded', false);\n  }\n\n  const adapter = adapters.getAdapter(config.adapter || defaults.adapter);\n\n  return adapter(config).then(function onAdapterResolution(response) {\n    throwIfCancellationRequested(config);\n\n    // Transform response data\n    response.data = transformData.call(\n      config,\n      config.transformResponse,\n      response\n    );\n\n    response.headers = AxiosHeaders.from(response.headers);\n\n    return response;\n  }, function onAdapterRejection(reason) {\n    if (!isCancel(reason)) {\n      throwIfCancellationRequested(config);\n\n      // Transform response data\n      if (reason && reason.response) {\n        reason.response.data = transformData.call(\n          config,\n          config.transformResponse,\n          reason.response\n        );\n        reason.response.headers = AxiosHeaders.from(reason.response.headers);\n      }\n    }\n\n    return Promise.reject(reason);\n  });\n}\n","'use strict';\n\nimport utils from '../utils.js';\nimport AxiosHeaders from \"./AxiosHeaders.js\";\n\nconst headersToObject = (thing) => thing instanceof AxiosHeaders ? thing.toJSON() : thing;\n\n/**\n * Config-specific merge-function which creates a new config-object\n * by merging two configuration objects together.\n *\n * @param {Object} config1\n * @param {Object} config2\n *\n * @returns {Object} New object resulting from merging config2 to config1\n */\nexport default function mergeConfig(config1, config2) {\n  // eslint-disable-next-line no-param-reassign\n  config2 = config2 || {};\n  const config = {};\n\n  function getMergedValue(target, source, caseless) {\n    if (utils.isPlainObject(target) && utils.isPlainObject(source)) {\n      return utils.merge.call({caseless}, target, source);\n    } else if (utils.isPlainObject(source)) {\n      return utils.merge({}, source);\n    } else if (utils.isArray(source)) {\n      return source.slice();\n    }\n    return source;\n  }\n\n  // eslint-disable-next-line consistent-return\n  function mergeDeepProperties(a, b, caseless) {\n    if (!utils.isUndefined(b)) {\n      return getMergedValue(a, b, caseless);\n    } else if (!utils.isUndefined(a)) {\n      return getMergedValue(undefined, a, caseless);\n    }\n  }\n\n  // eslint-disable-next-line consistent-return\n  function valueFromConfig2(a, b) {\n    if (!utils.isUndefined(b)) {\n      return getMergedValue(undefined, b);\n    }\n  }\n\n  // eslint-disable-next-line consistent-return\n  function defaultToConfig2(a, b) {\n    if (!utils.isUndefined(b)) {\n      return getMergedValue(undefined, b);\n    } else if (!utils.isUndefined(a)) {\n      return getMergedValue(undefined, a);\n    }\n  }\n\n  // eslint-disable-next-line consistent-return\n  function mergeDirectKeys(a, b, prop) {\n    if (prop in config2) {\n      return getMergedValue(a, b);\n    } else if (prop in config1) {\n      return getMergedValue(undefined, a);\n    }\n  }\n\n  const mergeMap = {\n    url: valueFromConfig2,\n    method: valueFromConfig2,\n    data: valueFromConfig2,\n    baseURL: defaultToConfig2,\n    transformRequest: defaultToConfig2,\n    transformResponse: defaultToConfig2,\n    paramsSerializer: defaultToConfig2,\n    timeout: defaultToConfig2,\n    timeoutMessage: defaultToConfig2,\n    withCredentials: defaultToConfig2,\n    adapter: defaultToConfig2,\n    responseType: defaultToConfig2,\n    xsrfCookieName: defaultToConfig2,\n    xsrfHeaderName: defaultToConfig2,\n    onUploadProgress: defaultToConfig2,\n    onDownloadProgress: defaultToConfig2,\n    decompress: defaultToConfig2,\n    maxContentLength: defaultToConfig2,\n    maxBodyLength: defaultToConfig2,\n    beforeRedirect: defaultToConfig2,\n    transport: defaultToConfig2,\n    httpAgent: defaultToConfig2,\n    httpsAgent: defaultToConfig2,\n    cancelToken: defaultToConfig2,\n    socketPath: defaultToConfig2,\n    responseEncoding: defaultToConfig2,\n    validateStatus: mergeDirectKeys,\n    headers: (a, b) => mergeDeepProperties(headersToObject(a), headersToObject(b), true)\n  };\n\n  utils.forEach(Object.keys(config1).concat(Object.keys(config2)), function computeConfigValue(prop) {\n    const merge = mergeMap[prop] || mergeDeepProperties;\n    const configValue = merge(config1[prop], config2[prop], prop);\n    (utils.isUndefined(configValue) && merge !== mergeDirectKeys) || (config[prop] = configValue);\n  });\n\n  return config;\n}\n","export const VERSION = \"1.3.4\";","'use strict';\n\nimport {VERSION} from '../env/data.js';\nimport AxiosError from '../core/AxiosError.js';\n\nconst validators = {};\n\n// eslint-disable-next-line func-names\n['object', 'boolean', 'number', 'function', 'string', 'symbol'].forEach((type, i) => {\n  validators[type] = function validator(thing) {\n    return typeof thing === type || 'a' + (i < 1 ? 'n ' : ' ') + type;\n  };\n});\n\nconst deprecatedWarnings = {};\n\n/**\n * Transitional option validator\n *\n * @param {function|boolean?} validator - set to false if the transitional option has been removed\n * @param {string?} version - deprecated version / removed since version\n * @param {string?} message - some message with additional info\n *\n * @returns {function}\n */\nvalidators.transitional = function transitional(validator, version, message) {\n  function formatMessage(opt, desc) {\n    return '[Axios v' + VERSION + '] Transitional option \\'' + opt + '\\'' + desc + (message ? '. ' + message : '');\n  }\n\n  // eslint-disable-next-line func-names\n  return (value, opt, opts) => {\n    if (validator === false) {\n      throw new AxiosError(\n        formatMessage(opt, ' has been removed' + (version ? ' in ' + version : '')),\n        AxiosError.ERR_DEPRECATED\n      );\n    }\n\n    if (version && !deprecatedWarnings[opt]) {\n      deprecatedWarnings[opt] = true;\n      // eslint-disable-next-line no-console\n      console.warn(\n        formatMessage(\n          opt,\n          ' has been deprecated since v' + version + ' and will be removed in the near future'\n        )\n      );\n    }\n\n    return validator ? validator(value, opt, opts) : true;\n  };\n};\n\n/**\n * Assert object's properties type\n *\n * @param {object} options\n * @param {object} schema\n * @param {boolean?} allowUnknown\n *\n * @returns {object}\n */\n\nfunction assertOptions(options, schema, allowUnknown) {\n  if (typeof options !== 'object') {\n    throw new AxiosError('options must be an object', AxiosError.ERR_BAD_OPTION_VALUE);\n  }\n  const keys = Object.keys(options);\n  let i = keys.length;\n  while (i-- > 0) {\n    const opt = keys[i];\n    const validator = schema[opt];\n    if (validator) {\n      const value = options[opt];\n      const result = value === undefined || validator(value, opt, options);\n      if (result !== true) {\n        throw new AxiosError('option ' + opt + ' must be ' + result, AxiosError.ERR_BAD_OPTION_VALUE);\n      }\n      continue;\n    }\n    if (allowUnknown !== true) {\n      throw new AxiosError('Unknown option ' + opt, AxiosError.ERR_BAD_OPTION);\n    }\n  }\n}\n\nexport default {\n  assertOptions,\n  validators\n};\n","'use strict';\n\nimport utils from './../utils.js';\nimport buildURL from '../helpers/buildURL.js';\nimport InterceptorManager from './InterceptorManager.js';\nimport dispatchRequest from './dispatchRequest.js';\nimport mergeConfig from './mergeConfig.js';\nimport buildFullPath from './buildFullPath.js';\nimport validator from '../helpers/validator.js';\nimport AxiosHeaders from './AxiosHeaders.js';\n\nconst validators = validator.validators;\n\n/**\n * Create a new instance of Axios\n *\n * @param {Object} instanceConfig The default config for the instance\n *\n * @return {Axios} A new instance of Axios\n */\nclass Axios {\n  constructor(instanceConfig) {\n    this.defaults = instanceConfig;\n    this.interceptors = {\n      request: new InterceptorManager(),\n      response: new InterceptorManager()\n    };\n  }\n\n  /**\n   * Dispatch a request\n   *\n   * @param {String|Object} configOrUrl The config specific for this request (merged with this.defaults)\n   * @param {?Object} config\n   *\n   * @returns {Promise} The Promise to be fulfilled\n   */\n  request(configOrUrl, config) {\n    /*eslint no-param-reassign:0*/\n    // Allow for axios('example/url'[, config]) a la fetch API\n    if (typeof configOrUrl === 'string') {\n      config = config || {};\n      config.url = configOrUrl;\n    } else {\n      config = configOrUrl || {};\n    }\n\n    config = mergeConfig(this.defaults, config);\n\n    const {transitional, paramsSerializer, headers} = config;\n\n    if (transitional !== undefined) {\n      validator.assertOptions(transitional, {\n        silentJSONParsing: validators.transitional(validators.boolean),\n        forcedJSONParsing: validators.transitional(validators.boolean),\n        clarifyTimeoutError: validators.transitional(validators.boolean)\n      }, false);\n    }\n\n    if (paramsSerializer !== undefined) {\n      validator.assertOptions(paramsSerializer, {\n        encode: validators.function,\n        serialize: validators.function\n      }, true);\n    }\n\n    // Set config.method\n    config.method = (config.method || this.defaults.method || 'get').toLowerCase();\n\n    let contextHeaders;\n\n    // Flatten headers\n    contextHeaders = headers && utils.merge(\n      headers.common,\n      headers[config.method]\n    );\n\n    contextHeaders && utils.forEach(\n      ['delete', 'get', 'head', 'post', 'put', 'patch', 'common'],\n      (method) => {\n        delete headers[method];\n      }\n    );\n\n    config.headers = AxiosHeaders.concat(contextHeaders, headers);\n\n    // filter out skipped interceptors\n    const requestInterceptorChain = [];\n    let synchronousRequestInterceptors = true;\n    this.interceptors.request.forEach(function unshiftRequestInterceptors(interceptor) {\n      if (typeof interceptor.runWhen === 'function' && interceptor.runWhen(config) === false) {\n        return;\n      }\n\n      synchronousRequestInterceptors = synchronousRequestInterceptors && interceptor.synchronous;\n\n      requestInterceptorChain.unshift(interceptor.fulfilled, interceptor.rejected);\n    });\n\n    const responseInterceptorChain = [];\n    this.interceptors.response.forEach(function pushResponseInterceptors(interceptor) {\n      responseInterceptorChain.push(interceptor.fulfilled, interceptor.rejected);\n    });\n\n    let promise;\n    let i = 0;\n    let len;\n\n    if (!synchronousRequestInterceptors) {\n      const chain = [dispatchRequest.bind(this), undefined];\n      chain.unshift.apply(chain, requestInterceptorChain);\n      chain.push.apply(chain, responseInterceptorChain);\n      len = chain.length;\n\n      promise = Promise.resolve(config);\n\n      while (i < len) {\n        promise = promise.then(chain[i++], chain[i++]);\n      }\n\n      return promise;\n    }\n\n    len = requestInterceptorChain.length;\n\n    let newConfig = config;\n\n    i = 0;\n\n    while (i < len) {\n      const onFulfilled = requestInterceptorChain[i++];\n      const onRejected = requestInterceptorChain[i++];\n      try {\n        newConfig = onFulfilled(newConfig);\n      } catch (error) {\n        onRejected.call(this, error);\n        break;\n      }\n    }\n\n    try {\n      promise = dispatchRequest.call(this, newConfig);\n    } catch (error) {\n      return Promise.reject(error);\n    }\n\n    i = 0;\n    len = responseInterceptorChain.length;\n\n    while (i < len) {\n      promise = promise.then(responseInterceptorChain[i++], responseInterceptorChain[i++]);\n    }\n\n    return promise;\n  }\n\n  getUri(config) {\n    config = mergeConfig(this.defaults, config);\n    const fullPath = buildFullPath(config.baseURL, config.url);\n    return buildURL(fullPath, config.params, config.paramsSerializer);\n  }\n}\n\n// Provide aliases for supported request methods\nutils.forEach(['delete', 'get', 'head', 'options'], function forEachMethodNoData(method) {\n  /*eslint func-names:0*/\n  Axios.prototype[method] = function(url, config) {\n    return this.request(mergeConfig(config || {}, {\n      method,\n      url,\n      data: (config || {}).data\n    }));\n  };\n});\n\nutils.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) {\n  /*eslint func-names:0*/\n\n  function generateHTTPMethod(isForm) {\n    return function httpMethod(url, data, config) {\n      return this.request(mergeConfig(config || {}, {\n        method,\n        headers: isForm ? {\n          'Content-Type': 'multipart/form-data'\n        } : {},\n        url,\n        data\n      }));\n    };\n  }\n\n  Axios.prototype[method] = generateHTTPMethod();\n\n  Axios.prototype[method + 'Form'] = generateHTTPMethod(true);\n});\n\nexport default Axios;\n","'use strict';\n\nimport CanceledError from './CanceledError.js';\n\n/**\n * A `CancelToken` is an object that can be used to request cancellation of an operation.\n *\n * @param {Function} executor The executor function.\n *\n * @returns {CancelToken}\n */\nclass CancelToken {\n  constructor(executor) {\n    if (typeof executor !== 'function') {\n      throw new TypeError('executor must be a function.');\n    }\n\n    let resolvePromise;\n\n    this.promise = new Promise(function promiseExecutor(resolve) {\n      resolvePromise = resolve;\n    });\n\n    const token = this;\n\n    // eslint-disable-next-line func-names\n    this.promise.then(cancel => {\n      if (!token._listeners) return;\n\n      let i = token._listeners.length;\n\n      while (i-- > 0) {\n        token._listeners[i](cancel);\n      }\n      token._listeners = null;\n    });\n\n    // eslint-disable-next-line func-names\n    this.promise.then = onfulfilled => {\n      let _resolve;\n      // eslint-disable-next-line func-names\n      const promise = new Promise(resolve => {\n        token.subscribe(resolve);\n        _resolve = resolve;\n      }).then(onfulfilled);\n\n      promise.cancel = function reject() {\n        token.unsubscribe(_resolve);\n      };\n\n      return promise;\n    };\n\n    executor(function cancel(message, config, request) {\n      if (token.reason) {\n        // Cancellation has already been requested\n        return;\n      }\n\n      token.reason = new CanceledError(message, config, request);\n      resolvePromise(token.reason);\n    });\n  }\n\n  /**\n   * Throws a `CanceledError` if cancellation has been requested.\n   */\n  throwIfRequested() {\n    if (this.reason) {\n      throw this.reason;\n    }\n  }\n\n  /**\n   * Subscribe to the cancel signal\n   */\n\n  subscribe(listener) {\n    if (this.reason) {\n      listener(this.reason);\n      return;\n    }\n\n    if (this._listeners) {\n      this._listeners.push(listener);\n    } else {\n      this._listeners = [listener];\n    }\n  }\n\n  /**\n   * Unsubscribe from the cancel signal\n   */\n\n  unsubscribe(listener) {\n    if (!this._listeners) {\n      return;\n    }\n    const index = this._listeners.indexOf(listener);\n    if (index !== -1) {\n      this._listeners.splice(index, 1);\n    }\n  }\n\n  /**\n   * Returns an object that contains a new `CancelToken` and a function that, when called,\n   * cancels the `CancelToken`.\n   */\n  static source() {\n    let cancel;\n    const token = new CancelToken(function executor(c) {\n      cancel = c;\n    });\n    return {\n      token,\n      cancel\n    };\n  }\n}\n\nexport default CancelToken;\n","'use strict';\n\n/**\n * Syntactic sugar for invoking a function and expanding an array for arguments.\n *\n * Common use case would be to use `Function.prototype.apply`.\n *\n *  ```js\n *  function f(x, y, z) {}\n *  var args = [1, 2, 3];\n *  f.apply(null, args);\n *  ```\n *\n * With `spread` this example can be re-written.\n *\n *  ```js\n *  spread(function(x, y, z) {})([1, 2, 3]);\n *  ```\n *\n * @param {Function} callback\n *\n * @returns {Function}\n */\nexport default function spread(callback) {\n  return function wrap(arr) {\n    return callback.apply(null, arr);\n  };\n}\n","'use strict';\n\nimport utils from './../utils.js';\n\n/**\n * Determines whether the payload is an error thrown by Axios\n *\n * @param {*} payload The value to test\n *\n * @returns {boolean} True if the payload is an error thrown by Axios, otherwise false\n */\nexport default function isAxiosError(payload) {\n  return utils.isObject(payload) && (payload.isAxiosError === true);\n}\n","const HttpStatusCode = {\n  Continue: 100,\n  SwitchingProtocols: 101,\n  Processing: 102,\n  EarlyHints: 103,\n  Ok: 200,\n  Created: 201,\n  Accepted: 202,\n  NonAuthoritativeInformation: 203,\n  NoContent: 204,\n  ResetContent: 205,\n  PartialContent: 206,\n  MultiStatus: 207,\n  AlreadyReported: 208,\n  ImUsed: 226,\n  MultipleChoices: 300,\n  MovedPermanently: 301,\n  Found: 302,\n  SeeOther: 303,\n  NotModified: 304,\n  UseProxy: 305,\n  Unused: 306,\n  TemporaryRedirect: 307,\n  PermanentRedirect: 308,\n  BadRequest: 400,\n  Unauthorized: 401,\n  PaymentRequired: 402,\n  Forbidden: 403,\n  NotFound: 404,\n  MethodNotAllowed: 405,\n  NotAcceptable: 406,\n  ProxyAuthenticationRequired: 407,\n  RequestTimeout: 408,\n  Conflict: 409,\n  Gone: 410,\n  LengthRequired: 411,\n  PreconditionFailed: 412,\n  PayloadTooLarge: 413,\n  UriTooLong: 414,\n  UnsupportedMediaType: 415,\n  RangeNotSatisfiable: 416,\n  ExpectationFailed: 417,\n  ImATeapot: 418,\n  MisdirectedRequest: 421,\n  UnprocessableEntity: 422,\n  Locked: 423,\n  FailedDependency: 424,\n  TooEarly: 425,\n  UpgradeRequired: 426,\n  PreconditionRequired: 428,\n  TooManyRequests: 429,\n  RequestHeaderFieldsTooLarge: 431,\n  UnavailableForLegalReasons: 451,\n  InternalServerError: 500,\n  NotImplemented: 501,\n  BadGateway: 502,\n  ServiceUnavailable: 503,\n  GatewayTimeout: 504,\n  HttpVersionNotSupported: 505,\n  VariantAlsoNegotiates: 506,\n  InsufficientStorage: 507,\n  LoopDetected: 508,\n  NotExtended: 510,\n  NetworkAuthenticationRequired: 511,\n};\n\nObject.entries(HttpStatusCode).forEach(([key, value]) => {\n  HttpStatusCode[value] = key;\n});\n\nexport default HttpStatusCode;\n","'use strict';\n\nimport utils from './utils.js';\nimport bind from './helpers/bind.js';\nimport Axios from './core/Axios.js';\nimport mergeConfig from './core/mergeConfig.js';\nimport defaults from './defaults/index.js';\nimport formDataToJSON from './helpers/formDataToJSON.js';\nimport CanceledError from './cancel/CanceledError.js';\nimport CancelToken from './cancel/CancelToken.js';\nimport isCancel from './cancel/isCancel.js';\nimport {VERSION} from './env/data.js';\nimport toFormData from './helpers/toFormData.js';\nimport AxiosError from './core/AxiosError.js';\nimport spread from './helpers/spread.js';\nimport isAxiosError from './helpers/isAxiosError.js';\nimport AxiosHeaders from \"./core/AxiosHeaders.js\";\nimport HttpStatusCode from './helpers/HttpStatusCode.js';\n\n/**\n * Create an instance of Axios\n *\n * @param {Object} defaultConfig The default config for the instance\n *\n * @returns {Axios} A new instance of Axios\n */\nfunction createInstance(defaultConfig) {\n  const context = new Axios(defaultConfig);\n  const instance = bind(Axios.prototype.request, context);\n\n  // Copy axios.prototype to instance\n  utils.extend(instance, Axios.prototype, context, {allOwnKeys: true});\n\n  // Copy context to instance\n  utils.extend(instance, context, null, {allOwnKeys: true});\n\n  // Factory for creating new instances\n  instance.create = function create(instanceConfig) {\n    return createInstance(mergeConfig(defaultConfig, instanceConfig));\n  };\n\n  return instance;\n}\n\n// Create the default instance to be exported\nconst axios = createInstance(defaults);\n\n// Expose Axios class to allow class inheritance\naxios.Axios = Axios;\n\n// Expose Cancel & CancelToken\naxios.CanceledError = CanceledError;\naxios.CancelToken = CancelToken;\naxios.isCancel = isCancel;\naxios.VERSION = VERSION;\naxios.toFormData = toFormData;\n\n// Expose AxiosError class\naxios.AxiosError = AxiosError;\n\n// alias for CanceledError for backward compatibility\naxios.Cancel = axios.CanceledError;\n\n// Expose all/spread\naxios.all = function all(promises) {\n  return Promise.all(promises);\n};\n\naxios.spread = spread;\n\n// Expose isAxiosError\naxios.isAxiosError = isAxiosError;\n\n// Expose mergeConfig\naxios.mergeConfig = mergeConfig;\n\naxios.AxiosHeaders = AxiosHeaders;\n\naxios.formToJSON = thing => formDataToJSON(utils.isHTMLForm(thing) ? new FormData(thing) : thing);\n\naxios.HttpStatusCode = HttpStatusCode;\n\naxios.default = axios;\n\n// this module should only have a default export\nexport default axios\n","import { Notification } from '../internal/classes/notification';\nimport LoggerFactory, { LogLevelEnum } from 'zhi-log';\nimport { FileClient } from '../api/file-api';\n\nimport zh_CN from '../i18n/zh_CN.json';\nimport en_US from '../i18n/en_US.json';\nimport axios from 'axios';\n\nconst factory = LoggerFactory.customLogFactory(LogLevelEnum.LOG_LEVEL_INFO, 'PluginSystem');\nconst pluginSystemLogger = factory.getLogger('plugin system');\n\nexport const log = (...p) => {\n    pluginSystemLogger.info(...p);\n};\n\nexport const request = axios.create({\n    withCredentials: false,\n    headers: {\n        'Cache-Control': 'no-cache',\n        Pragma: 'no-cache',\n        Expires: '0',\n    },\n});\n\nexport const sleep = async (t: number) => {\n    return new Promise((resolve) => {\n        setTimeout(() => resolve(null), t);\n    });\n};\n\nexport const error = (...p) => pluginSystemLogger.error(...p);\n\nexport const reloadWindow = () => window.location.reload();\n\nexport const getCrossPlatformAppDataFolder = () => {\n    const PROCESS_ENV = window.process?.env;\n    let configFilePath;\n    if (process.platform === 'darwin') {\n        configFilePath = `${PROCESS_ENV.HOME}/Library/Application Support`;\n    } else if (process.platform === 'win32') {\n        // Roaming包含在APPDATA中了\n        configFilePath = PROCESS_ENV.APPDATA;\n    } else if (process.platform === 'linux') {\n        configFilePath = PROCESS_ENV.HOME;\n    }\n    return configFilePath;\n};\n\n/**\n * genUUID  genernate UUID, copy from siyuan\n * @returns\n */\nexport const genUUID = () =>\n    ([1e7].toString() + -1e3 + -4e3 + -8e3 + -1e11).replace(/[018]/g, (c) =>\n        (parseInt(c, 10) ^ (window.crypto.getRandomValues(new Uint32Array(1))[0] & (15 >> (parseInt(c, 10) / 4)))).toString(16)\n    );\n\nexport function isDir(p: string) {\n    throw new Error('can not get dir by path:' + p);\n}\n\nexport async function isExists(p: string) {\n    try {\n        const res = await FileClient.getInstanceApi().fileApi.getFile(p);\n        return res !== null;\n    } catch {\n        return false;\n    }\n}\n\nexport class Info {\n    constructor(private message: string) {}\n}\nexport class Error {\n    constructor(private message: string) {}\n}\nexport class Warning {\n    constructor(private message: string) {}\n}\n\nexport const showInfoMessage = (message: string, timeout?: number) => new Notification({ type: 'info', message, timeout }).show();\nexport const showErrorMessage = (message: string, timeout?: number) => new Notification({ type: 'error', message, timeout }).show();\n\nexport const getLogger = (name: string) => factory.getLogger(name);\n\nconst langs = {\n    zh_CN,\n    en_US,\n};\n\nexport const _ = (v: string): string => {\n    return langs[window.siyuan.config.lang][v] || 'not defined';\n};\n","export var NAMED_TAG = \"named\";\nexport var NAME_TAG = \"name\";\nexport var UNMANAGED_TAG = \"unmanaged\";\nexport var OPTIONAL_TAG = \"optional\";\nexport var INJECT_TAG = \"inject\";\nexport var MULTI_INJECT_TAG = \"multi_inject\";\nexport var TAGGED = \"inversify:tagged\";\nexport var TAGGED_PROP = \"inversify:tagged_props\";\nexport var PARAM_TYPES = \"inversify:paramtypes\";\nexport var DESIGN_PARAM_TYPES = \"design:paramtypes\";\nexport var POST_CONSTRUCT = \"post_construct\";\nexport var PRE_DESTROY = \"pre_destroy\";\nfunction getNonCustomTagKeys() {\n    return [\n        INJECT_TAG,\n        MULTI_INJECT_TAG,\n        NAME_TAG,\n        UNMANAGED_TAG,\n        NAMED_TAG,\n        OPTIONAL_TAG,\n    ];\n}\nexport var NON_CUSTOM_TAG_KEYS = getNonCustomTagKeys();\n//# sourceMappingURL=metadata_keys.js.map","var BindingScopeEnum = {\n    Request: \"Request\",\n    Singleton: \"Singleton\",\n    Transient: \"Transient\"\n};\nvar BindingTypeEnum = {\n    ConstantValue: \"ConstantValue\",\n    Constructor: \"Constructor\",\n    DynamicValue: \"DynamicValue\",\n    Factory: \"Factory\",\n    Function: \"Function\",\n    Instance: \"Instance\",\n    Invalid: \"Invalid\",\n    Provider: \"Provider\"\n};\nvar TargetTypeEnum = {\n    ClassProperty: \"ClassProperty\",\n    ConstructorArgument: \"ConstructorArgument\",\n    Variable: \"Variable\"\n};\nexport { BindingScopeEnum, BindingTypeEnum, TargetTypeEnum };\n//# sourceMappingURL=literal_types.js.map","var idCounter = 0;\nfunction id() {\n    return idCounter++;\n}\nexport { id };\n//# sourceMappingURL=id.js.map","import { BindingScopeEnum, BindingTypeEnum } from \"../constants/literal_types\";\nimport { id } from \"../utils/id\";\nvar Binding = (function () {\n    function Binding(serviceIdentifier, scope) {\n        this.id = id();\n        this.activated = false;\n        this.serviceIdentifier = serviceIdentifier;\n        this.scope = scope;\n        this.type = BindingTypeEnum.Invalid;\n        this.constraint = function (request) { return true; };\n        this.implementationType = null;\n        this.cache = null;\n        this.factory = null;\n        this.provider = null;\n        this.onActivation = null;\n        this.onDeactivation = null;\n        this.dynamicValue = null;\n    }\n    Binding.prototype.clone = function () {\n        var clone = new Binding(this.serviceIdentifier, this.scope);\n        clone.activated = (clone.scope === BindingScopeEnum.Singleton) ? this.activated : false;\n        clone.implementationType = this.implementationType;\n        clone.dynamicValue = this.dynamicValue;\n        clone.scope = this.scope;\n        clone.type = this.type;\n        clone.factory = this.factory;\n        clone.provider = this.provider;\n        clone.constraint = this.constraint;\n        clone.onActivation = this.onActivation;\n        clone.onDeactivation = this.onDeactivation;\n        clone.cache = this.cache;\n        return clone;\n    };\n    return Binding;\n}());\nexport { Binding };\n//# sourceMappingURL=binding.js.map","export var DUPLICATED_INJECTABLE_DECORATOR = \"Cannot apply @injectable decorator multiple times.\";\nexport var DUPLICATED_METADATA = \"Metadata key was used more than once in a parameter:\";\nexport var NULL_ARGUMENT = \"NULL argument\";\nexport var KEY_NOT_FOUND = \"Key Not Found\";\nexport var AMBIGUOUS_MATCH = \"Ambiguous match found for serviceIdentifier:\";\nexport var CANNOT_UNBIND = \"Could not unbind serviceIdentifier:\";\nexport var NOT_REGISTERED = \"No matching bindings found for serviceIdentifier:\";\nexport var MISSING_INJECTABLE_ANNOTATION = \"Missing required @injectable annotation in:\";\nexport var MISSING_INJECT_ANNOTATION = \"Missing required @inject or @multiInject annotation in:\";\nexport var UNDEFINED_INJECT_ANNOTATION = function (name) {\n    return \"@inject called with undefined this could mean that the class \" + name + \" has \" +\n        \"a circular dependency problem. You can use a LazyServiceIdentifer to  \" +\n        \"overcome this limitation.\";\n};\nexport var CIRCULAR_DEPENDENCY = \"Circular dependency found:\";\nexport var NOT_IMPLEMENTED = \"Sorry, this feature is not fully implemented yet.\";\nexport var INVALID_BINDING_TYPE = \"Invalid binding type:\";\nexport var NO_MORE_SNAPSHOTS_AVAILABLE = \"No snapshot available to restore.\";\nexport var INVALID_MIDDLEWARE_RETURN = \"Invalid return type in middleware. Middleware must return!\";\nexport var INVALID_FUNCTION_BINDING = \"Value provided to function binding must be a function!\";\nexport var LAZY_IN_SYNC = function (key) { return \"You are attempting to construct '\" + key + \"' in a synchronous way\\n but it has asynchronous dependencies.\"; };\nexport var INVALID_TO_SELF_VALUE = \"The toSelf function can only be applied when a constructor is \" +\n    \"used as service identifier\";\nexport var INVALID_DECORATOR_OPERATION = \"The @inject @multiInject @tagged and @named decorators \" +\n    \"must be applied to the parameters of a class constructor or a class property.\";\nexport var ARGUMENTS_LENGTH_MISMATCH = function () {\n    var values = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        values[_i] = arguments[_i];\n    }\n    return \"The number of constructor arguments in the derived class \" +\n        (values[0] + \" must be >= than the number of constructor arguments of its base class.\");\n};\nexport var CONTAINER_OPTIONS_MUST_BE_AN_OBJECT = \"Invalid Container constructor argument. Container options \" +\n    \"must be an object.\";\nexport var CONTAINER_OPTIONS_INVALID_DEFAULT_SCOPE = \"Invalid Container option. Default scope must \" +\n    \"be a string ('singleton' or 'transient').\";\nexport var CONTAINER_OPTIONS_INVALID_AUTO_BIND_INJECTABLE = \"Invalid Container option. Auto bind injectable must \" +\n    \"be a boolean\";\nexport var CONTAINER_OPTIONS_INVALID_SKIP_BASE_CHECK = \"Invalid Container option. Skip base check must \" +\n    \"be a boolean\";\nexport var MULTIPLE_PRE_DESTROY_METHODS = \"Cannot apply @preDestroy decorator multiple times in the same class\";\nexport var MULTIPLE_POST_CONSTRUCT_METHODS = \"Cannot apply @postConstruct decorator multiple times in the same class\";\nexport var ASYNC_UNBIND_REQUIRED = \"Attempting to unbind dependency with asynchronous destruction (@preDestroy or onDeactivation)\";\nexport var POST_CONSTRUCT_ERROR = function (clazz, errorMessage) { return \"@postConstruct error in class \" + clazz + \": \" + errorMessage; };\nexport var PRE_DESTROY_ERROR = function (clazz, errorMessage) { return \"@preDestroy error in class \" + clazz + \": \" + errorMessage; };\nexport var ON_DEACTIVATION_ERROR = function (clazz, errorMessage) { return \"onDeactivation() error in class \" + clazz + \": \" + errorMessage; };\nexport var CIRCULAR_DEPENDENCY_IN_FACTORY = function (factoryType, serviceIdentifier) {\n    return \"It looks like there is a circular dependency in one of the '\" + factoryType + \"' bindings. Please investigate bindings with\" +\n        (\"service identifier '\" + serviceIdentifier + \"'.\");\n};\nexport var STACK_OVERFLOW = \"Maximum call stack size exceeded\";\n//# sourceMappingURL=error_msgs.js.map","import * as METADATA_KEY from \"../constants/metadata_keys\";\nvar MetadataReader = (function () {\n    function MetadataReader() {\n    }\n    MetadataReader.prototype.getConstructorMetadata = function (constructorFunc) {\n        var compilerGeneratedMetadata = Reflect.getMetadata(METADATA_KEY.PARAM_TYPES, constructorFunc);\n        var userGeneratedMetadata = Reflect.getMetadata(METADATA_KEY.TAGGED, constructorFunc);\n        return {\n            compilerGeneratedMetadata: compilerGeneratedMetadata,\n            userGeneratedMetadata: userGeneratedMetadata || {}\n        };\n    };\n    MetadataReader.prototype.getPropertiesMetadata = function (constructorFunc) {\n        var userGeneratedMetadata = Reflect.getMetadata(METADATA_KEY.TAGGED_PROP, constructorFunc) || [];\n        return userGeneratedMetadata;\n    };\n    return MetadataReader;\n}());\nexport { MetadataReader };\n//# sourceMappingURL=metadata_reader.js.map","var BindingCount = {\n    MultipleBindingsAvailable: 2,\n    NoBindingsAvailable: 0,\n    OnlyOneBindingAvailable: 1\n};\nexport { BindingCount };\n//# sourceMappingURL=binding_count.js.map","import * as ERROR_MSGS from \"../constants/error_msgs\";\nexport function isStackOverflowExeption(error) {\n    return (error instanceof RangeError ||\n        error.message === ERROR_MSGS.STACK_OVERFLOW);\n}\nexport var tryAndThrowErrorIfStackOverflow = function (fn, errorCallback) {\n    try {\n        return fn();\n    }\n    catch (error) {\n        if (isStackOverflowExeption(error)) {\n            error = errorCallback();\n        }\n        throw error;\n    }\n};\n//# sourceMappingURL=exceptions.js.map","import * as ERROR_MSGS from \"../constants/error_msgs\";\nfunction getServiceIdentifierAsString(serviceIdentifier) {\n    if (typeof serviceIdentifier === \"function\") {\n        var _serviceIdentifier = serviceIdentifier;\n        return _serviceIdentifier.name;\n    }\n    else if (typeof serviceIdentifier === \"symbol\") {\n        return serviceIdentifier.toString();\n    }\n    else {\n        var _serviceIdentifier = serviceIdentifier;\n        return _serviceIdentifier;\n    }\n}\nfunction listRegisteredBindingsForServiceIdentifier(container, serviceIdentifier, getBindings) {\n    var registeredBindingsList = \"\";\n    var registeredBindings = getBindings(container, serviceIdentifier);\n    if (registeredBindings.length !== 0) {\n        registeredBindingsList = \"\\nRegistered bindings:\";\n        registeredBindings.forEach(function (binding) {\n            var name = \"Object\";\n            if (binding.implementationType !== null) {\n                name = getFunctionName(binding.implementationType);\n            }\n            registeredBindingsList = registeredBindingsList + \"\\n \" + name;\n            if (binding.constraint.metaData) {\n                registeredBindingsList = registeredBindingsList + \" - \" + binding.constraint.metaData;\n            }\n        });\n    }\n    return registeredBindingsList;\n}\nfunction alreadyDependencyChain(request, serviceIdentifier) {\n    if (request.parentRequest === null) {\n        return false;\n    }\n    else if (request.parentRequest.serviceIdentifier === serviceIdentifier) {\n        return true;\n    }\n    else {\n        return alreadyDependencyChain(request.parentRequest, serviceIdentifier);\n    }\n}\nfunction dependencyChainToString(request) {\n    function _createStringArr(req, result) {\n        if (result === void 0) { result = []; }\n        var serviceIdentifier = getServiceIdentifierAsString(req.serviceIdentifier);\n        result.push(serviceIdentifier);\n        if (req.parentRequest !== null) {\n            return _createStringArr(req.parentRequest, result);\n        }\n        return result;\n    }\n    var stringArr = _createStringArr(request);\n    return stringArr.reverse().join(\" --> \");\n}\nfunction circularDependencyToException(request) {\n    request.childRequests.forEach(function (childRequest) {\n        if (alreadyDependencyChain(childRequest, childRequest.serviceIdentifier)) {\n            var services = dependencyChainToString(childRequest);\n            throw new Error(ERROR_MSGS.CIRCULAR_DEPENDENCY + \" \" + services);\n        }\n        else {\n            circularDependencyToException(childRequest);\n        }\n    });\n}\nfunction listMetadataForTarget(serviceIdentifierString, target) {\n    if (target.isTagged() || target.isNamed()) {\n        var m_1 = \"\";\n        var namedTag = target.getNamedTag();\n        var otherTags = target.getCustomTags();\n        if (namedTag !== null) {\n            m_1 += namedTag.toString() + \"\\n\";\n        }\n        if (otherTags !== null) {\n            otherTags.forEach(function (tag) {\n                m_1 += tag.toString() + \"\\n\";\n            });\n        }\n        return \" \" + serviceIdentifierString + \"\\n \" + serviceIdentifierString + \" - \" + m_1;\n    }\n    else {\n        return \" \" + serviceIdentifierString;\n    }\n}\nfunction getFunctionName(func) {\n    if (func.name) {\n        return func.name;\n    }\n    else {\n        var name_1 = func.toString();\n        var match = name_1.match(/^function\\s*([^\\s(]+)/);\n        return match ? match[1] : \"Anonymous function: \" + name_1;\n    }\n}\nfunction getSymbolDescription(symbol) {\n    return symbol.toString().slice(7, -1);\n}\nexport { getFunctionName, getServiceIdentifierAsString, listRegisteredBindingsForServiceIdentifier, listMetadataForTarget, circularDependencyToException, getSymbolDescription };\n//# sourceMappingURL=serialization.js.map","import { id } from \"../utils/id\";\nvar Context = (function () {\n    function Context(container) {\n        this.id = id();\n        this.container = container;\n    }\n    Context.prototype.addPlan = function (plan) {\n        this.plan = plan;\n    };\n    Context.prototype.setCurrentRequest = function (currentRequest) {\n        this.currentRequest = currentRequest;\n    };\n    return Context;\n}());\nexport { Context };\n//# sourceMappingURL=context.js.map","import * as METADATA_KEY from \"../constants/metadata_keys\";\nvar Metadata = (function () {\n    function Metadata(key, value) {\n        this.key = key;\n        this.value = value;\n    }\n    Metadata.prototype.toString = function () {\n        if (this.key === METADATA_KEY.NAMED_TAG) {\n            return \"named: \" + String(this.value).toString() + \" \";\n        }\n        else {\n            return \"tagged: { key:\" + this.key.toString() + \", value: \" + String(this.value) + \" }\";\n        }\n    };\n    return Metadata;\n}());\nexport { Metadata };\n//# sourceMappingURL=metadata.js.map","var Plan = (function () {\n    function Plan(parentContext, rootRequest) {\n        this.parentContext = parentContext;\n        this.rootRequest = rootRequest;\n    }\n    return Plan;\n}());\nexport { Plan };\n//# sourceMappingURL=plan.js.map","var LazyServiceIdentifer = (function () {\n    function LazyServiceIdentifer(cb) {\n        this._cb = cb;\n    }\n    LazyServiceIdentifer.prototype.unwrap = function () {\n        return this._cb();\n    };\n    return LazyServiceIdentifer;\n}());\nexport { LazyServiceIdentifer };\n//# sourceMappingURL=lazy_service_identifier.js.map","var QueryableString = (function () {\n    function QueryableString(str) {\n        this.str = str;\n    }\n    QueryableString.prototype.startsWith = function (searchString) {\n        return this.str.indexOf(searchString) === 0;\n    };\n    QueryableString.prototype.endsWith = function (searchString) {\n        var reverseString = \"\";\n        var reverseSearchString = searchString.split(\"\").reverse().join(\"\");\n        reverseString = this.str.split(\"\").reverse().join(\"\");\n        return this.startsWith.call({ str: reverseString }, reverseSearchString);\n    };\n    QueryableString.prototype.contains = function (searchString) {\n        return (this.str.indexOf(searchString) !== -1);\n    };\n    QueryableString.prototype.equals = function (compareString) {\n        return this.str === compareString;\n    };\n    QueryableString.prototype.value = function () {\n        return this.str;\n    };\n    return QueryableString;\n}());\nexport { QueryableString };\n//# sourceMappingURL=queryable_string.js.map","import * as METADATA_KEY from '../constants/metadata_keys';\nimport { id } from '../utils/id';\nimport { getSymbolDescription } from '../utils/serialization';\nimport { Metadata } from './metadata';\nimport { QueryableString } from './queryable_string';\nvar Target = (function () {\n    function Target(type, identifier, serviceIdentifier, namedOrTagged) {\n        this.id = id();\n        this.type = type;\n        this.serviceIdentifier = serviceIdentifier;\n        var queryableName = typeof identifier === 'symbol' ? getSymbolDescription(identifier) : identifier;\n        this.name = new QueryableString(queryableName || \"\");\n        this.identifier = identifier;\n        this.metadata = new Array();\n        var metadataItem = null;\n        if (typeof namedOrTagged === 'string') {\n            metadataItem = new Metadata(METADATA_KEY.NAMED_TAG, namedOrTagged);\n        }\n        else if (namedOrTagged instanceof Metadata) {\n            metadataItem = namedOrTagged;\n        }\n        if (metadataItem !== null) {\n            this.metadata.push(metadataItem);\n        }\n    }\n    Target.prototype.hasTag = function (key) {\n        for (var _i = 0, _a = this.metadata; _i < _a.length; _i++) {\n            var m = _a[_i];\n            if (m.key === key) {\n                return true;\n            }\n        }\n        return false;\n    };\n    Target.prototype.isArray = function () {\n        return this.hasTag(METADATA_KEY.MULTI_INJECT_TAG);\n    };\n    Target.prototype.matchesArray = function (name) {\n        return this.matchesTag(METADATA_KEY.MULTI_INJECT_TAG)(name);\n    };\n    Target.prototype.isNamed = function () {\n        return this.hasTag(METADATA_KEY.NAMED_TAG);\n    };\n    Target.prototype.isTagged = function () {\n        return this.metadata.some(function (metadata) { return METADATA_KEY.NON_CUSTOM_TAG_KEYS.every(function (key) { return metadata.key !== key; }); });\n    };\n    Target.prototype.isOptional = function () {\n        return this.matchesTag(METADATA_KEY.OPTIONAL_TAG)(true);\n    };\n    Target.prototype.getNamedTag = function () {\n        if (this.isNamed()) {\n            return this.metadata.filter(function (m) { return m.key === METADATA_KEY.NAMED_TAG; })[0];\n        }\n        return null;\n    };\n    Target.prototype.getCustomTags = function () {\n        if (this.isTagged()) {\n            return this.metadata.filter(function (metadata) { return METADATA_KEY.NON_CUSTOM_TAG_KEYS.every(function (key) { return metadata.key !== key; }); });\n        }\n        else {\n            return null;\n        }\n    };\n    Target.prototype.matchesNamedTag = function (name) {\n        return this.matchesTag(METADATA_KEY.NAMED_TAG)(name);\n    };\n    Target.prototype.matchesTag = function (key) {\n        var _this = this;\n        return function (value) {\n            for (var _i = 0, _a = _this.metadata; _i < _a.length; _i++) {\n                var m = _a[_i];\n                if (m.key === key && m.value === value) {\n                    return true;\n                }\n            }\n            return false;\n        };\n    };\n    return Target;\n}());\nexport { Target };\n//# sourceMappingURL=target.js.map","var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {\n    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\n        if (ar || !(i in from)) {\n            if (!ar) ar = Array.prototype.slice.call(from, 0, i);\n            ar[i] = from[i];\n        }\n    }\n    return to.concat(ar || Array.prototype.slice.call(from));\n};\nimport { LazyServiceIdentifer } from \"../annotation/lazy_service_identifier\";\nimport * as ERROR_MSGS from \"../constants/error_msgs\";\nimport { TargetTypeEnum } from \"../constants/literal_types\";\nimport * as METADATA_KEY from \"../constants/metadata_keys\";\nimport { getFunctionName } from \"../utils/serialization\";\nimport { Target } from \"./target\";\nfunction getDependencies(metadataReader, func) {\n    var constructorName = getFunctionName(func);\n    return getTargets(metadataReader, constructorName, func, false);\n}\nfunction getTargets(metadataReader, constructorName, func, isBaseClass) {\n    var metadata = metadataReader.getConstructorMetadata(func);\n    var serviceIdentifiers = metadata.compilerGeneratedMetadata;\n    if (serviceIdentifiers === undefined) {\n        var msg = ERROR_MSGS.MISSING_INJECTABLE_ANNOTATION + \" \" + constructorName + \".\";\n        throw new Error(msg);\n    }\n    var constructorArgsMetadata = metadata.userGeneratedMetadata;\n    var keys = Object.keys(constructorArgsMetadata);\n    var hasUserDeclaredUnknownInjections = (func.length === 0 && keys.length > 0);\n    var hasOptionalParameters = keys.length > func.length;\n    var iterations = (hasUserDeclaredUnknownInjections || hasOptionalParameters) ? keys.length : func.length;\n    var constructorTargets = getConstructorArgsAsTargets(isBaseClass, constructorName, serviceIdentifiers, constructorArgsMetadata, iterations);\n    var propertyTargets = getClassPropsAsTargets(metadataReader, func, constructorName);\n    var targets = __spreadArray(__spreadArray([], constructorTargets, true), propertyTargets, true);\n    return targets;\n}\nfunction getConstructorArgsAsTarget(index, isBaseClass, constructorName, serviceIdentifiers, constructorArgsMetadata) {\n    var targetMetadata = constructorArgsMetadata[index.toString()] || [];\n    var metadata = formatTargetMetadata(targetMetadata);\n    var isManaged = metadata.unmanaged !== true;\n    var serviceIdentifier = serviceIdentifiers[index];\n    var injectIdentifier = (metadata.inject || metadata.multiInject);\n    serviceIdentifier = (injectIdentifier) ? (injectIdentifier) : serviceIdentifier;\n    if (serviceIdentifier instanceof LazyServiceIdentifer) {\n        serviceIdentifier = serviceIdentifier.unwrap();\n    }\n    if (isManaged) {\n        var isObject = serviceIdentifier === Object;\n        var isFunction = serviceIdentifier === Function;\n        var isUndefined = serviceIdentifier === undefined;\n        var isUnknownType = (isObject || isFunction || isUndefined);\n        if (!isBaseClass && isUnknownType) {\n            var msg = ERROR_MSGS.MISSING_INJECT_ANNOTATION + \" argument \" + index + \" in class \" + constructorName + \".\";\n            throw new Error(msg);\n        }\n        var target = new Target(TargetTypeEnum.ConstructorArgument, metadata.targetName, serviceIdentifier);\n        target.metadata = targetMetadata;\n        return target;\n    }\n    return null;\n}\nfunction getConstructorArgsAsTargets(isBaseClass, constructorName, serviceIdentifiers, constructorArgsMetadata, iterations) {\n    var targets = [];\n    for (var i = 0; i < iterations; i++) {\n        var index = i;\n        var target = getConstructorArgsAsTarget(index, isBaseClass, constructorName, serviceIdentifiers, constructorArgsMetadata);\n        if (target !== null) {\n            targets.push(target);\n        }\n    }\n    return targets;\n}\nfunction _getServiceIdentifierForProperty(inject, multiInject, propertyName, className) {\n    var serviceIdentifier = (inject || multiInject);\n    if (serviceIdentifier === undefined) {\n        var msg = ERROR_MSGS.MISSING_INJECTABLE_ANNOTATION + \" for property \" + String(propertyName) + \" in class \" + className + \".\";\n        throw new Error(msg);\n    }\n    return serviceIdentifier;\n}\nfunction getClassPropsAsTargets(metadataReader, constructorFunc, constructorName) {\n    var classPropsMetadata = metadataReader.getPropertiesMetadata(constructorFunc);\n    var targets = [];\n    var symbolKeys = Object.getOwnPropertySymbols(classPropsMetadata);\n    var stringKeys = Object.keys(classPropsMetadata);\n    var keys = stringKeys.concat(symbolKeys);\n    for (var _i = 0, keys_1 = keys; _i < keys_1.length; _i++) {\n        var key = keys_1[_i];\n        var targetMetadata = classPropsMetadata[key];\n        var metadata = formatTargetMetadata(targetMetadata);\n        var identifier = metadata.targetName || key;\n        var serviceIdentifier = _getServiceIdentifierForProperty(metadata.inject, metadata.multiInject, key, constructorName);\n        var target = new Target(TargetTypeEnum.ClassProperty, identifier, serviceIdentifier);\n        target.metadata = targetMetadata;\n        targets.push(target);\n    }\n    var baseConstructor = Object.getPrototypeOf(constructorFunc.prototype).constructor;\n    if (baseConstructor !== Object) {\n        var baseTargets = getClassPropsAsTargets(metadataReader, baseConstructor, constructorName);\n        targets = __spreadArray(__spreadArray([], targets, true), baseTargets, true);\n    }\n    return targets;\n}\nfunction getBaseClassDependencyCount(metadataReader, func) {\n    var baseConstructor = Object.getPrototypeOf(func.prototype).constructor;\n    if (baseConstructor !== Object) {\n        var baseConstructorName = getFunctionName(baseConstructor);\n        var targets = getTargets(metadataReader, baseConstructorName, baseConstructor, true);\n        var metadata = targets.map(function (t) { return t.metadata.filter(function (m) { return m.key === METADATA_KEY.UNMANAGED_TAG; }); });\n        var unmanagedCount = [].concat.apply([], metadata).length;\n        var dependencyCount = targets.length - unmanagedCount;\n        if (dependencyCount > 0) {\n            return dependencyCount;\n        }\n        else {\n            return getBaseClassDependencyCount(metadataReader, baseConstructor);\n        }\n    }\n    else {\n        return 0;\n    }\n}\nfunction formatTargetMetadata(targetMetadata) {\n    var targetMetadataMap = {};\n    targetMetadata.forEach(function (m) {\n        targetMetadataMap[m.key.toString()] = m.value;\n    });\n    return {\n        inject: targetMetadataMap[METADATA_KEY.INJECT_TAG],\n        multiInject: targetMetadataMap[METADATA_KEY.MULTI_INJECT_TAG],\n        targetName: targetMetadataMap[METADATA_KEY.NAME_TAG],\n        unmanaged: targetMetadataMap[METADATA_KEY.UNMANAGED_TAG]\n    };\n}\nexport { getDependencies, getBaseClassDependencyCount, getFunctionName };\n//# sourceMappingURL=reflection_utils.js.map","import { id } from \"../utils/id\";\nvar Request = (function () {\n    function Request(serviceIdentifier, parentContext, parentRequest, bindings, target) {\n        this.id = id();\n        this.serviceIdentifier = serviceIdentifier;\n        this.parentContext = parentContext;\n        this.parentRequest = parentRequest;\n        this.target = target;\n        this.childRequests = [];\n        this.bindings = (Array.isArray(bindings) ? bindings : [bindings]);\n        this.requestScope = parentRequest === null\n            ? new Map()\n            : null;\n    }\n    Request.prototype.addChildRequest = function (serviceIdentifier, bindings, target) {\n        var child = new Request(serviceIdentifier, this.parentContext, this, bindings, target);\n        this.childRequests.push(child);\n        return child;\n    };\n    return Request;\n}());\nexport { Request };\n//# sourceMappingURL=request.js.map","import { BindingCount } from \"../bindings/binding_count\";\nimport * as ERROR_MSGS from \"../constants/error_msgs\";\nimport { BindingTypeEnum, TargetTypeEnum } from \"../constants/literal_types\";\nimport * as METADATA_KEY from \"../constants/metadata_keys\";\nimport { isStackOverflowExeption } from \"../utils/exceptions\";\nimport { circularDependencyToException, getServiceIdentifierAsString, listMetadataForTarget, listRegisteredBindingsForServiceIdentifier } from \"../utils/serialization\";\nimport { Context } from \"./context\";\nimport { Metadata } from \"./metadata\";\nimport { Plan } from \"./plan\";\nimport { getBaseClassDependencyCount, getDependencies, getFunctionName } from \"./reflection_utils\";\nimport { Request } from \"./request\";\nimport { Target } from \"./target\";\nfunction getBindingDictionary(cntnr) {\n    return cntnr._bindingDictionary;\n}\nfunction _createTarget(isMultiInject, targetType, serviceIdentifier, name, key, value) {\n    var metadataKey = isMultiInject ? METADATA_KEY.MULTI_INJECT_TAG : METADATA_KEY.INJECT_TAG;\n    var injectMetadata = new Metadata(metadataKey, serviceIdentifier);\n    var target = new Target(targetType, name, serviceIdentifier, injectMetadata);\n    if (key !== undefined) {\n        var tagMetadata = new Metadata(key, value);\n        target.metadata.push(tagMetadata);\n    }\n    return target;\n}\nfunction _getActiveBindings(metadataReader, avoidConstraints, context, parentRequest, target) {\n    var bindings = getBindings(context.container, target.serviceIdentifier);\n    var activeBindings = [];\n    if (bindings.length === BindingCount.NoBindingsAvailable &&\n        context.container.options.autoBindInjectable &&\n        typeof target.serviceIdentifier === \"function\" &&\n        metadataReader.getConstructorMetadata(target.serviceIdentifier).compilerGeneratedMetadata) {\n        context.container.bind(target.serviceIdentifier).toSelf();\n        bindings = getBindings(context.container, target.serviceIdentifier);\n    }\n    if (!avoidConstraints) {\n        activeBindings = bindings.filter(function (binding) {\n            var request = new Request(binding.serviceIdentifier, context, parentRequest, binding, target);\n            return binding.constraint(request);\n        });\n    }\n    else {\n        activeBindings = bindings;\n    }\n    _validateActiveBindingCount(target.serviceIdentifier, activeBindings, target, context.container);\n    return activeBindings;\n}\nfunction _validateActiveBindingCount(serviceIdentifier, bindings, target, container) {\n    switch (bindings.length) {\n        case BindingCount.NoBindingsAvailable:\n            if (target.isOptional()) {\n                return bindings;\n            }\n            else {\n                var serviceIdentifierString = getServiceIdentifierAsString(serviceIdentifier);\n                var msg = ERROR_MSGS.NOT_REGISTERED;\n                msg += listMetadataForTarget(serviceIdentifierString, target);\n                msg += listRegisteredBindingsForServiceIdentifier(container, serviceIdentifierString, getBindings);\n                throw new Error(msg);\n            }\n        case BindingCount.OnlyOneBindingAvailable:\n            return bindings;\n        case BindingCount.MultipleBindingsAvailable:\n        default:\n            if (!target.isArray()) {\n                var serviceIdentifierString = getServiceIdentifierAsString(serviceIdentifier);\n                var msg = ERROR_MSGS.AMBIGUOUS_MATCH + \" \" + serviceIdentifierString;\n                msg += listRegisteredBindingsForServiceIdentifier(container, serviceIdentifierString, getBindings);\n                throw new Error(msg);\n            }\n            else {\n                return bindings;\n            }\n    }\n}\nfunction _createSubRequests(metadataReader, avoidConstraints, serviceIdentifier, context, parentRequest, target) {\n    var activeBindings;\n    var childRequest;\n    if (parentRequest === null) {\n        activeBindings = _getActiveBindings(metadataReader, avoidConstraints, context, null, target);\n        childRequest = new Request(serviceIdentifier, context, null, activeBindings, target);\n        var thePlan = new Plan(context, childRequest);\n        context.addPlan(thePlan);\n    }\n    else {\n        activeBindings = _getActiveBindings(metadataReader, avoidConstraints, context, parentRequest, target);\n        childRequest = parentRequest.addChildRequest(target.serviceIdentifier, activeBindings, target);\n    }\n    activeBindings.forEach(function (binding) {\n        var subChildRequest = null;\n        if (target.isArray()) {\n            subChildRequest = childRequest.addChildRequest(binding.serviceIdentifier, binding, target);\n        }\n        else {\n            if (binding.cache) {\n                return;\n            }\n            subChildRequest = childRequest;\n        }\n        if (binding.type === BindingTypeEnum.Instance && binding.implementationType !== null) {\n            var dependencies = getDependencies(metadataReader, binding.implementationType);\n            if (!context.container.options.skipBaseClassChecks) {\n                var baseClassDependencyCount = getBaseClassDependencyCount(metadataReader, binding.implementationType);\n                if (dependencies.length < baseClassDependencyCount) {\n                    var error = ERROR_MSGS.ARGUMENTS_LENGTH_MISMATCH(getFunctionName(binding.implementationType));\n                    throw new Error(error);\n                }\n            }\n            dependencies.forEach(function (dependency) {\n                _createSubRequests(metadataReader, false, dependency.serviceIdentifier, context, subChildRequest, dependency);\n            });\n        }\n    });\n}\nfunction getBindings(container, serviceIdentifier) {\n    var bindings = [];\n    var bindingDictionary = getBindingDictionary(container);\n    if (bindingDictionary.hasKey(serviceIdentifier)) {\n        bindings = bindingDictionary.get(serviceIdentifier);\n    }\n    else if (container.parent !== null) {\n        bindings = getBindings(container.parent, serviceIdentifier);\n    }\n    return bindings;\n}\nfunction plan(metadataReader, container, isMultiInject, targetType, serviceIdentifier, key, value, avoidConstraints) {\n    if (avoidConstraints === void 0) { avoidConstraints = false; }\n    var context = new Context(container);\n    var target = _createTarget(isMultiInject, targetType, serviceIdentifier, \"\", key, value);\n    try {\n        _createSubRequests(metadataReader, avoidConstraints, serviceIdentifier, context, null, target);\n        return context;\n    }\n    catch (error) {\n        if (isStackOverflowExeption(error)) {\n            circularDependencyToException(context.plan.rootRequest);\n        }\n        throw error;\n    }\n}\nfunction createMockRequest(container, serviceIdentifier, key, value) {\n    var target = new Target(TargetTypeEnum.Variable, \"\", serviceIdentifier, new Metadata(key, value));\n    var context = new Context(container);\n    var request = new Request(serviceIdentifier, context, null, [], target);\n    return request;\n}\nexport { plan, createMockRequest, getBindingDictionary };\n//# sourceMappingURL=planner.js.map","function isPromise(object) {\n    var isObjectOrFunction = (typeof object === 'object' && object !== null) || typeof object === 'function';\n    return isObjectOrFunction && typeof object.then === \"function\";\n}\nfunction isPromiseOrContainsPromise(object) {\n    if (isPromise(object)) {\n        return true;\n    }\n    return Array.isArray(object) && object.some(isPromise);\n}\nexport { isPromise, isPromiseOrContainsPromise };\n//# sourceMappingURL=async.js.map","var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n    return new (P || (P = Promise))(function (resolve, reject) {\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\n    });\n};\nvar __generator = (this && this.__generator) || function (thisArg, body) {\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\n    function verb(n) { return function (v) { return step([n, v]); }; }\n    function step(op) {\n        if (f) throw new TypeError(\"Generator is already executing.\");\n        while (_) try {\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\n            if (y = 0, t) op = [op[0] & 2, t.value];\n            switch (op[0]) {\n                case 0: case 1: t = op; break;\n                case 4: _.label++; return { value: op[1], done: false };\n                case 5: _.label++; y = op[1]; op = [0]; continue;\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\n                default:\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\n                    if (t[2]) _.ops.pop();\n                    _.trys.pop(); continue;\n            }\n            op = body.call(thisArg, _);\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\n    }\n};\nimport { BindingScopeEnum } from \"../inversify\";\nimport { isPromise } from \"../utils/async\";\nexport var tryGetFromScope = function (requestScope, binding) {\n    if ((binding.scope === BindingScopeEnum.Singleton) && binding.activated) {\n        return binding.cache;\n    }\n    if (binding.scope === BindingScopeEnum.Request &&\n        requestScope.has(binding.id)) {\n        return requestScope.get(binding.id);\n    }\n    return null;\n};\nexport var saveToScope = function (requestScope, binding, result) {\n    if (binding.scope === BindingScopeEnum.Singleton) {\n        _saveToSingletonScope(binding, result);\n    }\n    if (binding.scope === BindingScopeEnum.Request) {\n        _saveToRequestScope(requestScope, binding, result);\n    }\n};\nvar _saveToRequestScope = function (requestScope, binding, result) {\n    if (!requestScope.has(binding.id)) {\n        requestScope.set(binding.id, result);\n    }\n};\nvar _saveToSingletonScope = function (binding, result) {\n    binding.cache = result;\n    binding.activated = true;\n    if (isPromise(result)) {\n        void _saveAsyncResultToSingletonScope(binding, result);\n    }\n};\nvar _saveAsyncResultToSingletonScope = function (binding, asyncResult) { return __awaiter(void 0, void 0, void 0, function () {\n    var result, ex_1;\n    return __generator(this, function (_a) {\n        switch (_a.label) {\n            case 0:\n                _a.trys.push([0, 2, , 3]);\n                return [4, asyncResult];\n            case 1:\n                result = _a.sent();\n                binding.cache = result;\n                return [3, 3];\n            case 2:\n                ex_1 = _a.sent();\n                binding.cache = null;\n                binding.activated = false;\n                throw ex_1;\n            case 3: return [2];\n        }\n    });\n}); };\n//# sourceMappingURL=scope.js.map","export var FactoryType;\n(function (FactoryType) {\n    FactoryType[\"DynamicValue\"] = \"toDynamicValue\";\n    FactoryType[\"Factory\"] = \"toFactory\";\n    FactoryType[\"Provider\"] = \"toProvider\";\n})(FactoryType || (FactoryType = {}));\n//# sourceMappingURL=factory_type.js.map","import { getServiceIdentifierAsString } from \"../inversify\";\nimport * as ERROR_MSGS from \"../constants/error_msgs\";\nimport { BindingTypeEnum } from \"../constants/literal_types\";\nimport { FactoryType } from \"./factory_type\";\nexport var multiBindToService = function (container) {\n    return function (service) {\n        return function () {\n            var types = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                types[_i] = arguments[_i];\n            }\n            return types.forEach(function (t) { return container.bind(t).toService(service); });\n        };\n    };\n};\nexport var ensureFullyBound = function (binding) {\n    var boundValue = null;\n    switch (binding.type) {\n        case BindingTypeEnum.ConstantValue:\n        case BindingTypeEnum.Function:\n            boundValue = binding.cache;\n            break;\n        case BindingTypeEnum.Constructor:\n        case BindingTypeEnum.Instance:\n            boundValue = binding.implementationType;\n            break;\n        case BindingTypeEnum.DynamicValue:\n            boundValue = binding.dynamicValue;\n            break;\n        case BindingTypeEnum.Provider:\n            boundValue = binding.provider;\n            break;\n        case BindingTypeEnum.Factory:\n            boundValue = binding.factory;\n            break;\n    }\n    if (boundValue === null) {\n        var serviceIdentifierAsString = getServiceIdentifierAsString(binding.serviceIdentifier);\n        throw new Error(ERROR_MSGS.INVALID_BINDING_TYPE + \" \" + serviceIdentifierAsString);\n    }\n};\nexport var getFactoryDetails = function (binding) {\n    switch (binding.type) {\n        case BindingTypeEnum.Factory:\n            return { factory: binding.factory, factoryType: FactoryType.Factory };\n        case BindingTypeEnum.Provider:\n            return { factory: binding.provider, factoryType: FactoryType.Provider };\n        case BindingTypeEnum.DynamicValue:\n            return { factory: binding.dynamicValue, factoryType: FactoryType.DynamicValue };\n        default:\n            throw new Error(\"Unexpected factory type \" + binding.type);\n    }\n};\n//# sourceMappingURL=binding_utils.js.map","var __assign = (this && this.__assign) || function () {\n    __assign = Object.assign || function(t) {\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\n            s = arguments[i];\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\n                t[p] = s[p];\n        }\n        return t;\n    };\n    return __assign.apply(this, arguments);\n};\nvar __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n    return new (P || (P = Promise))(function (resolve, reject) {\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\n    });\n};\nvar __generator = (this && this.__generator) || function (thisArg, body) {\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\n    function verb(n) { return function (v) { return step([n, v]); }; }\n    function step(op) {\n        if (f) throw new TypeError(\"Generator is already executing.\");\n        while (_) try {\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\n            if (y = 0, t) op = [op[0] & 2, t.value];\n            switch (op[0]) {\n                case 0: case 1: t = op; break;\n                case 4: _.label++; return { value: op[1], done: false };\n                case 5: _.label++; y = op[1]; op = [0]; continue;\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\n                default:\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\n                    if (t[2]) _.ops.pop();\n                    _.trys.pop(); continue;\n            }\n            op = body.call(thisArg, _);\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\n    }\n};\nvar __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {\n    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\n        if (ar || !(i in from)) {\n            if (!ar) ar = Array.prototype.slice.call(from, 0, i);\n            ar[i] = from[i];\n        }\n    }\n    return to.concat(ar || Array.prototype.slice.call(from));\n};\nimport { ON_DEACTIVATION_ERROR, POST_CONSTRUCT_ERROR, PRE_DESTROY_ERROR } from \"../constants/error_msgs\";\nimport { BindingScopeEnum, TargetTypeEnum } from \"../constants/literal_types\";\nimport * as METADATA_KEY from \"../constants/metadata_keys\";\nimport { isPromise, isPromiseOrContainsPromise } from \"../utils/async\";\nfunction _resolveRequests(childRequests, resolveRequest) {\n    return childRequests.reduce(function (resolvedRequests, childRequest) {\n        var injection = resolveRequest(childRequest);\n        var targetType = childRequest.target.type;\n        if (targetType === TargetTypeEnum.ConstructorArgument) {\n            resolvedRequests.constructorInjections.push(injection);\n        }\n        else {\n            resolvedRequests.propertyRequests.push(childRequest);\n            resolvedRequests.propertyInjections.push(injection);\n        }\n        if (!resolvedRequests.isAsync) {\n            resolvedRequests.isAsync = isPromiseOrContainsPromise(injection);\n        }\n        return resolvedRequests;\n    }, { constructorInjections: [], propertyInjections: [], propertyRequests: [], isAsync: false });\n}\nfunction _createInstance(constr, childRequests, resolveRequest) {\n    var result;\n    if (childRequests.length > 0) {\n        var resolved = _resolveRequests(childRequests, resolveRequest);\n        var createInstanceWithInjectionsArg = __assign(__assign({}, resolved), { constr: constr });\n        if (resolved.isAsync) {\n            result = createInstanceWithInjectionsAsync(createInstanceWithInjectionsArg);\n        }\n        else {\n            result = createInstanceWithInjections(createInstanceWithInjectionsArg);\n        }\n    }\n    else {\n        result = new constr();\n    }\n    return result;\n}\nfunction createInstanceWithInjections(args) {\n    var _a;\n    var instance = new ((_a = args.constr).bind.apply(_a, __spreadArray([void 0], args.constructorInjections, false)))();\n    args.propertyRequests.forEach(function (r, index) {\n        var property = r.target.identifier;\n        var injection = args.propertyInjections[index];\n        instance[property] = injection;\n    });\n    return instance;\n}\nfunction createInstanceWithInjectionsAsync(args) {\n    return __awaiter(this, void 0, void 0, function () {\n        var constructorInjections, propertyInjections;\n        return __generator(this, function (_a) {\n            switch (_a.label) {\n                case 0: return [4, possiblyWaitInjections(args.constructorInjections)];\n                case 1:\n                    constructorInjections = _a.sent();\n                    return [4, possiblyWaitInjections(args.propertyInjections)];\n                case 2:\n                    propertyInjections = _a.sent();\n                    return [2, createInstanceWithInjections(__assign(__assign({}, args), { constructorInjections: constructorInjections, propertyInjections: propertyInjections }))];\n            }\n        });\n    });\n}\nfunction possiblyWaitInjections(possiblePromiseinjections) {\n    return __awaiter(this, void 0, void 0, function () {\n        var injections, _i, possiblePromiseinjections_1, injection;\n        return __generator(this, function (_a) {\n            injections = [];\n            for (_i = 0, possiblePromiseinjections_1 = possiblePromiseinjections; _i < possiblePromiseinjections_1.length; _i++) {\n                injection = possiblePromiseinjections_1[_i];\n                if (Array.isArray(injection)) {\n                    injections.push(Promise.all(injection));\n                }\n                else {\n                    injections.push(injection);\n                }\n            }\n            return [2, Promise.all(injections)];\n        });\n    });\n}\nfunction _getInstanceAfterPostConstruct(constr, result) {\n    var postConstructResult = _postConstruct(constr, result);\n    if (isPromise(postConstructResult)) {\n        return postConstructResult.then(function () { return result; });\n    }\n    else {\n        return result;\n    }\n}\nfunction _postConstruct(constr, instance) {\n    var _a, _b;\n    if (Reflect.hasMetadata(METADATA_KEY.POST_CONSTRUCT, constr)) {\n        var data = Reflect.getMetadata(METADATA_KEY.POST_CONSTRUCT, constr);\n        try {\n            return (_b = (_a = instance)[data.value]) === null || _b === void 0 ? void 0 : _b.call(_a);\n        }\n        catch (e) {\n            throw new Error(POST_CONSTRUCT_ERROR(constr.name, e.message));\n        }\n    }\n}\nfunction _validateInstanceResolution(binding, constr) {\n    if (binding.scope !== BindingScopeEnum.Singleton) {\n        _throwIfHandlingDeactivation(binding, constr);\n    }\n}\nfunction _throwIfHandlingDeactivation(binding, constr) {\n    var scopeErrorMessage = \"Class cannot be instantiated in \" + (binding.scope === BindingScopeEnum.Request ?\n        \"request\" :\n        \"transient\") + \" scope.\";\n    if (typeof binding.onDeactivation === \"function\") {\n        throw new Error(ON_DEACTIVATION_ERROR(constr.name, scopeErrorMessage));\n    }\n    if (Reflect.hasMetadata(METADATA_KEY.PRE_DESTROY, constr)) {\n        throw new Error(PRE_DESTROY_ERROR(constr.name, scopeErrorMessage));\n    }\n}\nfunction resolveInstance(binding, constr, childRequests, resolveRequest) {\n    _validateInstanceResolution(binding, constr);\n    var result = _createInstance(constr, childRequests, resolveRequest);\n    if (isPromise(result)) {\n        return result.then(function (resolvedResult) { return _getInstanceAfterPostConstruct(constr, resolvedResult); });\n    }\n    else {\n        return _getInstanceAfterPostConstruct(constr, result);\n    }\n}\nexport { resolveInstance };\n//# sourceMappingURL=instantiation.js.map","var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n    return new (P || (P = Promise))(function (resolve, reject) {\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\n    });\n};\nvar __generator = (this && this.__generator) || function (thisArg, body) {\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\n    function verb(n) { return function (v) { return step([n, v]); }; }\n    function step(op) {\n        if (f) throw new TypeError(\"Generator is already executing.\");\n        while (_) try {\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\n            if (y = 0, t) op = [op[0] & 2, t.value];\n            switch (op[0]) {\n                case 0: case 1: t = op; break;\n                case 4: _.label++; return { value: op[1], done: false };\n                case 5: _.label++; y = op[1]; op = [0]; continue;\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\n                default:\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\n                    if (t[2]) _.ops.pop();\n                    _.trys.pop(); continue;\n            }\n            op = body.call(thisArg, _);\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\n    }\n};\nimport * as ERROR_MSGS from \"../constants/error_msgs\";\nimport { BindingTypeEnum } from \"../constants/literal_types\";\nimport { getBindingDictionary } from \"../planning/planner\";\nimport { saveToScope, tryGetFromScope } from \"../scope/scope\";\nimport { isPromise } from \"../utils/async\";\nimport { getFactoryDetails, ensureFullyBound } from \"../utils/binding_utils\";\nimport { tryAndThrowErrorIfStackOverflow } from \"../utils/exceptions\";\nimport { resolveInstance } from \"./instantiation\";\nvar _resolveRequest = function (requestScope) {\n    return function (request) {\n        request.parentContext.setCurrentRequest(request);\n        var bindings = request.bindings;\n        var childRequests = request.childRequests;\n        var targetIsAnArray = request.target && request.target.isArray();\n        var targetParentIsNotAnArray = !request.parentRequest ||\n            !request.parentRequest.target ||\n            !request.target ||\n            !request.parentRequest.target.matchesArray(request.target.serviceIdentifier);\n        if (targetIsAnArray && targetParentIsNotAnArray) {\n            return childRequests.map(function (childRequest) {\n                var _f = _resolveRequest(requestScope);\n                return _f(childRequest);\n            });\n        }\n        else {\n            if (request.target.isOptional() && bindings.length === 0) {\n                return undefined;\n            }\n            var binding = bindings[0];\n            return _resolveBinding(requestScope, request, binding);\n        }\n    };\n};\nvar _resolveFactoryFromBinding = function (binding, context) {\n    var factoryDetails = getFactoryDetails(binding);\n    return tryAndThrowErrorIfStackOverflow(function () { return factoryDetails.factory.bind(binding)(context); }, function () { return new Error(ERROR_MSGS.CIRCULAR_DEPENDENCY_IN_FACTORY(factoryDetails.factoryType, context.currentRequest.serviceIdentifier.toString())); });\n};\nvar _getResolvedFromBinding = function (requestScope, request, binding) {\n    var result;\n    var childRequests = request.childRequests;\n    ensureFullyBound(binding);\n    switch (binding.type) {\n        case BindingTypeEnum.ConstantValue:\n        case BindingTypeEnum.Function:\n            result = binding.cache;\n            break;\n        case BindingTypeEnum.Constructor:\n            result = binding.implementationType;\n            break;\n        case BindingTypeEnum.Instance:\n            result = resolveInstance(binding, binding.implementationType, childRequests, _resolveRequest(requestScope));\n            break;\n        default:\n            result = _resolveFactoryFromBinding(binding, request.parentContext);\n    }\n    return result;\n};\nvar _resolveInScope = function (requestScope, binding, resolveFromBinding) {\n    var result = tryGetFromScope(requestScope, binding);\n    if (result !== null) {\n        return result;\n    }\n    result = resolveFromBinding();\n    saveToScope(requestScope, binding, result);\n    return result;\n};\nvar _resolveBinding = function (requestScope, request, binding) {\n    return _resolveInScope(requestScope, binding, function () {\n        var result = _getResolvedFromBinding(requestScope, request, binding);\n        if (isPromise(result)) {\n            result = result.then(function (resolved) { return _onActivation(request, binding, resolved); });\n        }\n        else {\n            result = _onActivation(request, binding, result);\n        }\n        return result;\n    });\n};\nfunction _onActivation(request, binding, resolved) {\n    var result = _bindingActivation(request.parentContext, binding, resolved);\n    var containersIterator = _getContainersIterator(request.parentContext.container);\n    var container;\n    var containersIteratorResult = containersIterator.next();\n    do {\n        container = containersIteratorResult.value;\n        var context_1 = request.parentContext;\n        var serviceIdentifier = request.serviceIdentifier;\n        var activationsIterator = _getContainerActivationsForService(container, serviceIdentifier);\n        if (isPromise(result)) {\n            result = _activateContainerAsync(activationsIterator, context_1, result);\n        }\n        else {\n            result = _activateContainer(activationsIterator, context_1, result);\n        }\n        containersIteratorResult = containersIterator.next();\n    } while (containersIteratorResult.done !== true && !getBindingDictionary(container).hasKey(request.serviceIdentifier));\n    return result;\n}\nvar _bindingActivation = function (context, binding, previousResult) {\n    var result;\n    if (typeof binding.onActivation === \"function\") {\n        result = binding.onActivation(context, previousResult);\n    }\n    else {\n        result = previousResult;\n    }\n    return result;\n};\nvar _activateContainer = function (activationsIterator, context, result) {\n    var activation = activationsIterator.next();\n    while (!activation.done) {\n        result = activation.value(context, result);\n        if (isPromise(result)) {\n            return _activateContainerAsync(activationsIterator, context, result);\n        }\n        activation = activationsIterator.next();\n    }\n    return result;\n};\nvar _activateContainerAsync = function (activationsIterator, context, resultPromise) { return __awaiter(void 0, void 0, void 0, function () {\n    var result, activation;\n    return __generator(this, function (_a) {\n        switch (_a.label) {\n            case 0: return [4, resultPromise];\n            case 1:\n                result = _a.sent();\n                activation = activationsIterator.next();\n                _a.label = 2;\n            case 2:\n                if (!!activation.done) return [3, 4];\n                return [4, activation.value(context, result)];\n            case 3:\n                result = _a.sent();\n                activation = activationsIterator.next();\n                return [3, 2];\n            case 4: return [2, result];\n        }\n    });\n}); };\nvar _getContainerActivationsForService = function (container, serviceIdentifier) {\n    var activations = container._activations;\n    return activations.hasKey(serviceIdentifier) ? activations.get(serviceIdentifier).values() : [].values();\n};\nvar _getContainersIterator = function (container) {\n    var containersStack = [container];\n    var parent = container.parent;\n    while (parent !== null) {\n        containersStack.push(parent);\n        parent = parent.parent;\n    }\n    var getNextContainer = function () {\n        var nextContainer = containersStack.pop();\n        if (nextContainer !== undefined) {\n            return { done: false, value: nextContainer };\n        }\n        else {\n            return { done: true, value: undefined };\n        }\n    };\n    var containersIterator = {\n        next: getNextContainer,\n    };\n    return containersIterator;\n};\nfunction resolve(context) {\n    var _f = _resolveRequest(context.plan.rootRequest.requestScope);\n    return _f(context.plan.rootRequest);\n}\nexport { resolve };\n//# sourceMappingURL=resolver.js.map","import * as METADATA_KEY from \"../constants/metadata_keys\";\nimport { Metadata } from \"../planning/metadata\";\nvar traverseAncerstors = function (request, constraint) {\n    var parent = request.parentRequest;\n    if (parent !== null) {\n        return constraint(parent) ? true : traverseAncerstors(parent, constraint);\n    }\n    else {\n        return false;\n    }\n};\nvar taggedConstraint = function (key) { return function (value) {\n    var constraint = function (request) {\n        return request !== null && request.target !== null && request.target.matchesTag(key)(value);\n    };\n    constraint.metaData = new Metadata(key, value);\n    return constraint;\n}; };\nvar namedConstraint = taggedConstraint(METADATA_KEY.NAMED_TAG);\nvar typeConstraint = function (type) { return function (request) {\n    var binding = null;\n    if (request !== null) {\n        binding = request.bindings[0];\n        if (typeof type === \"string\") {\n            var serviceIdentifier = binding.serviceIdentifier;\n            return serviceIdentifier === type;\n        }\n        else {\n            var constructor = request.bindings[0].implementationType;\n            return type === constructor;\n        }\n    }\n    return false;\n}; };\nexport { traverseAncerstors, taggedConstraint, namedConstraint, typeConstraint };\n//# sourceMappingURL=constraint_helpers.js.map","import { BindingOnSyntax } from \"./binding_on_syntax\";\nimport { namedConstraint, taggedConstraint, traverseAncerstors, typeConstraint } from \"./constraint_helpers\";\nvar BindingWhenSyntax = (function () {\n    function BindingWhenSyntax(binding) {\n        this._binding = binding;\n    }\n    BindingWhenSyntax.prototype.when = function (constraint) {\n        this._binding.constraint = constraint;\n        return new BindingOnSyntax(this._binding);\n    };\n    BindingWhenSyntax.prototype.whenTargetNamed = function (name) {\n        this._binding.constraint = namedConstraint(name);\n        return new BindingOnSyntax(this._binding);\n    };\n    BindingWhenSyntax.prototype.whenTargetIsDefault = function () {\n        this._binding.constraint = function (request) {\n            if (request === null) {\n                return false;\n            }\n            var targetIsDefault = (request.target !== null) &&\n                (!request.target.isNamed()) &&\n                (!request.target.isTagged());\n            return targetIsDefault;\n        };\n        return new BindingOnSyntax(this._binding);\n    };\n    BindingWhenSyntax.prototype.whenTargetTagged = function (tag, value) {\n        this._binding.constraint = taggedConstraint(tag)(value);\n        return new BindingOnSyntax(this._binding);\n    };\n    BindingWhenSyntax.prototype.whenInjectedInto = function (parent) {\n        this._binding.constraint = function (request) {\n            return request !== null && typeConstraint(parent)(request.parentRequest);\n        };\n        return new BindingOnSyntax(this._binding);\n    };\n    BindingWhenSyntax.prototype.whenParentNamed = function (name) {\n        this._binding.constraint = function (request) {\n            return request !== null && namedConstraint(name)(request.parentRequest);\n        };\n        return new BindingOnSyntax(this._binding);\n    };\n    BindingWhenSyntax.prototype.whenParentTagged = function (tag, value) {\n        this._binding.constraint = function (request) {\n            return request !== null && taggedConstraint(tag)(value)(request.parentRequest);\n        };\n        return new BindingOnSyntax(this._binding);\n    };\n    BindingWhenSyntax.prototype.whenAnyAncestorIs = function (ancestor) {\n        this._binding.constraint = function (request) {\n            return request !== null && traverseAncerstors(request, typeConstraint(ancestor));\n        };\n        return new BindingOnSyntax(this._binding);\n    };\n    BindingWhenSyntax.prototype.whenNoAncestorIs = function (ancestor) {\n        this._binding.constraint = function (request) {\n            return request !== null && !traverseAncerstors(request, typeConstraint(ancestor));\n        };\n        return new BindingOnSyntax(this._binding);\n    };\n    BindingWhenSyntax.prototype.whenAnyAncestorNamed = function (name) {\n        this._binding.constraint = function (request) {\n            return request !== null && traverseAncerstors(request, namedConstraint(name));\n        };\n        return new BindingOnSyntax(this._binding);\n    };\n    BindingWhenSyntax.prototype.whenNoAncestorNamed = function (name) {\n        this._binding.constraint = function (request) {\n            return request !== null && !traverseAncerstors(request, namedConstraint(name));\n        };\n        return new BindingOnSyntax(this._binding);\n    };\n    BindingWhenSyntax.prototype.whenAnyAncestorTagged = function (tag, value) {\n        this._binding.constraint = function (request) {\n            return request !== null && traverseAncerstors(request, taggedConstraint(tag)(value));\n        };\n        return new BindingOnSyntax(this._binding);\n    };\n    BindingWhenSyntax.prototype.whenNoAncestorTagged = function (tag, value) {\n        this._binding.constraint = function (request) {\n            return request !== null && !traverseAncerstors(request, taggedConstraint(tag)(value));\n        };\n        return new BindingOnSyntax(this._binding);\n    };\n    BindingWhenSyntax.prototype.whenAnyAncestorMatches = function (constraint) {\n        this._binding.constraint = function (request) {\n            return request !== null && traverseAncerstors(request, constraint);\n        };\n        return new BindingOnSyntax(this._binding);\n    };\n    BindingWhenSyntax.prototype.whenNoAncestorMatches = function (constraint) {\n        this._binding.constraint = function (request) {\n            return request !== null && !traverseAncerstors(request, constraint);\n        };\n        return new BindingOnSyntax(this._binding);\n    };\n    return BindingWhenSyntax;\n}());\nexport { BindingWhenSyntax };\n//# sourceMappingURL=binding_when_syntax.js.map","import { BindingWhenSyntax } from \"./binding_when_syntax\";\nvar BindingOnSyntax = (function () {\n    function BindingOnSyntax(binding) {\n        this._binding = binding;\n    }\n    BindingOnSyntax.prototype.onActivation = function (handler) {\n        this._binding.onActivation = handler;\n        return new BindingWhenSyntax(this._binding);\n    };\n    BindingOnSyntax.prototype.onDeactivation = function (handler) {\n        this._binding.onDeactivation = handler;\n        return new BindingWhenSyntax(this._binding);\n    };\n    return BindingOnSyntax;\n}());\nexport { BindingOnSyntax };\n//# sourceMappingURL=binding_on_syntax.js.map","import { BindingOnSyntax } from \"./binding_on_syntax\";\nimport { BindingWhenSyntax } from \"./binding_when_syntax\";\nvar BindingWhenOnSyntax = (function () {\n    function BindingWhenOnSyntax(binding) {\n        this._binding = binding;\n        this._bindingWhenSyntax = new BindingWhenSyntax(this._binding);\n        this._bindingOnSyntax = new BindingOnSyntax(this._binding);\n    }\n    BindingWhenOnSyntax.prototype.when = function (constraint) {\n        return this._bindingWhenSyntax.when(constraint);\n    };\n    BindingWhenOnSyntax.prototype.whenTargetNamed = function (name) {\n        return this._bindingWhenSyntax.whenTargetNamed(name);\n    };\n    BindingWhenOnSyntax.prototype.whenTargetIsDefault = function () {\n        return this._bindingWhenSyntax.whenTargetIsDefault();\n    };\n    BindingWhenOnSyntax.prototype.whenTargetTagged = function (tag, value) {\n        return this._bindingWhenSyntax.whenTargetTagged(tag, value);\n    };\n    BindingWhenOnSyntax.prototype.whenInjectedInto = function (parent) {\n        return this._bindingWhenSyntax.whenInjectedInto(parent);\n    };\n    BindingWhenOnSyntax.prototype.whenParentNamed = function (name) {\n        return this._bindingWhenSyntax.whenParentNamed(name);\n    };\n    BindingWhenOnSyntax.prototype.whenParentTagged = function (tag, value) {\n        return this._bindingWhenSyntax.whenParentTagged(tag, value);\n    };\n    BindingWhenOnSyntax.prototype.whenAnyAncestorIs = function (ancestor) {\n        return this._bindingWhenSyntax.whenAnyAncestorIs(ancestor);\n    };\n    BindingWhenOnSyntax.prototype.whenNoAncestorIs = function (ancestor) {\n        return this._bindingWhenSyntax.whenNoAncestorIs(ancestor);\n    };\n    BindingWhenOnSyntax.prototype.whenAnyAncestorNamed = function (name) {\n        return this._bindingWhenSyntax.whenAnyAncestorNamed(name);\n    };\n    BindingWhenOnSyntax.prototype.whenAnyAncestorTagged = function (tag, value) {\n        return this._bindingWhenSyntax.whenAnyAncestorTagged(tag, value);\n    };\n    BindingWhenOnSyntax.prototype.whenNoAncestorNamed = function (name) {\n        return this._bindingWhenSyntax.whenNoAncestorNamed(name);\n    };\n    BindingWhenOnSyntax.prototype.whenNoAncestorTagged = function (tag, value) {\n        return this._bindingWhenSyntax.whenNoAncestorTagged(tag, value);\n    };\n    BindingWhenOnSyntax.prototype.whenAnyAncestorMatches = function (constraint) {\n        return this._bindingWhenSyntax.whenAnyAncestorMatches(constraint);\n    };\n    BindingWhenOnSyntax.prototype.whenNoAncestorMatches = function (constraint) {\n        return this._bindingWhenSyntax.whenNoAncestorMatches(constraint);\n    };\n    BindingWhenOnSyntax.prototype.onActivation = function (handler) {\n        return this._bindingOnSyntax.onActivation(handler);\n    };\n    BindingWhenOnSyntax.prototype.onDeactivation = function (handler) {\n        return this._bindingOnSyntax.onDeactivation(handler);\n    };\n    return BindingWhenOnSyntax;\n}());\nexport { BindingWhenOnSyntax };\n//# sourceMappingURL=binding_when_on_syntax.js.map","import { BindingScopeEnum } from \"../constants/literal_types\";\nimport { BindingWhenOnSyntax } from \"./binding_when_on_syntax\";\nvar BindingInSyntax = (function () {\n    function BindingInSyntax(binding) {\n        this._binding = binding;\n    }\n    BindingInSyntax.prototype.inRequestScope = function () {\n        this._binding.scope = BindingScopeEnum.Request;\n        return new BindingWhenOnSyntax(this._binding);\n    };\n    BindingInSyntax.prototype.inSingletonScope = function () {\n        this._binding.scope = BindingScopeEnum.Singleton;\n        return new BindingWhenOnSyntax(this._binding);\n    };\n    BindingInSyntax.prototype.inTransientScope = function () {\n        this._binding.scope = BindingScopeEnum.Transient;\n        return new BindingWhenOnSyntax(this._binding);\n    };\n    return BindingInSyntax;\n}());\nexport { BindingInSyntax };\n//# sourceMappingURL=binding_in_syntax.js.map","import { BindingInSyntax } from \"./binding_in_syntax\";\nimport { BindingOnSyntax } from \"./binding_on_syntax\";\nimport { BindingWhenSyntax } from \"./binding_when_syntax\";\nvar BindingInWhenOnSyntax = (function () {\n    function BindingInWhenOnSyntax(binding) {\n        this._binding = binding;\n        this._bindingWhenSyntax = new BindingWhenSyntax(this._binding);\n        this._bindingOnSyntax = new BindingOnSyntax(this._binding);\n        this._bindingInSyntax = new BindingInSyntax(binding);\n    }\n    BindingInWhenOnSyntax.prototype.inRequestScope = function () {\n        return this._bindingInSyntax.inRequestScope();\n    };\n    BindingInWhenOnSyntax.prototype.inSingletonScope = function () {\n        return this._bindingInSyntax.inSingletonScope();\n    };\n    BindingInWhenOnSyntax.prototype.inTransientScope = function () {\n        return this._bindingInSyntax.inTransientScope();\n    };\n    BindingInWhenOnSyntax.prototype.when = function (constraint) {\n        return this._bindingWhenSyntax.when(constraint);\n    };\n    BindingInWhenOnSyntax.prototype.whenTargetNamed = function (name) {\n        return this._bindingWhenSyntax.whenTargetNamed(name);\n    };\n    BindingInWhenOnSyntax.prototype.whenTargetIsDefault = function () {\n        return this._bindingWhenSyntax.whenTargetIsDefault();\n    };\n    BindingInWhenOnSyntax.prototype.whenTargetTagged = function (tag, value) {\n        return this._bindingWhenSyntax.whenTargetTagged(tag, value);\n    };\n    BindingInWhenOnSyntax.prototype.whenInjectedInto = function (parent) {\n        return this._bindingWhenSyntax.whenInjectedInto(parent);\n    };\n    BindingInWhenOnSyntax.prototype.whenParentNamed = function (name) {\n        return this._bindingWhenSyntax.whenParentNamed(name);\n    };\n    BindingInWhenOnSyntax.prototype.whenParentTagged = function (tag, value) {\n        return this._bindingWhenSyntax.whenParentTagged(tag, value);\n    };\n    BindingInWhenOnSyntax.prototype.whenAnyAncestorIs = function (ancestor) {\n        return this._bindingWhenSyntax.whenAnyAncestorIs(ancestor);\n    };\n    BindingInWhenOnSyntax.prototype.whenNoAncestorIs = function (ancestor) {\n        return this._bindingWhenSyntax.whenNoAncestorIs(ancestor);\n    };\n    BindingInWhenOnSyntax.prototype.whenAnyAncestorNamed = function (name) {\n        return this._bindingWhenSyntax.whenAnyAncestorNamed(name);\n    };\n    BindingInWhenOnSyntax.prototype.whenAnyAncestorTagged = function (tag, value) {\n        return this._bindingWhenSyntax.whenAnyAncestorTagged(tag, value);\n    };\n    BindingInWhenOnSyntax.prototype.whenNoAncestorNamed = function (name) {\n        return this._bindingWhenSyntax.whenNoAncestorNamed(name);\n    };\n    BindingInWhenOnSyntax.prototype.whenNoAncestorTagged = function (tag, value) {\n        return this._bindingWhenSyntax.whenNoAncestorTagged(tag, value);\n    };\n    BindingInWhenOnSyntax.prototype.whenAnyAncestorMatches = function (constraint) {\n        return this._bindingWhenSyntax.whenAnyAncestorMatches(constraint);\n    };\n    BindingInWhenOnSyntax.prototype.whenNoAncestorMatches = function (constraint) {\n        return this._bindingWhenSyntax.whenNoAncestorMatches(constraint);\n    };\n    BindingInWhenOnSyntax.prototype.onActivation = function (handler) {\n        return this._bindingOnSyntax.onActivation(handler);\n    };\n    BindingInWhenOnSyntax.prototype.onDeactivation = function (handler) {\n        return this._bindingOnSyntax.onDeactivation(handler);\n    };\n    return BindingInWhenOnSyntax;\n}());\nexport { BindingInWhenOnSyntax };\n//# sourceMappingURL=binding_in_when_on_syntax.js.map","import * as ERROR_MSGS from \"../constants/error_msgs\";\nimport { BindingScopeEnum, BindingTypeEnum } from \"../constants/literal_types\";\nimport { BindingInWhenOnSyntax } from \"./binding_in_when_on_syntax\";\nimport { BindingWhenOnSyntax } from \"./binding_when_on_syntax\";\nvar BindingToSyntax = (function () {\n    function BindingToSyntax(binding) {\n        this._binding = binding;\n    }\n    BindingToSyntax.prototype.to = function (constructor) {\n        this._binding.type = BindingTypeEnum.Instance;\n        this._binding.implementationType = constructor;\n        return new BindingInWhenOnSyntax(this._binding);\n    };\n    BindingToSyntax.prototype.toSelf = function () {\n        if (typeof this._binding.serviceIdentifier !== \"function\") {\n            throw new Error(\"\" + ERROR_MSGS.INVALID_TO_SELF_VALUE);\n        }\n        var self = this._binding.serviceIdentifier;\n        return this.to(self);\n    };\n    BindingToSyntax.prototype.toConstantValue = function (value) {\n        this._binding.type = BindingTypeEnum.ConstantValue;\n        this._binding.cache = value;\n        this._binding.dynamicValue = null;\n        this._binding.implementationType = null;\n        this._binding.scope = BindingScopeEnum.Singleton;\n        return new BindingWhenOnSyntax(this._binding);\n    };\n    BindingToSyntax.prototype.toDynamicValue = function (func) {\n        this._binding.type = BindingTypeEnum.DynamicValue;\n        this._binding.cache = null;\n        this._binding.dynamicValue = func;\n        this._binding.implementationType = null;\n        return new BindingInWhenOnSyntax(this._binding);\n    };\n    BindingToSyntax.prototype.toConstructor = function (constructor) {\n        this._binding.type = BindingTypeEnum.Constructor;\n        this._binding.implementationType = constructor;\n        this._binding.scope = BindingScopeEnum.Singleton;\n        return new BindingWhenOnSyntax(this._binding);\n    };\n    BindingToSyntax.prototype.toFactory = function (factory) {\n        this._binding.type = BindingTypeEnum.Factory;\n        this._binding.factory = factory;\n        this._binding.scope = BindingScopeEnum.Singleton;\n        return new BindingWhenOnSyntax(this._binding);\n    };\n    BindingToSyntax.prototype.toFunction = function (func) {\n        if (typeof func !== \"function\") {\n            throw new Error(ERROR_MSGS.INVALID_FUNCTION_BINDING);\n        }\n        var bindingWhenOnSyntax = this.toConstantValue(func);\n        this._binding.type = BindingTypeEnum.Function;\n        this._binding.scope = BindingScopeEnum.Singleton;\n        return bindingWhenOnSyntax;\n    };\n    BindingToSyntax.prototype.toAutoFactory = function (serviceIdentifier) {\n        this._binding.type = BindingTypeEnum.Factory;\n        this._binding.factory = function (context) {\n            var autofactory = function () { return context.container.get(serviceIdentifier); };\n            return autofactory;\n        };\n        this._binding.scope = BindingScopeEnum.Singleton;\n        return new BindingWhenOnSyntax(this._binding);\n    };\n    BindingToSyntax.prototype.toAutoNamedFactory = function (serviceIdentifier) {\n        this._binding.type = BindingTypeEnum.Factory;\n        this._binding.factory = function (context) {\n            return function (named) { return context.container.getNamed(serviceIdentifier, named); };\n        };\n        return new BindingWhenOnSyntax(this._binding);\n    };\n    BindingToSyntax.prototype.toProvider = function (provider) {\n        this._binding.type = BindingTypeEnum.Provider;\n        this._binding.provider = provider;\n        this._binding.scope = BindingScopeEnum.Singleton;\n        return new BindingWhenOnSyntax(this._binding);\n    };\n    BindingToSyntax.prototype.toService = function (service) {\n        this.toDynamicValue(function (context) { return context.container.get(service); });\n    };\n    return BindingToSyntax;\n}());\nexport { BindingToSyntax };\n//# sourceMappingURL=binding_to_syntax.js.map","var ContainerSnapshot = (function () {\n    function ContainerSnapshot() {\n    }\n    ContainerSnapshot.of = function (bindings, middleware, activations, deactivations, moduleActivationStore) {\n        var snapshot = new ContainerSnapshot();\n        snapshot.bindings = bindings;\n        snapshot.middleware = middleware;\n        snapshot.deactivations = deactivations;\n        snapshot.activations = activations;\n        snapshot.moduleActivationStore = moduleActivationStore;\n        return snapshot;\n    };\n    return ContainerSnapshot;\n}());\nexport { ContainerSnapshot };\n//# sourceMappingURL=container_snapshot.js.map","function isClonable(obj) {\n    return (typeof obj === 'object')\n        && (obj !== null)\n        && ('clone' in obj)\n        && typeof obj.clone === 'function';\n}\nexport { isClonable };\n//# sourceMappingURL=clonable.js.map","import * as ERROR_MSGS from \"../constants/error_msgs\";\nimport { isClonable } from \"../utils/clonable\";\nvar Lookup = (function () {\n    function Lookup() {\n        this._map = new Map();\n    }\n    Lookup.prototype.getMap = function () {\n        return this._map;\n    };\n    Lookup.prototype.add = function (serviceIdentifier, value) {\n        if (serviceIdentifier === null || serviceIdentifier === undefined) {\n            throw new Error(ERROR_MSGS.NULL_ARGUMENT);\n        }\n        if (value === null || value === undefined) {\n            throw new Error(ERROR_MSGS.NULL_ARGUMENT);\n        }\n        var entry = this._map.get(serviceIdentifier);\n        if (entry !== undefined) {\n            entry.push(value);\n        }\n        else {\n            this._map.set(serviceIdentifier, [value]);\n        }\n    };\n    Lookup.prototype.get = function (serviceIdentifier) {\n        if (serviceIdentifier === null || serviceIdentifier === undefined) {\n            throw new Error(ERROR_MSGS.NULL_ARGUMENT);\n        }\n        var entry = this._map.get(serviceIdentifier);\n        if (entry !== undefined) {\n            return entry;\n        }\n        else {\n            throw new Error(ERROR_MSGS.KEY_NOT_FOUND);\n        }\n    };\n    Lookup.prototype.remove = function (serviceIdentifier) {\n        if (serviceIdentifier === null || serviceIdentifier === undefined) {\n            throw new Error(ERROR_MSGS.NULL_ARGUMENT);\n        }\n        if (!this._map.delete(serviceIdentifier)) {\n            throw new Error(ERROR_MSGS.KEY_NOT_FOUND);\n        }\n    };\n    Lookup.prototype.removeIntersection = function (lookup) {\n        var _this = this;\n        this.traverse(function (serviceIdentifier, value) {\n            var lookupActivations = lookup.hasKey(serviceIdentifier) ? lookup.get(serviceIdentifier) : undefined;\n            if (lookupActivations !== undefined) {\n                var filteredValues = value.filter(function (lookupValue) {\n                    return !lookupActivations.some(function (moduleActivation) { return lookupValue === moduleActivation; });\n                });\n                _this._setValue(serviceIdentifier, filteredValues);\n            }\n        });\n    };\n    Lookup.prototype.removeByCondition = function (condition) {\n        var _this = this;\n        var removals = [];\n        this._map.forEach(function (entries, key) {\n            var updatedEntries = [];\n            for (var _i = 0, entries_1 = entries; _i < entries_1.length; _i++) {\n                var entry = entries_1[_i];\n                var remove = condition(entry);\n                if (remove) {\n                    removals.push(entry);\n                }\n                else {\n                    updatedEntries.push(entry);\n                }\n            }\n            _this._setValue(key, updatedEntries);\n        });\n        return removals;\n    };\n    Lookup.prototype.hasKey = function (serviceIdentifier) {\n        if (serviceIdentifier === null || serviceIdentifier === undefined) {\n            throw new Error(ERROR_MSGS.NULL_ARGUMENT);\n        }\n        return this._map.has(serviceIdentifier);\n    };\n    Lookup.prototype.clone = function () {\n        var copy = new Lookup();\n        this._map.forEach(function (value, key) {\n            value.forEach(function (b) { return copy.add(key, isClonable(b) ? b.clone() : b); });\n        });\n        return copy;\n    };\n    Lookup.prototype.traverse = function (func) {\n        this._map.forEach(function (value, key) {\n            func(key, value);\n        });\n    };\n    Lookup.prototype._setValue = function (serviceIdentifier, value) {\n        if (value.length > 0) {\n            this._map.set(serviceIdentifier, value);\n        }\n        else {\n            this._map.delete(serviceIdentifier);\n        }\n    };\n    return Lookup;\n}());\nexport { Lookup };\n//# sourceMappingURL=lookup.js.map","import { Lookup } from \"./lookup\";\nvar ModuleActivationStore = (function () {\n    function ModuleActivationStore() {\n        this._map = new Map();\n    }\n    ModuleActivationStore.prototype.remove = function (moduleId) {\n        if (this._map.has(moduleId)) {\n            var handlers = this._map.get(moduleId);\n            this._map.delete(moduleId);\n            return handlers;\n        }\n        return this._getEmptyHandlersStore();\n    };\n    ModuleActivationStore.prototype.addDeactivation = function (moduleId, serviceIdentifier, onDeactivation) {\n        this._getModuleActivationHandlers(moduleId)\n            .onDeactivations.add(serviceIdentifier, onDeactivation);\n    };\n    ModuleActivationStore.prototype.addActivation = function (moduleId, serviceIdentifier, onActivation) {\n        this._getModuleActivationHandlers(moduleId)\n            .onActivations.add(serviceIdentifier, onActivation);\n    };\n    ModuleActivationStore.prototype.clone = function () {\n        var clone = new ModuleActivationStore();\n        this._map.forEach(function (handlersStore, moduleId) {\n            clone._map.set(moduleId, {\n                onActivations: handlersStore.onActivations.clone(),\n                onDeactivations: handlersStore.onDeactivations.clone(),\n            });\n        });\n        return clone;\n    };\n    ModuleActivationStore.prototype._getModuleActivationHandlers = function (moduleId) {\n        var moduleActivationHandlers = this._map.get(moduleId);\n        if (moduleActivationHandlers === undefined) {\n            moduleActivationHandlers = this._getEmptyHandlersStore();\n            this._map.set(moduleId, moduleActivationHandlers);\n        }\n        return moduleActivationHandlers;\n    };\n    ModuleActivationStore.prototype._getEmptyHandlersStore = function () {\n        var handlersStore = {\n            onActivations: new Lookup(),\n            onDeactivations: new Lookup()\n        };\n        return handlersStore;\n    };\n    return ModuleActivationStore;\n}());\nexport { ModuleActivationStore };\n//# sourceMappingURL=module_activation_store.js.map","var __assign = (this && this.__assign) || function () {\n    __assign = Object.assign || function(t) {\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\n            s = arguments[i];\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\n                t[p] = s[p];\n        }\n        return t;\n    };\n    return __assign.apply(this, arguments);\n};\nvar __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n    return new (P || (P = Promise))(function (resolve, reject) {\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\n    });\n};\nvar __generator = (this && this.__generator) || function (thisArg, body) {\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\n    function verb(n) { return function (v) { return step([n, v]); }; }\n    function step(op) {\n        if (f) throw new TypeError(\"Generator is already executing.\");\n        while (_) try {\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\n            if (y = 0, t) op = [op[0] & 2, t.value];\n            switch (op[0]) {\n                case 0: case 1: t = op; break;\n                case 4: _.label++; return { value: op[1], done: false };\n                case 5: _.label++; y = op[1]; op = [0]; continue;\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\n                default:\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\n                    if (t[2]) _.ops.pop();\n                    _.trys.pop(); continue;\n            }\n            op = body.call(thisArg, _);\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\n    }\n};\nvar __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {\n    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\n        if (ar || !(i in from)) {\n            if (!ar) ar = Array.prototype.slice.call(from, 0, i);\n            ar[i] = from[i];\n        }\n    }\n    return to.concat(ar || Array.prototype.slice.call(from));\n};\nimport { Binding } from \"../bindings/binding\";\nimport * as ERROR_MSGS from \"../constants/error_msgs\";\nimport { BindingScopeEnum, TargetTypeEnum } from \"../constants/literal_types\";\nimport * as METADATA_KEY from \"../constants/metadata_keys\";\nimport { MetadataReader } from \"../planning/metadata_reader\";\nimport { createMockRequest, getBindingDictionary, plan } from \"../planning/planner\";\nimport { resolve } from \"../resolution/resolver\";\nimport { BindingToSyntax } from \"../syntax/binding_to_syntax\";\nimport { isPromise, isPromiseOrContainsPromise } from \"../utils/async\";\nimport { id } from \"../utils/id\";\nimport { getServiceIdentifierAsString } from \"../utils/serialization\";\nimport { ContainerSnapshot } from \"./container_snapshot\";\nimport { Lookup } from \"./lookup\";\nimport { ModuleActivationStore } from \"./module_activation_store\";\nvar Container = (function () {\n    function Container(containerOptions) {\n        var options = containerOptions || {};\n        if (typeof options !== \"object\") {\n            throw new Error(\"\" + ERROR_MSGS.CONTAINER_OPTIONS_MUST_BE_AN_OBJECT);\n        }\n        if (options.defaultScope === undefined) {\n            options.defaultScope = BindingScopeEnum.Transient;\n        }\n        else if (options.defaultScope !== BindingScopeEnum.Singleton &&\n            options.defaultScope !== BindingScopeEnum.Transient &&\n            options.defaultScope !== BindingScopeEnum.Request) {\n            throw new Error(\"\" + ERROR_MSGS.CONTAINER_OPTIONS_INVALID_DEFAULT_SCOPE);\n        }\n        if (options.autoBindInjectable === undefined) {\n            options.autoBindInjectable = false;\n        }\n        else if (typeof options.autoBindInjectable !== \"boolean\") {\n            throw new Error(\"\" + ERROR_MSGS.CONTAINER_OPTIONS_INVALID_AUTO_BIND_INJECTABLE);\n        }\n        if (options.skipBaseClassChecks === undefined) {\n            options.skipBaseClassChecks = false;\n        }\n        else if (typeof options.skipBaseClassChecks !== \"boolean\") {\n            throw new Error(\"\" + ERROR_MSGS.CONTAINER_OPTIONS_INVALID_SKIP_BASE_CHECK);\n        }\n        this.options = {\n            autoBindInjectable: options.autoBindInjectable,\n            defaultScope: options.defaultScope,\n            skipBaseClassChecks: options.skipBaseClassChecks\n        };\n        this.id = id();\n        this._bindingDictionary = new Lookup();\n        this._snapshots = [];\n        this._middleware = null;\n        this._activations = new Lookup();\n        this._deactivations = new Lookup();\n        this.parent = null;\n        this._metadataReader = new MetadataReader();\n        this._moduleActivationStore = new ModuleActivationStore();\n    }\n    Container.merge = function (container1, container2) {\n        var containers = [];\n        for (var _i = 2; _i < arguments.length; _i++) {\n            containers[_i - 2] = arguments[_i];\n        }\n        var container = new Container();\n        var targetContainers = __spreadArray([container1, container2], containers, true).map(function (targetContainer) { return getBindingDictionary(targetContainer); });\n        var bindingDictionary = getBindingDictionary(container);\n        function copyDictionary(origin, destination) {\n            origin.traverse(function (_key, value) {\n                value.forEach(function (binding) {\n                    destination.add(binding.serviceIdentifier, binding.clone());\n                });\n            });\n        }\n        targetContainers.forEach(function (targetBindingDictionary) {\n            copyDictionary(targetBindingDictionary, bindingDictionary);\n        });\n        return container;\n    };\n    Container.prototype.load = function () {\n        var modules = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            modules[_i] = arguments[_i];\n        }\n        var getHelpers = this._getContainerModuleHelpersFactory();\n        for (var _a = 0, modules_1 = modules; _a < modules_1.length; _a++) {\n            var currentModule = modules_1[_a];\n            var containerModuleHelpers = getHelpers(currentModule.id);\n            currentModule.registry(containerModuleHelpers.bindFunction, containerModuleHelpers.unbindFunction, containerModuleHelpers.isboundFunction, containerModuleHelpers.rebindFunction, containerModuleHelpers.unbindAsyncFunction, containerModuleHelpers.onActivationFunction, containerModuleHelpers.onDeactivationFunction);\n        }\n    };\n    Container.prototype.loadAsync = function () {\n        var modules = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            modules[_i] = arguments[_i];\n        }\n        return __awaiter(this, void 0, void 0, function () {\n            var getHelpers, _a, modules_2, currentModule, containerModuleHelpers;\n            return __generator(this, function (_b) {\n                switch (_b.label) {\n                    case 0:\n                        getHelpers = this._getContainerModuleHelpersFactory();\n                        _a = 0, modules_2 = modules;\n                        _b.label = 1;\n                    case 1:\n                        if (!(_a < modules_2.length)) return [3, 4];\n                        currentModule = modules_2[_a];\n                        containerModuleHelpers = getHelpers(currentModule.id);\n                        return [4, currentModule.registry(containerModuleHelpers.bindFunction, containerModuleHelpers.unbindFunction, containerModuleHelpers.isboundFunction, containerModuleHelpers.rebindFunction, containerModuleHelpers.unbindAsyncFunction, containerModuleHelpers.onActivationFunction, containerModuleHelpers.onDeactivationFunction)];\n                    case 2:\n                        _b.sent();\n                        _b.label = 3;\n                    case 3:\n                        _a++;\n                        return [3, 1];\n                    case 4: return [2];\n                }\n            });\n        });\n    };\n    Container.prototype.unload = function () {\n        var _this = this;\n        var modules = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            modules[_i] = arguments[_i];\n        }\n        modules.forEach(function (module) {\n            var deactivations = _this._removeModuleBindings(module.id);\n            _this._deactivateSingletons(deactivations);\n            _this._removeModuleHandlers(module.id);\n        });\n    };\n    Container.prototype.unloadAsync = function () {\n        var modules = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            modules[_i] = arguments[_i];\n        }\n        return __awaiter(this, void 0, void 0, function () {\n            var _a, modules_3, module_1, deactivations;\n            return __generator(this, function (_b) {\n                switch (_b.label) {\n                    case 0:\n                        _a = 0, modules_3 = modules;\n                        _b.label = 1;\n                    case 1:\n                        if (!(_a < modules_3.length)) return [3, 4];\n                        module_1 = modules_3[_a];\n                        deactivations = this._removeModuleBindings(module_1.id);\n                        return [4, this._deactivateSingletonsAsync(deactivations)];\n                    case 2:\n                        _b.sent();\n                        this._removeModuleHandlers(module_1.id);\n                        _b.label = 3;\n                    case 3:\n                        _a++;\n                        return [3, 1];\n                    case 4: return [2];\n                }\n            });\n        });\n    };\n    Container.prototype.bind = function (serviceIdentifier) {\n        var scope = this.options.defaultScope || BindingScopeEnum.Transient;\n        var binding = new Binding(serviceIdentifier, scope);\n        this._bindingDictionary.add(serviceIdentifier, binding);\n        return new BindingToSyntax(binding);\n    };\n    Container.prototype.rebind = function (serviceIdentifier) {\n        this.unbind(serviceIdentifier);\n        return this.bind(serviceIdentifier);\n    };\n    Container.prototype.rebindAsync = function (serviceIdentifier) {\n        return __awaiter(this, void 0, void 0, function () {\n            return __generator(this, function (_a) {\n                switch (_a.label) {\n                    case 0: return [4, this.unbindAsync(serviceIdentifier)];\n                    case 1:\n                        _a.sent();\n                        return [2, this.bind(serviceIdentifier)];\n                }\n            });\n        });\n    };\n    Container.prototype.unbind = function (serviceIdentifier) {\n        if (this._bindingDictionary.hasKey(serviceIdentifier)) {\n            var bindings = this._bindingDictionary.get(serviceIdentifier);\n            this._deactivateSingletons(bindings);\n        }\n        this._removeServiceFromDictionary(serviceIdentifier);\n    };\n    Container.prototype.unbindAsync = function (serviceIdentifier) {\n        return __awaiter(this, void 0, void 0, function () {\n            var bindings;\n            return __generator(this, function (_a) {\n                switch (_a.label) {\n                    case 0:\n                        if (!this._bindingDictionary.hasKey(serviceIdentifier)) return [3, 2];\n                        bindings = this._bindingDictionary.get(serviceIdentifier);\n                        return [4, this._deactivateSingletonsAsync(bindings)];\n                    case 1:\n                        _a.sent();\n                        _a.label = 2;\n                    case 2:\n                        this._removeServiceFromDictionary(serviceIdentifier);\n                        return [2];\n                }\n            });\n        });\n    };\n    Container.prototype.unbindAll = function () {\n        var _this = this;\n        this._bindingDictionary.traverse(function (_key, value) {\n            _this._deactivateSingletons(value);\n        });\n        this._bindingDictionary = new Lookup();\n    };\n    Container.prototype.unbindAllAsync = function () {\n        return __awaiter(this, void 0, void 0, function () {\n            var promises;\n            var _this = this;\n            return __generator(this, function (_a) {\n                switch (_a.label) {\n                    case 0:\n                        promises = [];\n                        this._bindingDictionary.traverse(function (_key, value) {\n                            promises.push(_this._deactivateSingletonsAsync(value));\n                        });\n                        return [4, Promise.all(promises)];\n                    case 1:\n                        _a.sent();\n                        this._bindingDictionary = new Lookup();\n                        return [2];\n                }\n            });\n        });\n    };\n    Container.prototype.onActivation = function (serviceIdentifier, onActivation) {\n        this._activations.add(serviceIdentifier, onActivation);\n    };\n    Container.prototype.onDeactivation = function (serviceIdentifier, onDeactivation) {\n        this._deactivations.add(serviceIdentifier, onDeactivation);\n    };\n    Container.prototype.isBound = function (serviceIdentifier) {\n        var bound = this._bindingDictionary.hasKey(serviceIdentifier);\n        if (!bound && this.parent) {\n            bound = this.parent.isBound(serviceIdentifier);\n        }\n        return bound;\n    };\n    Container.prototype.isCurrentBound = function (serviceIdentifier) {\n        return this._bindingDictionary.hasKey(serviceIdentifier);\n    };\n    Container.prototype.isBoundNamed = function (serviceIdentifier, named) {\n        return this.isBoundTagged(serviceIdentifier, METADATA_KEY.NAMED_TAG, named);\n    };\n    Container.prototype.isBoundTagged = function (serviceIdentifier, key, value) {\n        var bound = false;\n        if (this._bindingDictionary.hasKey(serviceIdentifier)) {\n            var bindings = this._bindingDictionary.get(serviceIdentifier);\n            var request_1 = createMockRequest(this, serviceIdentifier, key, value);\n            bound = bindings.some(function (b) { return b.constraint(request_1); });\n        }\n        if (!bound && this.parent) {\n            bound = this.parent.isBoundTagged(serviceIdentifier, key, value);\n        }\n        return bound;\n    };\n    Container.prototype.snapshot = function () {\n        this._snapshots.push(ContainerSnapshot.of(this._bindingDictionary.clone(), this._middleware, this._activations.clone(), this._deactivations.clone(), this._moduleActivationStore.clone()));\n    };\n    Container.prototype.restore = function () {\n        var snapshot = this._snapshots.pop();\n        if (snapshot === undefined) {\n            throw new Error(ERROR_MSGS.NO_MORE_SNAPSHOTS_AVAILABLE);\n        }\n        this._bindingDictionary = snapshot.bindings;\n        this._activations = snapshot.activations;\n        this._deactivations = snapshot.deactivations;\n        this._middleware = snapshot.middleware;\n        this._moduleActivationStore = snapshot.moduleActivationStore;\n    };\n    Container.prototype.createChild = function (containerOptions) {\n        var child = new Container(containerOptions || this.options);\n        child.parent = this;\n        return child;\n    };\n    Container.prototype.applyMiddleware = function () {\n        var middlewares = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            middlewares[_i] = arguments[_i];\n        }\n        var initial = (this._middleware) ? this._middleware : this._planAndResolve();\n        this._middleware = middlewares.reduce(function (prev, curr) { return curr(prev); }, initial);\n    };\n    Container.prototype.applyCustomMetadataReader = function (metadataReader) {\n        this._metadataReader = metadataReader;\n    };\n    Container.prototype.get = function (serviceIdentifier) {\n        var getArgs = this._getNotAllArgs(serviceIdentifier, false);\n        return this._getButThrowIfAsync(getArgs);\n    };\n    Container.prototype.getAsync = function (serviceIdentifier) {\n        return __awaiter(this, void 0, void 0, function () {\n            var getArgs;\n            return __generator(this, function (_a) {\n                getArgs = this._getNotAllArgs(serviceIdentifier, false);\n                return [2, this._get(getArgs)];\n            });\n        });\n    };\n    Container.prototype.getTagged = function (serviceIdentifier, key, value) {\n        var getArgs = this._getNotAllArgs(serviceIdentifier, false, key, value);\n        return this._getButThrowIfAsync(getArgs);\n    };\n    Container.prototype.getTaggedAsync = function (serviceIdentifier, key, value) {\n        return __awaiter(this, void 0, void 0, function () {\n            var getArgs;\n            return __generator(this, function (_a) {\n                getArgs = this._getNotAllArgs(serviceIdentifier, false, key, value);\n                return [2, this._get(getArgs)];\n            });\n        });\n    };\n    Container.prototype.getNamed = function (serviceIdentifier, named) {\n        return this.getTagged(serviceIdentifier, METADATA_KEY.NAMED_TAG, named);\n    };\n    Container.prototype.getNamedAsync = function (serviceIdentifier, named) {\n        return this.getTaggedAsync(serviceIdentifier, METADATA_KEY.NAMED_TAG, named);\n    };\n    Container.prototype.getAll = function (serviceIdentifier) {\n        var getArgs = this._getAllArgs(serviceIdentifier);\n        return this._getButThrowIfAsync(getArgs);\n    };\n    Container.prototype.getAllAsync = function (serviceIdentifier) {\n        var getArgs = this._getAllArgs(serviceIdentifier);\n        return this._getAll(getArgs);\n    };\n    Container.prototype.getAllTagged = function (serviceIdentifier, key, value) {\n        var getArgs = this._getNotAllArgs(serviceIdentifier, true, key, value);\n        return this._getButThrowIfAsync(getArgs);\n    };\n    Container.prototype.getAllTaggedAsync = function (serviceIdentifier, key, value) {\n        var getArgs = this._getNotAllArgs(serviceIdentifier, true, key, value);\n        return this._getAll(getArgs);\n    };\n    Container.prototype.getAllNamed = function (serviceIdentifier, named) {\n        return this.getAllTagged(serviceIdentifier, METADATA_KEY.NAMED_TAG, named);\n    };\n    Container.prototype.getAllNamedAsync = function (serviceIdentifier, named) {\n        return this.getAllTaggedAsync(serviceIdentifier, METADATA_KEY.NAMED_TAG, named);\n    };\n    Container.prototype.resolve = function (constructorFunction) {\n        var isBound = this.isBound(constructorFunction);\n        if (!isBound) {\n            this.bind(constructorFunction).toSelf();\n        }\n        var resolved = this.get(constructorFunction);\n        if (!isBound) {\n            this.unbind(constructorFunction);\n        }\n        return resolved;\n    };\n    Container.prototype._preDestroy = function (constructor, instance) {\n        if (Reflect.hasMetadata(METADATA_KEY.PRE_DESTROY, constructor)) {\n            var data = Reflect.getMetadata(METADATA_KEY.PRE_DESTROY, constructor);\n            return instance[data.value]();\n        }\n    };\n    Container.prototype._removeModuleHandlers = function (moduleId) {\n        var moduleActivationsHandlers = this._moduleActivationStore.remove(moduleId);\n        this._activations.removeIntersection(moduleActivationsHandlers.onActivations);\n        this._deactivations.removeIntersection(moduleActivationsHandlers.onDeactivations);\n    };\n    Container.prototype._removeModuleBindings = function (moduleId) {\n        return this._bindingDictionary.removeByCondition(function (binding) { return binding.moduleId === moduleId; });\n    };\n    Container.prototype._deactivate = function (binding, instance) {\n        var _this = this;\n        var constructor = Object.getPrototypeOf(instance).constructor;\n        try {\n            if (this._deactivations.hasKey(binding.serviceIdentifier)) {\n                var result = this._deactivateContainer(instance, this._deactivations.get(binding.serviceIdentifier).values());\n                if (isPromise(result)) {\n                    return this._handleDeactivationError(result.then(function () { return _this._propagateContainerDeactivationThenBindingAndPreDestroyAsync(binding, instance, constructor); }), constructor);\n                }\n            }\n            var propagateDeactivationResult = this._propagateContainerDeactivationThenBindingAndPreDestroy(binding, instance, constructor);\n            if (isPromise(propagateDeactivationResult)) {\n                return this._handleDeactivationError(propagateDeactivationResult, constructor);\n            }\n        }\n        catch (ex) {\n            throw new Error(ERROR_MSGS.ON_DEACTIVATION_ERROR(constructor.name, ex.message));\n        }\n    };\n    Container.prototype._handleDeactivationError = function (asyncResult, constructor) {\n        return __awaiter(this, void 0, void 0, function () {\n            var ex_1;\n            return __generator(this, function (_a) {\n                switch (_a.label) {\n                    case 0:\n                        _a.trys.push([0, 2, , 3]);\n                        return [4, asyncResult];\n                    case 1:\n                        _a.sent();\n                        return [3, 3];\n                    case 2:\n                        ex_1 = _a.sent();\n                        throw new Error(ERROR_MSGS.ON_DEACTIVATION_ERROR(constructor.name, ex_1.message));\n                    case 3: return [2];\n                }\n            });\n        });\n    };\n    Container.prototype._deactivateContainer = function (instance, deactivationsIterator) {\n        var _this = this;\n        var deactivation = deactivationsIterator.next();\n        while (deactivation.value) {\n            var result = deactivation.value(instance);\n            if (isPromise(result)) {\n                return result.then(function () {\n                    return _this._deactivateContainerAsync(instance, deactivationsIterator);\n                });\n            }\n            deactivation = deactivationsIterator.next();\n        }\n    };\n    Container.prototype._deactivateContainerAsync = function (instance, deactivationsIterator) {\n        return __awaiter(this, void 0, void 0, function () {\n            var deactivation;\n            return __generator(this, function (_a) {\n                switch (_a.label) {\n                    case 0:\n                        deactivation = deactivationsIterator.next();\n                        _a.label = 1;\n                    case 1:\n                        if (!deactivation.value) return [3, 3];\n                        return [4, deactivation.value(instance)];\n                    case 2:\n                        _a.sent();\n                        deactivation = deactivationsIterator.next();\n                        return [3, 1];\n                    case 3: return [2];\n                }\n            });\n        });\n    };\n    Container.prototype._getContainerModuleHelpersFactory = function () {\n        var _this = this;\n        var setModuleId = function (bindingToSyntax, moduleId) {\n            bindingToSyntax._binding.moduleId = moduleId;\n        };\n        var getBindFunction = function (moduleId) {\n            return function (serviceIdentifier) {\n                var bindingToSyntax = _this.bind(serviceIdentifier);\n                setModuleId(bindingToSyntax, moduleId);\n                return bindingToSyntax;\n            };\n        };\n        var getUnbindFunction = function () {\n            return function (serviceIdentifier) {\n                return _this.unbind(serviceIdentifier);\n            };\n        };\n        var getUnbindAsyncFunction = function () {\n            return function (serviceIdentifier) {\n                return _this.unbindAsync(serviceIdentifier);\n            };\n        };\n        var getIsboundFunction = function () {\n            return function (serviceIdentifier) {\n                return _this.isBound(serviceIdentifier);\n            };\n        };\n        var getRebindFunction = function (moduleId) {\n            return function (serviceIdentifier) {\n                var bindingToSyntax = _this.rebind(serviceIdentifier);\n                setModuleId(bindingToSyntax, moduleId);\n                return bindingToSyntax;\n            };\n        };\n        var getOnActivationFunction = function (moduleId) {\n            return function (serviceIdentifier, onActivation) {\n                _this._moduleActivationStore.addActivation(moduleId, serviceIdentifier, onActivation);\n                _this.onActivation(serviceIdentifier, onActivation);\n            };\n        };\n        var getOnDeactivationFunction = function (moduleId) {\n            return function (serviceIdentifier, onDeactivation) {\n                _this._moduleActivationStore.addDeactivation(moduleId, serviceIdentifier, onDeactivation);\n                _this.onDeactivation(serviceIdentifier, onDeactivation);\n            };\n        };\n        return function (mId) { return ({\n            bindFunction: getBindFunction(mId),\n            isboundFunction: getIsboundFunction(),\n            onActivationFunction: getOnActivationFunction(mId),\n            onDeactivationFunction: getOnDeactivationFunction(mId),\n            rebindFunction: getRebindFunction(mId),\n            unbindFunction: getUnbindFunction(),\n            unbindAsyncFunction: getUnbindAsyncFunction()\n        }); };\n    };\n    Container.prototype._getAll = function (getArgs) {\n        return Promise.all(this._get(getArgs));\n    };\n    Container.prototype._get = function (getArgs) {\n        var planAndResolveArgs = __assign(__assign({}, getArgs), { contextInterceptor: function (context) { return context; }, targetType: TargetTypeEnum.Variable });\n        if (this._middleware) {\n            var middlewareResult = this._middleware(planAndResolveArgs);\n            if (middlewareResult === undefined || middlewareResult === null) {\n                throw new Error(ERROR_MSGS.INVALID_MIDDLEWARE_RETURN);\n            }\n            return middlewareResult;\n        }\n        return this._planAndResolve()(planAndResolveArgs);\n    };\n    Container.prototype._getButThrowIfAsync = function (getArgs) {\n        var result = this._get(getArgs);\n        if (isPromiseOrContainsPromise(result)) {\n            throw new Error(ERROR_MSGS.LAZY_IN_SYNC(getArgs.serviceIdentifier));\n        }\n        return result;\n    };\n    Container.prototype._getAllArgs = function (serviceIdentifier) {\n        var getAllArgs = {\n            avoidConstraints: true,\n            isMultiInject: true,\n            serviceIdentifier: serviceIdentifier,\n        };\n        return getAllArgs;\n    };\n    Container.prototype._getNotAllArgs = function (serviceIdentifier, isMultiInject, key, value) {\n        var getNotAllArgs = {\n            avoidConstraints: false,\n            isMultiInject: isMultiInject,\n            serviceIdentifier: serviceIdentifier,\n            key: key,\n            value: value,\n        };\n        return getNotAllArgs;\n    };\n    Container.prototype._planAndResolve = function () {\n        var _this = this;\n        return function (args) {\n            var context = plan(_this._metadataReader, _this, args.isMultiInject, args.targetType, args.serviceIdentifier, args.key, args.value, args.avoidConstraints);\n            context = args.contextInterceptor(context);\n            var result = resolve(context);\n            return result;\n        };\n    };\n    Container.prototype._deactivateIfSingleton = function (binding) {\n        var _this = this;\n        if (!binding.activated) {\n            return;\n        }\n        if (isPromise(binding.cache)) {\n            return binding.cache.then(function (resolved) { return _this._deactivate(binding, resolved); });\n        }\n        return this._deactivate(binding, binding.cache);\n    };\n    Container.prototype._deactivateSingletons = function (bindings) {\n        for (var _i = 0, bindings_1 = bindings; _i < bindings_1.length; _i++) {\n            var binding = bindings_1[_i];\n            var result = this._deactivateIfSingleton(binding);\n            if (isPromise(result)) {\n                throw new Error(ERROR_MSGS.ASYNC_UNBIND_REQUIRED);\n            }\n        }\n    };\n    Container.prototype._deactivateSingletonsAsync = function (bindings) {\n        return __awaiter(this, void 0, void 0, function () {\n            var _this = this;\n            return __generator(this, function (_a) {\n                switch (_a.label) {\n                    case 0: return [4, Promise.all(bindings.map(function (b) { return _this._deactivateIfSingleton(b); }))];\n                    case 1:\n                        _a.sent();\n                        return [2];\n                }\n            });\n        });\n    };\n    Container.prototype._propagateContainerDeactivationThenBindingAndPreDestroy = function (binding, instance, constructor) {\n        if (this.parent) {\n            return this._deactivate.bind(this.parent)(binding, instance);\n        }\n        else {\n            return this._bindingDeactivationAndPreDestroy(binding, instance, constructor);\n        }\n    };\n    Container.prototype._propagateContainerDeactivationThenBindingAndPreDestroyAsync = function (binding, instance, constructor) {\n        return __awaiter(this, void 0, void 0, function () {\n            return __generator(this, function (_a) {\n                switch (_a.label) {\n                    case 0:\n                        if (!this.parent) return [3, 2];\n                        return [4, this._deactivate.bind(this.parent)(binding, instance)];\n                    case 1:\n                        _a.sent();\n                        return [3, 4];\n                    case 2: return [4, this._bindingDeactivationAndPreDestroyAsync(binding, instance, constructor)];\n                    case 3:\n                        _a.sent();\n                        _a.label = 4;\n                    case 4: return [2];\n                }\n            });\n        });\n    };\n    Container.prototype._removeServiceFromDictionary = function (serviceIdentifier) {\n        try {\n            this._bindingDictionary.remove(serviceIdentifier);\n        }\n        catch (e) {\n            throw new Error(ERROR_MSGS.CANNOT_UNBIND + \" \" + getServiceIdentifierAsString(serviceIdentifier));\n        }\n    };\n    Container.prototype._bindingDeactivationAndPreDestroy = function (binding, instance, constructor) {\n        var _this = this;\n        if (typeof binding.onDeactivation === \"function\") {\n            var result = binding.onDeactivation(instance);\n            if (isPromise(result)) {\n                return result.then(function () { return _this._preDestroy(constructor, instance); });\n            }\n        }\n        return this._preDestroy(constructor, instance);\n    };\n    Container.prototype._bindingDeactivationAndPreDestroyAsync = function (binding, instance, constructor) {\n        return __awaiter(this, void 0, void 0, function () {\n            return __generator(this, function (_a) {\n                switch (_a.label) {\n                    case 0:\n                        if (!(typeof binding.onDeactivation === \"function\")) return [3, 2];\n                        return [4, binding.onDeactivation(instance)];\n                    case 1:\n                        _a.sent();\n                        _a.label = 2;\n                    case 2: return [4, this._preDestroy(constructor, instance)];\n                    case 3:\n                        _a.sent();\n                        return [2];\n                }\n            });\n        });\n    };\n    return Container;\n}());\nexport { Container };\n//# sourceMappingURL=container.js.map","export function getFirstArrayDuplicate(array) {\n    var seenValues = new Set();\n    for (var _i = 0, array_1 = array; _i < array_1.length; _i++) {\n        var entry = array_1[_i];\n        if (seenValues.has(entry)) {\n            return entry;\n        }\n        else {\n            seenValues.add(entry);\n        }\n    }\n    return undefined;\n}\n//# sourceMappingURL=js.js.map","import * as ERROR_MSGS from \"../constants/error_msgs\";\nimport * as METADATA_KEY from \"../constants/metadata_keys\";\nimport { getFirstArrayDuplicate } from \"../utils/js\";\nfunction targetIsConstructorFunction(target) {\n    return target.prototype !== undefined;\n}\nfunction _throwIfMethodParameter(parameterName) {\n    if (parameterName !== undefined) {\n        throw new Error(ERROR_MSGS.INVALID_DECORATOR_OPERATION);\n    }\n}\nfunction tagParameter(annotationTarget, parameterName, parameterIndex, metadata) {\n    _throwIfMethodParameter(parameterName);\n    _tagParameterOrProperty(METADATA_KEY.TAGGED, annotationTarget, parameterIndex.toString(), metadata);\n}\nfunction tagProperty(annotationTarget, propertyName, metadata) {\n    if (targetIsConstructorFunction(annotationTarget)) {\n        throw new Error(ERROR_MSGS.INVALID_DECORATOR_OPERATION);\n    }\n    _tagParameterOrProperty(METADATA_KEY.TAGGED_PROP, annotationTarget.constructor, propertyName, metadata);\n}\nfunction _ensureNoMetadataKeyDuplicates(metadata) {\n    var metadatas = [];\n    if (Array.isArray(metadata)) {\n        metadatas = metadata;\n        var duplicate = getFirstArrayDuplicate(metadatas.map(function (md) { return md.key; }));\n        if (duplicate !== undefined) {\n            throw new Error(ERROR_MSGS.DUPLICATED_METADATA + \" \" + duplicate.toString());\n        }\n    }\n    else {\n        metadatas = [metadata];\n    }\n    return metadatas;\n}\nfunction _tagParameterOrProperty(metadataKey, annotationTarget, key, metadata) {\n    var metadatas = _ensureNoMetadataKeyDuplicates(metadata);\n    var paramsOrPropertiesMetadata = {};\n    if (Reflect.hasOwnMetadata(metadataKey, annotationTarget)) {\n        paramsOrPropertiesMetadata = Reflect.getMetadata(metadataKey, annotationTarget);\n    }\n    var paramOrPropertyMetadata = paramsOrPropertiesMetadata[key];\n    if (paramOrPropertyMetadata === undefined) {\n        paramOrPropertyMetadata = [];\n    }\n    else {\n        var _loop_1 = function (m) {\n            if (metadatas.some(function (md) { return md.key === m.key; })) {\n                throw new Error(ERROR_MSGS.DUPLICATED_METADATA + \" \" + m.key.toString());\n            }\n        };\n        for (var _i = 0, paramOrPropertyMetadata_1 = paramOrPropertyMetadata; _i < paramOrPropertyMetadata_1.length; _i++) {\n            var m = paramOrPropertyMetadata_1[_i];\n            _loop_1(m);\n        }\n    }\n    paramOrPropertyMetadata.push.apply(paramOrPropertyMetadata, metadatas);\n    paramsOrPropertiesMetadata[key] = paramOrPropertyMetadata;\n    Reflect.defineMetadata(metadataKey, paramsOrPropertiesMetadata, annotationTarget);\n}\nfunction createTaggedDecorator(metadata) {\n    return function (target, targetKey, indexOrPropertyDescriptor) {\n        if (typeof indexOrPropertyDescriptor === \"number\") {\n            tagParameter(target, targetKey, indexOrPropertyDescriptor, metadata);\n        }\n        else {\n            tagProperty(target, targetKey, metadata);\n        }\n    };\n}\nfunction _decorate(decorators, target) {\n    Reflect.decorate(decorators, target);\n}\nfunction _param(paramIndex, decorator) {\n    return function (target, key) { decorator(target, key, paramIndex); };\n}\nfunction decorate(decorator, target, parameterIndexOrProperty) {\n    if (typeof parameterIndexOrProperty === \"number\") {\n        _decorate([_param(parameterIndexOrProperty, decorator)], target);\n    }\n    else if (typeof parameterIndexOrProperty === \"string\") {\n        Reflect.decorate([decorator], target, parameterIndexOrProperty);\n    }\n    else {\n        _decorate([decorator], target);\n    }\n}\nexport { decorate, tagParameter, tagProperty, createTaggedDecorator };\n//# sourceMappingURL=decorator_utils.js.map","import * as ERRORS_MSGS from \"../constants/error_msgs\";\nimport * as METADATA_KEY from \"../constants/metadata_keys\";\nfunction injectable() {\n    return function (target) {\n        if (Reflect.hasOwnMetadata(METADATA_KEY.PARAM_TYPES, target)) {\n            throw new Error(ERRORS_MSGS.DUPLICATED_INJECTABLE_DECORATOR);\n        }\n        var types = Reflect.getMetadata(METADATA_KEY.DESIGN_PARAM_TYPES, target) || [];\n        Reflect.defineMetadata(METADATA_KEY.PARAM_TYPES, types, target);\n        return target;\n    };\n}\nexport { injectable };\n//# sourceMappingURL=injectable.js.map","import { UNDEFINED_INJECT_ANNOTATION } from \"../constants/error_msgs\";\nimport { Metadata } from \"../planning/metadata\";\nimport { createTaggedDecorator } from \"./decorator_utils\";\nexport function injectBase(metadataKey) {\n    return function (serviceIdentifier) {\n        return function (target, targetKey, indexOrPropertyDescriptor) {\n            if (serviceIdentifier === undefined) {\n                var className = typeof target === \"function\" ? target.name : target.constructor.name;\n                throw new Error(UNDEFINED_INJECT_ANNOTATION(className));\n            }\n            return createTaggedDecorator(new Metadata(metadataKey, serviceIdentifier))(target, targetKey, indexOrPropertyDescriptor);\n        };\n    };\n}\n//# sourceMappingURL=inject_base.js.map","import * as METADATA_KEY from \"../constants/metadata_keys\";\nimport { injectBase } from \"./inject_base\";\nvar inject = injectBase(METADATA_KEY.INJECT_TAG);\nexport { inject };\n//# sourceMappingURL=inject.js.map","import { PluginConfig } from '../types';\n\nexport const PLUGIN_SYSTEM_AUTO_UPDATE = 'PLUGIN_SYSTEM_AUTO_UPDATE';\nexport const PLUGIN_SYSTEM_PLUGIN = 'PLUGIN_SYSTEM_PLUGIN';\nexport const PLUGIN_SYSTEM_THIRD_PARTY_PLUGIN = 'PLUGIN_SYSTEM_THIRD_PARTY_PLUGIN';\nexport const PLUGIN_SYSTEM_SAFE_MODE_ENABLED = 'PLUGIN_SYSTEM_SAFE_MODE_ENABLED';\nexport const PLUGIN_STORE_URL = 'PLUGIN_STORE_URL';\n\nexport const defaultConfig: PluginConfig = {\n    [PLUGIN_SYSTEM_SAFE_MODE_ENABLED]: true,\n    [PLUGIN_SYSTEM_AUTO_UPDATE]: true,\n    [PLUGIN_SYSTEM_PLUGIN]: [{ key: 'setting', enabled: true }],\n    [PLUGIN_SYSTEM_THIRD_PARTY_PLUGIN]: [],\n    [PLUGIN_STORE_URL]: 'https://bitbucket.org/siyuan-plugin/siyuan-plugins/raw/main/',\n};\n","function noop() { }\nconst identity = x => x;\nfunction assign(tar, src) {\n    // @ts-ignore\n    for (const k in src)\n        tar[k] = src[k];\n    return tar;\n}\n// Adapted from https://github.com/then/is-promise/blob/master/index.js\n// Distributed under MIT License https://github.com/then/is-promise/blob/master/LICENSE\nfunction is_promise(value) {\n    return !!value && (typeof value === 'object' || typeof value === 'function') && typeof value.then === 'function';\n}\nfunction add_location(element, file, line, column, char) {\n    element.__svelte_meta = {\n        loc: { file, line, column, char }\n    };\n}\nfunction run(fn) {\n    return fn();\n}\nfunction blank_object() {\n    return Object.create(null);\n}\nfunction run_all(fns) {\n    fns.forEach(run);\n}\nfunction is_function(thing) {\n    return typeof thing === 'function';\n}\nfunction safe_not_equal(a, b) {\n    return a != a ? b == b : a !== b || ((a && typeof a === 'object') || typeof a === 'function');\n}\nlet src_url_equal_anchor;\nfunction src_url_equal(element_src, url) {\n    if (!src_url_equal_anchor) {\n        src_url_equal_anchor = document.createElement('a');\n    }\n    src_url_equal_anchor.href = url;\n    return element_src === src_url_equal_anchor.href;\n}\nfunction not_equal(a, b) {\n    return a != a ? b == b : a !== b;\n}\nfunction is_empty(obj) {\n    return Object.keys(obj).length === 0;\n}\nfunction validate_store(store, name) {\n    if (store != null && typeof store.subscribe !== 'function') {\n        throw new Error(`'${name}' is not a store with a 'subscribe' method`);\n    }\n}\nfunction subscribe(store, ...callbacks) {\n    if (store == null) {\n        return noop;\n    }\n    const unsub = store.subscribe(...callbacks);\n    return unsub.unsubscribe ? () => unsub.unsubscribe() : unsub;\n}\nfunction get_store_value(store) {\n    let value;\n    subscribe(store, _ => value = _)();\n    return value;\n}\nfunction component_subscribe(component, store, callback) {\n    component.$$.on_destroy.push(subscribe(store, callback));\n}\nfunction create_slot(definition, ctx, $$scope, fn) {\n    if (definition) {\n        const slot_ctx = get_slot_context(definition, ctx, $$scope, fn);\n        return definition[0](slot_ctx);\n    }\n}\nfunction get_slot_context(definition, ctx, $$scope, fn) {\n    return definition[1] && fn\n        ? assign($$scope.ctx.slice(), definition[1](fn(ctx)))\n        : $$scope.ctx;\n}\nfunction get_slot_changes(definition, $$scope, dirty, fn) {\n    if (definition[2] && fn) {\n        const lets = definition[2](fn(dirty));\n        if ($$scope.dirty === undefined) {\n            return lets;\n        }\n        if (typeof lets === 'object') {\n            const merged = [];\n            const len = Math.max($$scope.dirty.length, lets.length);\n            for (let i = 0; i < len; i += 1) {\n                merged[i] = $$scope.dirty[i] | lets[i];\n            }\n            return merged;\n        }\n        return $$scope.dirty | lets;\n    }\n    return $$scope.dirty;\n}\nfunction update_slot_base(slot, slot_definition, ctx, $$scope, slot_changes, get_slot_context_fn) {\n    if (slot_changes) {\n        const slot_context = get_slot_context(slot_definition, ctx, $$scope, get_slot_context_fn);\n        slot.p(slot_context, slot_changes);\n    }\n}\nfunction update_slot(slot, slot_definition, ctx, $$scope, dirty, get_slot_changes_fn, get_slot_context_fn) {\n    const slot_changes = get_slot_changes(slot_definition, $$scope, dirty, get_slot_changes_fn);\n    update_slot_base(slot, slot_definition, ctx, $$scope, slot_changes, get_slot_context_fn);\n}\nfunction get_all_dirty_from_scope($$scope) {\n    if ($$scope.ctx.length > 32) {\n        const dirty = [];\n        const length = $$scope.ctx.length / 32;\n        for (let i = 0; i < length; i++) {\n            dirty[i] = -1;\n        }\n        return dirty;\n    }\n    return -1;\n}\nfunction exclude_internal_props(props) {\n    const result = {};\n    for (const k in props)\n        if (k[0] !== '$')\n            result[k] = props[k];\n    return result;\n}\nfunction compute_rest_props(props, keys) {\n    const rest = {};\n    keys = new Set(keys);\n    for (const k in props)\n        if (!keys.has(k) && k[0] !== '$')\n            rest[k] = props[k];\n    return rest;\n}\nfunction compute_slots(slots) {\n    const result = {};\n    for (const key in slots) {\n        result[key] = true;\n    }\n    return result;\n}\nfunction once(fn) {\n    let ran = false;\n    return function (...args) {\n        if (ran)\n            return;\n        ran = true;\n        fn.call(this, ...args);\n    };\n}\nfunction null_to_empty(value) {\n    return value == null ? '' : value;\n}\nfunction set_store_value(store, ret, value) {\n    store.set(value);\n    return ret;\n}\nconst has_prop = (obj, prop) => Object.prototype.hasOwnProperty.call(obj, prop);\nfunction action_destroyer(action_result) {\n    return action_result && is_function(action_result.destroy) ? action_result.destroy : noop;\n}\n\nconst is_client = typeof window !== 'undefined';\nlet now = is_client\n    ? () => window.performance.now()\n    : () => Date.now();\nlet raf = is_client ? cb => requestAnimationFrame(cb) : noop;\n// used internally for testing\nfunction set_now(fn) {\n    now = fn;\n}\nfunction set_raf(fn) {\n    raf = fn;\n}\n\nconst tasks = new Set();\nfunction run_tasks(now) {\n    tasks.forEach(task => {\n        if (!task.c(now)) {\n            tasks.delete(task);\n            task.f();\n        }\n    });\n    if (tasks.size !== 0)\n        raf(run_tasks);\n}\n/**\n * For testing purposes only!\n */\nfunction clear_loops() {\n    tasks.clear();\n}\n/**\n * Creates a new task that runs on each raf frame\n * until it returns a falsy value or is aborted\n */\nfunction loop(callback) {\n    let task;\n    if (tasks.size === 0)\n        raf(run_tasks);\n    return {\n        promise: new Promise(fulfill => {\n            tasks.add(task = { c: callback, f: fulfill });\n        }),\n        abort() {\n            tasks.delete(task);\n        }\n    };\n}\n\n// Track which nodes are claimed during hydration. Unclaimed nodes can then be removed from the DOM\n// at the end of hydration without touching the remaining nodes.\nlet is_hydrating = false;\nfunction start_hydrating() {\n    is_hydrating = true;\n}\nfunction end_hydrating() {\n    is_hydrating = false;\n}\nfunction upper_bound(low, high, key, value) {\n    // Return first index of value larger than input value in the range [low, high)\n    while (low < high) {\n        const mid = low + ((high - low) >> 1);\n        if (key(mid) <= value) {\n            low = mid + 1;\n        }\n        else {\n            high = mid;\n        }\n    }\n    return low;\n}\nfunction init_hydrate(target) {\n    if (target.hydrate_init)\n        return;\n    target.hydrate_init = true;\n    // We know that all children have claim_order values since the unclaimed have been detached if target is not <head>\n    let children = target.childNodes;\n    // If target is <head>, there may be children without claim_order\n    if (target.nodeName === 'HEAD') {\n        const myChildren = [];\n        for (let i = 0; i < children.length; i++) {\n            const node = children[i];\n            if (node.claim_order !== undefined) {\n                myChildren.push(node);\n            }\n        }\n        children = myChildren;\n    }\n    /*\n    * Reorder claimed children optimally.\n    * We can reorder claimed children optimally by finding the longest subsequence of\n    * nodes that are already claimed in order and only moving the rest. The longest\n    * subsequence of nodes that are claimed in order can be found by\n    * computing the longest increasing subsequence of .claim_order values.\n    *\n    * This algorithm is optimal in generating the least amount of reorder operations\n    * possible.\n    *\n    * Proof:\n    * We know that, given a set of reordering operations, the nodes that do not move\n    * always form an increasing subsequence, since they do not move among each other\n    * meaning that they must be already ordered among each other. Thus, the maximal\n    * set of nodes that do not move form a longest increasing subsequence.\n    */\n    // Compute longest increasing subsequence\n    // m: subsequence length j => index k of smallest value that ends an increasing subsequence of length j\n    const m = new Int32Array(children.length + 1);\n    // Predecessor indices + 1\n    const p = new Int32Array(children.length);\n    m[0] = -1;\n    let longest = 0;\n    for (let i = 0; i < children.length; i++) {\n        const current = children[i].claim_order;\n        // Find the largest subsequence length such that it ends in a value less than our current value\n        // upper_bound returns first greater value, so we subtract one\n        // with fast path for when we are on the current longest subsequence\n        const seqLen = ((longest > 0 && children[m[longest]].claim_order <= current) ? longest + 1 : upper_bound(1, longest, idx => children[m[idx]].claim_order, current)) - 1;\n        p[i] = m[seqLen] + 1;\n        const newLen = seqLen + 1;\n        // We can guarantee that current is the smallest value. Otherwise, we would have generated a longer sequence.\n        m[newLen] = i;\n        longest = Math.max(newLen, longest);\n    }\n    // The longest increasing subsequence of nodes (initially reversed)\n    const lis = [];\n    // The rest of the nodes, nodes that will be moved\n    const toMove = [];\n    let last = children.length - 1;\n    for (let cur = m[longest] + 1; cur != 0; cur = p[cur - 1]) {\n        lis.push(children[cur - 1]);\n        for (; last >= cur; last--) {\n            toMove.push(children[last]);\n        }\n        last--;\n    }\n    for (; last >= 0; last--) {\n        toMove.push(children[last]);\n    }\n    lis.reverse();\n    // We sort the nodes being moved to guarantee that their insertion order matches the claim order\n    toMove.sort((a, b) => a.claim_order - b.claim_order);\n    // Finally, we move the nodes\n    for (let i = 0, j = 0; i < toMove.length; i++) {\n        while (j < lis.length && toMove[i].claim_order >= lis[j].claim_order) {\n            j++;\n        }\n        const anchor = j < lis.length ? lis[j] : null;\n        target.insertBefore(toMove[i], anchor);\n    }\n}\nfunction append(target, node) {\n    target.appendChild(node);\n}\nfunction append_styles(target, style_sheet_id, styles) {\n    const append_styles_to = get_root_for_style(target);\n    if (!append_styles_to.getElementById(style_sheet_id)) {\n        const style = element('style');\n        style.id = style_sheet_id;\n        style.textContent = styles;\n        append_stylesheet(append_styles_to, style);\n    }\n}\nfunction get_root_for_style(node) {\n    if (!node)\n        return document;\n    const root = node.getRootNode ? node.getRootNode() : node.ownerDocument;\n    if (root && root.host) {\n        return root;\n    }\n    return node.ownerDocument;\n}\nfunction append_empty_stylesheet(node) {\n    const style_element = element('style');\n    append_stylesheet(get_root_for_style(node), style_element);\n    return style_element.sheet;\n}\nfunction append_stylesheet(node, style) {\n    append(node.head || node, style);\n    return style.sheet;\n}\nfunction append_hydration(target, node) {\n    if (is_hydrating) {\n        init_hydrate(target);\n        if ((target.actual_end_child === undefined) || ((target.actual_end_child !== null) && (target.actual_end_child.parentNode !== target))) {\n            target.actual_end_child = target.firstChild;\n        }\n        // Skip nodes of undefined ordering\n        while ((target.actual_end_child !== null) && (target.actual_end_child.claim_order === undefined)) {\n            target.actual_end_child = target.actual_end_child.nextSibling;\n        }\n        if (node !== target.actual_end_child) {\n            // We only insert if the ordering of this node should be modified or the parent node is not target\n            if (node.claim_order !== undefined || node.parentNode !== target) {\n                target.insertBefore(node, target.actual_end_child);\n            }\n        }\n        else {\n            target.actual_end_child = node.nextSibling;\n        }\n    }\n    else if (node.parentNode !== target || node.nextSibling !== null) {\n        target.appendChild(node);\n    }\n}\nfunction insert(target, node, anchor) {\n    target.insertBefore(node, anchor || null);\n}\nfunction insert_hydration(target, node, anchor) {\n    if (is_hydrating && !anchor) {\n        append_hydration(target, node);\n    }\n    else if (node.parentNode !== target || node.nextSibling != anchor) {\n        target.insertBefore(node, anchor || null);\n    }\n}\nfunction detach(node) {\n    if (node.parentNode) {\n        node.parentNode.removeChild(node);\n    }\n}\nfunction destroy_each(iterations, detaching) {\n    for (let i = 0; i < iterations.length; i += 1) {\n        if (iterations[i])\n            iterations[i].d(detaching);\n    }\n}\nfunction element(name) {\n    return document.createElement(name);\n}\nfunction element_is(name, is) {\n    return document.createElement(name, { is });\n}\nfunction object_without_properties(obj, exclude) {\n    const target = {};\n    for (const k in obj) {\n        if (has_prop(obj, k)\n            // @ts-ignore\n            && exclude.indexOf(k) === -1) {\n            // @ts-ignore\n            target[k] = obj[k];\n        }\n    }\n    return target;\n}\nfunction svg_element(name) {\n    return document.createElementNS('http://www.w3.org/2000/svg', name);\n}\nfunction text(data) {\n    return document.createTextNode(data);\n}\nfunction space() {\n    return text(' ');\n}\nfunction empty() {\n    return text('');\n}\nfunction listen(node, event, handler, options) {\n    node.addEventListener(event, handler, options);\n    return () => node.removeEventListener(event, handler, options);\n}\nfunction prevent_default(fn) {\n    return function (event) {\n        event.preventDefault();\n        // @ts-ignore\n        return fn.call(this, event);\n    };\n}\nfunction stop_propagation(fn) {\n    return function (event) {\n        event.stopPropagation();\n        // @ts-ignore\n        return fn.call(this, event);\n    };\n}\nfunction self(fn) {\n    return function (event) {\n        // @ts-ignore\n        if (event.target === this)\n            fn.call(this, event);\n    };\n}\nfunction trusted(fn) {\n    return function (event) {\n        // @ts-ignore\n        if (event.isTrusted)\n            fn.call(this, event);\n    };\n}\nfunction attr(node, attribute, value) {\n    if (value == null)\n        node.removeAttribute(attribute);\n    else if (node.getAttribute(attribute) !== value)\n        node.setAttribute(attribute, value);\n}\nfunction set_attributes(node, attributes) {\n    // @ts-ignore\n    const descriptors = Object.getOwnPropertyDescriptors(node.__proto__);\n    for (const key in attributes) {\n        if (attributes[key] == null) {\n            node.removeAttribute(key);\n        }\n        else if (key === 'style') {\n            node.style.cssText = attributes[key];\n        }\n        else if (key === '__value') {\n            node.value = node[key] = attributes[key];\n        }\n        else if (descriptors[key] && descriptors[key].set) {\n            node[key] = attributes[key];\n        }\n        else {\n            attr(node, key, attributes[key]);\n        }\n    }\n}\nfunction set_svg_attributes(node, attributes) {\n    for (const key in attributes) {\n        attr(node, key, attributes[key]);\n    }\n}\nfunction set_custom_element_data_map(node, data_map) {\n    Object.keys(data_map).forEach((key) => {\n        set_custom_element_data(node, key, data_map[key]);\n    });\n}\nfunction set_custom_element_data(node, prop, value) {\n    if (prop in node) {\n        node[prop] = typeof node[prop] === 'boolean' && value === '' ? true : value;\n    }\n    else {\n        attr(node, prop, value);\n    }\n}\nfunction xlink_attr(node, attribute, value) {\n    node.setAttributeNS('http://www.w3.org/1999/xlink', attribute, value);\n}\nfunction get_binding_group_value(group, __value, checked) {\n    const value = new Set();\n    for (let i = 0; i < group.length; i += 1) {\n        if (group[i].checked)\n            value.add(group[i].__value);\n    }\n    if (!checked) {\n        value.delete(__value);\n    }\n    return Array.from(value);\n}\nfunction to_number(value) {\n    return value === '' ? null : +value;\n}\nfunction time_ranges_to_array(ranges) {\n    const array = [];\n    for (let i = 0; i < ranges.length; i += 1) {\n        array.push({ start: ranges.start(i), end: ranges.end(i) });\n    }\n    return array;\n}\nfunction children(element) {\n    return Array.from(element.childNodes);\n}\nfunction init_claim_info(nodes) {\n    if (nodes.claim_info === undefined) {\n        nodes.claim_info = { last_index: 0, total_claimed: 0 };\n    }\n}\nfunction claim_node(nodes, predicate, processNode, createNode, dontUpdateLastIndex = false) {\n    // Try to find nodes in an order such that we lengthen the longest increasing subsequence\n    init_claim_info(nodes);\n    const resultNode = (() => {\n        // We first try to find an element after the previous one\n        for (let i = nodes.claim_info.last_index; i < nodes.length; i++) {\n            const node = nodes[i];\n            if (predicate(node)) {\n                const replacement = processNode(node);\n                if (replacement === undefined) {\n                    nodes.splice(i, 1);\n                }\n                else {\n                    nodes[i] = replacement;\n                }\n                if (!dontUpdateLastIndex) {\n                    nodes.claim_info.last_index = i;\n                }\n                return node;\n            }\n        }\n        // Otherwise, we try to find one before\n        // We iterate in reverse so that we don't go too far back\n        for (let i = nodes.claim_info.last_index - 1; i >= 0; i--) {\n            const node = nodes[i];\n            if (predicate(node)) {\n                const replacement = processNode(node);\n                if (replacement === undefined) {\n                    nodes.splice(i, 1);\n                }\n                else {\n                    nodes[i] = replacement;\n                }\n                if (!dontUpdateLastIndex) {\n                    nodes.claim_info.last_index = i;\n                }\n                else if (replacement === undefined) {\n                    // Since we spliced before the last_index, we decrease it\n                    nodes.claim_info.last_index--;\n                }\n                return node;\n            }\n        }\n        // If we can't find any matching node, we create a new one\n        return createNode();\n    })();\n    resultNode.claim_order = nodes.claim_info.total_claimed;\n    nodes.claim_info.total_claimed += 1;\n    return resultNode;\n}\nfunction claim_element_base(nodes, name, attributes, create_element) {\n    return claim_node(nodes, (node) => node.nodeName === name, (node) => {\n        const remove = [];\n        for (let j = 0; j < node.attributes.length; j++) {\n            const attribute = node.attributes[j];\n            if (!attributes[attribute.name]) {\n                remove.push(attribute.name);\n            }\n        }\n        remove.forEach(v => node.removeAttribute(v));\n        return undefined;\n    }, () => create_element(name));\n}\nfunction claim_element(nodes, name, attributes) {\n    return claim_element_base(nodes, name, attributes, element);\n}\nfunction claim_svg_element(nodes, name, attributes) {\n    return claim_element_base(nodes, name, attributes, svg_element);\n}\nfunction claim_text(nodes, data) {\n    return claim_node(nodes, (node) => node.nodeType === 3, (node) => {\n        const dataStr = '' + data;\n        if (node.data.startsWith(dataStr)) {\n            if (node.data.length !== dataStr.length) {\n                return node.splitText(dataStr.length);\n            }\n        }\n        else {\n            node.data = dataStr;\n        }\n    }, () => text(data), true // Text nodes should not update last index since it is likely not worth it to eliminate an increasing subsequence of actual elements\n    );\n}\nfunction claim_space(nodes) {\n    return claim_text(nodes, ' ');\n}\nfunction find_comment(nodes, text, start) {\n    for (let i = start; i < nodes.length; i += 1) {\n        const node = nodes[i];\n        if (node.nodeType === 8 /* comment node */ && node.textContent.trim() === text) {\n            return i;\n        }\n    }\n    return nodes.length;\n}\nfunction claim_html_tag(nodes, is_svg) {\n    // find html opening tag\n    const start_index = find_comment(nodes, 'HTML_TAG_START', 0);\n    const end_index = find_comment(nodes, 'HTML_TAG_END', start_index);\n    if (start_index === end_index) {\n        return new HtmlTagHydration(undefined, is_svg);\n    }\n    init_claim_info(nodes);\n    const html_tag_nodes = nodes.splice(start_index, end_index - start_index + 1);\n    detach(html_tag_nodes[0]);\n    detach(html_tag_nodes[html_tag_nodes.length - 1]);\n    const claimed_nodes = html_tag_nodes.slice(1, html_tag_nodes.length - 1);\n    for (const n of claimed_nodes) {\n        n.claim_order = nodes.claim_info.total_claimed;\n        nodes.claim_info.total_claimed += 1;\n    }\n    return new HtmlTagHydration(claimed_nodes, is_svg);\n}\nfunction set_data(text, data) {\n    data = '' + data;\n    if (text.wholeText !== data)\n        text.data = data;\n}\nfunction set_input_value(input, value) {\n    input.value = value == null ? '' : value;\n}\nfunction set_input_type(input, type) {\n    try {\n        input.type = type;\n    }\n    catch (e) {\n        // do nothing\n    }\n}\nfunction set_style(node, key, value, important) {\n    if (value === null) {\n        node.style.removeProperty(key);\n    }\n    else {\n        node.style.setProperty(key, value, important ? 'important' : '');\n    }\n}\nfunction select_option(select, value) {\n    for (let i = 0; i < select.options.length; i += 1) {\n        const option = select.options[i];\n        if (option.__value === value) {\n            option.selected = true;\n            return;\n        }\n    }\n    select.selectedIndex = -1; // no option should be selected\n}\nfunction select_options(select, value) {\n    for (let i = 0; i < select.options.length; i += 1) {\n        const option = select.options[i];\n        option.selected = ~value.indexOf(option.__value);\n    }\n}\nfunction select_value(select) {\n    const selected_option = select.querySelector(':checked') || select.options[0];\n    return selected_option && selected_option.__value;\n}\nfunction select_multiple_value(select) {\n    return [].map.call(select.querySelectorAll(':checked'), option => option.__value);\n}\n// unfortunately this can't be a constant as that wouldn't be tree-shakeable\n// so we cache the result instead\nlet crossorigin;\nfunction is_crossorigin() {\n    if (crossorigin === undefined) {\n        crossorigin = false;\n        try {\n            if (typeof window !== 'undefined' && window.parent) {\n                void window.parent.document;\n            }\n        }\n        catch (error) {\n            crossorigin = true;\n        }\n    }\n    return crossorigin;\n}\nfunction add_resize_listener(node, fn) {\n    const computed_style = getComputedStyle(node);\n    if (computed_style.position === 'static') {\n        node.style.position = 'relative';\n    }\n    const iframe = element('iframe');\n    iframe.setAttribute('style', 'display: block; position: absolute; top: 0; left: 0; width: 100%; height: 100%; ' +\n        'overflow: hidden; border: 0; opacity: 0; pointer-events: none; z-index: -1;');\n    iframe.setAttribute('aria-hidden', 'true');\n    iframe.tabIndex = -1;\n    const crossorigin = is_crossorigin();\n    let unsubscribe;\n    if (crossorigin) {\n        iframe.src = \"data:text/html,<script>onresize=function(){parent.postMessage(0,'*')}</script>\";\n        unsubscribe = listen(window, 'message', (event) => {\n            if (event.source === iframe.contentWindow)\n                fn();\n        });\n    }\n    else {\n        iframe.src = 'about:blank';\n        iframe.onload = () => {\n            unsubscribe = listen(iframe.contentWindow, 'resize', fn);\n        };\n    }\n    append(node, iframe);\n    return () => {\n        if (crossorigin) {\n            unsubscribe();\n        }\n        else if (unsubscribe && iframe.contentWindow) {\n            unsubscribe();\n        }\n        detach(iframe);\n    };\n}\nfunction toggle_class(element, name, toggle) {\n    element.classList[toggle ? 'add' : 'remove'](name);\n}\nfunction custom_event(type, detail, { bubbles = false, cancelable = false } = {}) {\n    const e = document.createEvent('CustomEvent');\n    e.initCustomEvent(type, bubbles, cancelable, detail);\n    return e;\n}\nfunction query_selector_all(selector, parent = document.body) {\n    return Array.from(parent.querySelectorAll(selector));\n}\nfunction head_selector(nodeId, head) {\n    const result = [];\n    let started = 0;\n    for (const node of head.childNodes) {\n        if (node.nodeType === 8 /* comment node */) {\n            const comment = node.textContent.trim();\n            if (comment === `HEAD_${nodeId}_END`) {\n                started -= 1;\n                result.push(node);\n            }\n            else if (comment === `HEAD_${nodeId}_START`) {\n                started += 1;\n                result.push(node);\n            }\n        }\n        else if (started > 0) {\n            result.push(node);\n        }\n    }\n    return result;\n}\nclass HtmlTag {\n    constructor(is_svg = false) {\n        this.is_svg = false;\n        this.is_svg = is_svg;\n        this.e = this.n = null;\n    }\n    c(html) {\n        this.h(html);\n    }\n    m(html, target, anchor = null) {\n        if (!this.e) {\n            if (this.is_svg)\n                this.e = svg_element(target.nodeName);\n            else\n                this.e = element(target.nodeName);\n            this.t = target;\n            this.c(html);\n        }\n        this.i(anchor);\n    }\n    h(html) {\n        this.e.innerHTML = html;\n        this.n = Array.from(this.e.childNodes);\n    }\n    i(anchor) {\n        for (let i = 0; i < this.n.length; i += 1) {\n            insert(this.t, this.n[i], anchor);\n        }\n    }\n    p(html) {\n        this.d();\n        this.h(html);\n        this.i(this.a);\n    }\n    d() {\n        this.n.forEach(detach);\n    }\n}\nclass HtmlTagHydration extends HtmlTag {\n    constructor(claimed_nodes, is_svg = false) {\n        super(is_svg);\n        this.e = this.n = null;\n        this.l = claimed_nodes;\n    }\n    c(html) {\n        if (this.l) {\n            this.n = this.l;\n        }\n        else {\n            super.c(html);\n        }\n    }\n    i(anchor) {\n        for (let i = 0; i < this.n.length; i += 1) {\n            insert_hydration(this.t, this.n[i], anchor);\n        }\n    }\n}\nfunction attribute_to_object(attributes) {\n    const result = {};\n    for (const attribute of attributes) {\n        result[attribute.name] = attribute.value;\n    }\n    return result;\n}\nfunction get_custom_elements_slots(element) {\n    const result = {};\n    element.childNodes.forEach((node) => {\n        result[node.slot || 'default'] = true;\n    });\n    return result;\n}\nfunction construct_svelte_component(component, props) {\n    return new component(props);\n}\n\n// we need to store the information for multiple documents because a Svelte application could also contain iframes\n// https://github.com/sveltejs/svelte/issues/3624\nconst managed_styles = new Map();\nlet active = 0;\n// https://github.com/darkskyapp/string-hash/blob/master/index.js\nfunction hash(str) {\n    let hash = 5381;\n    let i = str.length;\n    while (i--)\n        hash = ((hash << 5) - hash) ^ str.charCodeAt(i);\n    return hash >>> 0;\n}\nfunction create_style_information(doc, node) {\n    const info = { stylesheet: append_empty_stylesheet(node), rules: {} };\n    managed_styles.set(doc, info);\n    return info;\n}\nfunction create_rule(node, a, b, duration, delay, ease, fn, uid = 0) {\n    const step = 16.666 / duration;\n    let keyframes = '{\\n';\n    for (let p = 0; p <= 1; p += step) {\n        const t = a + (b - a) * ease(p);\n        keyframes += p * 100 + `%{${fn(t, 1 - t)}}\\n`;\n    }\n    const rule = keyframes + `100% {${fn(b, 1 - b)}}\\n}`;\n    const name = `__svelte_${hash(rule)}_${uid}`;\n    const doc = get_root_for_style(node);\n    const { stylesheet, rules } = managed_styles.get(doc) || create_style_information(doc, node);\n    if (!rules[name]) {\n        rules[name] = true;\n        stylesheet.insertRule(`@keyframes ${name} ${rule}`, stylesheet.cssRules.length);\n    }\n    const animation = node.style.animation || '';\n    node.style.animation = `${animation ? `${animation}, ` : ''}${name} ${duration}ms linear ${delay}ms 1 both`;\n    active += 1;\n    return name;\n}\nfunction delete_rule(node, name) {\n    const previous = (node.style.animation || '').split(', ');\n    const next = previous.filter(name\n        ? anim => anim.indexOf(name) < 0 // remove specific animation\n        : anim => anim.indexOf('__svelte') === -1 // remove all Svelte animations\n    );\n    const deleted = previous.length - next.length;\n    if (deleted) {\n        node.style.animation = next.join(', ');\n        active -= deleted;\n        if (!active)\n            clear_rules();\n    }\n}\nfunction clear_rules() {\n    raf(() => {\n        if (active)\n            return;\n        managed_styles.forEach(info => {\n            const { ownerNode } = info.stylesheet;\n            // there is no ownerNode if it runs on jsdom.\n            if (ownerNode)\n                detach(ownerNode);\n        });\n        managed_styles.clear();\n    });\n}\n\nfunction create_animation(node, from, fn, params) {\n    if (!from)\n        return noop;\n    const to = node.getBoundingClientRect();\n    if (from.left === to.left && from.right === to.right && from.top === to.top && from.bottom === to.bottom)\n        return noop;\n    const { delay = 0, duration = 300, easing = identity, \n    // @ts-ignore todo: should this be separated from destructuring? Or start/end added to public api and documentation?\n    start: start_time = now() + delay, \n    // @ts-ignore todo:\n    end = start_time + duration, tick = noop, css } = fn(node, { from, to }, params);\n    let running = true;\n    let started = false;\n    let name;\n    function start() {\n        if (css) {\n            name = create_rule(node, 0, 1, duration, delay, easing, css);\n        }\n        if (!delay) {\n            started = true;\n        }\n    }\n    function stop() {\n        if (css)\n            delete_rule(node, name);\n        running = false;\n    }\n    loop(now => {\n        if (!started && now >= start_time) {\n            started = true;\n        }\n        if (started && now >= end) {\n            tick(1, 0);\n            stop();\n        }\n        if (!running) {\n            return false;\n        }\n        if (started) {\n            const p = now - start_time;\n            const t = 0 + 1 * easing(p / duration);\n            tick(t, 1 - t);\n        }\n        return true;\n    });\n    start();\n    tick(0, 1);\n    return stop;\n}\nfunction fix_position(node) {\n    const style = getComputedStyle(node);\n    if (style.position !== 'absolute' && style.position !== 'fixed') {\n        const { width, height } = style;\n        const a = node.getBoundingClientRect();\n        node.style.position = 'absolute';\n        node.style.width = width;\n        node.style.height = height;\n        add_transform(node, a);\n    }\n}\nfunction add_transform(node, a) {\n    const b = node.getBoundingClientRect();\n    if (a.left !== b.left || a.top !== b.top) {\n        const style = getComputedStyle(node);\n        const transform = style.transform === 'none' ? '' : style.transform;\n        node.style.transform = `${transform} translate(${a.left - b.left}px, ${a.top - b.top}px)`;\n    }\n}\n\nlet current_component;\nfunction set_current_component(component) {\n    current_component = component;\n}\nfunction get_current_component() {\n    if (!current_component)\n        throw new Error('Function called outside component initialization');\n    return current_component;\n}\n/**\n * Schedules a callback to run immediately before the component is updated after any state change.\n *\n * The first time the callback runs will be before the initial `onMount`\n *\n * https://svelte.dev/docs#run-time-svelte-beforeupdate\n */\nfunction beforeUpdate(fn) {\n    get_current_component().$$.before_update.push(fn);\n}\n/**\n * The `onMount` function schedules a callback to run as soon as the component has been mounted to the DOM.\n * It must be called during the component's initialisation (but doesn't need to live *inside* the component;\n * it can be called from an external module).\n *\n * `onMount` does not run inside a [server-side component](/docs#run-time-server-side-component-api).\n *\n * https://svelte.dev/docs#run-time-svelte-onmount\n */\nfunction onMount(fn) {\n    get_current_component().$$.on_mount.push(fn);\n}\n/**\n * Schedules a callback to run immediately after the component has been updated.\n *\n * The first time the callback runs will be after the initial `onMount`\n */\nfunction afterUpdate(fn) {\n    get_current_component().$$.after_update.push(fn);\n}\n/**\n * Schedules a callback to run immediately before the component is unmounted.\n *\n * Out of `onMount`, `beforeUpdate`, `afterUpdate` and `onDestroy`, this is the\n * only one that runs inside a server-side component.\n *\n * https://svelte.dev/docs#run-time-svelte-ondestroy\n */\nfunction onDestroy(fn) {\n    get_current_component().$$.on_destroy.push(fn);\n}\n/**\n * Creates an event dispatcher that can be used to dispatch [component events](/docs#template-syntax-component-directives-on-eventname).\n * Event dispatchers are functions that can take two arguments: `name` and `detail`.\n *\n * Component events created with `createEventDispatcher` create a\n * [CustomEvent](https://developer.mozilla.org/en-US/docs/Web/API/CustomEvent).\n * These events do not [bubble](https://developer.mozilla.org/en-US/docs/Learn/JavaScript/Building_blocks/Events#Event_bubbling_and_capture).\n * The `detail` argument corresponds to the [CustomEvent.detail](https://developer.mozilla.org/en-US/docs/Web/API/CustomEvent/detail)\n * property and can contain any type of data.\n *\n * https://svelte.dev/docs#run-time-svelte-createeventdispatcher\n */\nfunction createEventDispatcher() {\n    const component = get_current_component();\n    return (type, detail, { cancelable = false } = {}) => {\n        const callbacks = component.$$.callbacks[type];\n        if (callbacks) {\n            // TODO are there situations where events could be dispatched\n            // in a server (non-DOM) environment?\n            const event = custom_event(type, detail, { cancelable });\n            callbacks.slice().forEach(fn => {\n                fn.call(component, event);\n            });\n            return !event.defaultPrevented;\n        }\n        return true;\n    };\n}\n/**\n * Associates an arbitrary `context` object with the current component and the specified `key`\n * and returns that object. The context is then available to children of the component\n * (including slotted content) with `getContext`.\n *\n * Like lifecycle functions, this must be called during component initialisation.\n *\n * https://svelte.dev/docs#run-time-svelte-setcontext\n */\nfunction setContext(key, context) {\n    get_current_component().$$.context.set(key, context);\n    return context;\n}\n/**\n * Retrieves the context that belongs to the closest parent component with the specified `key`.\n * Must be called during component initialisation.\n *\n * https://svelte.dev/docs#run-time-svelte-getcontext\n */\nfunction getContext(key) {\n    return get_current_component().$$.context.get(key);\n}\n/**\n * Retrieves the whole context map that belongs to the closest parent component.\n * Must be called during component initialisation. Useful, for example, if you\n * programmatically create a component and want to pass the existing context to it.\n *\n * https://svelte.dev/docs#run-time-svelte-getallcontexts\n */\nfunction getAllContexts() {\n    return get_current_component().$$.context;\n}\n/**\n * Checks whether a given `key` has been set in the context of a parent component.\n * Must be called during component initialisation.\n *\n * https://svelte.dev/docs#run-time-svelte-hascontext\n */\nfunction hasContext(key) {\n    return get_current_component().$$.context.has(key);\n}\n// TODO figure out if we still want to support\n// shorthand events, or if we want to implement\n// a real bubbling mechanism\nfunction bubble(component, event) {\n    const callbacks = component.$$.callbacks[event.type];\n    if (callbacks) {\n        // @ts-ignore\n        callbacks.slice().forEach(fn => fn.call(this, event));\n    }\n}\n\nconst dirty_components = [];\nconst intros = { enabled: false };\nconst binding_callbacks = [];\nconst render_callbacks = [];\nconst flush_callbacks = [];\nconst resolved_promise = Promise.resolve();\nlet update_scheduled = false;\nfunction schedule_update() {\n    if (!update_scheduled) {\n        update_scheduled = true;\n        resolved_promise.then(flush);\n    }\n}\nfunction tick() {\n    schedule_update();\n    return resolved_promise;\n}\nfunction add_render_callback(fn) {\n    render_callbacks.push(fn);\n}\nfunction add_flush_callback(fn) {\n    flush_callbacks.push(fn);\n}\n// flush() calls callbacks in this order:\n// 1. All beforeUpdate callbacks, in order: parents before children\n// 2. All bind:this callbacks, in reverse order: children before parents.\n// 3. All afterUpdate callbacks, in order: parents before children. EXCEPT\n//    for afterUpdates called during the initial onMount, which are called in\n//    reverse order: children before parents.\n// Since callbacks might update component values, which could trigger another\n// call to flush(), the following steps guard against this:\n// 1. During beforeUpdate, any updated components will be added to the\n//    dirty_components array and will cause a reentrant call to flush(). Because\n//    the flush index is kept outside the function, the reentrant call will pick\n//    up where the earlier call left off and go through all dirty components. The\n//    current_component value is saved and restored so that the reentrant call will\n//    not interfere with the \"parent\" flush() call.\n// 2. bind:this callbacks cannot trigger new flush() calls.\n// 3. During afterUpdate, any updated components will NOT have their afterUpdate\n//    callback called a second time; the seen_callbacks set, outside the flush()\n//    function, guarantees this behavior.\nconst seen_callbacks = new Set();\nlet flushidx = 0; // Do *not* move this inside the flush() function\nfunction flush() {\n    // Do not reenter flush while dirty components are updated, as this can\n    // result in an infinite loop. Instead, let the inner flush handle it.\n    // Reentrancy is ok afterwards for bindings etc.\n    if (flushidx !== 0) {\n        return;\n    }\n    const saved_component = current_component;\n    do {\n        // first, call beforeUpdate functions\n        // and update components\n        try {\n            while (flushidx < dirty_components.length) {\n                const component = dirty_components[flushidx];\n                flushidx++;\n                set_current_component(component);\n                update(component.$$);\n            }\n        }\n        catch (e) {\n            // reset dirty state to not end up in a deadlocked state and then rethrow\n            dirty_components.length = 0;\n            flushidx = 0;\n            throw e;\n        }\n        set_current_component(null);\n        dirty_components.length = 0;\n        flushidx = 0;\n        while (binding_callbacks.length)\n            binding_callbacks.pop()();\n        // then, once components are updated, call\n        // afterUpdate functions. This may cause\n        // subsequent updates...\n        for (let i = 0; i < render_callbacks.length; i += 1) {\n            const callback = render_callbacks[i];\n            if (!seen_callbacks.has(callback)) {\n                // ...so guard against infinite loops\n                seen_callbacks.add(callback);\n                callback();\n            }\n        }\n        render_callbacks.length = 0;\n    } while (dirty_components.length);\n    while (flush_callbacks.length) {\n        flush_callbacks.pop()();\n    }\n    update_scheduled = false;\n    seen_callbacks.clear();\n    set_current_component(saved_component);\n}\nfunction update($$) {\n    if ($$.fragment !== null) {\n        $$.update();\n        run_all($$.before_update);\n        const dirty = $$.dirty;\n        $$.dirty = [-1];\n        $$.fragment && $$.fragment.p($$.ctx, dirty);\n        $$.after_update.forEach(add_render_callback);\n    }\n}\n\nlet promise;\nfunction wait() {\n    if (!promise) {\n        promise = Promise.resolve();\n        promise.then(() => {\n            promise = null;\n        });\n    }\n    return promise;\n}\nfunction dispatch(node, direction, kind) {\n    node.dispatchEvent(custom_event(`${direction ? 'intro' : 'outro'}${kind}`));\n}\nconst outroing = new Set();\nlet outros;\nfunction group_outros() {\n    outros = {\n        r: 0,\n        c: [],\n        p: outros // parent group\n    };\n}\nfunction check_outros() {\n    if (!outros.r) {\n        run_all(outros.c);\n    }\n    outros = outros.p;\n}\nfunction transition_in(block, local) {\n    if (block && block.i) {\n        outroing.delete(block);\n        block.i(local);\n    }\n}\nfunction transition_out(block, local, detach, callback) {\n    if (block && block.o) {\n        if (outroing.has(block))\n            return;\n        outroing.add(block);\n        outros.c.push(() => {\n            outroing.delete(block);\n            if (callback) {\n                if (detach)\n                    block.d(1);\n                callback();\n            }\n        });\n        block.o(local);\n    }\n    else if (callback) {\n        callback();\n    }\n}\nconst null_transition = { duration: 0 };\nfunction create_in_transition(node, fn, params) {\n    const options = { direction: 'in' };\n    let config = fn(node, params, options);\n    let running = false;\n    let animation_name;\n    let task;\n    let uid = 0;\n    function cleanup() {\n        if (animation_name)\n            delete_rule(node, animation_name);\n    }\n    function go() {\n        const { delay = 0, duration = 300, easing = identity, tick = noop, css } = config || null_transition;\n        if (css)\n            animation_name = create_rule(node, 0, 1, duration, delay, easing, css, uid++);\n        tick(0, 1);\n        const start_time = now() + delay;\n        const end_time = start_time + duration;\n        if (task)\n            task.abort();\n        running = true;\n        add_render_callback(() => dispatch(node, true, 'start'));\n        task = loop(now => {\n            if (running) {\n                if (now >= end_time) {\n                    tick(1, 0);\n                    dispatch(node, true, 'end');\n                    cleanup();\n                    return running = false;\n                }\n                if (now >= start_time) {\n                    const t = easing((now - start_time) / duration);\n                    tick(t, 1 - t);\n                }\n            }\n            return running;\n        });\n    }\n    let started = false;\n    return {\n        start() {\n            if (started)\n                return;\n            started = true;\n            delete_rule(node);\n            if (is_function(config)) {\n                config = config(options);\n                wait().then(go);\n            }\n            else {\n                go();\n            }\n        },\n        invalidate() {\n            started = false;\n        },\n        end() {\n            if (running) {\n                cleanup();\n                running = false;\n            }\n        }\n    };\n}\nfunction create_out_transition(node, fn, params) {\n    const options = { direction: 'out' };\n    let config = fn(node, params, options);\n    let running = true;\n    let animation_name;\n    const group = outros;\n    group.r += 1;\n    function go() {\n        const { delay = 0, duration = 300, easing = identity, tick = noop, css } = config || null_transition;\n        if (css)\n            animation_name = create_rule(node, 1, 0, duration, delay, easing, css);\n        const start_time = now() + delay;\n        const end_time = start_time + duration;\n        add_render_callback(() => dispatch(node, false, 'start'));\n        loop(now => {\n            if (running) {\n                if (now >= end_time) {\n                    tick(0, 1);\n                    dispatch(node, false, 'end');\n                    if (!--group.r) {\n                        // this will result in `end()` being called,\n                        // so we don't need to clean up here\n                        run_all(group.c);\n                    }\n                    return false;\n                }\n                if (now >= start_time) {\n                    const t = easing((now - start_time) / duration);\n                    tick(1 - t, t);\n                }\n            }\n            return running;\n        });\n    }\n    if (is_function(config)) {\n        wait().then(() => {\n            // @ts-ignore\n            config = config(options);\n            go();\n        });\n    }\n    else {\n        go();\n    }\n    return {\n        end(reset) {\n            if (reset && config.tick) {\n                config.tick(1, 0);\n            }\n            if (running) {\n                if (animation_name)\n                    delete_rule(node, animation_name);\n                running = false;\n            }\n        }\n    };\n}\nfunction create_bidirectional_transition(node, fn, params, intro) {\n    const options = { direction: 'both' };\n    let config = fn(node, params, options);\n    let t = intro ? 0 : 1;\n    let running_program = null;\n    let pending_program = null;\n    let animation_name = null;\n    function clear_animation() {\n        if (animation_name)\n            delete_rule(node, animation_name);\n    }\n    function init(program, duration) {\n        const d = (program.b - t);\n        duration *= Math.abs(d);\n        return {\n            a: t,\n            b: program.b,\n            d,\n            duration,\n            start: program.start,\n            end: program.start + duration,\n            group: program.group\n        };\n    }\n    function go(b) {\n        const { delay = 0, duration = 300, easing = identity, tick = noop, css } = config || null_transition;\n        const program = {\n            start: now() + delay,\n            b\n        };\n        if (!b) {\n            // @ts-ignore todo: improve typings\n            program.group = outros;\n            outros.r += 1;\n        }\n        if (running_program || pending_program) {\n            pending_program = program;\n        }\n        else {\n            // if this is an intro, and there's a delay, we need to do\n            // an initial tick and/or apply CSS animation immediately\n            if (css) {\n                clear_animation();\n                animation_name = create_rule(node, t, b, duration, delay, easing, css);\n            }\n            if (b)\n                tick(0, 1);\n            running_program = init(program, duration);\n            add_render_callback(() => dispatch(node, b, 'start'));\n            loop(now => {\n                if (pending_program && now > pending_program.start) {\n                    running_program = init(pending_program, duration);\n                    pending_program = null;\n                    dispatch(node, running_program.b, 'start');\n                    if (css) {\n                        clear_animation();\n                        animation_name = create_rule(node, t, running_program.b, running_program.duration, 0, easing, config.css);\n                    }\n                }\n                if (running_program) {\n                    if (now >= running_program.end) {\n                        tick(t = running_program.b, 1 - t);\n                        dispatch(node, running_program.b, 'end');\n                        if (!pending_program) {\n                            // we're done\n                            if (running_program.b) {\n                                // intro — we can tidy up immediately\n                                clear_animation();\n                            }\n                            else {\n                                // outro — needs to be coordinated\n                                if (!--running_program.group.r)\n                                    run_all(running_program.group.c);\n                            }\n                        }\n                        running_program = null;\n                    }\n                    else if (now >= running_program.start) {\n                        const p = now - running_program.start;\n                        t = running_program.a + running_program.d * easing(p / running_program.duration);\n                        tick(t, 1 - t);\n                    }\n                }\n                return !!(running_program || pending_program);\n            });\n        }\n    }\n    return {\n        run(b) {\n            if (is_function(config)) {\n                wait().then(() => {\n                    // @ts-ignore\n                    config = config(options);\n                    go(b);\n                });\n            }\n            else {\n                go(b);\n            }\n        },\n        end() {\n            clear_animation();\n            running_program = pending_program = null;\n        }\n    };\n}\n\nfunction handle_promise(promise, info) {\n    const token = info.token = {};\n    function update(type, index, key, value) {\n        if (info.token !== token)\n            return;\n        info.resolved = value;\n        let child_ctx = info.ctx;\n        if (key !== undefined) {\n            child_ctx = child_ctx.slice();\n            child_ctx[key] = value;\n        }\n        const block = type && (info.current = type)(child_ctx);\n        let needs_flush = false;\n        if (info.block) {\n            if (info.blocks) {\n                info.blocks.forEach((block, i) => {\n                    if (i !== index && block) {\n                        group_outros();\n                        transition_out(block, 1, 1, () => {\n                            if (info.blocks[i] === block) {\n                                info.blocks[i] = null;\n                            }\n                        });\n                        check_outros();\n                    }\n                });\n            }\n            else {\n                info.block.d(1);\n            }\n            block.c();\n            transition_in(block, 1);\n            block.m(info.mount(), info.anchor);\n            needs_flush = true;\n        }\n        info.block = block;\n        if (info.blocks)\n            info.blocks[index] = block;\n        if (needs_flush) {\n            flush();\n        }\n    }\n    if (is_promise(promise)) {\n        const current_component = get_current_component();\n        promise.then(value => {\n            set_current_component(current_component);\n            update(info.then, 1, info.value, value);\n            set_current_component(null);\n        }, error => {\n            set_current_component(current_component);\n            update(info.catch, 2, info.error, error);\n            set_current_component(null);\n            if (!info.hasCatch) {\n                throw error;\n            }\n        });\n        // if we previously had a then/catch block, destroy it\n        if (info.current !== info.pending) {\n            update(info.pending, 0);\n            return true;\n        }\n    }\n    else {\n        if (info.current !== info.then) {\n            update(info.then, 1, info.value, promise);\n            return true;\n        }\n        info.resolved = promise;\n    }\n}\nfunction update_await_block_branch(info, ctx, dirty) {\n    const child_ctx = ctx.slice();\n    const { resolved } = info;\n    if (info.current === info.then) {\n        child_ctx[info.value] = resolved;\n    }\n    if (info.current === info.catch) {\n        child_ctx[info.error] = resolved;\n    }\n    info.block.p(child_ctx, dirty);\n}\n\nconst globals = (typeof window !== 'undefined'\n    ? window\n    : typeof globalThis !== 'undefined'\n        ? globalThis\n        : global);\n\nfunction destroy_block(block, lookup) {\n    block.d(1);\n    lookup.delete(block.key);\n}\nfunction outro_and_destroy_block(block, lookup) {\n    transition_out(block, 1, 1, () => {\n        lookup.delete(block.key);\n    });\n}\nfunction fix_and_destroy_block(block, lookup) {\n    block.f();\n    destroy_block(block, lookup);\n}\nfunction fix_and_outro_and_destroy_block(block, lookup) {\n    block.f();\n    outro_and_destroy_block(block, lookup);\n}\nfunction update_keyed_each(old_blocks, dirty, get_key, dynamic, ctx, list, lookup, node, destroy, create_each_block, next, get_context) {\n    let o = old_blocks.length;\n    let n = list.length;\n    let i = o;\n    const old_indexes = {};\n    while (i--)\n        old_indexes[old_blocks[i].key] = i;\n    const new_blocks = [];\n    const new_lookup = new Map();\n    const deltas = new Map();\n    i = n;\n    while (i--) {\n        const child_ctx = get_context(ctx, list, i);\n        const key = get_key(child_ctx);\n        let block = lookup.get(key);\n        if (!block) {\n            block = create_each_block(key, child_ctx);\n            block.c();\n        }\n        else if (dynamic) {\n            block.p(child_ctx, dirty);\n        }\n        new_lookup.set(key, new_blocks[i] = block);\n        if (key in old_indexes)\n            deltas.set(key, Math.abs(i - old_indexes[key]));\n    }\n    const will_move = new Set();\n    const did_move = new Set();\n    function insert(block) {\n        transition_in(block, 1);\n        block.m(node, next);\n        lookup.set(block.key, block);\n        next = block.first;\n        n--;\n    }\n    while (o && n) {\n        const new_block = new_blocks[n - 1];\n        const old_block = old_blocks[o - 1];\n        const new_key = new_block.key;\n        const old_key = old_block.key;\n        if (new_block === old_block) {\n            // do nothing\n            next = new_block.first;\n            o--;\n            n--;\n        }\n        else if (!new_lookup.has(old_key)) {\n            // remove old block\n            destroy(old_block, lookup);\n            o--;\n        }\n        else if (!lookup.has(new_key) || will_move.has(new_key)) {\n            insert(new_block);\n        }\n        else if (did_move.has(old_key)) {\n            o--;\n        }\n        else if (deltas.get(new_key) > deltas.get(old_key)) {\n            did_move.add(new_key);\n            insert(new_block);\n        }\n        else {\n            will_move.add(old_key);\n            o--;\n        }\n    }\n    while (o--) {\n        const old_block = old_blocks[o];\n        if (!new_lookup.has(old_block.key))\n            destroy(old_block, lookup);\n    }\n    while (n)\n        insert(new_blocks[n - 1]);\n    return new_blocks;\n}\nfunction validate_each_keys(ctx, list, get_context, get_key) {\n    const keys = new Set();\n    for (let i = 0; i < list.length; i++) {\n        const key = get_key(get_context(ctx, list, i));\n        if (keys.has(key)) {\n            throw new Error('Cannot have duplicate keys in a keyed each');\n        }\n        keys.add(key);\n    }\n}\n\nfunction get_spread_update(levels, updates) {\n    const update = {};\n    const to_null_out = {};\n    const accounted_for = { $$scope: 1 };\n    let i = levels.length;\n    while (i--) {\n        const o = levels[i];\n        const n = updates[i];\n        if (n) {\n            for (const key in o) {\n                if (!(key in n))\n                    to_null_out[key] = 1;\n            }\n            for (const key in n) {\n                if (!accounted_for[key]) {\n                    update[key] = n[key];\n                    accounted_for[key] = 1;\n                }\n            }\n            levels[i] = n;\n        }\n        else {\n            for (const key in o) {\n                accounted_for[key] = 1;\n            }\n        }\n    }\n    for (const key in to_null_out) {\n        if (!(key in update))\n            update[key] = undefined;\n    }\n    return update;\n}\nfunction get_spread_object(spread_props) {\n    return typeof spread_props === 'object' && spread_props !== null ? spread_props : {};\n}\n\n// source: https://html.spec.whatwg.org/multipage/indices.html\nconst boolean_attributes = new Set([\n    'allowfullscreen',\n    'allowpaymentrequest',\n    'async',\n    'autofocus',\n    'autoplay',\n    'checked',\n    'controls',\n    'default',\n    'defer',\n    'disabled',\n    'formnovalidate',\n    'hidden',\n    'inert',\n    'ismap',\n    'itemscope',\n    'loop',\n    'multiple',\n    'muted',\n    'nomodule',\n    'novalidate',\n    'open',\n    'playsinline',\n    'readonly',\n    'required',\n    'reversed',\n    'selected'\n]);\n\n/** regex of all html void element names */\nconst void_element_names = /^(?:area|base|br|col|command|embed|hr|img|input|keygen|link|meta|param|source|track|wbr)$/;\nfunction is_void(name) {\n    return void_element_names.test(name) || name.toLowerCase() === '!doctype';\n}\n\nconst invalid_attribute_name_character = /[\\s'\">/=\\u{FDD0}-\\u{FDEF}\\u{FFFE}\\u{FFFF}\\u{1FFFE}\\u{1FFFF}\\u{2FFFE}\\u{2FFFF}\\u{3FFFE}\\u{3FFFF}\\u{4FFFE}\\u{4FFFF}\\u{5FFFE}\\u{5FFFF}\\u{6FFFE}\\u{6FFFF}\\u{7FFFE}\\u{7FFFF}\\u{8FFFE}\\u{8FFFF}\\u{9FFFE}\\u{9FFFF}\\u{AFFFE}\\u{AFFFF}\\u{BFFFE}\\u{BFFFF}\\u{CFFFE}\\u{CFFFF}\\u{DFFFE}\\u{DFFFF}\\u{EFFFE}\\u{EFFFF}\\u{FFFFE}\\u{FFFFF}\\u{10FFFE}\\u{10FFFF}]/u;\n// https://html.spec.whatwg.org/multipage/syntax.html#attributes-2\n// https://infra.spec.whatwg.org/#noncharacter\nfunction spread(args, attrs_to_add) {\n    const attributes = Object.assign({}, ...args);\n    if (attrs_to_add) {\n        const classes_to_add = attrs_to_add.classes;\n        const styles_to_add = attrs_to_add.styles;\n        if (classes_to_add) {\n            if (attributes.class == null) {\n                attributes.class = classes_to_add;\n            }\n            else {\n                attributes.class += ' ' + classes_to_add;\n            }\n        }\n        if (styles_to_add) {\n            if (attributes.style == null) {\n                attributes.style = style_object_to_string(styles_to_add);\n            }\n            else {\n                attributes.style = style_object_to_string(merge_ssr_styles(attributes.style, styles_to_add));\n            }\n        }\n    }\n    let str = '';\n    Object.keys(attributes).forEach(name => {\n        if (invalid_attribute_name_character.test(name))\n            return;\n        const value = attributes[name];\n        if (value === true)\n            str += ' ' + name;\n        else if (boolean_attributes.has(name.toLowerCase())) {\n            if (value)\n                str += ' ' + name;\n        }\n        else if (value != null) {\n            str += ` ${name}=\"${value}\"`;\n        }\n    });\n    return str;\n}\nfunction merge_ssr_styles(style_attribute, style_directive) {\n    const style_object = {};\n    for (const individual_style of style_attribute.split(';')) {\n        const colon_index = individual_style.indexOf(':');\n        const name = individual_style.slice(0, colon_index).trim();\n        const value = individual_style.slice(colon_index + 1).trim();\n        if (!name)\n            continue;\n        style_object[name] = value;\n    }\n    for (const name in style_directive) {\n        const value = style_directive[name];\n        if (value) {\n            style_object[name] = value;\n        }\n        else {\n            delete style_object[name];\n        }\n    }\n    return style_object;\n}\nconst ATTR_REGEX = /[&\"]/g;\nconst CONTENT_REGEX = /[&<]/g;\n/**\n * Note: this method is performance sensitive and has been optimized\n * https://github.com/sveltejs/svelte/pull/5701\n */\nfunction escape(value, is_attr = false) {\n    const str = String(value);\n    const pattern = is_attr ? ATTR_REGEX : CONTENT_REGEX;\n    pattern.lastIndex = 0;\n    let escaped = '';\n    let last = 0;\n    while (pattern.test(str)) {\n        const i = pattern.lastIndex - 1;\n        const ch = str[i];\n        escaped += str.substring(last, i) + (ch === '&' ? '&amp;' : (ch === '\"' ? '&quot;' : '&lt;'));\n        last = i + 1;\n    }\n    return escaped + str.substring(last);\n}\nfunction escape_attribute_value(value) {\n    // keep booleans, null, and undefined for the sake of `spread`\n    const should_escape = typeof value === 'string' || (value && typeof value === 'object');\n    return should_escape ? escape(value, true) : value;\n}\nfunction escape_object(obj) {\n    const result = {};\n    for (const key in obj) {\n        result[key] = escape_attribute_value(obj[key]);\n    }\n    return result;\n}\nfunction each(items, fn) {\n    let str = '';\n    for (let i = 0; i < items.length; i += 1) {\n        str += fn(items[i], i);\n    }\n    return str;\n}\nconst missing_component = {\n    $$render: () => ''\n};\nfunction validate_component(component, name) {\n    if (!component || !component.$$render) {\n        if (name === 'svelte:component')\n            name += ' this={...}';\n        throw new Error(`<${name}> is not a valid SSR component. You may need to review your build config to ensure that dependencies are compiled, rather than imported as pre-compiled modules. Otherwise you may need to fix a <${name}>.`);\n    }\n    return component;\n}\nfunction debug(file, line, column, values) {\n    console.log(`{@debug} ${file ? file + ' ' : ''}(${line}:${column})`); // eslint-disable-line no-console\n    console.log(values); // eslint-disable-line no-console\n    return '';\n}\nlet on_destroy;\nfunction create_ssr_component(fn) {\n    function $$render(result, props, bindings, slots, context) {\n        const parent_component = current_component;\n        const $$ = {\n            on_destroy,\n            context: new Map(context || (parent_component ? parent_component.$$.context : [])),\n            // these will be immediately discarded\n            on_mount: [],\n            before_update: [],\n            after_update: [],\n            callbacks: blank_object()\n        };\n        set_current_component({ $$ });\n        const html = fn(result, props, bindings, slots);\n        set_current_component(parent_component);\n        return html;\n    }\n    return {\n        render: (props = {}, { $$slots = {}, context = new Map() } = {}) => {\n            on_destroy = [];\n            const result = { title: '', head: '', css: new Set() };\n            const html = $$render(result, props, {}, $$slots, context);\n            run_all(on_destroy);\n            return {\n                html,\n                css: {\n                    code: Array.from(result.css).map(css => css.code).join('\\n'),\n                    map: null // TODO\n                },\n                head: result.title + result.head\n            };\n        },\n        $$render\n    };\n}\nfunction add_attribute(name, value, boolean) {\n    if (value == null || (boolean && !value))\n        return '';\n    const assignment = (boolean && value === true) ? '' : `=\"${escape(value, true)}\"`;\n    return ` ${name}${assignment}`;\n}\nfunction add_classes(classes) {\n    return classes ? ` class=\"${classes}\"` : '';\n}\nfunction style_object_to_string(style_object) {\n    return Object.keys(style_object)\n        .filter(key => style_object[key])\n        .map(key => `${key}: ${escape_attribute_value(style_object[key])};`)\n        .join(' ');\n}\nfunction add_styles(style_object) {\n    const styles = style_object_to_string(style_object);\n    return styles ? ` style=\"${styles}\"` : '';\n}\n\nfunction bind(component, name, callback) {\n    const index = component.$$.props[name];\n    if (index !== undefined) {\n        component.$$.bound[index] = callback;\n        callback(component.$$.ctx[index]);\n    }\n}\nfunction create_component(block) {\n    block && block.c();\n}\nfunction claim_component(block, parent_nodes) {\n    block && block.l(parent_nodes);\n}\nfunction mount_component(component, target, anchor, customElement) {\n    const { fragment, after_update } = component.$$;\n    fragment && fragment.m(target, anchor);\n    if (!customElement) {\n        // onMount happens before the initial afterUpdate\n        add_render_callback(() => {\n            const new_on_destroy = component.$$.on_mount.map(run).filter(is_function);\n            // if the component was destroyed immediately\n            // it will update the `$$.on_destroy` reference to `null`.\n            // the destructured on_destroy may still reference to the old array\n            if (component.$$.on_destroy) {\n                component.$$.on_destroy.push(...new_on_destroy);\n            }\n            else {\n                // Edge case - component was destroyed immediately,\n                // most likely as a result of a binding initialising\n                run_all(new_on_destroy);\n            }\n            component.$$.on_mount = [];\n        });\n    }\n    after_update.forEach(add_render_callback);\n}\nfunction destroy_component(component, detaching) {\n    const $$ = component.$$;\n    if ($$.fragment !== null) {\n        run_all($$.on_destroy);\n        $$.fragment && $$.fragment.d(detaching);\n        // TODO null out other refs, including component.$$ (but need to\n        // preserve final state?)\n        $$.on_destroy = $$.fragment = null;\n        $$.ctx = [];\n    }\n}\nfunction make_dirty(component, i) {\n    if (component.$$.dirty[0] === -1) {\n        dirty_components.push(component);\n        schedule_update();\n        component.$$.dirty.fill(0);\n    }\n    component.$$.dirty[(i / 31) | 0] |= (1 << (i % 31));\n}\nfunction init(component, options, instance, create_fragment, not_equal, props, append_styles, dirty = [-1]) {\n    const parent_component = current_component;\n    set_current_component(component);\n    const $$ = component.$$ = {\n        fragment: null,\n        ctx: [],\n        // state\n        props,\n        update: noop,\n        not_equal,\n        bound: blank_object(),\n        // lifecycle\n        on_mount: [],\n        on_destroy: [],\n        on_disconnect: [],\n        before_update: [],\n        after_update: [],\n        context: new Map(options.context || (parent_component ? parent_component.$$.context : [])),\n        // everything else\n        callbacks: blank_object(),\n        dirty,\n        skip_bound: false,\n        root: options.target || parent_component.$$.root\n    };\n    append_styles && append_styles($$.root);\n    let ready = false;\n    $$.ctx = instance\n        ? instance(component, options.props || {}, (i, ret, ...rest) => {\n            const value = rest.length ? rest[0] : ret;\n            if ($$.ctx && not_equal($$.ctx[i], $$.ctx[i] = value)) {\n                if (!$$.skip_bound && $$.bound[i])\n                    $$.bound[i](value);\n                if (ready)\n                    make_dirty(component, i);\n            }\n            return ret;\n        })\n        : [];\n    $$.update();\n    ready = true;\n    run_all($$.before_update);\n    // `false` as a special case of no DOM component\n    $$.fragment = create_fragment ? create_fragment($$.ctx) : false;\n    if (options.target) {\n        if (options.hydrate) {\n            start_hydrating();\n            const nodes = children(options.target);\n            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n            $$.fragment && $$.fragment.l(nodes);\n            nodes.forEach(detach);\n        }\n        else {\n            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n            $$.fragment && $$.fragment.c();\n        }\n        if (options.intro)\n            transition_in(component.$$.fragment);\n        mount_component(component, options.target, options.anchor, options.customElement);\n        end_hydrating();\n        flush();\n    }\n    set_current_component(parent_component);\n}\nlet SvelteElement;\nif (typeof HTMLElement === 'function') {\n    SvelteElement = class extends HTMLElement {\n        constructor() {\n            super();\n            this.attachShadow({ mode: 'open' });\n        }\n        connectedCallback() {\n            const { on_mount } = this.$$;\n            this.$$.on_disconnect = on_mount.map(run).filter(is_function);\n            // @ts-ignore todo: improve typings\n            for (const key in this.$$.slotted) {\n                // @ts-ignore todo: improve typings\n                this.appendChild(this.$$.slotted[key]);\n            }\n        }\n        attributeChangedCallback(attr, _oldValue, newValue) {\n            this[attr] = newValue;\n        }\n        disconnectedCallback() {\n            run_all(this.$$.on_disconnect);\n        }\n        $destroy() {\n            destroy_component(this, 1);\n            this.$destroy = noop;\n        }\n        $on(type, callback) {\n            // TODO should this delegate to addEventListener?\n            if (!is_function(callback)) {\n                return noop;\n            }\n            const callbacks = (this.$$.callbacks[type] || (this.$$.callbacks[type] = []));\n            callbacks.push(callback);\n            return () => {\n                const index = callbacks.indexOf(callback);\n                if (index !== -1)\n                    callbacks.splice(index, 1);\n            };\n        }\n        $set($$props) {\n            if (this.$$set && !is_empty($$props)) {\n                this.$$.skip_bound = true;\n                this.$$set($$props);\n                this.$$.skip_bound = false;\n            }\n        }\n    };\n}\n/**\n * Base class for Svelte components. Used when dev=false.\n */\nclass SvelteComponent {\n    $destroy() {\n        destroy_component(this, 1);\n        this.$destroy = noop;\n    }\n    $on(type, callback) {\n        if (!is_function(callback)) {\n            return noop;\n        }\n        const callbacks = (this.$$.callbacks[type] || (this.$$.callbacks[type] = []));\n        callbacks.push(callback);\n        return () => {\n            const index = callbacks.indexOf(callback);\n            if (index !== -1)\n                callbacks.splice(index, 1);\n        };\n    }\n    $set($$props) {\n        if (this.$$set && !is_empty($$props)) {\n            this.$$.skip_bound = true;\n            this.$$set($$props);\n            this.$$.skip_bound = false;\n        }\n    }\n}\n\nfunction dispatch_dev(type, detail) {\n    document.dispatchEvent(custom_event(type, Object.assign({ version: '3.55.1' }, detail), { bubbles: true }));\n}\nfunction append_dev(target, node) {\n    dispatch_dev('SvelteDOMInsert', { target, node });\n    append(target, node);\n}\nfunction append_hydration_dev(target, node) {\n    dispatch_dev('SvelteDOMInsert', { target, node });\n    append_hydration(target, node);\n}\nfunction insert_dev(target, node, anchor) {\n    dispatch_dev('SvelteDOMInsert', { target, node, anchor });\n    insert(target, node, anchor);\n}\nfunction insert_hydration_dev(target, node, anchor) {\n    dispatch_dev('SvelteDOMInsert', { target, node, anchor });\n    insert_hydration(target, node, anchor);\n}\nfunction detach_dev(node) {\n    dispatch_dev('SvelteDOMRemove', { node });\n    detach(node);\n}\nfunction detach_between_dev(before, after) {\n    while (before.nextSibling && before.nextSibling !== after) {\n        detach_dev(before.nextSibling);\n    }\n}\nfunction detach_before_dev(after) {\n    while (after.previousSibling) {\n        detach_dev(after.previousSibling);\n    }\n}\nfunction detach_after_dev(before) {\n    while (before.nextSibling) {\n        detach_dev(before.nextSibling);\n    }\n}\nfunction listen_dev(node, event, handler, options, has_prevent_default, has_stop_propagation) {\n    const modifiers = options === true ? ['capture'] : options ? Array.from(Object.keys(options)) : [];\n    if (has_prevent_default)\n        modifiers.push('preventDefault');\n    if (has_stop_propagation)\n        modifiers.push('stopPropagation');\n    dispatch_dev('SvelteDOMAddEventListener', { node, event, handler, modifiers });\n    const dispose = listen(node, event, handler, options);\n    return () => {\n        dispatch_dev('SvelteDOMRemoveEventListener', { node, event, handler, modifiers });\n        dispose();\n    };\n}\nfunction attr_dev(node, attribute, value) {\n    attr(node, attribute, value);\n    if (value == null)\n        dispatch_dev('SvelteDOMRemoveAttribute', { node, attribute });\n    else\n        dispatch_dev('SvelteDOMSetAttribute', { node, attribute, value });\n}\nfunction prop_dev(node, property, value) {\n    node[property] = value;\n    dispatch_dev('SvelteDOMSetProperty', { node, property, value });\n}\nfunction dataset_dev(node, property, value) {\n    node.dataset[property] = value;\n    dispatch_dev('SvelteDOMSetDataset', { node, property, value });\n}\nfunction set_data_dev(text, data) {\n    data = '' + data;\n    if (text.wholeText === data)\n        return;\n    dispatch_dev('SvelteDOMSetData', { node: text, data });\n    text.data = data;\n}\nfunction validate_each_argument(arg) {\n    if (typeof arg !== 'string' && !(arg && typeof arg === 'object' && 'length' in arg)) {\n        let msg = '{#each} only iterates over array-like objects.';\n        if (typeof Symbol === 'function' && arg && Symbol.iterator in arg) {\n            msg += ' You can use a spread to convert this iterable into an array.';\n        }\n        throw new Error(msg);\n    }\n}\nfunction validate_slots(name, slot, keys) {\n    for (const slot_key of Object.keys(slot)) {\n        if (!~keys.indexOf(slot_key)) {\n            console.warn(`<${name}> received an unexpected slot \"${slot_key}\".`);\n        }\n    }\n}\nfunction validate_dynamic_element(tag) {\n    const is_string = typeof tag === 'string';\n    if (tag && !is_string) {\n        throw new Error('<svelte:element> expects \"this\" attribute to be a string.');\n    }\n}\nfunction validate_void_dynamic_element(tag) {\n    if (tag && is_void(tag)) {\n        console.warn(`<svelte:element this=\"${tag}\"> is self-closing and cannot have content.`);\n    }\n}\nfunction construct_svelte_component_dev(component, props) {\n    const error_message = 'this={...} of <svelte:component> should specify a Svelte component.';\n    try {\n        const instance = new component(props);\n        if (!instance.$$ || !instance.$set || !instance.$on || !instance.$destroy) {\n            throw new Error(error_message);\n        }\n        return instance;\n    }\n    catch (err) {\n        const { message } = err;\n        if (typeof message === 'string' && message.indexOf('is not a constructor') !== -1) {\n            throw new Error(error_message);\n        }\n        else {\n            throw err;\n        }\n    }\n}\n/**\n * Base class for Svelte components with some minor dev-enhancements. Used when dev=true.\n */\nclass SvelteComponentDev extends SvelteComponent {\n    constructor(options) {\n        if (!options || (!options.target && !options.$$inline)) {\n            throw new Error(\"'target' is a required option\");\n        }\n        super();\n    }\n    $destroy() {\n        super.$destroy();\n        this.$destroy = () => {\n            console.warn('Component was already destroyed'); // eslint-disable-line no-console\n        };\n    }\n    $capture_state() { }\n    $inject_state() { }\n}\n/**\n * Base class to create strongly typed Svelte components.\n * This only exists for typing purposes and should be used in `.d.ts` files.\n *\n * ### Example:\n *\n * You have component library on npm called `component-library`, from which\n * you export a component called `MyComponent`. For Svelte+TypeScript users,\n * you want to provide typings. Therefore you create a `index.d.ts`:\n * ```ts\n * import { SvelteComponentTyped } from \"svelte\";\n * export class MyComponent extends SvelteComponentTyped<{foo: string}> {}\n * ```\n * Typing this makes it possible for IDEs like VS Code with the Svelte extension\n * to provide intellisense and to use the component like this in a Svelte file\n * with TypeScript:\n * ```svelte\n * <script lang=\"ts\">\n * \timport { MyComponent } from \"component-library\";\n * </script>\n * <MyComponent foo={'bar'} />\n * ```\n *\n * #### Why not make this part of `SvelteComponent(Dev)`?\n * Because\n * ```ts\n * class ASubclassOfSvelteComponent extends SvelteComponent<{foo: string}> {}\n * const component: typeof SvelteComponent = ASubclassOfSvelteComponent;\n * ```\n * will throw a type error, so we need to separate the more strictly typed class.\n */\nclass SvelteComponentTyped extends SvelteComponentDev {\n    constructor(options) {\n        super(options);\n    }\n}\nfunction loop_guard(timeout) {\n    const start = Date.now();\n    return () => {\n        if (Date.now() - start > timeout) {\n            throw new Error('Infinite loop detected');\n        }\n    };\n}\n\nexport { HtmlTag, HtmlTagHydration, SvelteComponent, SvelteComponentDev, SvelteComponentTyped, SvelteElement, action_destroyer, add_attribute, add_classes, add_flush_callback, add_location, add_render_callback, add_resize_listener, add_styles, add_transform, afterUpdate, append, append_dev, append_empty_stylesheet, append_hydration, append_hydration_dev, append_styles, assign, attr, attr_dev, attribute_to_object, beforeUpdate, bind, binding_callbacks, blank_object, bubble, check_outros, children, claim_component, claim_element, claim_html_tag, claim_space, claim_svg_element, claim_text, clear_loops, component_subscribe, compute_rest_props, compute_slots, construct_svelte_component, construct_svelte_component_dev, createEventDispatcher, create_animation, create_bidirectional_transition, create_component, create_in_transition, create_out_transition, create_slot, create_ssr_component, current_component, custom_event, dataset_dev, debug, destroy_block, destroy_component, destroy_each, detach, detach_after_dev, detach_before_dev, detach_between_dev, detach_dev, dirty_components, dispatch_dev, each, element, element_is, empty, end_hydrating, escape, escape_attribute_value, escape_object, exclude_internal_props, fix_and_destroy_block, fix_and_outro_and_destroy_block, fix_position, flush, getAllContexts, getContext, get_all_dirty_from_scope, get_binding_group_value, get_current_component, get_custom_elements_slots, get_root_for_style, get_slot_changes, get_spread_object, get_spread_update, get_store_value, globals, group_outros, handle_promise, hasContext, has_prop, head_selector, identity, init, insert, insert_dev, insert_hydration, insert_hydration_dev, intros, invalid_attribute_name_character, is_client, is_crossorigin, is_empty, is_function, is_promise, is_void, listen, listen_dev, loop, loop_guard, merge_ssr_styles, missing_component, mount_component, noop, not_equal, now, null_to_empty, object_without_properties, onDestroy, onMount, once, outro_and_destroy_block, prevent_default, prop_dev, query_selector_all, raf, run, run_all, safe_not_equal, schedule_update, select_multiple_value, select_option, select_options, select_value, self, setContext, set_attributes, set_current_component, set_custom_element_data, set_custom_element_data_map, set_data, set_data_dev, set_input_type, set_input_value, set_now, set_raf, set_store_value, set_style, set_svg_attributes, space, spread, src_url_equal, start_hydrating, stop_propagation, subscribe, svg_element, text, tick, time_ranges_to_array, to_number, toggle_class, transition_in, transition_out, trusted, update_await_block_branch, update_keyed_each, update_slot, update_slot_base, validate_component, validate_dynamic_element, validate_each_argument, validate_each_keys, validate_slots, validate_store, validate_void_dynamic_element, xlink_attr };\n","<script lang=\"ts\">\n    import { ICommandManager, Command } from '@/types';\n    import { Dialog } from '../../classes/dialog';\n    import { onMount } from 'svelte';\n    import { container } from '../../../container';\n    import { _ } from '@/util';\n    const commandManager = container.get<ICommandManager>('CommandManager');\n\n    let commands: Command[] = [];\n\n    let command = '';\n\n    let currentIndex = 0;\n\n    let result: Command[] = [];\n\n    const onkeypress = (e: KeyboardEvent) => {\n        if (e.keyCode === 13) {\n            onEnter();\n            return;\n        }\n\n        // moveUp\n        if (e.keyCode === 38) {\n            e.preventDefault();\n            if (currentIndex === 0) {\n                return;\n            }\n            currentIndex--;\n            return;\n        }\n        // moveDown\n        if (e.keyCode === 40) {\n            const len = result.length;\n            e.preventDefault();\n            if (currentIndex >= len - 1) {\n                return;\n            }\n            currentIndex++;\n        }\n    };\n\n    const onEnter = () => {\n        const com = result[currentIndex];\n        Dialog.destroyAll();\n        com.callback();\n    };\n\n    const onClick = (i: number) => {\n        currentIndex = i;\n        onEnter();\n    };\n\n    const hasContent = (v: string | undefined, c: string) => v && v.toLowerCase().indexOf(c.toLowerCase()) >= 0;\n\n    $: {\n        currentIndex = 0;\n        if (!command) {\n            result = commands;\n        } else {\n            result = commands.filter((c) => {\n                return (\n                    hasContent(c.plugin, command) ||\n                    hasContent(c.pluginName, command) ||\n                    hasContent(c.command, command) ||\n                    hasContent(c.description, command)\n                );\n            });\n        }\n    }\n\n    onMount(() => {\n        commands = commandManager.getCommands();\n        const el = document.getElementById('commandPanelInput');\n        el.focus();\n    });\n</script>\n\n<div class=\"fn__flex-column\" style=\"border-radius: 4px;overflow: hidden;position: relative; width: max(80vw, 1000px)\">\n    <div class=\"b3-form__icon search__header\">\n        <svg\n            style=\"left: 14px;\"\n            class=\"b3-form__icon-icon\"\n            viewBox=\"0 0 1024 1024\"\n            version=\"1.1\"\n            xmlns=\"http://www.w3.org/2000/svg\"\n            width=\"200\"\n            height=\"200\"\n            ><path\n                d=\"M64 112v800h896V112H64z m846 750H114V162h796v700zM234.6 688.8L411.3 512 234.6 335.2l35.4-35.4L482.1 512 269.9 724.1l-35.3-35.3z m554.8-10.2h-300v-50h300v50z\"\n            /></svg\n        >\n        <input\n            id=\"commandPanelInput\"\n            class=\"b3-text-field b3-text-field--text fn__block b3-form__icon-input\"\n            bind:value={command}\n            on:keydown={onkeypress}\n        />\n    </div>\n    {#if result}\n        {#each result as com, i}\n            <!-- svelte-ignore a11y-click-events-have-key-events -->\n            <div class={i === currentIndex ? 'command-selected command' : 'command'} on:click={() => onClick(i)}>\n                <span class=\"command-plugin\">{com.pluginName} {':'} </span>\n                <span class=\"command-description\">{com.command} {com.description || ''}</span>\n                {#if com.shortcut}\n                    <div class=\"command-shortcut\">{_('shortcut')}: {com.shortcut}</div>\n                {/if}\n            </div>\n        {/each}\n    {/if}\n</div>\n\n<style>\n    .command {\n        padding: 8px 12px;\n    }\n    .command:hover {\n        cursor: pointer;\n        background-color: rgba(0, 0, 0, 0.2);\n        color: var(--b3-theme-primary);\n    }\n    .command-selected {\n        color: var(--b3-theme-primary);\n        background-color: rgba(0, 0, 0, 0.2);\n    }\n    .command-plugin {\n        font-size: 14px;\n    }\n    .command-shortcut {\n        font-size: 12px;\n        color: var(--color-text-3);\n    }\n</style>\n","import { Plugin } from '@/api/plugin';\nimport { Dialog } from '@/internal/classes';\nimport { Shortcut } from '@/core/shortcut';\nimport CommandPanel__SvelteComponent_ from './command-panel.svelte';\nimport { _ } from '@/util';\n\nexport class CommandPanelPlugin extends Plugin {\n    shortcut: Shortcut;\n\n    onload(): void {\n        this.registerCommand({\n            command: 'Show command panel',\n            description: _('show_command_panel'),\n            shortcut: 'ctrl+shift+o,command+shift+o',\n            callback: () => {\n                this.showPanel();\n            },\n        });\n    }\n\n    showPanel() {\n        Dialog.destroyAll();\n        new Dialog({ content: '<div id=\"command-panel\"></div>' });\n        setImmediate(() => {\n            new CommandPanel__SvelteComponent_({\n                target: document.getElementById('command-panel'),\n            });\n        });\n    }\n}\n","<script lang=\"ts\">\n    import { onMount } from 'svelte';\n    import { defaultConfig, PLUGIN_STORE_URL, PLUGIN_SYSTEM_AUTO_UPDATE, PLUGIN_SYSTEM_SAFE_MODE_ENABLED } from '@/core/plugin-config';\n    import { container } from '@/container';\n    import { TYPES } from '@/config';\n    import { IPluginSystem, IStorageManager } from '@/types';\n    import { _ } from '@/util';\n\n    const storageManager = container.get<IStorageManager>(TYPES.StorageManager);\n    const pluginSystem = container.get<IPluginSystem>(TYPES.PluginSystem);\n\n    let configs = [\n        {\n            label: _('safemode'),\n            tip: _('safemodetip'),\n            checked: true,\n            type: 'checkbox',\n            onChange: (event) => {\n                const checked = event.target.checked;\n                if (checked) {\n                    pluginSystem.turnOnSafeMode();\n                } else {\n                    pluginSystem.turnOffSafeMode();\n                }\n            },\n        },\n        // {\n        //     label: _('autoupgrade'),\n        //     tip: _('autoupgradetip'),\n        //     checked: true,\n        //     type: 'checkbox',\n        //     onChange: (event) => {\n        //         storageManager.set(PLUGIN_SYSTEM_AUTO_UPDATE, event.target.checked);\n        //     },\n        // },\n        {\n            label: _('store_url'),\n            tip: `${_('store_url_tip')} ${defaultConfig.PLUGIN_STORE_URL}`,\n            type: 'input',\n            value: storageManager.get(PLUGIN_STORE_URL),\n            onChange: (event) => {\n                storageManager.set(PLUGIN_STORE_URL, event.target.value);\n            },\n        },\n    ];\n\n    onMount(() => {\n        const securityMode = storageManager.get(PLUGIN_SYSTEM_SAFE_MODE_ENABLED);\n        configs[0].checked = securityMode;\n        const autoUpdate = storageManager.get(PLUGIN_SYSTEM_AUTO_UPDATE);\n        configs[1].checked = autoUpdate;\n    });\n</script>\n\n{#each configs as config}\n    <label class=\"fn__flex b3-label config__item\">\n        <div class=\"fn__flex-1\">\n            {config.label}\n            <div class=\"b3-label__text\">{config.tip}</div>\n        </div>\n        <span class=\"fn__space\" />\n        {#if config.type === 'checkbox'}\n            <input class=\"b3-switch fn__flex-center\" type=\"checkbox\" bind:checked={config.checked} on:change={config.onChange} />\n        {:else if config.type === 'input'}\n            <input class=\"b3-text-field fn__flex-center fn__size200\" type=\"input\" bind:value={config.value} on:change={config.onChange} />\n        {/if}\n    </label>\n{/each}\n","<script lang=\"ts\">\n    import { createEventDispatcher, onMount } from 'svelte';\n    import { container } from '@/container';\n    import { TYPES } from '@/config';\n    import { IPluginSystem, IStorageManager, PluginManifest } from '@/types';\n    import { PLUGIN_SYSTEM_SAFE_MODE_ENABLED } from '@/core/plugin-config';\n    import { _ } from '@/util';\n\n    const storageManager = container.get<IStorageManager>(TYPES.StorageManager);\n    const pluginSystem = container.get<IPluginSystem>(TYPES.PluginSystem);\n\n    let plugins: PluginManifest[] = [];\n\n    $: outsidePlugins = plugins.filter((p) => p.script);\n\n    const loadPlugins = () => {\n        plugins = storageManager.getPlugins();\n    };\n\n    const dispatcher = createEventDispatcher();\n\n    const onPluginEnabledChange = (key: string) => async (event) => {\n        const safeMode = storageManager.get(PLUGIN_SYSTEM_SAFE_MODE_ENABLED);\n        const checked = event.target.checked;\n        await storageManager.setPluginEnabled(key, checked);\n        if (safeMode) {\n            return;\n        }\n        if (checked) {\n            pluginSystem.loadPlugin(key);\n        } else {\n            pluginSystem.unloadPlugin(key);\n        }\n        dispatcher('update');\n    };\n\n    const uninstall = async (key: string, event: MouseEvent) => {\n        event.preventDefault();\n        event.stopPropagation();\n        await pluginSystem.unloadPlugin(key);\n        await storageManager.uninstallPlugin(key);\n        await storageManager.initStorage();\n        loadPlugins();\n    };\n\n    onMount(async () => {\n        await storageManager.initStorage();\n        loadPlugins();\n    });\n</script>\n\n<label class=\"b3-label fn__flex\">\n    <div class=\"fn__flex-1\">\n        {#each outsidePlugins as plugin}\n            {#if !plugin.hidden}\n                <label class=\"fn__flex b3-label\">\n                    <div class=\"plugin fn__flex-1\">\n                        {plugin.name}\n                        {plugin.version}\n                        <!-- svelte-ignore a11y-click-events-have-key-events -->\n                        <span class=\"remove\" on:click={(event) => uninstall(plugin.key, event)}>{_('uninstall')}</span>\n                        <div class=\"b3-label__text\">\n                            {plugin.description || _('nodescription')}\n                        </div>\n                    </div>\n                    <span class=\"fn__space\" />\n                    <input\n                        class=\"b3-switch fn__flex-center\"\n                        id=\"fullWidth\"\n                        type=\"checkbox\"\n                        bind:checked={plugin.enabled}\n                        on:change={onPluginEnabledChange(plugin.key)}\n                    />\n                </label>\n            {/if}\n        {/each}\n    </div>\n</label>\n\n<style>\n    .plugin span.remove {\n        display: none;\n        color: var(--b3-theme-error);\n        margin-left: 4px;\n    }\n    .plugin:hover span.remove {\n        display: inline;\n        cursor: pointer;\n    }\n    .plugin:hover span.remove:hover {\n        text-decoration: underline;\n    }\n</style>\n","import { TYPES } from '@/config';\nimport { PLUGIN_STORE_URL } from '@/core/plugin-config';\nimport { IStorageManager, IStore, StorePluginManifest, StorePluginStatus } from '@/types';\nimport { AxiosResponse } from 'axios';\nimport { inject, injectable } from 'inversify';\nimport { SemVer } from 'semver';\nimport { request, sleep } from '@/util';\nimport { FileClient } from '@/api/file-api';\n\n@injectable()\nexport class Store implements IStore {\n    private plugins: StorePluginManifest[];\n    private pluginStatus: StorePluginStatus[];\n\n    constructor(@inject<IStorageManager>(TYPES.StorageManager) private storageManager: IStorageManager) {\n        this.plugins = [];\n        this.pluginStatus = [];\n    }\n\n    public async init() {\n        this.plugins = [];\n        this.pluginStatus = [];\n        await Promise.all([this.loadPluginsFromUrl(), this.storageManager.initStorage()]);\n        const plugins = this.storageManager.getPlugins();\n        const storePlugins: StorePluginStatus[] = [];\n        for (const plugin of this.plugins) {\n            const p: StorePluginStatus = { ...plugin, isExist: false, needUpgrade: false };\n            const oldPlugin = plugins.find((p) => p.key === plugin.key);\n            if (oldPlugin) {\n                p.isExist = true;\n                const pV = new SemVer(p.version);\n                const oldPluginV = new SemVer(oldPlugin.version);\n                if (pV.compare(oldPluginV) === 1) {\n                    p.needUpgrade = true;\n                }\n            }\n            storePlugins.push(p);\n        }\n        this.pluginStatus = storePlugins;\n    }\n\n    public getStoreUrl() {\n        return this.storageManager.get(PLUGIN_STORE_URL);\n    }\n\n    public getPlugins() {\n        return this.plugins;\n    }\n\n    public async loadPlugins() {\n        await this.init();\n        return this.getPluginsWithStatus();\n    }\n\n    public getPluginsWithStatus() {\n        return this.pluginStatus;\n    }\n\n    public async loadPluginsFromUrl() {\n        const storeUrl = this.getStoreUrl();\n        if (!storeUrl) {\n            return;\n        }\n        let res: AxiosResponse;\n        try {\n            res = await request.get(storeUrl + '/plugins.json', {\n                headers: {\n                    'Cache-Control': 'no-cache',\n                },\n            });\n        } catch (e) {\n            console.error(e);\n            return;\n        }\n        const req = [];\n        if (Array.isArray(res.data?.plugins)) {\n            for (const pluginKey of res.data?.plugins || {}) {\n                const plugin = this.getPluginManifest(`${storeUrl}/${pluginKey}`);\n                req.push(plugin);\n            }\n        }\n        this.plugins = await Promise.all(req);\n    }\n\n    public async getPluginByUrl(url: string) {\n        return Promise.all([this.getPluginManifest(url), this.getPluginMainJs(url)]).then((value) => {\n            return {\n                manifest: value[0],\n                mainJs: value[1],\n            };\n        });\n    }\n\n    public async getPluginManifest(url: string) {\n        try {\n            const manifest = await request.get(`${url}/manifest.json`, {\n                headers: {\n                    'Content-Type': 'application/json',\n                    'Cache-Control': 'no-cache',\n                },\n            });\n            return manifest.data;\n        } catch (e) {\n            console.error(e);\n            return null;\n        }\n    }\n\n    public async getPluginMainJs(url: string) {\n        try {\n            const res = await request.get(`${url}/main.js`, {\n                headers: {\n                    'Content-Type': 'text/plain',\n                    'Cache-Control': 'no-cache',\n                },\n            });\n            return res.data;\n        } catch (e) {\n            console.error(e);\n            return null;\n        }\n    }\n\n    public async getPluginReadme(key: string) {\n        const url = `${this.getStoreUrl()}/${key}`;\n        try {\n            const res = await request.get(`${url}/README.md`, {\n                headers: {\n                    'Content-Type': 'text/plain',\n                    'Cache-Control': 'no-cache',\n                },\n            });\n            return res.data as string;\n        } catch (e) {\n            console.error(e);\n            return null;\n        }\n    }\n\n    public async downloadPlugin(key: string) {\n        await sleep(500);\n        const files = await this.getPluginByUrl(`${this.getStoreUrl()}/${key}`);\n        const manifestJson = files.manifest;\n        const mainJs = files.mainJs;\n        return await Promise.all([\n            FileClient.getInstanceApi().fileApi.putFile(`/data/plugins/${key}`, null, true),\n            FileClient.getInstanceApi().fileApi.putFile(`/data/plugins/${key}/manifest.json`, JSON.stringify(manifestJson), false),\n            FileClient.getInstanceApi().fileApi.putFile(`/data/plugins/${key}/main.js`, mainJs, false),\n        ]);\n    }\n}\n","<script lang=\"ts\">\n    export let onClick: () => void = null;\n    export let disabled: boolean = false;\n</script>\n\n<button on:click={onClick} {disabled} class=\"b3-button\"><slot /></button>\n","<script lang=\"ts\">\n    import { container } from '@/container';\n    import { IStore, PluginManifest } from '@/types';\n    import { _ } from '@/util';\n    import { onMount } from 'svelte';\n    import { createEventDispatcher } from 'svelte';\n\n    const dispatch = createEventDispatcher();\n\n    let loading = true;\n\n    export let plugin: PluginManifest;\n\n    const getPluginReadme = async () => {\n        readme = await container.get<IStore>('Store').getPluginReadme(plugin.key);\n        loading = false;\n    };\n\n    let readme: string;\n\n    const LuteMdConverter = window.Lute.New();\n\n    $: previewHTML = () => {\n        return readme ? LuteMdConverter.Md2HTML(readme) : '';\n    };\n\n    onMount(() => {\n        getPluginReadme();\n    });\n\n    const goBack = () => {\n        dispatch('goback');\n    };\n</script>\n\n<div class=\"plugin-detail\">\n    <div class=\"plugin-basic\">\n        <div class=\"plugin-info\">\n            <div class=\"plugin-name\">{plugin.name}</div>\n            <div class=\"plugin-key\">({plugin.key})</div>\n            <!-- svelte-ignore a11y-click-events-have-key-events -->\n            <!-- svelte-ignore a11y-missing-attribute -->\n            <button class=\"go-back b3-button\" on:click={() => goBack()}><svg class=\"go-back-icon\"><use xlink:href=\"#iconBack\" /></svg>{_('goBack')}</button>\n        </div>\n \n        <div class=\"plugin-manifest\">\n            {#if plugin.url}<div class=\"plugin-item\">{_('url')}: <a href={plugin.url} target=\"_blank\" rel=\"noreferrer\">{plugin.url}</a></div> {/if}\n            {#if plugin.author}<div class=\"plugin-item\">{_('author')}: {plugin.author}</div> {/if}\n            {#if plugin.version}<div class=\"plugin-item\">{_('version')}: {plugin.version}</div> {/if}\n            {#if plugin.description}<div class=\"plugin-item\">{_('description')}: {plugin.description}</div> {/if}\n        </div>\n    </div>\n    <hr/>\n    <div class=\"plugin-readme b3-typography\">\n        {#if loading}\n            <span>{_('readme')}</span>\n        {:else}\n            {@html previewHTML()}\n        {/if}\n    </div>\n</div>\n\n<style>\n    .plugin-info {\n        display: flex;\n        align-items: center;\n    }\n    .plugin-detail {\n        margin-top: 12px;\n        width: 100%;\n    }\n    .plugin-name {\n        display: inline;\n        margin-right: 6px;\n        font-size: 24px;\n    }\n    .plugin-key {\n        display: inline;\n        font-size: 16px;\n    }\n    .plugin-manifest {\n        margin-top: 12px;\n    }\n    .plugin-readme {\n        margin-top: 20px;\n    }\n    .go-back {\n        margin-left: 12px;\n        font-size: 12px;\n        height: 24px;\n    }\n    .go-back-icon {\n        height: 12px;\n        width: 12px;\n        margin-right: 4px;\n    }\n</style>\n","<script lang=\"ts\">\n    import { TYPES } from '@/config';\n    import { container } from '@/container';\n    import { Store } from '@/core/store';\n    import Button from '@/internal/components/Button.svelte';\n    import { StorePluginStatus } from '@/types';\n    import { StorePluginManifest } from '@/types';\n    import { _ } from '@/util';\n    import { onMount } from 'svelte';\n    import SettingPreview from './setting-preview.svelte';\n\n    const store = container.get<Store>(TYPES.Store);\n    let plugins: StorePluginStatus[] = [];\n    let loading = true;\n\n    const loadingMap = {};\n\n    onMount(async () => {\n        plugins = await store.loadPlugins();\n        loading = false;\n    });\n\n    const downloadPlugin = async (key: string) => {\n        if (loadingMap[key]) {\n            return;\n        }\n        try {\n            loadingMap[key] = true;\n            await store.downloadPlugin(key);\n            const p = plugins.find((k) => k.key === key);\n            if (p) {\n                p.isExist = true;\n                p.needUpgrade = false;\n            }\n        } finally {\n            loadingMap[key] = false;\n        }\n    };\n\n    let selectedPlugin: StorePluginManifest = null;\n\n    const previewPlugin = (event: MouseEvent, plugin: StorePluginManifest) => {\n        selectedPlugin = plugin;\n        event.stopPropagation();\n        event.preventDefault();\n    };\n</script>\n\n<div class=\"b3-label fn__flex\">\n    {#if loading}\n        <div>{_('loading')}</div>\n    {:else if !selectedPlugin}\n        <div class=\"fn__flex-1\">\n            {#each plugins as plugin}\n                <!-- svelte-ignore a11y-label-has-associated-control -->\n                <label class=\"fn__flex b3-label\">\n                    <div class=\"fn__flex-1\">\n                        <!-- svelte-ignore a11y-click-events-have-key-events -->\n                        <!-- svelte-ignore a11y-invalid-attribute -->\n                        <a href=\"javascript:void(0)\" class=\"\" on:click={(event) => previewPlugin(event, plugin)}>{plugin.name}</a>\n                        {plugin.version}\n                        <div class=\"b3-label__text\">\n                            {plugin.description || ''}\n                        </div>\n                    </div>\n                    <span class=\"fn__space\" />\n                    {#if loadingMap[plugin.key]}\n                        <Button disabled={true}>{_('downloading')}</Button>\n                    {:else if plugin.isExist}\n                        {#if plugin.needUpgrade}\n                            <Button onClick={() => downloadPlugin(plugin.key)}>{_('upgrade')}</Button>\n                        {:else}\n                            <Button disabled={true}>{_('downloaded')}</Button>\n                        {/if}\n                    {:else}\n                        <Button onClick={() => downloadPlugin(plugin.key)}>{_('download')}</Button>\n                    {/if}\n                </label>\n            {/each}\n        </div>\n    {:else}\n        <SettingPreview on:goback={() => selectedPlugin = null } plugin={selectedPlugin}></SettingPreview>\n    {/if}\n</div>\n","<script lang=\"ts\">\n    import { SettingRender } from '@/types';\n    import { onMount } from 'svelte';\n\n    let root: HTMLElement;\n\n    export let render: SettingRender;\n\n    $: {\n        const el = document.getElementById('setting-custom-render');\n        if (el) {\n            if (root) {\n                root.remove();\n            }\n            root = document.createElement('div');\n            document.getElementById('setting-custom-render').appendChild(root);\n            render(root);\n        }\n        \n    }\n\n    onMount(() => {\n        root = document.createElement('div');\n        document.getElementById('setting-custom-render').appendChild(root);\n        render(root);\n    });\n    \n\n</script>\n\n\n<div id=\"setting-custom-render\"></div>","<script lang=\"ts\">\n    import { _ } from '@/util';\n    import SettingCommon from './setting-common.svelte';\n    import SettingList from './setting-list.svelte';\n    import SettingStore from './setting-store.svelte';\n    import { container } from '@/container';\n    import { TYPES } from '@/config';\n    import { ISettingManager, IStorageManager, SettingRender } from '@/types';\n    import SettingCustom from './setting-custom.svelte';\n\n    type Menu = { key: string; name: string; type: 'internal' | 'custom'; component?: any; render?: SettingRender; };\n\n    const menus: Menu[] = [\n        {\n            key: 'common',\n            name: _('menu_common'),\n            type: 'internal',\n            component: SettingCommon,\n        },\n        {\n            key: 'list',\n            name: _('menu_list'),\n            type: 'internal',\n            component: SettingList,\n        },\n        {\n            key: 'store',\n            name: _('menu_store'),\n            type: 'internal',\n            component: SettingStore,\n        },\n    ];\n\n    const sm = container.get<ISettingManager>(TYPES.SettingManager);\n    const sm1 = container.get<IStorageManager>(TYPES.StorageManager);\n    const plugins = sm1.getThirdPartyPlugins();\n    let settingRenders = sm.getSettingRenders();\n    const getName = (key: string) => plugins.find((p) => p.key === key)?.name;\n    \n    $: thirdMenus = settingRenders.map((s) => {\n        return {\n            key: s.key,\n            name: getName(s.key),\n            component: SettingCommon,\n            type: 'custom',\n            render: s.value,\n        };\n    });\n\n    const setCurrentSelection = (menu) => (currentSelection = menu);\n    const updateMenus = () => {\n        settingRenders = [...sm.getSettingRenders()];\n    };\n    let currentSelection = menus[0];\n</script>\n\n<div class=\"fn__flex-column\" style=\"border-radius: 4px;overflow: auto;position: relative; height: 80vh\">\n    <div class=\"fn__flex-1 fn__flex config__panel\">\n        <ul class=\"b3-tab-bar b3-list b3-list--background\" style=\"height: unset !important;\">\n            {#each menus as menu}\n                <!-- svelte-ignore a11y-click-events-have-key-events -->\n                <li\n                    data-name={menu.key}\n                    class={currentSelection.key === menu.key\n                        ? 'b3-list-item--focus b3-list-item b3-list-item--big'\n                        : 'b3-list-item b3-list-item--big'} \n                    on:click={() => setCurrentSelection(menu)}\n                >\n                    <span class=\"b3-list-item__text\">{menu.name}</span>\n                </li>\n            {/each}\n            {#if thirdMenus.length > 0}\n                <hr style=\"margin: 12px;\">\n            {/if}\n            {#each thirdMenus as menu}\n                <!-- svelte-ignore a11y-click-events-have-key-events -->\n                <li\n                    data-name={menu.key}\n                    class={currentSelection.key === menu.key\n                        ? 'b3-list-item--focus b3-list-item b3-list-item--big'\n                        : 'b3-list-item b3-list-item--big'} \n                    on:click={() => setCurrentSelection(menu)}\n                >\n                    <span class=\"b3-list-item__text\">{menu.name}</span>\n                </li>\n            {/each}\n        </ul>\n        <div class=\"config__tab-container\" style=\"height: unset !important;\" data-name={currentSelection.key}>\n            {#if currentSelection.type === 'internal'}\n                <svelte:component this={currentSelection.component} on:update={() => updateMenus()} />\n            {:else}\n                <SettingCustom render={currentSelection.render} />\n            {/if}\n        </div>\n    </div>\n</div>\n","import { Menu, MenuItem, Dialog } from '@/internal';\nimport * as clientApi from '@/api/client-api';\nimport { Plugin } from '@/api/plugin';\nimport Settings from './setting.svelte';\nimport { _ } from '@/util';\n\nexport class InternalSettingPlugin extends Plugin {\n    constructor() {\n        super();\n    }\n    svg =\n        '<svg t=\"1679703027227\" class=\"icon\" viewBox=\"0 0 1024 1024\" version=\"1.1\" xmlns=\"http://www.w3.org/2000/svg\" p-id=\"24715\" width=\"200\" height=\"200\"><path d=\"M512 1023.99984a75.519988 75.519988 0 0 1-53.679992-22.207997L22.368077 565.455912c-29.487995-29.679995-29.487995-77.919988-0.064-107.519984l159.711975-159.839975a31.951995 31.951995 0 0 1 54.047991 28.207996 131.10398 131.10398 0 0 0-2.368 23.135996c0 69.951989 56.895991 128.11198 126.847981 128.11198 69.999989 0 121.119981-58.159991 121.119981-128.11198 0-70.079989-51.119992-127.07198-121.119981-127.07198a130.87998 130.87998 0 0 0-23.007997 2.384 31.759995 31.759995 0 0 1-33.919994-16.671998 31.999995 31.999995 0 0 1 5.743999-37.423994l148.895976-149.103976c28.847995-28.719996 78.719988-28.655996 107.423984-0.064l109.023983 109.183983C697.439971 59.887991 763.871961 8.479999 842.015948 8.479999c96.911985 0 175.743973 78.959988 175.743973 175.967972 0 78.239988-51.295992 144.719977-122.063981 167.471974l105.887984 105.951983a76.351988 76.351988 0 0 1 0.031999 107.551984L565.743992 1001.775843A75.759988 75.759988 0 0 1 512 1023.99984z\" fill=\"\" p-id=\"24716\"></path></svg>';\n    onload() {\n        const internalSettingButton = document.createElement('button');\n        internalSettingButton.setAttribute('aria-label', _('plugin_system'));\n        internalSettingButton.classList.add('toolbar__item', 'b3-tooltips', 'b3-tooltips__sw');\n        internalSettingButton.insertAdjacentHTML('beforeend', this.svg);\n        internalSettingButton.addEventListener('click', (event) => {\n            new Menu('internalSettingButton')\n                .addItem(\n                    new MenuItem({\n                        label: _('plugin_system_setting'),\n                        icon: 'iconEdit',\n                        click: () => showSettingDialog(),\n                    })\n                )\n                .addSeparator()\n                .addItem(\n                    new MenuItem({\n                        label: _('reload'),\n                        icon: 'iconRefresh',\n                        click: () => window.location.reload(),\n                    })\n                )\n                .showAtMouseEvent(event);\n            event.stopPropagation();\n        });\n        clientApi.addToolbarRight(internalSettingButton);\n\n        this.registerCommand({\n            command: 'Show plugin system conifg',\n            description: _('show_plugin_system_config'),\n            shortcut: 'command+option+p',\n            callback: () => showSettingDialog(),\n        });\n        this.registerCommand({\n            command: 'Reload Window',\n            description: _('reload_window'),\n            callback: () => window.location.reload(),\n        });\n    }\n}\n\nfunction showSettingDialog() {\n    new Dialog({\n        title: _('plugin_system_setting'),\n        content: '<div id=\"plugin-settings\"></div>',\n        width: '90vw',\n        height: '80vh',\n    });\n    setTimeout(() => {\n        new Settings({\n            target: document.getElementById('plugin-settings'),\n        });\n    });\n}\n","export * from './classes';\nimport { PluginManifest } from '@/types';\nimport { CommandPanelPlugin } from './plugins/command-panel';\nimport { InternalSettingPlugin } from './plugins/setting';\n\nexport const internalPlugins: PluginManifest[] = [\n    { key: 'setting', name: 'setting', plugin: InternalSettingPlugin, enabled: true, hidden: true, version: '1.0.0' },\n    { key: 'commandPanel', name: 'commandPanel', plugin: CommandPanelPlugin, enabled: true, hidden: true, version: '1.0.0' },\n];\n","'use strict';\n\nfunction isHighSurrogate(codePoint) {\n  return codePoint >= 0xd800 && codePoint <= 0xdbff;\n}\n\nfunction isLowSurrogate(codePoint) {\n  return codePoint >= 0xdc00 && codePoint <= 0xdfff;\n}\n\n// Truncate string by size in bytes\nmodule.exports = function truncate(getLength, string, byteLength) {\n  if (typeof string !== \"string\") {\n    throw new Error(\"Input must be string\");\n  }\n\n  var charLength = string.length;\n  var curByteLength = 0;\n  var codePoint;\n  var segment;\n\n  for (var i = 0; i < charLength; i += 1) {\n    codePoint = string.charCodeAt(i);\n    segment = string[i];\n\n    if (isHighSurrogate(codePoint) && isLowSurrogate(string.charCodeAt(i + 1))) {\n      i += 1;\n      segment += string[i];\n    }\n\n    curByteLength += getLength(segment);\n\n    if (curByteLength === byteLength) {\n      return string.slice(0, i + 1);\n    }\n    else if (curByteLength > byteLength) {\n      return string.slice(0, i - segment.length + 1);\n    }\n  }\n\n  return string;\n};\n\n","'use strict';\n\nfunction isHighSurrogate(codePoint) {\n  return codePoint >= 0xd800 && codePoint <= 0xdbff;\n}\n\nfunction isLowSurrogate(codePoint) {\n  return codePoint >= 0xdc00 && codePoint <= 0xdfff;\n}\n\n// Truncate string by size in bytes\nmodule.exports = function getByteLength(string) {\n  if (typeof string !== \"string\") {\n    throw new Error(\"Input must be string\");\n  }\n\n  var charLength = string.length;\n  var byteLength = 0;\n  var codePoint = null;\n  var prevCodePoint = null;\n  for (var i = 0; i < charLength; i++) {\n    codePoint = string.charCodeAt(i);\n    // handle 4-byte non-BMP chars\n    // low surrogate\n    if (isLowSurrogate(codePoint)) {\n      // when parsing previous hi-surrogate, 3 is added to byteLength\n      if (prevCodePoint != null && isHighSurrogate(prevCodePoint)) {\n        byteLength += 1;\n      }\n      else {\n        byteLength += 3;\n      }\n    }\n    else if (codePoint <= 0x7f ) {\n      byteLength += 1;\n    }\n    else if (codePoint >= 0x80 && codePoint <= 0x7ff) {\n      byteLength += 2;\n    }\n    else if (codePoint >= 0x800 && codePoint <= 0xffff) {\n      byteLength += 3;\n    }\n    prevCodePoint = codePoint;\n  }\n\n  return byteLength;\n};\n","'use strict';\n\nvar truncate = require(\"./lib/truncate\");\nvar getLength = require(\"utf8-byte-length/browser\");\nmodule.exports = truncate.bind(null, getLength);\n","/*jshint node:true*/\n'use strict';\n\n/**\n * Replaces characters in strings that are illegal/unsafe for filenames.\n * Unsafe characters are either removed or replaced by a substitute set\n * in the optional `options` object.\n *\n * Illegal Characters on Various Operating Systems\n * / ? < > \\ : * | \"\n * https://kb.acronis.com/content/39790\n *\n * Unicode Control codes\n * C0 0x00-0x1f & C1 (0x80-0x9f)\n * http://en.wikipedia.org/wiki/C0_and_C1_control_codes\n *\n * Reserved filenames on Unix-based systems (\".\", \"..\")\n * Reserved filenames in Windows (\"CON\", \"PRN\", \"AUX\", \"NUL\", \"COM1\",\n * \"COM2\", \"COM3\", \"COM4\", \"COM5\", \"COM6\", \"COM7\", \"COM8\", \"COM9\",\n * \"LPT1\", \"LPT2\", \"LPT3\", \"LPT4\", \"LPT5\", \"LPT6\", \"LPT7\", \"LPT8\", and\n * \"LPT9\") case-insesitively and with or without filename extensions.\n *\n * Capped at 255 characters in length.\n * http://unix.stackexchange.com/questions/32795/what-is-the-maximum-allowed-filename-and-folder-size-with-ecryptfs\n *\n * @param  {String} input   Original filename\n * @param  {Object} options {replacement: String | Function }\n * @return {String}         Sanitized filename\n */\n\nvar truncate = require(\"truncate-utf8-bytes\");\n\nvar illegalRe = /[\\/\\?<>\\\\:\\*\\|\"]/g;\nvar controlRe = /[\\x00-\\x1f\\x80-\\x9f]/g;\nvar reservedRe = /^\\.+$/;\nvar windowsReservedRe = /^(con|prn|aux|nul|com[0-9]|lpt[0-9])(\\..*)?$/i;\nvar windowsTrailingRe = /[\\. ]+$/;\n\nfunction sanitize(input, replacement) {\n  if (typeof input !== 'string') {\n    throw new Error('Input must be string');\n  }\n  var sanitized = input\n    .replace(illegalRe, replacement)\n    .replace(controlRe, replacement)\n    .replace(reservedRe, replacement)\n    .replace(windowsReservedRe, replacement)\n    .replace(windowsTrailingRe, replacement);\n  return truncate(sanitized, 255);\n}\n\nmodule.exports = function (input, options) {\n  var replacement = (options && options.replacement) || '';\n  var output = sanitize(input, replacement);\n  if (replacement === '') {\n    return output;\n  }\n  return sanitize(output, '');\n};\n","import { inject, injectable } from 'inversify';\nimport { getLocalStorage, setStorageVal } from '../api/server-api';\nimport { defaultConfig, PLUGIN_SYSTEM_PLUGIN, PLUGIN_SYSTEM_SAFE_MODE_ENABLED, PLUGIN_SYSTEM_THIRD_PARTY_PLUGIN } from './plugin-config';\nimport { internalPlugins } from '../internal';\nimport { TYPES } from '../config';\nimport { IPluginFileManager, IStorageManager, PluginConfig, PluginEnableConfig, PluginManifest } from '../types';\nimport { showErrorMessage } from '@/util';\nimport sanitize from 'sanitize-filename';\nimport { FileClient } from '@/api/file-api';\n\n@injectable()\nexport class StorageManager implements IStorageManager {\n    private pluginFileManager: IPluginFileManager;\n\n    private config: PluginConfig;\n\n    private internalPlugins: PluginManifest[];\n\n    private thirdPartyPlugins: PluginManifest[];\n\n    constructor(@inject(TYPES.PluginFileManager) pluginFileManager) {\n        this.config = Object.assign({}, defaultConfig);\n        this.pluginFileManager = pluginFileManager;\n    }\n\n    public get(key: keyof PluginConfig) {\n        return this.config[key];\n    }\n\n    public async set(key: string, val: any) {\n        this.config[key] = val;\n        return setStorageVal(key, val);\n    }\n\n    async initStorage() {\n        const all = await getLocalStorage();\n        const configKeys = Object.keys(defaultConfig);\n        for (const key of configKeys) {\n            if (all[key] !== undefined) {\n                this.config[key] = all[key];\n            } else {\n                await setStorageVal(key, defaultConfig[key]);\n            }\n        }\n        // load all plugins\n        this.thirdPartyPlugins = await this.pluginFileManager.getAllPlugins();\n        this.internalPlugins = [...internalPlugins];\n        this.init3rdPartyEnabled();\n        this.initInternalEnabled();\n        await this.savePluginsEnabled();\n\n        return this;\n    }\n\n    private init3rdPartyEnabled() {\n        const enabledPlugins = this.get(PLUGIN_SYSTEM_THIRD_PARTY_PLUGIN) as PluginEnableConfig[];\n        for (const ep of enabledPlugins) {\n            for (const p of this.thirdPartyPlugins) {\n                if (p.key === ep.key) {\n                    p.enabled = ep.enabled || false;\n                    break;\n                }\n            }\n        }\n    }\n\n    private initInternalEnabled() {\n        const enabledPlugins = this.get(PLUGIN_SYSTEM_PLUGIN) as PluginEnableConfig[];\n        for (const ep of enabledPlugins) {\n            for (const p of this.internalPlugins) {\n                if (p.key === ep.key) {\n                    p.enabled = ep.enabled || false;\n                    break;\n                }\n            }\n        }\n    }\n\n    public getPlugins() {\n        return [...this.internalPlugins, ...this.thirdPartyPlugins];\n    }\n\n    public getInternalPlugins() {\n        return this.internalPlugins;\n    }\n\n    public getThirdPartyPlugins() {\n        return this.thirdPartyPlugins;\n    }\n\n    public getPluginByKey(key) {\n        return this.getPlugins().find((p) => p.key === key);\n    }\n\n    public async setPluginEnabled(key: string, enabled: boolean) {\n        for (const p of [...this.internalPlugins, ...this.thirdPartyPlugins]) {\n            if (p.key === key) {\n                p.enabled = enabled;\n                break;\n            }\n        }\n        await this.savePluginsEnabled();\n    }\n\n    public async setSafeModeEnabled(enabled: boolean) {\n        return this.set(PLUGIN_SYSTEM_SAFE_MODE_ENABLED, enabled);\n    }\n\n    public async savePluginsEnabled() {\n        await this.set(\n            PLUGIN_SYSTEM_PLUGIN,\n            this.internalPlugins.map((p) => ({ key: p.key, enabled: p.enabled }))\n        );\n        return this.set(\n            PLUGIN_SYSTEM_THIRD_PARTY_PLUGIN,\n            this.thirdPartyPlugins.map((p) => ({ key: p.key, enabled: p.enabled }))\n        );\n    }\n\n    public async setPluginStorage(pluginKey: string, filename: string, content: any) {\n        try {\n            if (this.isFileNameIllegal(filename)) {\n                showErrorMessage(`插件${pluginKey}存储文件名不合法`);\n                return;\n            }\n            await this.addPluginStorageFolderIfNotExist(pluginKey);\n            await FileClient.getInstanceApi().fileApi.putFile(`/data/plugins/.storage/${pluginKey}/${filename}`, content);\n        } catch (e) {\n            showErrorMessage(`插件${pluginKey}存储保存失败`, 2000);\n        }\n    }\n\n    public async getPluginStorage(pluginKey: string, filename: string): Promise<Response> {\n        try {\n            return await FileClient.getInstanceApi().fileApi.getFile(`/data/plugins/.storage/${pluginKey}/${filename}`);\n        } catch (e) {\n            showErrorMessage(`插件${pluginKey}存储保存失败`, 2000);\n            return null;\n        }\n    }\n\n    public async uninstallPlugin(pluginKey: string): Promise<void> {\n        await FileClient.getInstanceApi().fileApi.removeFile(`/data/plugins/${pluginKey}`);\n        await FileClient.getInstanceApi().fileApi.removeFile(`/data/plugins//.storage/${pluginKey}`);\n    }\n\n    private async addPluginStorageFolderIfNotExist(pluginKey: string) {\n        const folder = `/data/plugins/.storage/${pluginKey}`;\n        await FileClient.getInstanceApi().fileApi.putFile(folder, null, true);\n    }\n\n    private isFileNameIllegal(filename: string) {\n        return filename !== sanitize(filename);\n    }\n}\n","import 'reflect-metadata';\nimport { inject, injectable } from 'inversify';\nimport { TYPES, VERSION } from '../config';\nimport { IPluginSystem, IStorageManager } from '../types';\nimport { PLUGIN_SYSTEM_SAFE_MODE_ENABLED } from './plugin-config';\nimport { log } from '../util';\n\n@injectable()\nexport class PluginSystem implements IPluginSystem {\n    public version = VERSION;\n\n    constructor(\n        @inject(TYPES.PluginLoader) private pluginLoader,\n        @inject(TYPES.SystemManager) private pslm,\n        @inject(TYPES.StorageManager) private storageManager: IStorageManager,\n        @inject(TYPES.CommandManager) private commandManager,\n        @inject(TYPES.Store) private store\n    ) {}\n\n    async init() {\n        await this.storageManager.initStorage();\n        const internalPlugins = this.storageManager.getInternalPlugins();\n        this.pluginLoader.loadEnabledPlugins(internalPlugins);\n        log(`Loading internal enabled plugins: ${internalPlugins.map((p) => p.key).join(',')}`);\n        const securityModeEnabled = this.storageManager.get(PLUGIN_SYSTEM_SAFE_MODE_ENABLED);\n        if (!securityModeEnabled) {\n            const plugins = this.storageManager.getThirdPartyPlugins();\n            log(`Loading 3rd party enabled plugins: ${plugins.map((p) => p.key).join(',')}`);\n            this.pluginLoader.loadEnabledPlugins(plugins);\n        }\n        this.pslm.localCacheInit();\n        return this;\n    }\n\n    async loadPlugin(key: string) {\n        this.storageManager.setPluginEnabled(key, true);\n        const plugin = this.storageManager.getPluginByKey(key);\n        this.pluginLoader.loadPlugin(plugin);\n    }\n\n    async unloadPlugin(key: string) {\n        this.storageManager.setPluginEnabled(key, false);\n        this.pluginLoader.unloadPlugin(key);\n    }\n\n    async turnOffSafeMode() {\n        this.storageManager.setSafeModeEnabled(false);\n        const plugins = this.storageManager.getThirdPartyPlugins();\n        return this.pluginLoader.loadEnabledPlugins(plugins);\n    }\n\n    async turnOnSafeMode() {\n        this.storageManager.setSafeModeEnabled(true);\n        const plugins = this.storageManager.getThirdPartyPlugins();\n        return this.pluginLoader.unloadThirdPartyPlugins(plugins);\n    }\n}\n","export const migrate = async () => {\n    const SNIPPET_NAME = 'plugin-system-bazzar';\n    const content = `(async () => {\n        window.pluginSystemSource = 'bazzar';\n        const response = await fetch('/api/file/getFile', {\n            method: 'POST',\n            mode: 'cors',\n            cache: 'no-cache',\n            credentials: 'same-origin',\n            headers: {\n                'Content-Type': 'application/json',\n            },\n            redirect: 'follow',\n            referrerPolicy: 'no-referrer',\n            body: JSON.stringify({ path: '/data/widgets/插件系统/plugin.js' }),\n        });\n        const js = await response.text();\n        eval(js);\n    })()`;\n\n    const request = async (url, body) => {\n        const response = await fetch(url, {\n            method: 'POST',\n            mode: 'cors',\n            cache: 'no-cache',\n            credentials: 'same-origin',\n            headers: {\n                'Content-Type': 'application/json',\n            },\n            redirect: 'follow',\n            referrerPolicy: 'no-referrer',\n            body: JSON.stringify(body),\n        });\n        return response.json();\n    };\n\n    const res = await request('/api/snippet/getSnippet', { enabled: 2, type: 'all' });\n\n    const snippets = res.data.snippets;\n\n    for (const snippet of snippets) {\n        if (snippet.type !== 'js') {\n            continue;\n        }\n        if (snippet.content.indexOf('https://gitee.com/zuoez02/siyuan-plugin-system/raw/main/main.js') !== -1) {\n            snippet.enabled = false;\n        }\n        if (snippet.name === SNIPPET_NAME) {\n            snippet.enabled = true;\n            snippet.content = content;\n            await request('/api/snippet/setSnippet', { snippets });\n            return;\n        }\n    }\n\n    snippets.splice(0, 0, {\n        id: '20230324100959-plugind',\n        name: SNIPPET_NAME,\n        type: 'js',\n        enabled: true,\n        content,\n    });\n    await request('/api/snippet/setSnippet', { snippets });\n    setTimeout(() => window.parent.location.reload(), 1000);\n};\n","import { PLUGIN_SYS_ABS_PATH, SCRIPT_URL, VERSION, VERSION_URL } from '../config';\nimport { TYPES } from '../config';\nimport { _, log, reloadWindow, showInfoMessage } from '../util';\nimport { inject, injectable } from 'inversify';\nimport { PLUGIN_SYSTEM_AUTO_UPDATE } from './plugin-config';\nimport { IStorageManager, ISystemManager } from '../types';\nimport { FileClient } from '@/api/file-api';\nimport { migrate } from '@/util/migrate';\nimport { serverApi } from '@/api';\nimport { SemVer } from 'semver';\nimport { Notification } from '@/internal/classes/notification';\n\nconst pluginScriptPosition = PLUGIN_SYS_ABS_PATH;\n\n@injectable()\nexport class SystemManager implements ISystemManager {\n    storageMangager: IStorageManager;\n\n    constructor(@inject(TYPES.StorageManager) storageManager) {\n        this.storageMangager = storageManager;\n    }\n\n    public async saveToLocal(p: string, content: string) {\n        FileClient.getInstanceApi().fileApi.putFile(p, content);\n    }\n\n    async localCacheInit() {\n        try {\n            const plugin = FileClient.getInstanceApi().fileApi.getFile(pluginScriptPosition);\n            if (plugin !== null) {\n                this.delayAutoUpgrade();\n            }\n            return;\n        } catch (e) {\n            log('Plugin system not found');\n        }\n        const script = window.siyuanPluginScript;\n        if (!script) {\n            return;\n        }\n        await this.saveToLocal(pluginScriptPosition, script);\n        this.delayAutoUpgrade();\n    }\n\n    delayAutoUpgrade() {\n        return false;\n        setTimeout(() => {\n            const autoUpdate = this.storageMangager.get(PLUGIN_SYSTEM_AUTO_UPDATE);\n            if (!autoUpdate) {\n                log('Auto Update skipped');\n            } else {\n                this.tryUpgrade();\n            }\n        }, 1000);\n    }\n\n    async tryUpgrade() {\n        if (window.pluginSystemSource === 'bazzar') {\n            log('Plugin installed from bazzar version, upgrade skip');\n            this.compareWidgetVersion();\n            return;\n        }\n        log('Try getting online version');\n        const onlineVersion = await this.getOnlineVersion();\n        if (onlineVersion !== VERSION) {\n            showInfoMessage(`插件系统获取到最新版本 ${onlineVersion}，即将自动更新`);\n            log('Online Version: ' + onlineVersion + ', local version: ' + VERSION);\n            log('Downloading new version of Plugin System');\n            this.upgrade();\n        } else {\n            log('Version is ' + VERSION + ', OK');\n        }\n    }\n\n    async getOnlineVersion() {\n        return fetch(VERSION_URL, { cache: 'no-cache' }).then((res) => res.text());\n    }\n\n    async upgrade() {\n        const script = await fetch(SCRIPT_URL, { cache: 'no-cache' }).then((res) => res.text());\n        if (!script) {\n            return;\n        }\n        migrate();\n\n        showInfoMessage('插件系统升级中，即将自动重载...');\n        await this.saveToLocal(pluginScriptPosition, script);\n        log('Plugin system upgraded, reloading...');\n        setTimeout(() => reloadWindow(), 3000);\n    }\n\n    async compareWidgetVersion() {\n        const res = await serverApi.getBazzarWidget();\n        const packages = res.packages;\n        const ps = packages.find((p) => p.name === '插件系统');\n        if (!ps) {\n            return;\n        }\n        const latestVersion = ps.version;\n        const result = new SemVer(VERSION).compare(latestVersion);\n        if (result < 0) {\n            new Notification({ message: _('new_version_widget'), type: 'info' }).show();\n        }\n    }\n}\n","import { Plugin } from '../api/plugin';\nimport api from '../api';\nimport {\n    IPluginCommand,\n    ICommandManager,\n    IPlugin,\n    IPluginFileManager,\n    IPluginLoader,\n    PluginManifest,\n    SettingRender,\n    ISettingManager,\n} from '../types';\nimport { internalPlugins } from '../internal';\nimport { log } from '../util';\nimport { inject, injectable } from 'inversify';\nimport { TYPES } from '../config';\nimport { container } from '@/container';\nimport { IStorageManager } from '../types';\nimport { error } from '../util';\nimport axios from 'axios';\n\nlet components: { [key: string]: any };\n\n@injectable()\nexport class PluginLoader implements IPluginLoader {\n    pluginFileManager: IPluginFileManager;\n\n    loadedPlugins: Map<string, IPlugin>;\n\n    constructor(@inject(TYPES.PluginFileManager) pluginFileManager) {\n        this.pluginFileManager = pluginFileManager;\n        this.loadedPlugins = new Map();\n    }\n\n    async loadEnabledPlugins(plugins: PluginManifest[]) {\n        if (!plugins || !plugins.length) {\n            return;\n        }\n        for (const p of plugins) {\n            if (!p.enabled) {\n                continue;\n            }\n            await this.loadPlugin(p);\n        }\n    }\n\n    async loadAllInternalPlugins() {\n        internalPlugins.forEach(async (p) => {\n            const plug = new p.plugin();\n            if (!(plug instanceof Plugin)) {\n                throw new Error(`Failed to load plugin ${p.name}`);\n            }\n            log(`Load internal plugin: ${p.key}(${p.name})`);\n            this.addAdditionalMethod(plug, p.key, p.name);\n            await plug.onload();\n            this.loadedPlugins.set(p.key, plug);\n        });\n    }\n\n    async loadAllLocalPlugins() {\n        const plugins = await this.pluginFileManager.getAllPlugins();\n        if (!plugins) {\n            return;\n        }\n        for (const p of plugins) {\n            await this.loadPlugin(p);\n        }\n    }\n\n    async loadPlugin(plugin: PluginManifest) {\n        if (!components) {\n            this.generateRequiredModules();\n        }\n        if (!plugin.enabled || (!plugin.plugin && !plugin.script)) {\n            return;\n        }\n        if (plugin.plugin) {\n            // internal plugin\n            const plug = new plugin.plugin();\n            if (!(plug instanceof Plugin)) {\n                throw new Error(`Failed to load plugin ${plugin.name}`);\n            }\n            log(`Load internal plugin: ${plugin.key}(${plugin.name})`);\n            this.addAdditionalMethod(plug, plugin.key, plugin.name);\n            await plug.onload();\n            this.loadedPlugins.set(plugin.key, plug);\n            return;\n        }\n        const exports: { [key: string]: any } = {};\n        const module = { exports };\n        function run(script: string, name: string) {\n            return eval('(function anonymous(require,module,exports){'.concat(script, '\\n})\\n//# sourceURL=').concat(name, '\\n'));\n        }\n        const __require = (name: string) => {\n            if (components[name]) {\n                return components[name];\n            }\n            throw new Error(`module ${name} not found`);\n        };\n        const pluginName = plugin.key;\n        try {\n            run(plugin.script, plugin.key)(__require, module, exports);\n        } catch (e) {\n            error('Error plugin:' + plugin.key + ' ->', e);\n            return;\n        }\n        let pluginConstructor;\n        if (!(pluginConstructor = (module.exports || exports).default || module.exports)) {\n            throw new Error(`Failed to load plugin ${pluginName}. No exports detected.`);\n        }\n        const plug = new pluginConstructor();\n        if (!(plug instanceof Plugin)) {\n            throw new Error(`Failed to load plugin ${pluginName}`);\n        }\n        this.addAdditionalMethod(plug, plugin.key, pluginName);\n        try {\n            await plug.onload();\n            this.loadedPlugins.set(plugin.key, plug);\n        } catch (e) {\n            error('Error plugin:' + plugin.key + ' ->', e);\n        }\n    }\n\n    async unloadPlugin(key: string) {\n        const plugin = this.loadedPlugins.get(key);\n        if (!plugin) {\n            return;\n        }\n        plugin.onunload();\n        container.get<ICommandManager>(TYPES.CommandManager).unregisterCommandByPlugin(key);\n        container.get<ISettingManager>(TYPES.SettingManager).unregisterSetting(key);\n        this.loadedPlugins.delete(key);\n    }\n\n    async unloadThirdPartyPlugins(plugins: PluginManifest[]) {\n        const keys = plugins.filter((p) => p.enabled).map((p) => p.key);\n        for (const k of keys) {\n            log(`unload third party plugin: ${k}`);\n            await this.unloadPlugin(k);\n        }\n    }\n\n    async loadThirdPartyEnabledPlugins(plugins: PluginManifest[]) {\n        return this.loadEnabledPlugins(plugins);\n    }\n\n    public generateRequiredModules() {\n        components = {\n            siyuan: api,\n            axios: axios,\n        };\n    }\n\n    private addAdditionalMethod(plugin: Plugin, pluginKey: string, pluginName: string) {\n        plugin.registerCommand = (command: IPluginCommand) => {\n            const cm = container.get<ICommandManager>(TYPES.CommandManager);\n            cm.registerCommand({\n                ...command,\n                plugin: pluginKey,\n                pluginName,\n            });\n        };\n\n        const sm = container.get<IStorageManager>(TYPES.StorageManager);\n        plugin.writeStorage = async (filename: string, content: any) => {\n            return await sm.setPluginStorage(pluginKey, filename, content);\n        };\n        plugin.loadStorage = async (filename: string) => {\n            return await sm.getPluginStorage(pluginKey, filename);\n        };\n        plugin.registerSettingRender = (settingRender: SettingRender) => {\n            const cm = container.get<ISettingManager>(TYPES.SettingManager);\n            cm.registerSetting(pluginKey, settingRender);\n        };\n    }\n}\n","import { FileClient } from '@/api/file-api';\nimport { injectable } from 'inversify';\nimport { PluginManifest } from '../types';\nimport { error, isExists, log } from '../util';\n\nexport const MANIFEST = 'manifest.json';\n\nexport const SCRIPT = 'main.js';\n\n@injectable()\nexport class PluginFileManager {\n    async scanPlugins(pluginFolder: string): Promise<string[]> {\n        const res = await FileClient.getInstanceApi().fileApi.readDir(pluginFolder);\n        if (!res) {\n            return [];\n        }\n        const files = res;\n        const result: string[] = [];\n        for (const f of files) {\n            if (f.name.startsWith('.')) {\n                continue;\n            }\n            if (f.isDir && (await isExists(`/data/plugins/${f.name}/manifest.json`)) && (await isExists(`/data/plugins/${f.name}/main.js`))) {\n                result.push(`/data/plugins/${f.name}`);\n            }\n        }\n        return result;\n    }\n\n    async getFileContent(f: string): Promise<string> {\n        const res = await FileClient.getInstanceApi().fileApi.getFile(f);\n        return res || '';\n    }\n\n    async getManifest(manifest: string) {\n        const content = await this.getFileContent(manifest);\n        try {\n            return JSON.parse(content);\n        } catch (e) {\n            error('loading manifest: ' + manifest, e);\n            return null;\n        }\n    }\n\n    async getScript(script: string) {\n        return await this.getFileContent(script);\n    }\n\n    async getAllPlugins(): Promise<PluginManifest[]> {\n        const plugins = await this.scanPlugins('/data/plugins');\n        if (!plugins || !plugins.length) {\n            log('No plugin found in ' + '/data/plugins');\n            return [];\n        }\n        const req = [];\n        for (const p of plugins) {\n            log('Reading plugin from filesystem: ' + p);\n            const key = this.getFolderName(p);\n            const f = async () => {\n                const [manifest, script] = await Promise.all([this.getManifest(`${p}/manifest.json`), this.getScript(`${p}/main.js`)]);\n                return { ...manifest, script, enabled: false, key };\n            };\n            req.push(f());\n        }\n        const result: PluginManifest[] = await Promise.all(req);\n        return result || [];\n    }\n\n    getFolderName(p) {\n        const f = p.split('/');\n        for (let i = f.length - 1; i >= 0; i--) {\n            if (f[i]) {\n                return f[i];\n            }\n        }\n        return '';\n    }\n}\n","import { IEventBus, Listener } from '@/types';\nimport { injectable } from 'inversify';\n\n@injectable()\nexport class EventBus implements IEventBus {\n    private eventListeners: { [key: string]: Listener[] };\n\n    constructor() {\n        this.eventListeners = {};\n    }\n\n    destroy() {\n        delete this.eventListeners;\n    }\n\n    on(eventName: string, callback: Listener) {\n        if (!this.eventListeners[eventName]) {\n            this.eventListeners[eventName] = [];\n        }\n        this.eventListeners[eventName].push(callback);\n        return () => this.off(eventName, callback);\n    }\n\n    off(eventName: string, callback?: Listener) {\n        if (!callback) {\n            delete this.eventListeners[eventName];\n            return;\n        }\n        for (let i = 0; i < this.eventListeners[eventName].length; i++) {\n            if (this.eventListeners[eventName][i] === callback) {\n                this.eventListeners[eventName].splice(i, 1);\n                return;\n            }\n        }\n    }\n\n    emit(eventName: string, ...args: any) {\n        if (this.eventListeners[eventName]) {\n            this.eventListeners[eventName].forEach((cb) => {\n                cb(...args);\n            });\n        }\n    }\n}\n","import { TYPES } from '@/config';\nimport { Command, ICommandManager } from '@/types';\nimport { Error, log, Warning } from '@/util';\nimport { inject, injectable } from 'inversify';\nimport { Shortcut } from './shortcut';\n\n@injectable()\nexport class CommandManager implements ICommandManager {\n    private shortcut: Shortcut;\n    private commandList: Command[];\n\n    public constructor(@inject(TYPES.Shortcut) shortcut) {\n        this.commandList = [];\n        this.shortcut = shortcut;\n    }\n\n    public registerCommand(command: Command) {\n        if (\n            this.commandList.some((com) => {\n                com.plugin === command.plugin && com.command === command.command;\n            })\n        ) {\n            return new Error('Command is already registered, do not register command repeatly');\n        }\n        if (\n            command.shortcut &&\n            this.commandList.some((com) => {\n                com.shortcut === command.shortcut;\n            })\n        ) {\n            return new Warning('shortcut has already registered');\n        }\n        this.commandList.push(command);\n        this.shortcut.registerKeyboardEventFromPlugin(command);\n        log(`Register plugin: ${command.plugin} command: ${command.command}`);\n    }\n\n    public unregisterCommandByPlugin(plugin: string) {\n        for (let i = 0; i < this.commandList.length; i++) {\n            if (plugin === this.commandList[i].plugin) {\n                const com = this.commandList[i];\n                log(`Unregister plugin: ${plugin} command: ${com.command}`);\n                this.commandList.splice(i, 1);\n                if (com.shortcut) {\n                    this.shortcut.unregisterKeyboardEvent(com.shortcut);\n                }\n            }\n        }\n    }\n\n    public unregisterCommand(command: Command) {\n        for (let i = 0; i < this.commandList.length; i++) {\n            if (command.command === this.commandList[i].command && command.plugin === this.commandList[i].plugin) {\n                this.commandList.splice(i, 1);\n                break;\n            }\n        }\n        this.shortcut.registerKeyboardEventFromPlugin(command);\n    }\n\n    public getCommands(): Command[] {\n        return this.commandList;\n    }\n}\n","/**! \n * hotkeys-js v3.10.1 \n * A simple micro-library for defining and dispatching keyboard shortcuts. It has no dependencies. \n * \n * Copyright (c) 2022 kenny wong <wowohoo@qq.com> \n * http://jaywcjlove.github.io/hotkeys \n * Licensed under the MIT license \n */\n\nvar isff = typeof navigator !== 'undefined' ? navigator.userAgent.toLowerCase().indexOf('firefox') > 0 : false; // 绑定事件\n\nfunction addEvent(object, event, method, useCapture) {\n  if (object.addEventListener) {\n    object.addEventListener(event, method, useCapture);\n  } else if (object.attachEvent) {\n    object.attachEvent(\"on\".concat(event), function () {\n      method(window.event);\n    });\n  }\n} // 修饰键转换成对应的键码\n\n\nfunction getMods(modifier, key) {\n  var mods = key.slice(0, key.length - 1);\n\n  for (var i = 0; i < mods.length; i++) {\n    mods[i] = modifier[mods[i].toLowerCase()];\n  }\n\n  return mods;\n} // 处理传的key字符串转换成数组\n\n\nfunction getKeys(key) {\n  if (typeof key !== 'string') key = '';\n  key = key.replace(/\\s/g, ''); // 匹配任何空白字符,包括空格、制表符、换页符等等\n\n  var keys = key.split(','); // 同时设置多个快捷键，以','分割\n\n  var index = keys.lastIndexOf(''); // 快捷键可能包含','，需特殊处理\n\n  for (; index >= 0;) {\n    keys[index - 1] += ',';\n    keys.splice(index, 1);\n    index = keys.lastIndexOf('');\n  }\n\n  return keys;\n} // 比较修饰键的数组\n\n\nfunction compareArray(a1, a2) {\n  var arr1 = a1.length >= a2.length ? a1 : a2;\n  var arr2 = a1.length >= a2.length ? a2 : a1;\n  var isIndex = true;\n\n  for (var i = 0; i < arr1.length; i++) {\n    if (arr2.indexOf(arr1[i]) === -1) isIndex = false;\n  }\n\n  return isIndex;\n}\n\nvar _keyMap = {\n  backspace: 8,\n  '⌫': 8,\n  tab: 9,\n  clear: 12,\n  enter: 13,\n  '↩': 13,\n  return: 13,\n  esc: 27,\n  escape: 27,\n  space: 32,\n  left: 37,\n  up: 38,\n  right: 39,\n  down: 40,\n  del: 46,\n  delete: 46,\n  ins: 45,\n  insert: 45,\n  home: 36,\n  end: 35,\n  pageup: 33,\n  pagedown: 34,\n  capslock: 20,\n  num_0: 96,\n  num_1: 97,\n  num_2: 98,\n  num_3: 99,\n  num_4: 100,\n  num_5: 101,\n  num_6: 102,\n  num_7: 103,\n  num_8: 104,\n  num_9: 105,\n  num_multiply: 106,\n  num_add: 107,\n  num_enter: 108,\n  num_subtract: 109,\n  num_decimal: 110,\n  num_divide: 111,\n  '⇪': 20,\n  ',': 188,\n  '.': 190,\n  '/': 191,\n  '`': 192,\n  '-': isff ? 173 : 189,\n  '=': isff ? 61 : 187,\n  ';': isff ? 59 : 186,\n  '\\'': 222,\n  '[': 219,\n  ']': 221,\n  '\\\\': 220\n}; // Modifier Keys\n\nvar _modifier = {\n  // shiftKey\n  '⇧': 16,\n  shift: 16,\n  // altKey\n  '⌥': 18,\n  alt: 18,\n  option: 18,\n  // ctrlKey\n  '⌃': 17,\n  ctrl: 17,\n  control: 17,\n  // metaKey\n  '⌘': 91,\n  cmd: 91,\n  command: 91\n};\nvar modifierMap = {\n  16: 'shiftKey',\n  18: 'altKey',\n  17: 'ctrlKey',\n  91: 'metaKey',\n  shiftKey: 16,\n  ctrlKey: 17,\n  altKey: 18,\n  metaKey: 91\n};\nvar _mods = {\n  16: false,\n  18: false,\n  17: false,\n  91: false\n};\nvar _handlers = {}; // F1~F12 special key\n\nfor (var k = 1; k < 20; k++) {\n  _keyMap[\"f\".concat(k)] = 111 + k;\n}\n\nvar _downKeys = []; // 记录摁下的绑定键\n\nvar winListendFocus = false; // window是否已经监听了focus事件\n\nvar _scope = 'all'; // 默认热键范围\n\nvar elementHasBindEvent = []; // 已绑定事件的节点记录\n// 返回键码\n\nvar code = function code(x) {\n  return _keyMap[x.toLowerCase()] || _modifier[x.toLowerCase()] || x.toUpperCase().charCodeAt(0);\n};\n\nvar getKey = function getKey(x) {\n  return Object.keys(_keyMap).find(function (k) {\n    return _keyMap[k] === x;\n  });\n};\n\nvar getModifier = function getModifier(x) {\n  return Object.keys(_modifier).find(function (k) {\n    return _modifier[k] === x;\n  });\n}; // 设置获取当前范围（默认为'所有'）\n\n\nfunction setScope(scope) {\n  _scope = scope || 'all';\n} // 获取当前范围\n\n\nfunction getScope() {\n  return _scope || 'all';\n} // 获取摁下绑定键的键值\n\n\nfunction getPressedKeyCodes() {\n  return _downKeys.slice(0);\n}\n\nfunction getPressedKeyString() {\n  return _downKeys.map(function (c) {\n    return getKey(c) || getModifier(c) || String.fromCharCode(c);\n  });\n} // 表单控件控件判断 返回 Boolean\n// hotkey is effective only when filter return true\n\n\nfunction filter(event) {\n  var target = event.target || event.srcElement;\n  var tagName = target.tagName;\n  var flag = true; // ignore: isContentEditable === 'true', <input> and <textarea> when readOnly state is false, <select>\n\n  if (target.isContentEditable || (tagName === 'INPUT' || tagName === 'TEXTAREA' || tagName === 'SELECT') && !target.readOnly) {\n    flag = false;\n  }\n\n  return flag;\n} // 判断摁下的键是否为某个键，返回true或者false\n\n\nfunction isPressed(keyCode) {\n  if (typeof keyCode === 'string') {\n    keyCode = code(keyCode); // 转换成键码\n  }\n\n  return _downKeys.indexOf(keyCode) !== -1;\n} // 循环删除handlers中的所有 scope(范围)\n\n\nfunction deleteScope(scope, newScope) {\n  var handlers;\n  var i; // 没有指定scope，获取scope\n\n  if (!scope) scope = getScope();\n\n  for (var key in _handlers) {\n    if (Object.prototype.hasOwnProperty.call(_handlers, key)) {\n      handlers = _handlers[key];\n\n      for (i = 0; i < handlers.length;) {\n        if (handlers[i].scope === scope) handlers.splice(i, 1);else i++;\n      }\n    }\n  } // 如果scope被删除，将scope重置为all\n\n\n  if (getScope() === scope) setScope(newScope || 'all');\n} // 清除修饰键\n\n\nfunction clearModifier(event) {\n  var key = event.keyCode || event.which || event.charCode;\n\n  var i = _downKeys.indexOf(key); // 从列表中清除按压过的键\n\n\n  if (i >= 0) {\n    _downKeys.splice(i, 1);\n  } // 特殊处理 cmmand 键，在 cmmand 组合快捷键 keyup 只执行一次的问题\n\n\n  if (event.key && event.key.toLowerCase() === 'meta') {\n    _downKeys.splice(0, _downKeys.length);\n  } // 修饰键 shiftKey altKey ctrlKey (command||metaKey) 清除\n\n\n  if (key === 93 || key === 224) key = 91;\n\n  if (key in _mods) {\n    _mods[key] = false; // 将修饰键重置为false\n\n    for (var k in _modifier) {\n      if (_modifier[k] === key) hotkeys[k] = false;\n    }\n  }\n}\n\nfunction unbind(keysInfo) {\n  // unbind(), unbind all keys\n  if (typeof keysInfo === 'undefined') {\n    Object.keys(_handlers).forEach(function (key) {\n      return delete _handlers[key];\n    });\n  } else if (Array.isArray(keysInfo)) {\n    // support like : unbind([{key: 'ctrl+a', scope: 's1'}, {key: 'ctrl-a', scope: 's2', splitKey: '-'}])\n    keysInfo.forEach(function (info) {\n      if (info.key) eachUnbind(info);\n    });\n  } else if (typeof keysInfo === 'object') {\n    // support like unbind({key: 'ctrl+a, ctrl+b', scope:'abc'})\n    if (keysInfo.key) eachUnbind(keysInfo);\n  } else if (typeof keysInfo === 'string') {\n    for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n      args[_key - 1] = arguments[_key];\n    }\n\n    // support old method\n    // eslint-disable-line\n    var scope = args[0],\n        method = args[1];\n\n    if (typeof scope === 'function') {\n      method = scope;\n      scope = '';\n    }\n\n    eachUnbind({\n      key: keysInfo,\n      scope: scope,\n      method: method,\n      splitKey: '+'\n    });\n  }\n} // 解除绑定某个范围的快捷键\n\n\nvar eachUnbind = function eachUnbind(_ref) {\n  var key = _ref.key,\n      scope = _ref.scope,\n      method = _ref.method,\n      _ref$splitKey = _ref.splitKey,\n      splitKey = _ref$splitKey === void 0 ? '+' : _ref$splitKey;\n  var multipleKeys = getKeys(key);\n  multipleKeys.forEach(function (originKey) {\n    var unbindKeys = originKey.split(splitKey);\n    var len = unbindKeys.length;\n    var lastKey = unbindKeys[len - 1];\n    var keyCode = lastKey === '*' ? '*' : code(lastKey);\n    if (!_handlers[keyCode]) return; // 判断是否传入范围，没有就获取范围\n\n    if (!scope) scope = getScope();\n    var mods = len > 1 ? getMods(_modifier, unbindKeys) : [];\n    _handlers[keyCode] = _handlers[keyCode].filter(function (record) {\n      // 通过函数判断，是否解除绑定，函数相等直接返回\n      var isMatchingMethod = method ? record.method === method : true;\n      return !(isMatchingMethod && record.scope === scope && compareArray(record.mods, mods));\n    });\n  });\n}; // 对监听对应快捷键的回调函数进行处理\n\n\nfunction eventHandler(event, handler, scope, element) {\n  if (handler.element !== element) {\n    return;\n  }\n\n  var modifiersMatch; // 看它是否在当前范围\n\n  if (handler.scope === scope || handler.scope === 'all') {\n    // 检查是否匹配修饰符（如果有返回true）\n    modifiersMatch = handler.mods.length > 0;\n\n    for (var y in _mods) {\n      if (Object.prototype.hasOwnProperty.call(_mods, y)) {\n        if (!_mods[y] && handler.mods.indexOf(+y) > -1 || _mods[y] && handler.mods.indexOf(+y) === -1) {\n          modifiersMatch = false;\n        }\n      }\n    } // 调用处理程序，如果是修饰键不做处理\n\n\n    if (handler.mods.length === 0 && !_mods[16] && !_mods[18] && !_mods[17] && !_mods[91] || modifiersMatch || handler.shortcut === '*') {\n      if (handler.method(event, handler) === false) {\n        if (event.preventDefault) event.preventDefault();else event.returnValue = false;\n        if (event.stopPropagation) event.stopPropagation();\n        if (event.cancelBubble) event.cancelBubble = true;\n      }\n    }\n  }\n} // 处理keydown事件\n\n\nfunction dispatch(event, element) {\n  var asterisk = _handlers['*'];\n  var key = event.keyCode || event.which || event.charCode; // 表单控件过滤 默认表单控件不触发快捷键\n\n  if (!hotkeys.filter.call(this, event)) return; // Gecko(Firefox)的command键值224，在Webkit(Chrome)中保持一致\n  // Webkit左右 command 键值不一样\n\n  if (key === 93 || key === 224) key = 91;\n  /**\n   * Collect bound keys\n   * If an Input Method Editor is processing key input and the event is keydown, return 229.\n   * https://stackoverflow.com/questions/25043934/is-it-ok-to-ignore-keydown-events-with-keycode-229\n   * http://lists.w3.org/Archives/Public/www-dom/2010JulSep/att-0182/keyCode-spec.html\n   */\n\n  if (_downKeys.indexOf(key) === -1 && key !== 229) _downKeys.push(key);\n  /**\n   * Jest test cases are required.\n   * ===============================\n   */\n\n  ['ctrlKey', 'altKey', 'shiftKey', 'metaKey'].forEach(function (keyName) {\n    var keyNum = modifierMap[keyName];\n\n    if (event[keyName] && _downKeys.indexOf(keyNum) === -1) {\n      _downKeys.push(keyNum);\n    } else if (!event[keyName] && _downKeys.indexOf(keyNum) > -1) {\n      _downKeys.splice(_downKeys.indexOf(keyNum), 1);\n    } else if (keyName === 'metaKey' && event[keyName] && _downKeys.length === 3) {\n      /**\n       * Fix if Command is pressed:\n       * ===============================\n       */\n      if (!(event.ctrlKey || event.shiftKey || event.altKey)) {\n        _downKeys = _downKeys.slice(_downKeys.indexOf(keyNum));\n      }\n    }\n  });\n  /**\n   * -------------------------------\n   */\n\n  if (key in _mods) {\n    _mods[key] = true; // 将特殊字符的key注册到 hotkeys 上\n\n    for (var k in _modifier) {\n      if (_modifier[k] === key) hotkeys[k] = true;\n    }\n\n    if (!asterisk) return;\n  } // 将 modifierMap 里面的修饰键绑定到 event 中\n\n\n  for (var e in _mods) {\n    if (Object.prototype.hasOwnProperty.call(_mods, e)) {\n      _mods[e] = event[modifierMap[e]];\n    }\n  }\n  /**\n   * https://github.com/jaywcjlove/hotkeys/pull/129\n   * This solves the issue in Firefox on Windows where hotkeys corresponding to special characters would not trigger.\n   * An example of this is ctrl+alt+m on a Swedish keyboard which is used to type μ.\n   * Browser support: https://caniuse.com/#feat=keyboardevent-getmodifierstate\n   */\n\n\n  if (event.getModifierState && !(event.altKey && !event.ctrlKey) && event.getModifierState('AltGraph')) {\n    if (_downKeys.indexOf(17) === -1) {\n      _downKeys.push(17);\n    }\n\n    if (_downKeys.indexOf(18) === -1) {\n      _downKeys.push(18);\n    }\n\n    _mods[17] = true;\n    _mods[18] = true;\n  } // 获取范围 默认为 `all`\n\n\n  var scope = getScope(); // 对任何快捷键都需要做的处理\n\n  if (asterisk) {\n    for (var i = 0; i < asterisk.length; i++) {\n      if (asterisk[i].scope === scope && (event.type === 'keydown' && asterisk[i].keydown || event.type === 'keyup' && asterisk[i].keyup)) {\n        eventHandler(event, asterisk[i], scope, element);\n      }\n    }\n  } // key 不在 _handlers 中返回\n\n\n  if (!(key in _handlers)) return;\n\n  for (var _i = 0; _i < _handlers[key].length; _i++) {\n    if (event.type === 'keydown' && _handlers[key][_i].keydown || event.type === 'keyup' && _handlers[key][_i].keyup) {\n      if (_handlers[key][_i].key) {\n        var record = _handlers[key][_i];\n        var splitKey = record.splitKey;\n        var keyShortcut = record.key.split(splitKey);\n        var _downKeysCurrent = []; // 记录当前按键键值\n\n        for (var a = 0; a < keyShortcut.length; a++) {\n          _downKeysCurrent.push(code(keyShortcut[a]));\n        }\n\n        if (_downKeysCurrent.sort().join('') === _downKeys.sort().join('')) {\n          // 找到处理内容\n          eventHandler(event, record, scope, element);\n        }\n      }\n    }\n  }\n} // 判断 element 是否已经绑定事件\n\n\nfunction isElementBind(element) {\n  return elementHasBindEvent.indexOf(element) > -1;\n}\n\nfunction hotkeys(key, option, method) {\n  _downKeys = [];\n  var keys = getKeys(key); // 需要处理的快捷键列表\n\n  var mods = [];\n  var scope = 'all'; // scope默认为all，所有范围都有效\n\n  var element = document; // 快捷键事件绑定节点\n\n  var i = 0;\n  var keyup = false;\n  var keydown = true;\n  var splitKey = '+';\n  var capture = false; // 对为设定范围的判断\n\n  if (method === undefined && typeof option === 'function') {\n    method = option;\n  }\n\n  if (Object.prototype.toString.call(option) === '[object Object]') {\n    if (option.scope) scope = option.scope; // eslint-disable-line\n\n    if (option.element) element = option.element; // eslint-disable-line\n\n    if (option.keyup) keyup = option.keyup; // eslint-disable-line\n\n    if (option.keydown !== undefined) keydown = option.keydown; // eslint-disable-line\n\n    if (option.capture !== undefined) capture = option.capture; // eslint-disable-line\n\n    if (typeof option.splitKey === 'string') splitKey = option.splitKey; // eslint-disable-line\n  }\n\n  if (typeof option === 'string') scope = option; // 对于每个快捷键进行处理\n\n  for (; i < keys.length; i++) {\n    key = keys[i].split(splitKey); // 按键列表\n\n    mods = []; // 如果是组合快捷键取得组合快捷键\n\n    if (key.length > 1) mods = getMods(_modifier, key); // 将非修饰键转化为键码\n\n    key = key[key.length - 1];\n    key = key === '*' ? '*' : code(key); // *表示匹配所有快捷键\n    // 判断key是否在_handlers中，不在就赋一个空数组\n\n    if (!(key in _handlers)) _handlers[key] = [];\n\n    _handlers[key].push({\n      keyup: keyup,\n      keydown: keydown,\n      scope: scope,\n      mods: mods,\n      shortcut: keys[i],\n      method: method,\n      key: keys[i],\n      splitKey: splitKey,\n      element: element\n    });\n  } // 在全局document上设置快捷键\n\n\n  if (typeof element !== 'undefined' && !isElementBind(element) && window) {\n    elementHasBindEvent.push(element);\n    addEvent(element, 'keydown', function (e) {\n      dispatch(e, element);\n    }, capture);\n\n    if (!winListendFocus) {\n      winListendFocus = true;\n      addEvent(window, 'focus', function () {\n        _downKeys = [];\n      }, capture);\n    }\n\n    addEvent(element, 'keyup', function (e) {\n      dispatch(e, element);\n      clearModifier(e);\n    }, capture);\n  }\n}\n\nfunction trigger(shortcut) {\n  var scope = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'all';\n  Object.keys(_handlers).forEach(function (key) {\n    var dataList = _handlers[key].filter(function (item) {\n      return item.scope === scope && item.shortcut === shortcut;\n    });\n\n    dataList.forEach(function (data) {\n      if (data && data.method) {\n        data.method();\n      }\n    });\n  });\n}\n\nvar _api = {\n  getPressedKeyString: getPressedKeyString,\n  setScope: setScope,\n  getScope: getScope,\n  deleteScope: deleteScope,\n  getPressedKeyCodes: getPressedKeyCodes,\n  isPressed: isPressed,\n  filter: filter,\n  trigger: trigger,\n  unbind: unbind,\n  keyMap: _keyMap,\n  modifier: _modifier,\n  modifierMap: modifierMap\n};\n\nfor (var a in _api) {\n  if (Object.prototype.hasOwnProperty.call(_api, a)) {\n    hotkeys[a] = _api[a];\n  }\n}\n\nif (typeof window !== 'undefined') {\n  var _hotkeys = window.hotkeys;\n\n  hotkeys.noConflict = function (deep) {\n    if (deep && window.hotkeys === hotkeys) {\n      window.hotkeys = _hotkeys;\n    }\n\n    return hotkeys;\n  };\n\n  window.hotkeys = hotkeys;\n}\n\nexport { hotkeys as default };\n","import { TYPES } from '@/config';\nimport { Command, IEventBus, IShortcut } from '@/types';\nimport { log } from '@/util';\nimport hotkeys from 'hotkeys-js';\nimport { inject, injectable } from 'inversify';\n\nhotkeys.filter = function () {\n    return true;\n};\n\n@injectable()\nexport class Shortcut implements IShortcut {\n    private eventBus: IEventBus;\n\n    private option = {\n        capture: true,\n    };\n\n    public constructor(@inject(TYPES.EventBus) eventBus: IEventBus) {\n        log('Initialize shortcut subsystem');\n        this.eventBus = eventBus;\n    }\n\n    public registerKeyboardEvent(shortcut: string, callback: (e: KeyboardEvent) => void) {\n        hotkeys(shortcut, this.option, callback);\n        this.eventBus.on(shortcut.toString(), callback);\n    }\n\n    public unregisterKeyboardEvent(shortcut: string) {\n        hotkeys.unbind(shortcut);\n        this.eventBus.off(shortcut.toString());\n    }\n\n    public registerKeyboardEventFromPlugin(command: Command) {\n        if (command.shortcut && command.callback) {\n            this.registerKeyboardEvent(command.shortcut, command.callback);\n        }\n    }\n\n    public unregisterKeyboardEventFromPlugin(command: Command) {\n        if (command.shortcut && command.callback) {\n            this.unregisterKeyboardEvent(command.shortcut);\n        }\n    }\n}\n","import { injectable } from 'inversify';\nimport { ISettingManager, SettingRender } from '../types';\n\n@injectable()\nexport class SettingManager implements ISettingManager {\n    settingRenders: Map<string, SettingRender>;\n\n    public constructor() {\n        this.settingRenders = new Map();\n    }\n\n    registerSetting(pluginKey: string, settingRender: SettingRender) {\n        this.settingRenders.set(pluginKey, settingRender);\n    }\n\n    unregisterSetting(key: string) {\n        this.settingRenders.delete(key);\n    }\n\n    getSettingRenders() {\n        const result: Array<{ key: string; value: SettingRender }> = [];\n        this.settingRenders.forEach((value, key) => {\n            result.push({ key, value });\n        });\n        return result;\n    }\n}\n","import { Container } from 'inversify';\nimport { StorageManager } from './core/storage-manager';\nimport { PluginSystem } from './core';\nimport { TYPES } from './config';\nimport { SystemManager } from './core/system-manager';\nimport { PluginLoader } from './core/loader';\nimport { PluginFileManager } from './core/plugin-file-manager';\nimport {\n    IStorageManager,\n    ISystemManager,\n    IPluginSystem,\n    IPluginLoader,\n    IPluginFileManager,\n    IEventBus,\n    IShortcut,\n    ICommandManager,\n    IStore,\n    ISettingManager,\n} from './types';\nimport { EventBus } from './core/event-bus';\nimport { CommandManager } from './core/command-manager';\nimport { Shortcut } from './core/shortcut';\nimport { Store } from './core/store';\nimport { SettingManager } from './core/setting-manager';\n\nconst container = new Container();\ncontainer.bind<IStorageManager>(TYPES.StorageManager).to(StorageManager).inSingletonScope();\ncontainer.bind<ISystemManager>(TYPES.SystemManager).to(SystemManager).inSingletonScope();\ncontainer.bind<IPluginSystem>(TYPES.PluginSystem).to(PluginSystem).inSingletonScope();\ncontainer.bind<IPluginLoader>(TYPES.PluginLoader).to(PluginLoader).inSingletonScope();\ncontainer.bind<IPluginFileManager>(TYPES.PluginFileManager).to(PluginFileManager).inSingletonScope();\ncontainer.bind<IEventBus>(TYPES.EventBus).to(EventBus);\ncontainer.bind<IShortcut>(TYPES.Shortcut).to(Shortcut).inSingletonScope();\ncontainer.bind<ICommandManager>(TYPES.CommandManager).to(CommandManager).inSingletonScope();\ncontainer.bind<IStore>(TYPES.Store).to(Store).inSingletonScope();\ncontainer.bind<ISettingManager>(TYPES.SettingManager).to(SettingManager).inSingletonScope();\n\nexport { container };\n","import 'reflect-metadata';\n\nimport { VERSION } from './config';\nimport { log } from './util';\nimport { container } from './container';\nimport { TYPES } from './config';\nimport { IPluginSystem } from './types';\n\nfunction initPluginSystem() {\n    if (!window.pluginSystem) {\n        log('Siyuan Plugin System loading...');\n        window.pluginSystemVersion = VERSION;\n        window.pluginSystem = container.get<IPluginSystem>(TYPES.PluginSystem).init();\n        window.pluginSystemIocContainer = container;\n    }\n}\n\nexport { initPluginSystem };\nexport default initPluginSystem;\n"],"names":["Reflect","factory","global","Metadata","P","hasOwn","_a","iterator","k","prototype","MapIterator","error","Map","getKey","insert","_","Set","WeakMap","VERSION","request","url","transactions","sql","name","id","text","serverApi.pushErrMsg","serverApi.pushMsg","t","a","e","l","p","c","MAX_LENGTH","MAX_SAFE_INTEGER","constants","debug","MAX_SAFE_COMPONENT_LENGTH","require$$0","require$$1","exports","module","re","R","parseOptions","compareIdentifiers","b","identifiers","require$$2","require$$3","require$$4","SemVer","version","semver","parse","valid","clean","inc","compare","eq","diff","major","minor","patch","prerelease","rcompare","compareLoose","compareBuild","sort","rsort","gt","lt","neq","gte","lte","require$$5","cmp","coerce","self","trim","Range","range","Comparator","M","z","ANY","satisfies","toComparators","maxSatisfying","minSatisfying","minVersion","comparator","validRange","require$$6","require$$7","outside","gtr","ltr","intersects","subset","require$$8","require$$9","require$$10","require$$11","require$$12","require$$13","require$$14","require$$15","require$$16","require$$17","require$$18","require$$19","require$$20","require$$21","require$$22","require$$23","require$$24","require$$25","require$$26","require$$27","require$$28","require$$29","require$$30","require$$31","require$$32","require$$33","require$$34","require$$35","require$$36","require$$37","require$$38","require$$39","require$$40","resolve","descriptors","filter","hasOwnProperty","noop","code","config","encode","append","toString","URLSearchParams","FormData","Blob","isFormData","isFileList","transitional","defaults","AxiosHeaders","validateStatus","standardBrowserEnv","isURLSameOrigin","nonStandardBrowserEnv","adapters","merge","validators","validator","opts","InterceptorManager","forEachMethodNoData","forEachMethodWithData","defaultConfig","Axios","instance","CancelToken","HttpStatusCode","LoggerFactory","LogLevelEnum","axios","Error","Binding","MetadataReader","METADATA_KEY.PARAM_TYPES","METADATA_KEY.TAGGED","METADATA_KEY.TAGGED_PROP","ERROR_MSGS.STACK_OVERFLOW","container","getBindings","ERROR_MSGS.CIRCULAR_DEPENDENCY","Context","plan","METADATA_KEY.NAMED_TAG","Plan","LazyServiceIdentifer","QueryableString","Target","METADATA_KEY.MULTI_INJECT_TAG","METADATA_KEY.NON_CUSTOM_TAG_KEYS","METADATA_KEY.OPTIONAL_TAG","__spreadArray","this","ERROR_MSGS.MISSING_INJECTABLE_ANNOTATION","isObject","isFunction","isUndefined","ERROR_MSGS.MISSING_INJECT_ANNOTATION","inject","METADATA_KEY.UNMANAGED_TAG","METADATA_KEY.INJECT_TAG","METADATA_KEY.NAME_TAG","Request","ERROR_MSGS.NOT_REGISTERED","ERROR_MSGS.AMBIGUOUS_MATCH","ERROR_MSGS.ARGUMENTS_LENGTH_MISMATCH","__awaiter","__generator","FactoryType","ERROR_MSGS.INVALID_BINDING_TYPE","__assign","METADATA_KEY.POST_CONSTRUCT","METADATA_KEY.PRE_DESTROY","ERROR_MSGS.CIRCULAR_DEPENDENCY_IN_FACTORY","BindingWhenSyntax","BindingOnSyntax","BindingWhenOnSyntax","BindingInSyntax","BindingInWhenOnSyntax","BindingToSyntax","ERROR_MSGS.INVALID_TO_SELF_VALUE","ERROR_MSGS.INVALID_FUNCTION_BINDING","ContainerSnapshot","Lookup","ERROR_MSGS.NULL_ARGUMENT","ERROR_MSGS.KEY_NOT_FOUND","ModuleActivationStore","Container","ERROR_MSGS.CONTAINER_OPTIONS_MUST_BE_AN_OBJECT","ERROR_MSGS.CONTAINER_OPTIONS_INVALID_DEFAULT_SCOPE","ERROR_MSGS.CONTAINER_OPTIONS_INVALID_AUTO_BIND_INJECTABLE","ERROR_MSGS.CONTAINER_OPTIONS_INVALID_SKIP_BASE_CHECK","ERROR_MSGS.NO_MORE_SNAPSHOTS_AVAILABLE","ERROR_MSGS.ON_DEACTIVATION_ERROR","ERROR_MSGS.INVALID_MIDDLEWARE_RETURN","ERROR_MSGS.LAZY_IN_SYNC","ERROR_MSGS.ASYNC_UNBIND_REQUIRED","ERROR_MSGS.CANNOT_UNBIND","ERROR_MSGS.INVALID_DECORATOR_OPERATION","ERROR_MSGS.DUPLICATED_METADATA","m","ERRORS_MSGS.DUPLICATED_INJECTABLE_DECORATOR","METADATA_KEY.DESIGN_PARAM_TYPES","element","detach","create_fragment","ctx","create_if_block_1","create_if_block","CommandPanel__SvelteComponent_","uninstall","plugin","__decorateClass","__decorateParam","create_if_block_4","create_if_block_3","create_if_block_2","dispatch","loading","readme","goBack","render","SettingCommon","SettingList","SettingStore","clientApi.addToolbarRight","Settings","isHighSurrogate","isLowSurrogate","truncate","getLength","browser","all","sanitize","internalPlugins","script","serverApi.getBazzarWidget","plug","pluginName","shortcut","getModifier","eachUnbind"],"mappings":"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"} diff --git a/packages/zhi-loader/public/core/plugin-system/zhi-plugin-loader.js b/packages/zhi-loader/public/core/plugin-system/zhi-plugin-loader.js new file mode 100644 index 00000000..b7621d08 --- /dev/null +++ b/packages/zhi-loader/public/core/plugin-system/zhi-plugin-loader.js @@ -0,0 +1,158 @@ +/* + * Copyright (c) 2023, Terwer . All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. Terwer designates this + * particular file as subject to the "Classpath" exception as provided + * by Terwer in the LICENSE file that accompanied this code. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Terwer, Shenzhen, Guangdong, China, youweics@163.com + * or visit www.terwer.space if you need additional information or have any + * questions. + */ +/* eslint-disable */ + +/** + * StorageManager: 'StorageManager', + * PluginSystem: 'PluginSystem', + * SystemManager: 'PluginSystemLocalManager', + * PluginLoader: 'PluginLoader', + * PluginFileManager: 'PluginFileManager', + * EventBus: 'EventBus', + * Shortcut: 'Shortcut', + * CommandManager: 'CommandManager', + * Store: 'Store', + * SettingManager: 'SettingManager', + */ + +// const zhiPluginBase = "/appearance/themes/zhi/plugin" +const zhiPluginBase = "/data/storage/zhi/plugin" +const log = window.zhiLog.info + +async function getFile(path, type) { + const response = await fetch("/api/file/getFile", { + method: "POST", + headers: { + Authorization: `Token `, + }, + body: JSON.stringify({ + path: path, + }), + }) + if (response.status === 200) { + if (type === "text") { + return await response.text() + } + if (type === "json") { + return (await response.json()).data + } + } + return null +} + +async function isExists(p, type) { + try { + const res = await getFile(p, type) + return res !== null + } catch { + return false + } +} + +async function readDir(path) { + const response = await fetch("/api/file/readDir", { + method: "POST", + headers: { + Authorization: `Token `, + }, + body: JSON.stringify({ + path: path, + }), + }) + if (response.status === 200) { + return (await response.json()).data + } + return null +} + +async function scanPlugins(pluginFolder) { + const res = await readDir(pluginFolder) + // log("readDir res=>", res) + if (!res) { + return [] + } + const files = res + const result = [] + for (const f of files) { + if (f.name.startsWith(".")) { + continue + } + if ( + f.isDir && + (await isExists(`${zhiPluginBase}/${f.name}/manifest.json`, "json")) && + (await isExists(`${zhiPluginBase}/${f.name}/main.js`, "text")) + ) { + result.push(`${zhiPluginBase}/${f.name}`) + } + } + return result +} + +async function getZhiInternalPlugins() { + const container = window.pluginSystemIocContainer + const pluginFileManager = container.get("PluginFileManager") + // log("pluginFileManager=>", pluginFileManager) + + const plugins = await scanPlugins(zhiPluginBase) + if (!plugins || !plugins.length) { + log("No plugin found in " + zhiPluginBase) + return [] + } + const req = [] + for (const p of plugins) { + log("Reading zhi core plugin from filesystem: " + p) + const key = pluginFileManager.getFolderName(p) + const f = async () => { + const [manifest, script] = await Promise.all([ + pluginFileManager.getManifest(`${p}/manifest.json`), + pluginFileManager.getScript(`${p}/main.js`), + ]) + return { ...manifest, script, enabled: true, key } + } + req.push(f()) + } + const result = await Promise.all(req) + return result || [] +} + +async function init() { + // TODO + // 由于目前的 API 仅支持 data 目录，不支持 appearance ，所以先同步一波 + // await syncPlugins() + + const container = window.pluginSystemIocContainer + // const pluginSystem = container.get("PluginSystem") + const pluginLoader = container.get("PluginLoader") + // log("Check plugin system version", container) + // log("pluginSystem=>", pluginSystem) + // log("pluginLoader=>", pluginLoader) + + const zhiInternalPlugins = await getZhiInternalPlugins() + // log("zhiInternalPlugins=>", zhiInternalPlugins) + await pluginLoader.loadEnabledPlugins(zhiInternalPlugins) + log(`Loaded zhi theme internal enabled plugins: ${zhiInternalPlugins.map((p) => p.key).join(",")}`) +} + +export { init as default, init }